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: # ---------------------------iye ha aam zindegi---------------------------------------------
  import math
  import random
  import heapq,bisect
  import sys
  from collections import deque, defaultdict
  from fractions import Fraction
  import sys
  import threading
  from collections import defaultdict
  threading.stack_size(10**8)
  mod = 10 ** 9 + 7
  mod1 = 998244353
  
  # ------------------------------warmup----------------------------
  import os
  import sys
  from io import BytesIO, IOBase
  sys.setrecursionlimit(300000)
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  # -------------------game starts now----------------------------------------------------import math
  class TreeNode:
      def __init__(self, k, v):
          self.key = k
          self.value = v
          self.left = None
          self.right = None
          self.parent = None
          self.height = 1
          self.num_left = 1
          self.num_total = 1
  
  
  class AvlTree:
  
      def __init__(self):
          self._tree = None
  
      def add(self, k, v):
          if not self._tree:
              self._tree = TreeNode(k, v)
              return
          node = self._add(k, v)
          if node:
              self._rebalance(node)
  
      def _add(self, k, v):
          node = self._tree
          while node:
              if k < node.key:
                  if node.left:
                      node = node.left
                  else:
                      node.left = TreeNode(k, v)
                      node.left.parent = node
                      return node.left
              elif node.key < k:
                  if node.right:
                      node = node.right
                  else:
                      node.right = TreeNode(k, v)
                      node.right.parent = node
                      return node.right
              else:
                  node.value = v
                  return
  
      @staticmethod
      def get_height(x):
          return x.height if x else 0
  
      @staticmethod
      def get_num_total(x):
          return x.num_total if x else 0
  
      def _rebalance(self, node):
  
          n = node
          while n:
              lh = self.get_height(n.left)
              rh = self.get_height(n.right)
              n.height = max(lh, rh) + 1
              balance_factor = lh - rh
              n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
              n.num_left = 1 + self.get_num_total(n.left)
  
              if balance_factor > 1:
                  if self.get_height(n.left.left) < self.get_height(n.left.right):
                      self._rotate_left(n.left)
                  self._rotate_right(n)
              elif balance_factor < -1:
                  if self.get_height(n.right.right) < self.get_height(n.right.left):
                      self._rotate_right(n.right)
                  self._rotate_left(n)
              else:
                  n = n.parent
  
      def _remove_one(self, node):
          """
          Side effect!!! Changes node. Node should have exactly one child
          """
          replacement = node.left or node.right
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = replacement
              else:
                  node.parent.right = replacement
              replacement.parent = node.parent
              node.parent = None
          else:
              self._tree = replacement
              replacement.parent = None
          node.left = None
          node.right = None
          node.parent = None
          self._rebalance(replacement)
  
      def _remove_leaf(self, node):
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = None
              else:
                  node.parent.right = None
              self._rebalance(node.parent)
          else:
              self._tree = None
          node.parent = None
          node.left = None
          node.right = None
  
      def remove(self, k):
          node = self._get_node(k)
          if not node:
              return
          if AvlTree._is_leaf(node):
              self._remove_leaf(node)
              return
          if node.left and node.right:
              nxt = AvlTree._get_next(node)
              node.key = nxt.key
              node.value = nxt.value
              if self._is_leaf(nxt):
                  self._remove_leaf(nxt)
              else:
                  self._remove_one(nxt)
              self._rebalance(node)
          else:
              self._remove_one(node)
  
      def get(self, k):
          node = self._get_node(k)
          return node.value if node else -1
  
      def _get_node(self, k):
          if not self._tree:
              return None
          node = self._tree
          while node:
              if k < node.key:
                  node = node.left
              elif node.key < k:
                  node = node.right
              else:
                  return node
          return None
  
      def get_at(self, pos):
          x = pos + 1
          node = self._tree
          while node:
              if x < node.num_left:
                  node = node.left
              elif node.num_left < x:
                  x -= node.num_left
                  node = node.right
              else:
                  return (node.key, node.value)
          raise IndexError("Out of ranges")
  
      @staticmethod
      def _is_left(node):
          return node.parent.left and node.parent.left == node
  
      @staticmethod
      def _is_leaf(node):
          return node.left is None and node.right is None
  
      def _rotate_right(self, node):
          if not node.parent:
              self._tree = node.left
              node.left.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.left
              node.left.parent = node.parent
          else:
              node.parent.right = node.left
              node.left.parent = node.parent
          bk = node.left.right
          node.left.right = node
          node.parent = node.left
          node.left = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      def _rotate_left(self, node):
          if not node.parent:
              self._tree = node.right
              node.right.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.right
              node.right.parent = node.parent
          else:
              node.parent.right = node.right
              node.right.parent = node.parent
          bk = node.right.left
          node.right.left = node
          node.parent = node.right
          node.right = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      @staticmethod
      def _get_next(node):
          if not node.right:
              return node.parent
          n = node.right
          while n.left:
              n = n.left
          return n
  
  
  # -----------------------------------------------binary seacrh tree---------------------------------------
  class SegmentTree1:
      def __init__(self, data, default=2*10**9, func=lambda a, b: min(a,b)):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------game starts now----------------------------------------------------import math
  class SegmentTree:
      def __init__(self, data, default=-1, func=lambda a, b: max(a,b)):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------------------iye ha chutiya zindegi-------------------------------------
  class Factorial:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorials = [1, 1]
          self.invModulos = [0, 1]
          self.invFactorial_ = [1, 1]
  
      def calc(self, n):
          if n <= -1:
              print("Invalid argument to calculate n!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.factorials):
              return self.factorials[n]
          nextArr = [0] * (n + 1 - len(self.factorials))
          initialI = len(self.factorials)
          prev = self.factorials[-1]
          m = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = prev * i % m
          self.factorials += nextArr
          return self.factorials[n]
  
      def inv(self, n):
          if n <= -1:
              print("Invalid argument to calculate n^(-1)")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          p = self.MOD
          pi = n % p
          if pi < len(self.invModulos):
              return self.invModulos[pi]
          nextArr = [0] * (n + 1 - len(self.invModulos))
          initialI = len(self.invModulos)
          for i in range(initialI, min(p, n + 1)):
              next = -self.invModulos[p % i] * (p // i) % p
              self.invModulos.append(next)
          return self.invModulos[pi]
  
      def invFactorial(self, n):
          if n <= -1:
              print("Invalid argument to calculate (n^(-1))!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.invFactorial_):
              return self.invFactorial_[n]
          self.inv(n)  # To make sure already calculated n^-1
          nextArr = [0] * (n + 1 - len(self.invFactorial_))
          initialI = len(self.invFactorial_)
          prev = self.invFactorial_[-1]
          p = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
          self.invFactorial_ += nextArr
          return self.invFactorial_[n]
  
  
  class Combination:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorial = Factorial(MOD)
  
      def ncr(self, n, k):
          if k < 0 or n < k:
              return 0
          k = min(k, n - k)
          f = self.factorial
          return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
  
  
  # --------------------------------------iye ha combinations ka zindegi---------------------------------
  def powm(a, n, m):
      if a == 1 or n == 0:
          return 1
      if n % 2 == 0:
          s = powm(a, n // 2, m)
          return s * s % m
      else:
          return a * powm(a, n - 1, m) % m
  
  
  # --------------------------------------iye ha power ka zindegi---------------------------------
  def sort_list(list1, list2):
      zipped_pairs = zip(list2, list1)
  
      z = [x for _, x in sorted(zipped_pairs)]
  
      return z
  
  
  # --------------------------------------------------product----------------------------------------
  def product(l):
      por = 1
      for i in range(len(l)):
          por *= l[i]
      return por
  
  
  # --------------------------------------------------binary----------------------------------------
  def binarySearchCount(arr, n, key):
      left = 0
      right = n - 1
  
      count = 0
  
      while (left <= right):
          mid = int((right + left) / 2)
  
          # Check if middle element is
          # less than or equal to key
          if (arr[mid] < key):
              count = mid + 1
              left = mid + 1
  
          # If key is smaller, ignore right half
          else:
              right = mid - 1
  
      return count
  
  
  # --------------------------------------------------binary----------------------------------------
  def countdig(n):
      c = 0
      while (n > 0):
          n //= 10
          c += 1
      return c
  def binary(x, length):
      y = bin(x)[2:]
      return y if len(y) >= length else "0" * (length - len(y)) + y
  
  def countGreater(arr, n, k):
      l = 0
      r = n - 1
  
      # Stores the index of the left most element
      # from the array which is greater than k
      leftGreater = n
  
      # Finds number of elements greater than k
      while (l <= r):
          m = int(l + (r - l) / 2)
          if (arr[m] >= k):
              leftGreater = m
              r = m - 1
  
          # If mid element is less than
          # or equal to k update l
          else:
              l = m + 1
  
      # Return the count of elements
      # greater than k
      return (n - leftGreater)
  
  class TrieNode:
      def __init__(self):
          self.children = [None] * 26
          self.isEndOfWord = False
  class Trie:
      def __init__(self):
          self.root = self.getNode()
      def getNode(self):
          return TrieNode()
      def _charToIndex(self, ch):
          return ord(ch) - ord('a')
      def insert(self, key):
          pCrawl = self.root
          length = len(key)
          for level in range(length):
              index = self._charToIndex(key[level])
              if not pCrawl.children[index]:
                  pCrawl.children[index] = self.getNode()
              pCrawl = pCrawl.children[index]
          pCrawl.isEndOfWord = True
      def search(self, key):
          pCrawl = self.root
          length = len(key)
          for level in range(length):
              index = self._charToIndex(key[level])
              if not pCrawl.children[index]:
                  return False
              pCrawl = pCrawl.children[index]
          return pCrawl != None and pCrawl.isEndOfWord
  #-----------------------------------------trie---------------------------------
  class Node:
      def __init__(self, data):
          self.data = data
          self.count=0
          self.left = None  # left node for 0
          self.right = None  # right node for 1
  class BinaryTrie:
      def __init__(self):
          self.root = Node(0)
      def insert(self, pre_xor):
          self.temp = self.root
          for i in range(31, -1, -1):
              val = pre_xor & (1 << i)
              if val:
                  if not self.temp.right:
                      self.temp.right = Node(0)
                  self.temp = self.temp.right
                  self.temp.count+=1
              if not val:
                  if not self.temp.left:
                      self.temp.left = Node(0)
                  self.temp = self.temp.left
                  self.temp.count += 1
          self.temp.data = pre_xor
      def query(self, xor):
          self.temp = self.root
          for i in range(31, -1, -1):
              val = xor & (1 << i)
              if not val:
                  if self.temp.left and self.temp.left.count>0:
                      self.temp = self.temp.left
                  elif self.temp.right:
                      self.temp = self.temp.right
              else:
                  if self.temp.right and self.temp.right.count>0:
                      self.temp = self.temp.right
                  elif self.temp.left:
                      self.temp = self.temp.left
              self.temp.count-=1
          return xor ^ self.temp.data
  # --------------------------------------------------binary-----------------------------------
  for ik in range(int(input())):
      n=int(input())
      ans=0
      r=[]
      for i in range(n):
          r.append(list(map(int,input().split())))
      for i in range(1,n):
          c=0
          for j in range(5):
              if r[i][j]<r[ans][j]:
                  c+=1
              if c==3:
                  ans=i
                  break
      for i in range(n):
          c=0
          if ans==i:
              continue
          for j in range(5):
              if r[i][j]<r[ans][j]:
                  c+=1
              if c==3:
                  ans=-2
                  break
          if ans==-2:
              break
      print(ans+1)