description: In Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.
  
  Let's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 ⋅ 1 + 5 ⋅ 10 = 59 burles, and there's no way to do it with fewer banknotes.
  
  For a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
  
  The first line of each test case contains two integers n and k (1 ≤ n ≤ 10; 1 ≤ k ≤ 10^9).
  
  The next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n ≤ 9).
  
  Output
  
  For each test case, print one integer — the minimum positive number of burles s that cannot be represented with k or fewer banknotes.
  
  Example
  
  Input
  
  
  4
  3 13
  0 1 2
  2 777
  0 4
  3 255
  0 1 3
  10 1000000000
  0 1 2 3 4 5 6 7 8 9
  
  
  Output
  
  
  59
  778
  148999
  999999920999999999
solution: '''
  def fun():
      n = int(input())
      up = list(map(int, input().split()))
      down = list(map(int, input().split()))
      up = up[::-1]
      down = down[::-1]
      curr_idx = 0
      stops = []
      power = up[curr_idx]-down[curr_idx] #power = max steps frog can jump
      while True:
          print(curr_idx, power)
          if power+curr_idx == n:
              break
          old_power = power
          old_curr_idx = curr_idx
  
          new_power = power
          new_curr_idx = curr_idx
          
          for i in range(old_curr_idx+1, old_power+old_curr_idx+1, 1):
              if i+up[i]-down[i] > new_power+new_curr_idx :
                  new_power = up[i]-down[i]
                  new_curr_idx = i
          if new_power == old_power and new_curr_idx == old_curr_idx:
              print(-1)
              return
          curr_idx = new_curr_idx
          power = new_power
          stops.append(n-new_curr_idx)
      
      print(len(stops))
      for i in stops:
          print(i, end=" ")
      return
      
  fun()
  '''
  
  
  def fun():
      t = int(input())
      for i in range(t):
          k, n = map(int, input().split())
          arr = list(map(int, input().split()))
          for i in range(len(arr)):
              arr[i] = 10**arr[i]
          mn = prev = 0
          done=False
          for i in range(1, len(arr)):
              prev = mn
              mn += ((arr[i]-arr[i-1])//arr[i-1])
              if mn > n:
                  extra = n-prev
                  print((extra+1)*arr[i-1]+arr[i-1]-1)
                  done = True
                  break
          
          #print(mn)
          if not done:
              print((n-mn)*arr[-1]+arr[-1]+arr[-1]-1)
              
  
  fun()
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  