description: Vlad has n friends, for each of whom he wants to buy one gift for the New Year.
  
  There are m shops in the city, in each of which he can buy a gift for any of his friends. If the j-th friend (1 ≤ j ≤ n) receives a gift bought in the shop with the number i (1 ≤ i ≤ m), then the friend receives p_{ij} units of joy. The rectangular table p_{ij} is given in the input.
  
  Vlad has time to visit at most n-1 shops (where n is the number of friends). He chooses which shops he will visit and for which friends he will buy gifts in each of them.
  
  Let the j-th friend receive a_j units of joy from Vlad's gift. Let's find the value α=min\\{a_1, a_2, ..., a_n\}. Vlad's goal is to buy gifts so that the value of α is as large as possible. In other words, Vlad wants to maximize the minimum of the joys of his friends.
  
  For example, let m = 2, n = 2. Let the joy from the gifts that we can buy in the first shop: p_{11} = 1, p_{12}=2, in the second shop: p_{21} = 3, p_{22}=4.
  
  Then it is enough for Vlad to go only to the second shop and buy a gift for the first friend, bringing joy 3, and for the second — bringing joy 4. In this case, the value α will be equal to min\{3, 4\} = 3
  
  Help Vlad choose gifts for his friends so that the value of α is as high as possible. Please note that each friend must receive one gift. Vlad can visit at most n-1 shops (where n is the number of friends). In the shop, he can buy any number of gifts.
  
  Input
  
  The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input.
  
  An empty line is written before each test case. Then there is a line containing integers m and n (2 ≤ n, 2 ≤ n ⋅ m ≤ 10^5) separated by a space — the number of shops and the number of friends, where n ⋅ m is the product of n and m.
  
  Then m lines follow, each containing n numbers. The number in the i-th row of the j-th column p_{ij} (1 ≤ p_{ij} ≤ 10^9) is the joy of the product intended for friend number j in shop number i.
  
  It is guaranteed that the sum of the values n ⋅ m over all test cases in the test does not exceed 10^5.
  
  Output
  
  Print t lines, each line must contain the answer to the corresponding test case — the maximum possible value of α, where α is the minimum of the joys from a gift for all of Vlad's friends.
  
  Example
  
  Input
  
  
  5
  
  2 2
  1 2
  3 4
  
  4 3
  1 3 1
  3 1 1
  1 2 2
  1 1 3
  
  2 3
  5 3 4
  2 5 1
  
  4 2
  7 9
  8 1
  9 6
  10 8
  
  2 4
  6 5 2 1
  7 9 7 2
  
  
  Output
  
  
  3
  2
  4
  8
  2
solution: # cook your dish here
  import sys
  import bisect
  from bisect import bisect_left as lb
  from bisect import bisect_right as rb
  input_=lambda: sys.stdin.readline().strip("\r\n")
  from math import log
  from math import gcd
  from math import atan2,acos
  from random import randint
  sa=lambda :input_()
  sb=lambda:int(input_())
  sc=lambda:input_().split()
  sd=lambda:list(map(int,input_().split()))
  sflo=lambda:list(map(float,input_().split()))
  se=lambda:float(input_())
  sf=lambda:list(input_())
  flsh=lambda: sys.stdout.flush()
  sys.setrecursionlimit(3*10**5)
  mod=10**9+7
  mod1=998244353
  gp=[]
  cost=[]
  dp=[]
  mx=[]
  ans1=[]
  ans2=[]
  special=[]
  specnode=[]
  a=0
  kthpar=[]
  def dfs2(root,par):
      if par!=-1:
          dp[root]=dp[par]+1
      for i in range(1,20):
          if kthpar[root][i-1]!=-1:
              kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]
      for child in gp[root]:
          if child==par:continue
          kthpar[child][0]=root
          dfs(child,root)
          
  ans=0
  a=[]
  n,k=0,0
  b=[]
  vis=[]
  tot=0
  time=[]
  time1=[]
  adj=[]
  mx=-1
  eps=0.0000001
  x=0
  pref=[]
  lvl=[]
  gp=[]
  ans=[]
  f=0
  w=[]
  
  def dfs(i,prod,rem,n):
      if rem==0:
          while(i<len(n)):
              prod*=int(n[i])
              i+=1
          return prod
      if i==len(n):
          return prod
      mx=0
      for j in range(9-int(n[i])):
          mx=max(dfs(i+1,(int(n[i])+min(j,rem))*prod,rem-min(j,rem),n),mx)
      return mx
  def hnbhai(tc):
      sa()
      #print()
      m,n=sd()
      mat=[]
      d={}
      mn=float("inf")
      for i in range(m):
          mat.append(sd())
          for j in range(n):
              #if d.get(j) is nNone:
              d[j]=max(d.get(j,0),(mat[i][j]))
      for i in d:
          mn=min(mn,d[i])
      if n>m:
          print(mn)
          return
      low=1
      high=10**9
      ans=0
      while(low<=high):
          mid=(low+high)//2
          tot=0
          fl=0
          for i in range(m):
              tot=0
              for j in range(n):
                  if mat[i][j]>=mid:
                      tot+=1
              if tot>=2:
                  fl=1
                  break
          if fl==1:
              low=mid+1
              ans=mid
          else:
              high=mid-1
      print(min(ans,mn))
  for _ in range(sb()):
      hnbhai(_+1)
  ##case
  
  #.
  