description: You are given an array a consisting of n positive integers. You have to choose a positive integer d and paint all elements into two colors. All elements which are divisible by d will be painted red, and all other elements will be painted blue.
  
  The coloring is called beautiful if there are no pairs of adjacent elements with the same color in the array. Your task is to find any value of d which yields a beautiful coloring, or report that it is impossible.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
  
  The first line of each testcase contains one integer n (2 ≤ n ≤ 100) — the number of elements of the array.
  
  The second line of each testcase contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}).
  
  Output
  
  For each testcase print a single integer. If there is no such value of d that yields a beautiful coloring, print 0. Otherwise, print any suitable value of d (1 ≤ d ≤ 10^{18}).
  
  Example
  
  Input
  
  
  5
  5
  1 2 3 4 5
  3
  10 5 15
  3
  100 10 200
  10
  9 8 2 6 6 2 8 6 5 4
  2
  1 3
  
  
  Output
  
  
  2
  0
  100
  0
  3
solution: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Scanner;
  import java.util.StringTokenizer;
  import java.io.*;
  import java.util.*;
  import java.text.DecimalFormat;
  import java.math.*;
  
  public class Main {
  
  static int  mod = 1000000007;
  /*****************code By Priyanshu *******************************************/ 
  
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
  
          public FastReader()
          {
              br = new BufferedReader(
                  new InputStreamReader(System.in));
          }
  
          String next()
          {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() { return Integer.parseInt(next()); }
  
          long nextLong() { return Long.parseLong(next()); }
  
  
  
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
  
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
      // this > other return +ve
      // this < other return -ve
      // this == other return 0
       public static class Pair implements Comparable<Pair> {
        long st;
        long et;
  
        public Pair(long st, long et) {
           this.st = st;
           this.et = et;
        }
  
        public int compareTo(Pair other) {
           if (this.st != other.st) {
              return (int)(this.st - other.st);
           } else {
              return (int)(this.et - other.et);
           }
        }
     }
  
      static long fastPower(long a, long b, int n) {
              
              long res = 1;
              
              while ( b > 0) {
                  
                  if ( (b&1) != 0) {
                      res = (res * a % n) % n;
                  }
                  
                  a = (a % n * a % n) % n;
                  b =  b >> 1;
              }
              
              return res;
              
          }
  
       // function to find
      // the rightmost set bit
      static int PositionRightmostSetbit(int n)
      {
          // Position variable initialize
          // with 1 m variable is used to
          // check the set bit
          int position = 1;
          int m = 1;
   
          while ((n & m) == 0) {
   
              // left shift
              m = m << 1;
              position++;
          }
          return position;
      }
      
           // used for swapping ith and jth elements of array
        // public static void swap(int[] arr, int i, int j) {
        //   int temp = arr[i];
        //   arr[i] = arr[j];
        //   arr[j] = temp;
        // }
          public static void swap(long i, long j) {
          long temp = i;
          i = j;
          j = temp;
        }
  
  
      static boolean palindrome(String s) {
          return new StringBuilder(s).reverse().toString().equals(s);
      }
      
    static boolean isPerfectSquare(double x)
      {
              double sr = Math.sqrt(x);
              return ((sr * sr) == x);     
      }
  
  
   public static long gcd(long a, long b)
      {
        if (b == 0)
          return a;
        return gcd(b, a % b);
      }
      
     
  
     static int nod(long l) {
         if(l>=1000000000000000000l) return 19;
         if(l>=100000000000000000l) return 18;
         if(l>=10000000000000000l) return 17;
         if(l>=1000000000000000l) return 16;
         if(l>=100000000000000l) return 15;
         if(l>=10000000000000l) return 14;
         if(l>=1000000000000l) return 13;
         if(l>=100000000000l) return 12;
         if(l>=10000000000l) return 11;
         if(l>=1000000000) return 10;
         if(l>=100000000) return 9;
         if(l>=10000000) return 8;
         if(l>=1000000) return 7;
         if(l>=100000) return 6;
         if(l>=10000) return 5;
         if(l>=1000) return 4;
         if(l>=100) return 3;
         if(l>=10) return 2;
         return 1;
      }
        //Arrays.sort(a,(c,d) -> Integer.compare(c[0],d[0]));
  
      
      public static boolean areAllBitsSet(int n )
      {
          // all bits are not set
          if (n == 0)
              return false;
       
          // if true, then all bits are set
          if (((n + 1) & n) == 0)
              return true;
       
          // else all bits are not set
          return false;
      }
  
       public static long[] sort(long[] arr) {
          List<Long> temp = new ArrayList();
          for (long i : arr) temp.add(i);
          Collections.sort(temp);
          int start = 0;
          for (long i : temp) arr[start++] = i;
          return arr;
      }
     
   
  
          public static int[] radixSort2(int[] a)
      {
          int n = a.length;
          int[] c0 = new int[0x101];
          int[] c1 = new int[0x101];
          int[] c2 = new int[0x101];
          int[] c3 = new int[0x101];
          for(int v : a) {
              c0[(v&0xff)+1]++;
              c1[(v>>>8&0xff)+1]++;
              c2[(v>>>16&0xff)+1]++;
              c3[(v>>>24^0x80)+1]++;
          }
          for(int i = 0;i < 0xff;i++) {
              c0[i+1] += c0[i];
              c1[i+1] += c1[i];
              c2[i+1] += c2[i];
              c3[i+1] += c3[i];
          }
          int[] t = new int[n];
          for(int v : a)t[c0[v&0xff]++] = v;
          for(int v : t)a[c1[v>>>8&0xff]++] = v;
          for(int v : a)t[c2[v>>>16&0xff]++] = v;
          for(int v : t)a[c3[v>>>24^0x80]++] = v;
          return a;
      } 
  
      public static void print( int arr[] ){
          Arrays.stream(arr).forEach(str -> System.out.print(str + " "));
      }
  
      static boolean isPowerOfTwo (int x)
      {
        /* First x in the below expression is 
          for the case when x is 0 */
          return x!=0 && ((x&(x-1)) == 0);
            
      }
  
  
     
  
    static class Help {
      int index;
      int val;
      int res ;
      //Constructor
      Help(int i, int v) {
        index = i;
        val = v;
        res = 0;
      }
    }
   
  
  
    public static void main(
          String[] args)
      {
          try {
              System.setIn(new FileInputStream("input.txt"));
              System.setOut(new PrintStream(new FileOutputStream("output.txt")));
          } catch (Exception e) {
              System.err.println("Error");
          }
           
         FastReader sc = new FastReader();
      
         int t = Integer.parseInt(sc.next());
        // int t = 1;
        
  
         // StringBuilder ans = new StringBuilder();
    //  ArrayList<Integer> a = new ArrayList<>();
      
     while(t-->0){
  
   
    int n  = sc.nextInt();
  
  
    long a[] = new long[n];
  
    for (int i = 0;i<n ;i++) {
      a[i] = sc.nextLong();
    }
   
    long g1 = a[0];
    long g2 = a[1];
    for(int i = 0;i<n;i+=2){
      g1 = gcd(g1,a[i]);
    }
    for(int i = 1;i<n;i+=2){
      g2 = gcd(g2,a[i]);
    }
  
  
   // System.out.println("g1  " + g);
    int ok  = 1;
  
  
  
     for(int i = 1;i<n;i+=2){
        if(a[i]%g1 == 0){
          ok = 0;
        }
    }
  
    if(ok == 1){
      System.out.println(g1);
      continue;
    }else{
       ok = 1;
         for(int i = 0;i<n;i+=2){
          if(a[i]%g2 == 0){
            ok = 0;
          }
      }
  
      if(ok == 1){
        System.out.println(g2);
      }else{
        System.out.println(0);
      }
    }
  
   
   
  
      }
    }
  }
  
  
  
  
  
  
  //code By Priyanshu 
  
  