#include <cstdio>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

int t;
int x[2001];
int y[2001];
int plansza[4002][4002];
bool start[4002][4002];
int bok[2001];
int infx;
int infy;

int max_naprawo(int x, int y, int fill)
{
	int m = -2;
	
	for (int i = x + 1; i < infx; ++i)
	{
		if (plansza[i][y] > -1)
		{
			m = i - 1;
			break;
		}
		else
		{
			plansza[i][y] = fill;
		}
	}
	return m;
}
int rosnij(int x, int y, int maxx, int fill, int szerokosc, vector<int>& ps)
{
	if (y + 1 == infy)
	{
		return -2;
	}

	int wysokosc = ps[y + 1] - ps[y];

	if (szerokosc == wysokosc)
	{
		return - 1;
	}


	for (int j = y + 1; j <= infy; ++j)
	{
		if (j == infy)
		{
			return -2;
		}
		int maxw = -1;
		for (int i = x; i <= maxx; ++i)
		{
			maxw = max(plansza[i][j], maxw);
		}
		if (maxw == -1)
		{
			for (int i = x; i <= maxx; ++i)
			{
				plansza[i][j] = fill;
			}
			if (j+1 == infy)
			{
				return -2;
			}

			wysokosc = ps[j+1] - ps[y];
			if (szerokosc == wysokosc)
			{
				return -1;
			}
			if (wysokosc > szerokosc)
			{
				return 1;
			}

		}
		else
		{
			return 1;
		}
	}
	return 1;
}
int max_dogory(int x, int y, int fill)
{
	int  res = y;
	for (int j = y + 1; j <= infy; ++j)
	{
		if (j == infy)
		{
			return -2;
		}
		int maxw = -1;
		for (int i = x; i < infx; ++i)
		{
			maxw = max(plansza[i][j], maxw);
		}
		if (maxw == -1)
		{
			for (int i = x; i < infx; ++i)
			{
				plansza[i][j] = fill;
			}
			res = j;
		}
		else
		{
			break;
		}
	}
	return res;

}


int main()
{
	scanf("%d", &t);

	while (t-- > 0)
	{
		int n;
		scanf("%d", &n);

		for (int i = 0; i < n; ++i)
		{
			scanf("%d%d", &x[i], &y[i]);
			bok[i] = 1;
		}


		vector<int> ps(x, x + n);
		ps.insert(ps.end(), y, y + n);

		sort(ps.begin(), ps.end());
		ps.erase(unique(ps.begin(), ps.end()), ps.end());

		for (int i = 0; i < ps.size(); ++i)
		{
			for (int j = 0; j < ps.size(); ++j)
			{
				plansza[i][j] = -1;
				start[i][j] = false;
			}
		}

		for (int i = 0; i < n; ++i)
		{
			auto xIt = lower_bound(ps.begin(), ps.end(), x[i]);
			auto xIndex = distance(ps.begin(), xIt);

			auto yIt = lower_bound(ps.begin(), ps.end(), y[i]);
			auto yIndex = distance(ps.begin(), yIt);

			plansza[xIndex][yIndex] = i;
			start[xIndex][yIndex] = true;
		}


		int maxXv = *max_element(x, x + n);
		int maxYv = *max_element(y, y + n);
		int minXv = *min_element(x, x + n);
		int minYv = *min_element(y, y + n);

		auto xIt = lower_bound(ps.begin(), ps.end(), maxXv);
		int maxX = distance(ps.begin(), xIt);
		auto xIt2 = lower_bound(ps.begin(), ps.end(), minXv);
		int minX = distance(ps.begin(), xIt2);

		auto yIt = lower_bound(ps.begin(), ps.end(), maxYv);
		int maxY = distance(ps.begin(), yIt);
		auto yIt2 = lower_bound(ps.begin(), ps.end(), minYv);
		int minY= distance(ps.begin(), yIt2);

		infx = maxX + 1;
		infy = maxY + 1;
		

		for (int i = 0; i < 4002; ++i)
		{
			plansza[i][infy] = -2; // inf
		}
		for (int i = 0; i < 4002; ++i)
		{
			plansza[infx][i] = -2; // inf
		}


		int prawy = -2;
		int gorny = -2;
		int zobu = -1;
		int zobux = -1;
		int zobuy = -1;

		bool isValid = true;

		for (int j = minY; j < infy; ++j)
		{
			for (int i = minX; i < infx; ++i)
			{
				int cellValue = plansza[i][j];

				// powinno byc wypelnione!
				if (cellValue == -1)
				{
					isValid = false; break;
				}

                // groooooowwwwww as max as you can :)
				if ((cellValue > -1) && (start[i][j]))
				{
					int mw = max_naprawo(i, j, cellValue);
					if (mw > -2) // napotkalismy cos z prawej! mamy szerokosc
					{
						int szerokosc = ps[mw+1] - ps[i];
						bok[cellValue] = szerokosc;
						int md = rosnij(i, j, mw, cellValue, szerokosc, ps);
						if (md > 0) // nie moglem urosnac tyle coc trzeba :(
						{
							isValid == false; break;
						}
						if (md == -1) // uroslem tyle co trzeba
						{
							
						}
						if (md == -2) // napotkalem sufit
						{
							int potrzebna_wysokosc = ps[j] + szerokosc;
							if (gorny == -2)
							{
								gorny = potrzebna_wysokosc;
							}
							if (gorny != potrzebna_wysokosc)
							{
								isValid == false; break;
							}
						}
					}
					else
					{ 
					   // mamy nieskonczonosc z prawej
						if (prawy == -2)
						{
							int md = max_dogory(i, j, cellValue);
							if (md > -1)
							{
								int wysokosc = ps[md + 1] - ps[j];
								bok[cellValue] = wysokosc;
								int potrzebna_szerokosc = ps[i] + wysokosc;
								if (prawy == -2)
								{
									prawy = potrzebna_szerokosc;
								}
								if (prawy != potrzebna_szerokosc)
								{
									isValid = false; break;
								}
							}
							if (md == -2)
							{
								// nieskonczonosc z obu stron :D
								zobu = cellValue;
								zobux = i;
								zobuy = j;
							}
						}
						else
						{
							// mamy nieskonczonosc z prawej, ale juz mamy tez maks szerokosc!
							int szerokosc = prawy - ps[i];
							bok[cellValue] = szerokosc;
							int md = rosnij(i, j, infx-1, cellValue, szerokosc, ps);
							if (md > 0) // nie moglem urosnac tyle coc trzeba :(
							{
								isValid == false; break;
							}
							if (md == -2) // napotkalem sufit
							{
								int potrzebna_wysokosc = ps[j] + szerokosc;
								if (gorny == -2)
								{
									gorny = potrzebna_wysokosc;
								}
								if (gorny != potrzebna_wysokosc)
								{
									isValid == false; break;
								}
							}

						}
					}
				}

				if (isValid == false)
				{
					break;
				}
			}
			if (isValid == false)
			{
				break;
			}
		}

		if ((isValid) && (zobu > -1))
		{
			if ((gorny > -1) && (prawy > -1))
			{
				int wys = gorny - ps[zobuy];
				int sze = prawy - ps[zobux];
				if (wys == sze)
				{
					bok[zobu] = wys;
				}
				else
				{
					isValid = false;						
				}
			}
			if ((gorny == -2) && (prawy > -1))
			{
				bok[zobu] = prawy - ps[zobux];
			}
			if ((gorny > -1) && (prawy == -2))
			{
				bok[zobu] = gorny - ps[zobuy];
			}
			if ((gorny == -2) && (prawy == -2))
			{
				bok[zobu] = 1;
			}
		}



		if (isValid)
		{
			printf("TAK ");
			for (int i = 0; i < n; ++i)
			{
				printf("%d ", bok[i]);
			}
			printf("\n");
		}
		else
		{
			printf("NIE\n");
		}
	}

	return 0;
}