description: The Olympic Games have just started and Federico is eager to watch the marathon race.
  
  There will be n athletes, numbered from 1 to n, competing in the marathon, and all of them have taken part in 5 important marathons, numbered from 1 to 5, in the past. For each 1≤ i≤ n and 1≤ j≤ 5, Federico remembers that athlete i ranked r_{i,j}-th in marathon j (e.g., r_{2,4}=3 means that athlete 2 was third in marathon 4).
  
  Federico considers athlete x superior to athlete y if athlete x ranked better than athlete y in at least 3 past marathons, i.e., r_{x,j}<r_{y,j} for at least 3 distinct values of j.
  
  Federico believes that an athlete is likely to get the gold medal at the Olympics if he is superior to all other athletes.
  
  Find any athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes), or determine that there is no such athlete.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
  
  The first line of each test case contains a single integer n (1≤ n≤ 50 000) — the number of athletes.
  
  Then n lines follow, each describing the ranking positions of one athlete.
  
  The i-th of these lines contains the 5 integers r_{i,1},\,r_{i,2},\,r_{i,3},\,r_{i,4},  r_{i,5} (1≤ r_{i,j}≤ 50 000) — the ranking positions of athlete i in the past 5 marathons. It is guaranteed that, in each of the 5 past marathons, the n athletes have distinct ranking positions, i.e., for each 1≤ j≤ 5, the n values r_{1,j},  r_{2, j},  ...,  r_{n, j} are distinct.
  
  It is guaranteed that the sum of n over all test cases does not exceed 50 000.
  
  Output
  
  For each test case, print a single integer — the number of an athlete who is likely to get the gold medal (that is, an athlete who is superior to all other athletes). If there are no such athletes, print -1. If there is more than such one athlete, print any of them.
  
  Example
  
  Input
  
  
  4
  1
  50000 1 50000 50000 50000
  3
  10 10 20 30 30
  20 20 30 10 10
  30 30 10 20 20
  3
  1 1 1 1 1
  2 2 2 2 2
  3 3 3 3 3
  6
  9 5 3 7 1
  7 4 1 6 8
  5 6 7 3 2
  6 7 8 8 6
  4 2 2 4 5
  8 3 6 9 4
  
  
  Output
  
  
  1
  -1
  1
  5
  
  Note
  
  Explanation of the first test case: There is only one athlete, therefore he is superior to everyone else (since there is no one else), and thus he is likely to get the gold medal.
  
  Explanation of the second test case: There are n=3 athletes. 
  
    * Athlete 1 is superior to athlete 2. Indeed athlete 1 ranks better than athlete 2 in the marathons 1, 2 and 3. 
    * Athlete 2 is superior to athlete 3. Indeed athlete 2 ranks better than athlete 3 in the marathons 1, 2, 4 and 5. 
    * Athlete 3 is superior to athlete 1. Indeed athlete 3 ranks better than athlete 1 in the marathons 3, 4 and 5. 
  
  
  
  Explanation of the third test case: There are n=3 athletes. 
  
    * Athlete 1 is superior to athletes 2 and 3. Since he is superior to all other athletes, he is likely to get the gold medal. 
    * Athlete 2 is superior to athlete 3. 
    * Athlete 3 is not superior to any other athlete. 
  
  
  
  Explanation of the fourth test case: There are n=6 athletes. 
  
    * Athlete 1 is superior to athletes 3, 4, 6. 
    * Athlete 2 is superior to athletes 1, 4, 6. 
    * Athlete 3 is superior to athletes 2, 4, 6. 
    * Athlete 4 is not superior to any other athlete. 
    * Athlete 5 is superior to athletes 1, 2, 3, 4, 6. Since he is superior to all other athletes, he is likely to get the gold medal. 
    * Athlete 6 is only superior to athlete 4. 
solution: import java.util.*;
  
  import java.io.*;
  import java.math.*;
  import java.awt.geom.*;
  
  import static java.lang.Math.*;
  
  public class Solution implements Runnable {
  
  	long mod1 = (long) 1e9 + 7;
  	int mod2 = 998244353;
  
  	public void solve() throws Exception {
  		int t = sc.nextInt();
  		while (t-- > 0) {
  			int n=sc.nextInt();
  			
  			int arr[][] = new int[n][5];
  			
  			for(int i=0;i<n;i++) {
  				arr[i] = sc.readArray(5);
  			}
  			int winner[] = new int[n];
  			int ans=0;
  			if(n==1) {
  				out.println(1);
  				continue;
  			}
  			HashSet<Integer> set=new HashSet<>();
  			for(int i=0;i<n;i++) {
  				set.add(i);
  			}
  			
  			while(set.size()!=1) {
  //				out.println(set.size());
  				ArrayList<Integer> li = new ArrayList<>();
  				for(int i:set) {
  					li.add(i);
  				}
  				for(int i=0;i<li.size();i+=2) {
  					if(i+1==li.size()) continue;
  					int s=0,f=0;
  					for(int j=0;j<5;j++) {
  						if(arr[li.get(i)][j]>arr[li.get(i+1)][j]) {
  							s++;
  						}
  						else {
  							f++;
  						}
  					}
  					if(s>f) {
  						set.remove(li.get(i));
  					}
  					else {
  						set.remove(li.get(i+1));
  					}
  				}
  				
  			}
  			int temp=-1;
  			for(int i:set) {
  				temp=i;
  			}
  			boolean check=true;
  			for(int i=0;i<n;i++) {
  				if(i==temp) continue;
  				int s=0,f=0;
  				for(int j=0;j<5;j++) {
  					if(arr[i][j]>arr[temp][j]) {
  						s++;
  					}
  					else {
  						f++;
  					}
  				}
  				if(f<s) {
  					continue;
  				}
  				else {
  					check=false;
  				}
  			}
  			
  			out.println(check?temp+1:-1);
  			
  
  		}
  
  	}
  
  	static long gcd(long a, long b) {
  		if (a == 0)
  			return b;
  		return gcd(b % a, a);
  	}
  
  	static void sort(int[] a) {
  		ArrayList<Integer> l = new ArrayList<>();
  		for (int i : a)
  			l.add(i);
  		Collections.sort(l);
  		for (int i = 0; i < a.length; i++)
  			a[i] = l.get(i);
  	}
  
  	static long ncr(int n, int r, long p) {
  		if (r > n)
  			return 0l;
  		if (r > n - r)
  			r = n - r;
  
  		long C[] = new long[r + 1];
  
  		C[0] = 1;
  
  		for (int i = 1; i <= n; i++) {
  
  			for (int j = Math.min(i, r); j > 0; j--)
  				C[j] = (C[j] + C[j - 1]) % p;
  		}
  		return C[r] % p;
  	}
  
  	void sieveOfEratosthenes(boolean prime[], int size) {
  		for (int i = 0; i < size; i++)
  			prime[i] = true;
  
  		for (int p = 2; p * p < size; p++) {
  			if (prime[p] == true) {
  				for (int i = p * p; i < size; i += p)
  					prime[i] = false;
  			}
  		}
  	}
  
  	static int LowerBound(int a[], int x) { // smallest index having value >= x
  		int l = -1, r = a.length;
  		while (l + 1 < r) {
  			int m = (l + r) >>> 1;
  			if (a[m] >= x)
  				r = m;
  			else
  				l = m;
  		}
  		return r;
  	}
  
  	static int UpperBound(int a[], int x) {// biggest index having value <= x
  		int l = -1, r = a.length;
  		while (l + 1 < r) {
  			int m = (l + r) >>> 1;
  			if (a[m] <= x)
  				l = m;
  			else
  				r = m;
  		}
  		return l + 1;
  	}
  
  	public long power(long x, long y, long p) {
  		long res = 1;
  		// out.println(x+" "+y);
  		x = x % p;
  		if (x == 0)
  			return 0;
  
  		while (y > 0) {
  			if ((y & 1) == 1)
  				res = (res * x) % p;
  			y = y >> 1;
  			x = (x * x) % p;
  		}
  		return res;
  	}
  
  	static Throwable uncaught;
  
  	BufferedReader in;
  	FastScanner sc;
  	PrintWriter out;
  
  	@Override
  	public void run() {
  		try {
  			in = new BufferedReader(new InputStreamReader(System.in));
  			out = new PrintWriter(System.out);
  			sc = new FastScanner(in);
  			solve();
  		} catch (Throwable uncaught) {
  			Solution.uncaught = uncaught;
  		} finally {
  			out.close();
  		}
  	}
  
  	public static void main(String[] args) throws Throwable {
  		Thread thread = new Thread(null, new Solution(), "", (1 << 26));
  		thread.start();
  		thread.join();
  		if (Solution.uncaught != null) {
  			throw Solution.uncaught;
  		}
  	}
  
  }
  
  class FastScanner {
  
  	BufferedReader in;
  	StringTokenizer st;
  
  	public FastScanner(BufferedReader in) {
  		this.in = in;
  	}
  
  	public String nextToken() throws Exception {
  		while (st == null || !st.hasMoreTokens()) {
  			st = new StringTokenizer(in.readLine());
  		}
  		return st.nextToken();
  	}
  
  	public int nextInt() throws Exception {
  		return Integer.parseInt(nextToken());
  	}
  
  	public int[] readArray(int n) throws Exception {
  		int[] a = new int[n];
  		for (int i = 0; i < n; i++)
  			a[i] = nextInt();
  		return a;
  	}
  
  	public long nextLong() throws Exception {
  		return Long.parseLong(nextToken());
  	}
  
  	public double nextDouble() throws Exception {
  		return Double.parseDouble(nextToken());
  	}
  
  }