description: YouKn0wWho has an integer sequence a_1, a_2, …, a_n. He will perform the following operation until the sequence becomes empty: select an index i such that 1 ≤ i ≤ |a| and a_i is not divisible by (i + 1), and erase this element from the sequence. Here |a| is the length of sequence a at the moment of operation. Note that the sequence a changes and the next operation is performed on this changed sequence.
  
  For example, if a=[3,5,4,5], then he can select i = 2, because a_2 = 5 is not divisible by i+1 = 3. After this operation the sequence is [3,4,5].
  
  Help YouKn0wWho determine if it is possible to erase the whole sequence using the aforementioned operation.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
  
  The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
  
  The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
  
  It is guaranteed that the sum of n over all test cases doesn't exceed 3 ⋅ 10^5.
  
  Output
  
  For each test case, print "YES" (without quotes) if it is possible to erase the whole sequence using the aforementioned operation, print "NO" (without quotes) otherwise. You can print each letter in any register (upper or lower).
  
  Example
  
  Input
  
  
  5
  3
  1 2 3
  1
  2
  2
  7 7
  10
  384836991 191890310 576823355 782177068 404011431 818008580 954291757 160449218 155374934 840594328
  8
  6 69 696 69696 696969 6969696 69696969 696969696
  
  
  Output
  
  
  YES
  NO
  YES
  YES
  NO
  
  Note
  
  In the first test case, YouKn0wWho can perform the following operations (the erased elements are underlined): [1, \underline{2}, 3] → [\underline{1}, 3] → [\underline{3}] → [ ].
  
  In the second test case, it is impossible to erase the sequence as i can only be 1, and when i=1, a_1 = 2 is divisible by i + 1 = 2.
solution: import sys
  import time
  import os
  from io import BytesIO, IOBase
  
  M=10**9+7
  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")
   
   
  def print(*args, **kwargs):
      """Prints the values to a stream, or to sys.stdout by default."""
      sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
      at_start = True
      for x in args:
          if not at_start:
              file.write(sep)
          file.write(str(x))
          at_start = False
      file.write(kwargs.pop("end", "\n"))
      if kwargs.pop("flush", False):
          file.flush()
   
   
  if sys.version_info[0] < 3:
      sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
  else:
      sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
   
  def inputf(): 
      return sys.stdin.readline().rstrip("\r\n")  
   
   
  def printf(var): 
      sys.stdout.write(str(var)+"\n")  
   
   
  def get_ints(): 
      return list(map(int, inputf().split()))
   
   
  def get_string(): 
      return list(map(str, inputf().split()))
  
  
  
  
  
  global maximum
   
   
  def _lis(arr, n):
   
      global maximum
   
      if n == 1:
          return 1
   
      maxEndingHere = 1
      for i in range(1, n):
          res = _lis(arr, i)
          if arr[i-1] < arr[n-1] and res+1 > maxEndingHere:
              maxEndingHere = res + 1
   
      maximum = max(maximum, maxEndingHere)
   
      return maxEndingHere
   
   
  def LIS(arr):
   
      global maximum
   
      n = len(arr)
   
      maximum = 1
   
      _lis(arr, n)
   
      return maximum
   
  
  def binary_search(data, elem):
      
      low = 0
      high = len(data) - 1
      while low <= high:
        
          middle = (low + high)//2
          if data[middle] == elem:
              return middle
              
          elif data[middle] > elem:
  
              high = middle - 1
          else:
              low = middle + 1
  
      return middle   
  
  def upper_bound(my_list, key):
      large = len(my_list) -1
      small = 0
  
      while (small <= large):
          mid = (small + large) // 2
          if my_list[mid] < key:
              small = mid + 1
          elif my_list[mid] > key:
              large = mid - 1
          else:
              return mid
      if my_list[mid]>key:
          return mid
      else:
          return mid+1
  
  
  def lower_bound(my_list, key):
      large = len(my_list) -1
      small = 0
  
      while (small <= large):
          mid = (small + large) // 2
          if my_list[mid] < key:
              small = mid + 1
          elif my_list[mid] > key:
              large = mid - 1
          else:
              return mid
      if my_list[mid]<key:
          return mid
      else:
          return mid-1
  
  
  a=[]
  def SieveOfEratosthenes(n):
      
  	prime = [True for i in range(n+1)]
  	p = 2
  	while (p * p <= n):
  
  		if (prime[p] == True):
  
  			for i in range(p * p, n+1, p):
  				prime[i] = False
  		p += 1
  
  	for p in range(2, n+1):
  		if prime[p]:
  			a.append(p)
  
  def roman_number(x):
      if x > 15999:
          return
      value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
      symbol = ["F", "MF", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
      roman = ""
      i = 0
      while x > 0:
          div = x // value[i]
          x = x % value[i]
          while div:
              roman += symbol[i]
              div -= 1
          i += 1
      return roman
  
  def maxSubArraySum(a,size):
       
      max_so_far = a[0]   
      max_ending_here = 0
       
      for i in range(0, size):
          max_ending_here = max_ending_here + a[i]
          if max_ending_here < 0:
              max_ending_here = 0
           
          elif (max_so_far < max_ending_here):   
              max_so_far = max_ending_here
               
      return max_so_far
  
      
  def prefixSum(test_list):
      res = [sum(test_list[ : i + 1]) for i in range(len(test_list))]
      return res
  
  """
  def find_shortest_path(graph, start, end, path):
      path = path + [start]
      if start == end:
          return path
      if start not in graph:
          return None
      shortest = None
      for node in graph[start]:
          if node not in path:
              newpath = find_shortest_path(graph, node, end, path)
              if newpath:
                  if not shortest or len(newpath) < len(shortest):
                      shortest = newpath
      return shortest
  """ 
  
  """
  def dfs(root,nodeVal,nodeConnection,visited):
      leftVal = nodeVal[root][0]
      rightVal = nodeVal[root][1]
      solution = []
      if nodeConnection[root]:
          visited.add(root)
          for i in nodeConnection[root]:
              if i not in visited:
                  solution.append(dfs(i,nodeVal,nodeConnection,visited))
          leftMax = 0
          rightMax = 0
          for i in solution:
              l, r = i
              leftMax += max(abs(leftVal - l[0]) + l[1], abs(leftVal - r[0]) + r[1])
              rightMax += max(abs(rightVal - l[0]) + l[1], abs(rightVal - r[0]) + r[1])
          return ((leftVal, leftMax), (rightVal, rightMax))
      else:
          return ((leftVal, 0), (rightVal, 0))
   
  """
   
  """
  def BFS(adj,src,dist,paths,n):
      visited=[False]*n
      dist[src]=0
      paths[0]=1
      q=[src]
      visited[src]=True
      while(q):
          p=q.pop(0)
          for j in adj[p]:
              if not visited[j]:
                  q.append(j)
                  visited[j]=True
              if dist[j]>dist[p]+1:
                  dist[j] = dist[p]+1
                  paths[j] = paths[p]
              elif dist[j]==dist[p]+1:
                  paths[j] +=paths[p]
      return paths
   
  """
  
  testcase=int(inputf())
  for test in range(0,testcase):
      n=int(inputf())
      a=get_ints()
      available=0
      for i in range(0,n):
          for j in range(i+2,i+2-available-1,-1):
              if a[i]%j!=0:
                  break
          else:
              print("NO")
              break
          available+=1
      else:
          print("YES")