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

#define PI 3.1415926
//전체 영역을 커버하는 것이 불가능 할 경우 IMP를 리턴합니다.
#define IMP 200000000

using namespace std;

//초소의 위치 정보와 감시영역을 저장하는 클래스 입니다.
class GuardPoint{
    private:
        double y,x,r;
    public:
        GuardPoint(){}
        GuardPoint(double ypos,double xpos,double radix)
        :y(ypos),x(xpos),r(radix){}
        double& GetY(void){return y;}
        double& GetX(void){return x;}
        double& GetR(void){return r;}
};

//구간을 시작점 오름차순으로 정렬 할 때 쓰일 비교함수 입니다.
class COMPARE{
    public:
        bool operator()(const pair<double,double>& r1,const pair<double,double>& r2){
            return r1.first<r2.first;
        }
};

//N개의 초소를 의미합니다.
int N;
//변수 입력에 쓰일 임시 변수 입니다.
double T1,T2,T3;
//초소를 저장할 벡터입니다.
vector< GuardPoint > GP;
//초소를 구간 범위 pair로 저장할 벡터입니다.
vector< pair<double,double> > I;

//간단한 max함수 입니다.
template<typename T>
T bigger(const T r1,const T r2){return (r1>r2)? r1:r2;}
//간단한 min함수 입니다.
template<typename T>
T smaller(const T r1,const T r2){return (r1<r2)? r1:r2;}

//초소의 정보를 구간정보로 변환 시켜주는 함수 입니다.
//atan 대신 asin을 사용하였습니다.
//loc은 항상 [0,2pi]를 만족하게 구해지고,range는 [0,pi]를 만족하게 구해집니다.
void mk_interval(void){
    double loc,range;
    for(int i=0;i<GP.size();i++){
        //loc가 1사분면의 각인 경우.
        if(GP[i].GetX()>0&&GP[i].GetY()>=0){
            loc=asin(GP[i].GetY()/8);
        }
        //loc가 2사분면의 각인 경우.
        else if(GP[i].GetX()<=0&&GP[i].GetY()>0){
            loc=PI-asin(GP[i].GetY()/8);
        }
        //loc가 3사분면의 각인 경우.
        else if(GP[i].GetX()<0&&GP[i].GetY()<=0){
            loc=PI-asin(GP[i].GetY()/8);
        }
        //loc가 4사분면의 각인 경우.
        else{loc=2*PI+asin(GP[i].GetY()/8);}
        //몇사분면이냐에 관계없이 range는 아래와 같습니다.
        range=2*asin(GP[i].GetR()/16);
        //I에 저장합니다.
        I.push_back(pair<double,double>(loc-range,loc+range));
    }
    return;
}

//동경을 나타내는 radian값 po가 주어지고, 범위가 iv로 주어질때
//범위 iv를 1바퀴(2pi)만큼 변화 시켜보면서 
//po가 iv에 속하는 지를 반환합니다.
bool is_include(const double po,const pair<double,double>& iv){
    bool ret=false;
    for(int i=0;i<2;i++){if(iv.first<=po+2*PI*i&&po+2*PI*i<iv.second){ret=true;break;}}
    return ret;
}

//덮개들이 있을 때, 직선을 덮는 문제라고 생각하여 답을 내는 함수 입니다.
//직선의 시작점과 종료점이 주어집니다.
int mk_linear(double sp,double ep){
    int ret=0,idx=0;
    double biggest;
    //직선이 남아 있을때 까지 반복합니다.
    while(sp<ep){
        //최대로 멀리까지 덮을 때의 끝점 값입니다.
        //최대값을 찾을 것이므로 처음엔 -1로 초기화 합니다.
        biggest=-1;
        //구간들을 순회합니다.
        //greedy choice property에 따라 idx를 0부터 순회 할 필요는 없습니다.
        for(;idx<I.size();idx++){
            //직선의 시작점이 I[idx]에 속한다면, 그들중 가장 멀리서 끝나는 덮개를 찾습니다.
            if(is_include(sp,I[idx])){
                biggest=bigger(biggest,fmod(I[idx].second,2*PI));
        }}
        //어떠한 덮개도 찾지 못했다면 IMP를 리턴합니다.
        if(biggest==-1){return IMP;}
        //위의 논리에 맞게 sp를 수정해줍니다.
        sp=biggest;
        //하나를 사용했으니 리턴값도 1 증가 합니다.
        ret++;
    }
    return ret;
}

//답을 반환하는 함수입니다.
int mk_answer(void){
    int temp,ret=IMP;
    //모든 저장된 덮개(구간)들을 순회하면서, 아래를 실행합니다.
    for(int i=0;i<I.size();i++){
        //덮개가 0 radian을 덮는 경우
        if(is_include(0,I[i])){
            //[0,2pi]인 직선을 덮는 문제로 변형해줍니다.
            //mk_linear에 직선의 시작점과 종료점을 전달하여 줍니다.
            temp=mk_linear(fmod(I[i].second,2*PI),fmod(2*PI+I[i].first,2*PI));
            //그중 최솟값을 찾아줍니다.
            ret=smaller(ret,1+temp);
    }}
    return ret;
}

int main(void){
    int TC;
    cin>>TC;
    while(TC--){
        GP.clear();
        I.clear();
        //입력을 받습니다.
        cin>>N;
        for(int i=0;i<N;i++){
            cin>>T1>>T2>>T3;
            GP.push_back(GuardPoint(T1,T2,T3));
        }
        //초소를 구간으로 변경합니다.
        mk_interval();
        //구간의 시작점 오름차순으로 정렬합니다.
        sort(I.begin(),I.end(),COMPARE());
        cout<<"ANSWER : "<<mk_answer()<<endl;
    }
    return 0;
}