#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

typedef struct _Tree
{
    int x,y,r;
    vector<struct _Tree *> child;
}Tree;

vector<int> x,y,r;
int rx,ry,rr,idx;

int fortress(int);
Tree *GenerateTree(int);
void ReleaseTree(Tree*);
int GetMaxDepth(Tree*,int);
int  Recursion(Tree*);
bool inCircle(int,int,int,int,int,int);

int main()
{
    int i,j;
    int c,n,t;

    cin >> c;
    for( i = 0; i < c; i++ ){
        cin >> n;
        for( j = 0; j < n; j++ ){
            cin >> t;
            x.push_back(t);
            cin >> t;
            y.push_back(t);
            cin >> t;
            r.push_back(t);
        }
        cout << fortress(n) << endl;
    }
    return 0;
}
int fortress(int n)
{
    Tree *head;
    int i,rn,tn;
    int ix,mx1,mx2;

    head = GenerateTree(n);
    rn = head->child.size();

    mx1 = GetMaxDepth(head,0)-1;
    ix = idx;
    for( i = mx2 = 0; i < rn; i++ ){
        if( i == ix ) continue;
        tn = GetMaxDepth(head->child[i],0);
        if( mx2 < tn ) mx2 = tn;
    }

    idx = 0;
    ReleaseTree(head);
    return mx1+mx2;
}
int GetMaxDepth(Tree *tr, int dep)
{
    int i,n,ret;
    int depth;

    n = tr->child.size();
    depth = 0;

    for( i = 0; i < n; i++ ){
        ret = GetMaxDepth(tr->child[i],dep+1);
        if( depth < ret ){
            depth = ret;
            if( !dep ) idx = i;
        }
    }
    return depth+1;
}
Tree *GenerateTree(int n)
{
    int i,tidx,mx;
    Tree *head;

    head = new Tree;
    for( i = mx = 0; i < n; i++ ){
        if( mx < r[i] ){
            mx = r[i];
            tidx = i;
        }
    }

    head->x = x[tidx];
    head->y = y[tidx];
    head->r = r[tidx];
    head->child.clear();
    x.erase(x.begin()+tidx);
    y.erase(y.begin()+tidx);
    r.erase(r.begin()+tidx);

    for( i = 0; i < n-1; i++ ){
        rx = x[i];
        ry = y[i];
        rr = r[i];
        Recursion(head);
    }

    x.clear();y.clear();r.clear();
    return head;
}
void ReleaseTree(Tree *tr)
{
    int i,n;

    n = tr->child.size();
    for( i = 0; i < n; i++ )
        ReleaseTree(tr->child[i]);

    delete tr;
}
int Recursion(Tree *tr)
{
    int i,n,ret;
    Tree *t;

    if( inCircle(rx,ry,rr,tr->x,tr->y,tr->r) ){
        n = tr->child.size();
        for( i = 0; i < n; i++ ){
            ret = Recursion(tr->child[i]);
            if( ret == 1 ) return 1;
            else if( ret == 2 ){
                t = new Tree;
                t->x = rx;
                t->y = ry;
                t->r = rr;
                t->child.push_back(tr->child[i]);
                tr->child.erase(tr->child.begin()+i);
                tr->child.push_back(t);
                return 1;
            }
        }
        t = new Tree;
        t->x = rx;
        t->y = ry;
        t->r = rr;
        t->child.clear();
        tr->child.push_back(t);
        return 1;
    }
    else if( inCircle(tr->x,tr->y,tr->r,rx,ry,rr) ) return 2;

    return 0;
}
bool inCircle(int x1, int y1, int r1, int x2, int y2, int r2)
{
    double t;

    if( r1 >= r2 ) return false;
    else{
        t = sqrt( (double)(((x2-x1)*(x2-x1)) + ((y2-y1)*(y2-y1))) );
        if( (double)r2 > t ) return true;
    }
    return false;
}