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: def main():
      
      def segfunc(x, y):
          return min(x,y)
      INF = 10**10
      ide_ele = INF
      
      
      class SegTree:
          """
          Segment Tree
          """
      
          def __init__(self, init_val, segfunc, ide_ele):
              """
              初期化
      
              init_val: 配列の初期値
              """
              n = len(init_val)
              self.segfunc = segfunc
              self.ide_ele = ide_ele
              self.num = 1 << (n - 1).bit_length()
              self.tree = [ide_ele] * 2 * self.num
              # 配列の値を葉にセット
              for i in range(n):
                  self.tree[self.num + i] = init_val[i]
              # 構築していく
              for i in range(self.num - 1, 0, -1):
                  self.tree[i] = segfunc(self.tree[2 * i], self.tree[2 * i + 1])
      
          def update(self, k, x):
              """
              k番目の値をxに更新
      
              k: index(0-index)
              x: update value
              """
              k += self.num
              self.tree[k] = x
              while k > 1:
                  self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
                  k >>= 1
      
          def query(self, l, r):
              """
              [l, r)のsegfuncしたものを得る
      
              l: index(0-index)
              r: index(0-index)
              """
              res = self.ide_ele
      
              l += self.num
              r += self.num
              while l < r:
                  if l & 1:
                      res = self.segfunc(res, self.tree[l])
                      l += 1
                  if r & 1:
                      res = self.segfunc(res, self.tree[r - 1])
                  l >>= 1
                  r >>= 1
              return res
  
      
      def answer():
          m,n = map(int,input().split())
          p = [list(map(int,input().split())) for _ in range(m)]
          p = list(zip(*p))
          
          M = [max(p[i]) for i in range(n)]
          T = SegTree(M,segfunc,ide_ele)
          
          if n>m:
              print(min(M))
              return
          
          ans = -1
  
          for i in range(n-1):
              tm = T.query(0,i)
              if tm == -1:
                  tm = INF
              pi = p[i]
              for j in range(i+1,n):
                  pj = p[j]
                  tmp = -1
                  for k in range(m):
                      tmp = max(tmp,min(pi[k],pj[k]))
                  tij = T.query(i+1,j)
                  if tij == -1:
                      tij = INF
                  tj = T.query(j+1,n)
                  if tj == -1:
                      tj = INF
                  t_ans = min(tmp,tm,tij,tj)
                  ans = max(ans,t_ans)
                  
          print(ans)
                  
                  
          
          
      for _ in range(int(input())):
          x = input()
          answer()
  main()