//God's Grace
#include <iostream>
#include <map>
#include <algorithm>
#include <queue>
#include <list>
#include <string>
#include <cmath>
#include <stack>
#include <cstdio>
#include <fstream>
#include <climits>
#include <set>
#include <vector>
#include <tuple>
#include <cstring>
#include <functional>
#include <utility>
#include <iomanip>

using namespace std;

#define endl '\n'
#define f(k,a,b) for(int k=(a);k<(b);k++)
#define vi vector <int>
#define vvi vector <vector <int> >
#define vii vector <pair <int, int > >
#define int long long
#define lli long long
#define pii pair <int,int>
#define piii pair< pair<lli,lli>, lli >
#define fsd fflush(stdout);
#define pb(x) push_back(x)
#define fast_io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
//#define tdef typedef
#define ret return
const int fix = (int)1e9 + 7;

int po2(lli a){double temp = a;if(log2(temp)==(int)log2(temp))return log2(temp);return -1;}
void tc(int i){cout<<"Case #"<<i+1<<": ";}
void yes(){cout<<"YES"<<endl;}
void no(){cout<<"NO"<<endl;}
void impb(){cout<<"IMPOSSIBLE"<<endl;}
int ct(){int t;scanf("%lld",&t);return t;}
int gcd(int a, int b) {if (b == 0)return a;return gcd(b, a % b);}
int pwr(int a, int b){ int x=1, y=a; while(b>0){if(b%2) x = (x*y)%fix; y=(y*y)%fix; b/=2;} return x;}
int pmodinv(int a){return pwr(a,fix-2);}

vvi adj;


const int N = 1e5+5;
bool visited[N]= {};
queue <int> q;

int comanc(int u, int v,int parent[]){
	while(u^v){
		if(u==1||v==1)
			return 1;
		u = parent[u];
		v = parent[v];
	}

	return u;
}
int x;

int max(int a, int b){
	if (a>b)
		return a;
	return b;
}

vector <int> factorial((int)4002);

int nCr(int n, int k){
	return (factorial[n]*((pmodinv(factorial[k])*pmodinv(factorial[n-k]))%fix))%fix;
}


/******************** -- DSU -- ********************/
int dsu_par[N];
int sze[N];
void make_set(int n){
	f(j,1,n+1){
		dsu_par[j]=j;
		sze[j]=1;
	}
}

int find_set(int a){
	if(dsu_par[a]==a)
		return a;
	return dsu_par[a] = find_set(dsu_par[a]);
}

void union_set(int a, int b){
	a = find_set(a);
	    b = find_set(b);
	    if (a^b) {
	        if (sze[a] < sze[b])
	            swap(a, b);
	        dsu_par[b] = a;
	       sze[a] += sze[b];

	    }
}

/********************* LCA **********************/
map <pii, int> mp;
vvi up;
vi tin, tout;
int dfs_timer=0;
int lim;
int dist[N]={};
void _dfs(int v, int par){
	tin[v] = ++dfs_timer;
	up[v][0] = par;
	f(j,1,lim+1)
	up[v][j] = up[up[v][j-1]][j-1];

	for(int u:adj[v]){
		if(u^par){
			dist[u] = dist[v] + mp.find(pii(u,v))->second;
			//parent[u]=v;
			_dfs(u,v);
		}
	}

	tout[v] = ++dfs_timer;
}

bool is_anc(int u, int v){ return tin[u] <= tin[v] && tout[u] >= tout[v];}
int lca(int u, int v){
	if(is_anc(u,v))
		return u;
	if(is_anc(v,u))
		return v;
	for(int i=lim;i>=0;i--)
		if(is_anc(up[u][i],v)^1)
			u = up[u][i];

	return up[u][0];
}




/*bool check(int start, int end, vi& e,vi& r,int sum){

	for(int j=start;j<=end;j++){
		sum-=e[j];
		if(sum<r[j]){
			return false;
		}
		sum+=e[j];
	}
	return true;
}*/

int bisearch(vi& e,vi&r,vi& v,int lo,int hi,int target){
	while(lo<hi){
		int mid = lo + (hi-lo)/2;
		int index = v[mid];
		if(e[index]+r[index]>=target)
			hi = mid;
		else
			lo = mid +1;
	}

	ret lo;
}

int solve3(){

	int n=ct();
	vi e(n);
	vi r(n);
	int sum1 = 0;
	int val =0;
	priority_queue <pii> pq;
	priority_queue <pii> qp;
	f(j,0,n){e[j]=ct(); r[j]=ct();sum1+=e[j];pq.push(pii(e[j]+r[j],e[j]));
	qp.push(pii(e[j]+r[j],j));}

	int sum2 = sum1;

	bool flag=1;
	while(!pq.empty()&&flag){
		if(sum1<pq.top().first){
			sum1-=pq.top().second;
			pq.pop();
		}else{
			flag=0;
		}
	}

	if(pq.size()){
		cout<<n-pq.size()<<" INDEFINITELY";
	}else{
		int ma = sum2;
		int temp = sum2;
		int act = 0;
		int cnt = 0;
		f(j,0,n){

			if(sum2>=e[j]+r[j]){
				temp+=e[j];
			}else{
				temp-=e[j];
				cnt++;
				sum2-=e[j];
			}
			if(temp>=ma){

/*				if(sum2<e[j]+r[j]){
					cnt--;
				}*/
				if(temp==ma){
					act = min(act,cnt);
				}else{
					act =cnt;
				}

				ma = temp;
			}
			//ma = max(ma,temp);
		}


		cout<<act<<" "<<ma;

/*		vector <int> v(n);
		f(j,0,n){
			v[j] = qp.top().second;
			qp.pop();
		}
		reverse(v.begin(),v.end());*/

	}


}

int solve4(){

}

int32_t main() {


	int t = ct();
	f(ii,0,t){

		tc(ii);

		solve3();
		cout<<endl;
	}



	ret 0;
}