#include <bits/stdc++.h>
using namespace std;

typedef double dbl;

const dbl EPS = 1e-8;
int sgn(dbl a) { return (a > EPS) - (a < -EPS); }
int sgn(dbl a, dbl b) { return sgn(a-b); }

template <typename T> T sq(T a) { return a*a; }

const int MAXN = 2.1e4;

int curX;

struct circle {
    int a, b, r;

    circle() {}

    circle(int a_, int b_, int r_) : a(a_), b(b_), r(r_) {}

    dbl get_y(int t) {
        dbl y = t * sqrt(sq(r) - sq(curX-a)) + b;
        return y;
    }
} circs[MAXN];

struct event {
    int x, ind;

    event() {}

    event(int x_, int ind_) : x(x_), ind(ind_) {}

    bool operator < (const event& o) const {
        return make_pair(x, ind) < make_pair(o.x, o.ind);
    }
};

int sgn(int i) { return (i >= 0) - (i < 0); }
int realind(int i) { return max(i, ~i); }

struct cmp {
    bool operator () (int i, int j) const {
        dbl yi = circs[realind(i)].get_y(sgn(i));
        dbl yj = circs[realind(j)].get_y(sgn(j));
        int s = sgn(yi, yj);
        if (s == 0) {
            return i < j;
        } else {
			return s < 0;
        }
    }
};

vector<int> adj[MAXN];
int depth[MAXN];
int par[MAXN];

int dfs_grundy(int cur) {
    int res = 0;
    for (int z = 0; z < int(adj[cur].size()); z++) {
        int nxt = adj[cur][z];
        res ^= dfs_grundy(nxt)+1;
    }
    return res;
}

bool go() {
    int N; cin >> N;

    circs[0] = circle(0, 0, int(4.1e4));
    N++;
    for (int i = 1; i < N; i++) {
        int a, b, r; cin >> a >> b >> r;
        circs[i] = circle(a, b, r);
    }

    vector<event> evts; evts.reserve(2*N);
    for (int i = 0; i < N; i++) {
        int a = circs[i].a;
        int r = circs[i].r;
        evts.push_back(event(a-r, i));
        evts.push_back(event(a+r, ~i));
    }
    sort(evts.begin(), evts.end());

    for (int i = 0; i < N; i++) {
        adj[i].clear();
        depth[i] = -1;
        par[i] = -1;
    }
    depth[0] = 0;

    set<int, cmp> arcs;
    for (int z = 0; z < 2*N; z++) {
        event& evt = evts[z];
        curX = evt.x;
        int i = evt.ind;

        if (i < 0) {
            arcs.erase(i);
            arcs.erase(~i);
        } else {
            set<int, cmp>::iterator hi = arcs.lower_bound(i);
            set<int, cmp>::iterator lo = hi;
            if (hi == arcs.end() || lo == arcs.begin()) {
				// root
            } else {
                --lo;

                int ilo = realind(*lo);
                int ihi = realind(*hi);
                if (ilo == ihi) {
                    adj[ilo].push_back(i);
                    depth[i] = depth[ilo]+1;
                    par[i] = ilo;
                } else {
                    if (depth[ilo] > depth[ihi]) swap(ilo, ihi);
					adj[par[ihi]].push_back(i);
                    depth[i] = depth[par[ihi]]+1;
                    par[i] = par[ihi];
                }
            }

            arcs.insert(i);
            arcs.insert(~i);
        }
    }

    return bool(dfs_grundy(0));
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);

    int T; cin >> T;
    while (T--) {
        cout << (go() ? "Alice" : "Bob") << '\n';
    }

    return 0;
}