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 java.io.*;
  import java.util.*;
  
  public class Main {
      static int mod = 1000_000_007;
      static long mod1 = 998244353;
      static boolean memory = true;
      static FastScanner f;
      static PrintWriter pw;
      static double eps = 1e-6;
      static int oo = (int) 1e9;
      
      static class Maths {
          public int add(int a , int b , int mod) {
              return ((a % mod) + (b % mod)) % mod;
          }
  
          public long add(long a , long b , long mod) {
              return ((a % mod) + (b % mod)) % mod;
          }
  
          public int sub(int a , int b , int mod) {
              return ((a % mod) - (b % mod) + mod) % mod;
          }
          
          public long sub(long a , long b , long mod) {
              return ((a % mod) - (b % mod) + mod) % mod;
          }
  
          public int mul(int a , int b , int mod) {
              return ((a % mod) * (b % mod)) % mod;
          }
          
          public long mul(long a , long b , long mod) {
              return ((a % mod) * (b % mod)) % mod;
          }
  
          public int pow(int a , int b , int mod) {
              int ans = 1;
              while (b > 0) {
                  if ((b & 1) == 1) ans = mul(ans , a , mod);
                  a = mul(a , a , mod);
                  b >>= 1;
              }
              return ans;
          }
          
          public long pow(long a , long b , long mod) {
              long ans = 1;
              while (b > 0) {
                  if ((b & 1) == 1) ans = mul(ans , a , mod);
                  a = mul(a , a , mod);
                  b >>= 1;
              }
              return ans;
          }
  
          public int gcd(int a , int b) {
              if (b == 0) return a;
              return gcd(b , a % b);
          }
  
          public long gcd(long a , long b) {
              if (b == 0) return a;
              return gcd(b , a % b);
          }
  
          public long[] exgcd(long x , long y)  {
              long[] u = {1 , 0 , x};
              long[] v = {0 , 1,  y};
              long[] t = new long[3];
  
              while (v[2] != 0) {
                  long q = u[2] / v[2];
                  for (int i = 0; i < 3; ++i) {
                      t[i] = u[i] - v[i] * q;
                      u[i] = v[i];
                      v[i] = t[i];
                  }
              }
  
              return u;
          }
  
          public int[] exgcd(int x , int y)  {
              int[] u = {1 , 0 , x};
              int[] v = {0 , 1,  y};
              int[] t = new int[3];
  
              while (v[2] != 0) {
                  int q = u[2] / v[2];
                  for (int i = 0; i < 3; ++i) {
                      t[i] = u[i] - v[i] * q;
                      u[i] = v[i];
                      v[i] = t[i];
                  }
              }
              return u;
          }
  
          public long exgcdInv(long x , long mod) {
              long temp = mod;
              long p = 1;
              long q = 0;
  
              while (temp > 0) {
                  long c = x / temp;
                  long d;
                  d = x;
                  x = temp;
                  temp = d % temp;
                  d = p;
                  p = q;
                  q = d - c * q;
              }
  
              return p < 0 ? p + mod : p;
          }
  
          public int exgcdInv(int x , int mod) {
              int temp = mod;
              int p = 1;
              int q = 0;
  
              while (temp > 0) {
                  int c = x / temp;
                  int d;
                  d = x;
                  x = temp;
                  temp = d % temp;
                  d = p;
                  p = q;
                  q = d - c * q;
              }
  
              return p < 0 ? p + mod : p;
          }
  
          public int modInverse(int a , int mod) {
              return pow(a, mod - 2, mod);
          }
  
          public long modInverse(long a , long mod) {
              return pow(a , mod - 2 , mod);
          }
  
          public long lcm(long a, long b) {
              return (a * b / gcd(a, b));
          }
  
          public int countDig(long a) {
              int cnt = 0;
              while (a > 0) {
                  a /= 10;
                  ++cnt;
              }
              return Math.max(1, cnt);
          }
          
          public int countDig(int a) {
              int cnt = 0;
              while (a > 0) {
                  a /= 10;
                  ++cnt;
              }
              return Math.max(1, cnt);
          }
  
          public boolean isPrime(long n) {
              if (n <= 1)
                  return false;
              if (n <= 3)
                  return true;
              if (n % 2 == 0 || n % 3 == 0)
                  return false;
              for (long i = 5; i * i <= n; i = i + 6)
                  if (n % i == 0 || n % (i + 2) == 0)
                      return false;
              return true;
          }
  
          public boolean isPrime(int n) {
              if (n <= 1)
                  return false;
              if (n <= 3)
                  return true;
              if (n % 2 == 0 || n % 3 == 0)
                  return false;
              for (long i = 5; i * i <= n; i = i + 6)
                  if (n % i == 0 || n % (i + 2) == 0)
                      return false;
              return true;
          }
          
          public long[] prepareFactorials(int n , long mod) {
                  long[] f = new long[n + 1];
                  f[0] = 1l;
                  for (int i = 1; i <= n; ++i) f[i] = mul(f[i - 1] , (long)i , mod);
                  return f;
          }
          
          public int[] generateSPF(int n) {
              int[] spf = new int[n + 1];
              spf[0] = 0;
              spf[1] = 1;
              for (int i = 2; i <= n; ++i) {
                  if (spf[i] == 0) {
                      spf[i] = i;
                      for (int j = i + i; j <= n; j += i) {
                          spf[j] = i;
                      }
                  }
              }
              return spf;
          }
  
          public long toDeci(String str , int base) {
              int len = str.length();
              long power = 1l;
              long num = 0;
              int i;
  
              for (i = len - 1; i >= 0; i--) {
                  char c = str.charAt(i);
                  int val = 0;
                  if (c >= '0' && c <= '9') val = c - '0';
                  else val = c - 'A' + 10;
                  if (val >= base) {
                      return -1;
                  }
                  num += val * power;
                  power *= base;
              }
              return num;
          }
      }
  
      public static void solve() throws Exception {
          int n = f.ni();
          int[] a = new int[n];
          for (int i = 0; i < n; ++i) {
              a[i] = f.ni();
          }
          Maths m = new Maths();
          long lcm = 2;
          for (int i = 0; i < n; ++i) {
              if (a[i] % lcm == 0) {
                  pn("NO");
                  return;
              }
              lcm = m.lcm(lcm , (long)(i + 3));
          }
          pn("YES");
      }
  
      public static void main(String[] args) throws Exception {
          if (memory)
              new Thread(null, new Runnable() {
                  public void run() {
                      try {
                          Main.run();
                      } catch (Exception e) {
                          e.printStackTrace();
                          System.exit(1);
                      }
                  }
              }, "", 1 << 28).start();
          else {
              Main.run();
          }
      }
  
      static void run() throws Exception {
          if (System.getProperty("ONLINE_JUDGE") == null) {
              f = new FastScanner("");
              File file = new File("!out.txt");
              pw = new PrintWriter(file);
          } else {
              f = new FastScanner();
              pw = new PrintWriter(System.out);
          }
  
          int t = f.ni();
          while (t --> 0) {
              solve();
          }
  
          pw.flush();
          pw.close();
      }
  
      public static class FastScanner {
          BufferedReader br;
          StringTokenizer st;
  
          public FastScanner(String str) throws Exception {
              try {
                  br = new BufferedReader(new FileReader("!a.txt"));
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
  
          public FastScanner() {
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          public String next() throws IOException {
              while (st == null || !st.hasMoreTokens())
                  st = new StringTokenizer(br.readLine());
              return st.nextToken();
          }
  
          public int ni() throws IOException {
              return Integer.parseInt(next());
          }
  
          public long nl() throws IOException {
              return Long.parseLong(next());
          }
  
          public String nextLine() throws IOException {
              return br.readLine();
          }
  
          public double nd() throws IOException {
              return Double.parseDouble(next());
          }
  
      }
  
      public static void pn(Object... o) {
          for (int i = 0; i < o.length; ++i)
              pw.print(o[i] + (i + 1 < o.length ? " " : "\n"));
      }
  
      public static void p(Object... o) {
          for (int i = 0; i < o.length; ++i)
              pw.print(o[i] + (i + 1 < o.length ? " " : ""));
      }
  
      public static void pni(Object... o) {
          for (Object obj : o)
              pw.print(obj + " ");
          pw.println();
          pw.flush();
      }
  
      public static void sort(int[] a) {
          ArrayList<Integer> l = new ArrayList<>();
          for (int i : a)
              l.add(i);
          Collections.sort(l);
          for (int i = 0; i < a.length; ++i)
              a[i] = l.get(i);
      }
  
      public static void sort(long[] a) {
          ArrayList<Long> l = new ArrayList<>();
          for (long i : a)
              l.add(i);
          Collections.sort(l);
          for (int i = 0; i < a.length; ++i)
              a[i] = l.get(i);
      }
  }