#include <bits/stdc++.h>

#define long long long
#define Integer_MAX_VALUE 0x7fffffff
#define Integer_MIN_VALUE 0x80000000
#define Long_MAX_VALUE 0x7fffffffffffffffL
#define Long_MIN_VALUE 0x8000000000000000L

using namespace std;

struct Edge
{
    int id, u, v, ans = -1;

    int get_next(int now)
    {
        return now != u ? u : v;
    }
};

struct Node
{
    vector<Edge *> edge;
};

struct Solution
{
    Node *nodes;
    bool *visited;

    void run()
    {
        int n;
        cin >> n;

        nodes = new Node[n];

        Edge *edges[n - 1];

        for (int i = 0; i < n - 1; i++)
        {
            edges[i] = new Edge();
            edges[i]->id = i;
            cin >> edges[i]->u >> edges[i]->v;
            edges[i]->u--;
            edges[i]->v--;

            nodes[edges[i]->u].edge.push_back(edges[i]);
            nodes[edges[i]->v].edge.push_back(edges[i]);
        }

        for (int i = 0; i < n; i++)
        {
            if (nodes[i].edge.size() >= 3)
            {
                cout << -1 << endl;
                return;
            }
        }

        int end_pos = 0;
        visited = new bool[n]{false};
        while (nodes[end_pos].edge.size() != 1)
        {
            end_pos++;
        }

        visited = new bool[n]{false};
        dfs(end_pos, 2);

        for (int i = 0; i < n - 1; i++)
        {
            cout << edges[i]->ans << " ";
        }
        cout << endl;
    }

    void dfs(int now, int d)
    {
        visited[now] = true;
        for (Edge *edge : nodes[now].edge)
        {
            if (visited[edge->get_next(now)])
            {
                continue;
            }

            edge->ans = d;
            dfs(edge->get_next(now), d ^ 1);
        }
    }
};

int main()
{
    ios_base::sync_with_stdio(false);

    Solution solution = Solution();

    int t;
    cin >> t;
    for (int i = 0; i < t; i++)
    {
        solution.run();
    }
    return 0;
}