#include <iostream>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <set>

using namespace std;

bool sprawdz(const vector<vector<int> > & punkty, int ktory, int bok)
{
    int licz=1;
    while(punkty[ktory+licz][0]<punkty[ktory][0]+bok)
    {
        if(punkty[ktory+licz][1]>punkty[ktory][1] && punkty[ktory+licz][1]<punkty[ktory][1]+bok)
        {
            return false;
        }
        licz++;
        if(ktory+licz==punkty.size()) return true;
    }
    return true;
}

int main()
{
    int t;
    scanf("%d", &t);
    for(int i=0; i<t; i++)
    {
        int n;
        scanf("%d", &n);
        vector<int> kwadraty(n);
        vector<vector<int> > punkty(n);//first-y, second-x
        set<pair<int, int> > doszukania;
        vector<pair<int, int> > dodane;
        vector<pair<int, int> > dosprawdzenia;
        vector<vector<int> > krawedzie;
        for(int j=0; j<n; j++)
        {
            int x,y;
            scanf("%d%d", &x, &y);
            punkty[j].push_back(y);
            punkty[j].push_back(x);
            punkty[j].push_back(j);
            doszukania.insert(make_pair(y, x));
        }
        sort(punkty.begin(), punkty.end());
        for(int j=0; j<punkty.size(); j++)
        {
            //cout << "punkt " << j << endl;
            bool czykrawedz=false;
            if(j==punkty.size()-1)
            {
                //cout << "ostatni" << endl;
                for(int z=0; z<krawedzie.size(); z++)
                {
                    //cout << "z " << z << endl;
                    if(krawedzie[z][1]>punkty[j][1] && krawedzie[z][0]<punkty[j][0] && krawedzie[z][0]+krawedzie[z][2]>punkty[j][0])
                    {
                        int bok=krawedzie[z][1]-punkty[j][1];
                        if(sprawdz(punkty, j, bok))
                        {
                            kwadraty[j]=bok;
                            dodane.push_back(make_pair(punkty[j][0], punkty[j][1]+bok));
                            dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]));
                            dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]+bok));
                            vector<int> tmp;
                            tmp.push_back(punkty[j][0]);
                            tmp.push_back(punkty[j][1]);
                            tmp.push_back(bok);
                            krawedzie.push_back(tmp);
                            vector<int> tmp2;
                            tmp2.push_back(punkty[j][0]);
                            tmp2.push_back(punkty[j][1]+bok);
                            tmp2.push_back(bok);
                            krawedzie.push_back(tmp2);
                            sort(krawedzie.begin(), krawedzie.end());
                        }
                        else
                        {
                            cout << "NIE" << endl;
                            return 0;
                        }
                        czykrawedz=true;
                    }
                    if(!czykrawedz) dosprawdzenia.push_back(make_pair(punkty[j][0], punkty[j][1]));
                    goto a;
                }
            }
            for(int z=0; z<krawedzie.size(); z++)
            {
                //cout << "krawedz " << z << endl;
                if(punkty[j+1][0]==punkty[j][0])
                {
                    //cout << "jest punkt " << endl;
                    if(krawedzie[z][1]>punkty[j][1] && krawedzie[z][1]<punkty[j+1][i] && krawedzie[z][0]<punkty[j][0] && krawedzie[z][0]+krawedzie[z][2]>punkty[j][0])
                    {
                        //cout << "ta krawedz blokuje: " << krawedzie[z][1] << " " << krawedzie[z][0] << " " << krawedzie[z][2] << endl;
                        int bok=krawedzie[z][1]-punkty[j][1];
                        if(sprawdz(punkty, j, bok))
                        {
                            kwadraty[j]=bok;
                            dodane.push_back(make_pair(punkty[j][0], punkty[j][1]+bok));
                        dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]));
                        dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]+bok));
                            vector<int> tmp;
                            tmp.push_back(punkty[j][0]);
                            tmp.push_back(punkty[j][1]);
                            tmp.push_back(bok);
                            krawedzie.push_back(tmp);
                            vector<int> tmp2;
                            tmp2.push_back(punkty[j][0]);
                            tmp2.push_back(punkty[j][1]+bok);
                            tmp2.push_back(bok);
                            krawedzie.push_back(tmp2);
                            sort(krawedzie.begin(), krawedzie.end());
                        }
                        else
                        {
                            cout << "NIE" << endl;
                            return 0;
                        }
                        //cout <<"krawedz dla " << j << endl;
                        czykrawedz=true;
                        break;
                    }
                }
                else
                {
                    if(krawedzie[z][1]>punkty[j][1] && krawedzie[z][0]<punkty[j][0] && krawedzie[z][0]+krawedzie[z][2]>punkty[j][0])
                    {
                        int bok=krawedzie[z][1]-punkty[j][1];
                        if(sprawdz(punkty, j, bok))
                        {
                            kwadraty[j]=bok;
                            dodane.push_back(make_pair(punkty[j][0], punkty[j][1]+bok));
                            dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]));
                            dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]+bok));
                            vector<int> tmp;
                            tmp.push_back(punkty[j][0]);
                            tmp.push_back(punkty[j][1]);
                            tmp.push_back(bok);
                            krawedzie.push_back(tmp);
                            vector<int> tmp2;
                            tmp2.push_back(punkty[j][0]);
                            tmp2.push_back(punkty[j][1]+bok);
                            tmp2.push_back(bok);
                            krawedzie.push_back(tmp2);
                            sort(krawedzie.begin(), krawedzie.end());
                        }
                        else
                        {
                            cout << "NIE" << endl;
                            return 0;
                        }
                        czykrawedz=true;
                        break;
                    }
                }
            }
            if(punkty[j+1][0]==punkty[j][0] && !czykrawedz)
            {
                int bok=punkty[j+1][1]-punkty[j][1];
                if(sprawdz(punkty, j, bok))
                {
                    kwadraty[j]=bok;
                    dodane.push_back(make_pair(punkty[j][0], punkty[j][1]+bok));
                    dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]));
                    dodane.push_back(make_pair(punkty[j][0]+bok, punkty[j][1]+bok));
                    vector<int> tmp;
                    tmp.push_back(punkty[j][0]);
                    tmp.push_back(punkty[j][1]);
                    tmp.push_back(bok);
                    krawedzie.push_back(tmp);
                    vector<int> tmp2;
                    tmp2.push_back(punkty[j][0]);
                    tmp2.push_back(punkty[j][1]+bok);
                    tmp2.push_back(bok);
                    krawedzie.push_back(tmp2);
                    sort(krawedzie.begin(), krawedzie.end());
                }
                else
                {
                    cout << "NIE" << endl;
                    return 0;
                }
            }
            else
            {
                if(!czykrawedz) dosprawdzenia.push_back(make_pair(punkty[j][0], punkty[j][1]));
            }
        }
        a:
        /*for(int c=0; c<n; c++)
        {
            cout << "nr " << c << " : " << kwadraty[c] << endl;
        }
        cout << "do sprawdzenia " << endl;
        for(int c=0; c<dosprawdzenia.size(); c++)
        {
            cout << dosprawdzenia[c].second << " " << dosprawdzenia[c].first << endl;
        }
        cout << "krawedzie " << endl;
        for(int x=0; x<krawedzie.size(); x++)
        {
            cout << krawedzie[x][1] << " " << krawedzie[x][0] << " " << krawedzie[x][2] << endl;
        }

        cout << "dodane: " << endl;
        sort(dodane.begin(), dodane.end());
        for(int x=0; x<dodane.size(); x++)
        {
            pair<int, int> pom;
            pom.first=dodane[x].first;
            pom.second=dodane[x].second;
            set<pair<int, int> >::iterator it=doszukania.find(pom);
            if(it!=doszukania.end())
            {
                dodane.erase(dodane.begin()+x);
                x--;
            }
        }
        for(int x=0; x<dodane.size(); x++)
        {
            cout << dodane[x].second << " " << dodane[x].first << endl;
        }
        /*int obecny;
        int igrek=1;
        int bk;
        int bok;
        cout << "warunek " << dodane[dodane.size()-1].first << endl;
        int warunek=dodane[dodane.size()-1].first;
        if(dosprawdzenia.size()==0) goto za;
        for(igrek; igrek<=warunek; igrek++)
        {
            cout << "igrek " << igrek << endl;
            bool jest=false;
            for(int l=0; l<punkty.size(); l++)
            {
                if(punkty[l][0]==igrek && punkty[l][1]==dosprawdzenia[0].second)
                {
                    bk=punkty[l][2];
                    jest=true;
                    break;
                }
            }
            if(jest)
            {
                bok=punkty[bk][1];
                kwadraty[bk]=bok;
                dodane.push_back(make_pair(punkty[bk][0], punkty[bk][1]+bok));
                dodane.push_back(make_pair(punkty[bk][0]+bok, punkty[bk][1]));
                dodane.push_back(make_pair(punkty[bk][0]+bok, punkty[bk][1]+bok));
                vector<int> tmp;
                tmp.push_back(punkty[bk][0]);
                tmp.push_back(punkty[bk][1]);
                tmp.push_back(bok);
                krawedzie.push_back(tmp);
                vector<int> tmp2;
                tmp2.push_back(punkty[bk][0]);
                tmp2.push_back(punkty[bk][1]+bok);
                tmp2.push_back(bok);
                krawedzie.push_back(tmp2);
                sort(krawedzie.begin(), krawedzie.end());
                for(int x=0; x<dodane.size(); x++)
                {
                    pair<int, int> pom;
                    pom.first=dodane[x].first;
                    pom.second=dodane[x].second;
                    set<pair<int, int> >::iterator it=doszukania.find(pom);
                    if(it!=doszukania.end())
                    {
                        dodane.erase(dodane.begin()+x);
                        x--;
                    }
                }
            }
            else
            {
                for(int l=0; l<dodane.size(); l++)
                {
                    if(dodane[l].first==igrek && dodane[l].second==dosprawdzenia[0].second)
                    {
                        obecny=dodane[l].first;
                        break;
                    }
                }
            }
            if(igrek==warunek)
            {
                cout << "nie ma glownego" << endl;
                //cout << "obecny " << obecny << endl;
                bok=obecny-dosprawdzenia[0].first;
                //cout << "bok " << bok << endl;
                kwadraty[obecny]=bok;
                dodane.push_back(make_pair(dosprawdzenia[0].first, dosprawdzenia[0].second+bok));
                dodane.push_back(make_pair(dosprawdzenia[0].first+bok, dosprawdzenia[0].second));
                dodane.push_back(make_pair(dosprawdzenia[0].first+bok, dosprawdzenia[0].second+bok));
                vector<int> tmp;
                tmp.push_back(dosprawdzenia[0].first);
                tmp.push_back(dosprawdzenia[0].second);
                tmp.push_back(bok);
                krawedzie.push_back(tmp);
                vector<int> tmp2;
                tmp2.push_back(dosprawdzenia[0].first);
                tmp2.push_back(dosprawdzenia[0].second+bok);
                tmp2.push_back(bok);
                krawedzie.push_back(tmp2);
                sort(krawedzie.begin(), krawedzie.end());
                for(int x=0; x<dodane.size(); x++)
                {
                    pair<int, int> pom;
                    pom.first=dodane[x].first;
                    pom.second=dodane[x].second;
                    set<pair<int, int> >::iterator it=doszukania.find(pom);
                    if(it!=doszukania.end())
                    {
                        dodane.erase(dodane.begin()+x);
                        x--;
                    }
                }

            }
        }
        za:
        for(int y=0; y<dosprawdzenia.size(); y++)
        {
            bool czykrawedz=false;
            for(int z=0; z<krawedzie.size(); z++)
            {
                cout << "krawedz " << z << endl;
                if(krawedzie[z][1]>dosprawdzenia[y].second && krawedzie[z][0]<dosprawdzenia[y].first && krawedzie[z][0]+krawedzie[z][2]>dosprawdzenia[y].first)
                {
                    int bok=krawedzie[z][1]-dosprawdzenia[y].second;
                    //if(sprawdz(punkty, j, bok))
                    //{
                        kwadraty[j]=bok;
                        dodane.push_back(make_pair(dosprawdzenia[y].first, dosprawdzenia[y].second+bok));
                        dodane.push_back(make_pair(dosprawdzenia[y].first+bok, dosprawdzenia[y].second));
                        dodane.push_back(make_pair(dosprawdzenia[y].first+bok, dosprawdzenia[y].second+bok));
                        vector<int> tmp;
                        tmp.push_back(dosprawdzenia[y].first);
                        tmp.push_back(dosprawdzenia[y].second);
                        tmp.push_back(bok);
                        krawedzie.push_back(tmp);
                        vector<int> tmp2;
                        tmp2.push_back(dosprawdzenia[y].first);
                        tmp2.push_back(dosprawdzenia[y].second+bok);
                        tmp2.push_back(bok);
                        krawedzie.push_back(tmp2);
                        sort(krawedzie.begin(), krawedzie.end());
                        for(int x=0; x<dodane.size(); x++)
                        {
                            pair<int, int> pom;
                            pom.first=dodane[x].first;
                            pom.second=dodane[x].second;
                            set<pair<int, int> >::iterator it=doszukania.find(pom);
                            if(it!=doszukania.end())
                            {
                                dodane.erase(dodane.begin()+x);
                                x--;
                            }
                        }
                    /*}
                    else
                    {
                        cout << "NIE" << endl;
                        return 0;
                    }
                    czykrawedz=true;
                    break;
                }

            }*/

        cout << "TAK" << " ";
        for(int k=0; k<kwadraty.size(); k++)
        {
            cout << kwadraty[k] << " ";
        }

    }
}