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
1
5
6 5 12 5 16
 1
5
3 5 6 11 2

2
 0

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.System.*;
import static java.util.Arrays.sort;
import static java.util.Collections.replaceAll;
import static java.util.Collections.reverseOrder;

public class C {
    public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE") == null;
    // public static final boolean LOCAL = System.getProperty("LOCAL")!=null;
    public static final String ANSI_RED = "\u001B[31m";
    public static final String ANSI_RESET = "\u001B[0m";
    static  int M = (int)998244353;
    static final long MM = (long) M * M;
    static final int MAX = Integer.MAX_VALUE;
    static final int MIN = Integer.MIN_VALUE;
    static final int SIZE = (int) 1e9 * 2;
    static ArrayList<Integer> primes = new ArrayList<>();
    //static Scanner sc = new Scanner(System.in);
    static FastReader sc = new FastReader();
    static long startTime;
    static long endTime;
    static boolean[] prime;
    static int[] visited;
    static ArrayList<ArrayList<Integer>> graph;
    static ArrayList<Integer> dfs;
    static boolean isCyclic = false;

    public static int swap(int... args) {
        return args[0];
    }

    public static void main(String[] args) throws IOException {
        do {
            startTime = currentTimeMillis();
            //setOut(new PrintStream("output"));
            //setIn(new FileInputStream("input"));
//            int MAX = 2_00_000;
//            fact = new long[MAX+1];
//            fact[0]++;
//            for(int i=1;i<=MAX;i++) {
//                fact[i] = (fact[i-1] * i)%M;
//            }
//            inv = new long[MAX+1];
//            inv[MAX] = modpow(fact[MAX], M-2, M);
//            for(int i=MAX-1;i>=0;--i) {
//                inv[i] = ((i+1)*inv[i+1])%M;
//            }

            int T = sc.nextInt();while (T-- != 0)
            {
                solve();

            }
            out.close();
            endTime = currentTimeMillis();
            long duration = endTime - startTime;
            //out.println(duration);
        } while (LOCAL);
    }

    static long[] fact, inv;
    static long nCr(int n, int r) {
        if(r>n || n<0 || r<0) {
            return 0;
        }
        return (((fact[n] * inv[r])%M) * inv[n-r])%M;
    }
    static long modpow(long x, long y, long MOD) {
        if(y==0) {
            return 1;
        }
        if((y&1)==0) {
            return modpow((x*x)%MOD, y>>1, MOD);
        }
        else return (x*modpow(x, y-1, MOD))%MOD;
    }
    static PrintWriter out = new PrintWriter(System.out);
    public static void solve(){
/////////////////////////////////////////////////////////////////////
        int n =sc.nextInt();
       ArrayList<Long> even = new ArrayList<>();
       ArrayList<Long> odd = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if(i%2==0){
                even.add(sc.nextLong());
            }
            else {
                odd.add(sc.nextLong());
            }
        }
        Collections.sort(even);
        Collections.sort(odd);
        long ansEven ;
        long ansOdd;
        if(even.size()>=2)
        ansEven = gcd(even.get(0),even.get(1));
        else ansEven = even.get(0);
        if(odd.size()>=2)
        ansOdd = gcd(odd.get(0),odd.get(1));
        else ansOdd = odd.get(0);
        for (int i = 2; i < even.size() ; i++) {
            ansEven = gcd(ansEven,even.get(i));
        }

        for (int i = 2; i < odd.size() ; i++) {
            ansOdd = gcd(ansOdd,odd.get(i));
        }
        for (int i = 0; i < even.size() ; i++) { // even is ans
            if(even.get(i)%ansEven!=0){
                ansEven=-1;
                break;
            }
        }
        if(ansEven!=-1)
        for (int i = 0; i < odd.size(); i++) {
            if(odd.get(i)%ansEven==0){
                ansEven=-1;
                break;
            }
        }

        for (int i = 0; i < odd.size(); i++) {
                if(odd.get(i)%ansOdd!=0){
                    ansOdd=-1;
                    break;
                }
        }
        if(ansOdd!=-1)
        for (int i = 0; i < even.size(); i++) {
            if(even.get(i)%ansOdd==0){
                ansOdd=-1;
                break;
            }
        }
        if(ansEven+ansOdd==-2){
            System.out.println(0);
        }
        else System.out.println(max(ansEven,ansOdd));
///////////////////////////////////////////////////////////////////////

    }
    static void dfs(int src) {
        visited[src] = 1;
        for (Integer integer : graph.get(src)) {
            if (visited[integer] != 1) {
                dfs(integer);
            }
        }
        dfs.add(src);

    }

    static void detectCycle(int src) {
        visited[src] = 2;
        for (Integer integer : graph.get(src)) {
            if (visited[integer] == 0) {
                detectCycle(integer);
            } else if (visited[integer] == 2) {
                isCyclic = true;
                return;
            }

        }
        visited[src] = 1;
    }

    static <Array, Target> int count(Array[] array, Target target) {
        int cn = 0;
        for (Array value : array) {
            if (value.equals(target)) cn++;
        }
        return cn;
    }

    static int count(String string, char target) {
        int cn = 0;
        for (int i = 0; i < string.length(); i++) {
            if (string.charAt(i) == target) cn++;
        }
        return cn;
    }

    static <Array> void revArray(Array[] arr) {
        int n = arr.length;
        for (int i = 0; i < n / 2; i++) {
            Array temp = arr[i];
            arr[i] = arr[n - i - 1];
            arr[n - i - 1] = temp;
        }

    }

    static <Array> void printArray(Array[] arr) {
        int n = arr.length;
        for (Array array : arr) out.print(array + " ");
        out.println();
    }

    static void yes() {
        out.println("YES");
    }

    static void no() {
        out.println("NO");
    }

    public static boolean isPal(String s) {
        StringBuilder stringBuilder = new StringBuilder(s);
        return s.equals(stringBuilder.reverse().toString());
    }

    public static int lowerBound(Integer[] array, int length, int value) {
        int low = -1;
        int hi = length;
        while (low + 1 < hi) {
            int mid = (low + hi) / 2;
            if (array[mid] <= value) {
                low = mid;
            } else {
                hi = mid;
            }
        }
        return low;
    }

    public static int upperBound(Integer[] array, int length, int value) {
        int low = -1;
        int hi = length;
        while (low + 1 < hi) {
            int mid = (low + hi) >> 1;
            if (array[mid] >= value) {
                hi = mid;
            } else low = mid;
        }
        return hi;
    }

    public static int binarySearch(Integer[] arr, int length, int value) {
        int low = 0;
        int hi = length - 1;
        int ans = -1;
        while (low <= hi) {
            int mid = (low + hi) >> 1;
            if (arr[mid] > value) {
                hi = mid - 1;
            } else if (arr[mid] < value) {
                low = mid + 1;
            } else {
                ans = mid;
                break;
            }
        }
        return ans;
    }

    public static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    public static long lcm(long  a, long b) {
        return a / gcd(a, b) * b;
    }

    public static int countDivs(int n) {
        int cn = 0;
        int sqr = (int) Math.sqrt(n);
        for (int i = 1; i <= sqr; ++i) {
            if (n % i == 0) {
                ++cn;
            }
        }
        cn *= 2;
        if (sqr * sqr == n) cn--;
        return cn;
    }

    static void prime(int x) {
        //sieve algorithm. nlog(log(n)).
        prime = new boolean[(x + 1)];
        Arrays.fill(prime, true);
        prime[0] = prime[1] = false;
        for (int i = 2; i * i <= x; i++)
            if (prime[i])
                for (int j = i * i; j <= x; j += i)
                    prime[j] = false;
    }

    static boolean isEven(long x) {
        return x % 2 == 0;
    }

    static boolean isPrime(long x) {
        boolean flag = true;
        int sqr = (int) Math.sqrt(x);
        if (x < 2) return false;
        for (int i = 2; i <= sqr; i++) {
            if (x % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    static long factorial(long x) {
        long total = 1;
        for (int i = 2; i <= x; i++)
            total = (total * i) %M;
        return total;
    }

    static long power(long x, long n) {
        if (n == 0) {
            return 1;
        }
        long pow = power(x, n / 2L);
        if ((n & 1) == 1) {
            return (x * (pow) * (pow));
        }
        return (pow * pow);
    }

    private static <T> String ts(T t) {
        if (t == null) {
            return "null";
        }
        try {
            return ts((Iterable) t);
        } catch (ClassCastException e) {
            if (t instanceof int[]) {
                String s = Arrays.toString((int[]) t);
                return "{" + s.substring(1, s.length() - 1) + "}";
            } else if (t instanceof long[]) {
                String s = Arrays.toString((long[]) t);
                return "{" + s.substring(1, s.length() - 1) + "}";
            } else if (t instanceof char[]) {
                String s = Arrays.toString((char[]) t);
                return "{" + s.substring(1, s.length() - 1) + "}";
            } else if (t instanceof double[]) {
                String s = Arrays.toString((double[]) t);
                return "{" + s.substring(1, s.length() - 1) + "}";
            } else if (t instanceof boolean[]) {
                String s = Arrays.toString((boolean[]) t);
                return "{" + s.substring(1, s.length() - 1) + "}";
            }
            try {
                return ts((Object[]) t);
            } catch (ClassCastException e1) {
                return t.toString();
            }
        }
    }

    private static <T> String ts(T[] arr) {
        StringBuilder ret = new StringBuilder();
        ret.append("{");
        boolean first = true;
        for (T t : arr) {
            if (!first) {
                ret.append(", ");
            }
            first = false;
            ret.append(ts(t));
        }
        ret.append("}");
        return ret.toString();
    }

    private static <T> String ts(Iterable<T> iter) {
        StringBuilder ret = new StringBuilder();
        ret.append("{");
        boolean first = true;
        for (T t : iter) {
            if (!first) {
                ret.append(", ");
            }
            first = false;
            ret.append(ts(t));
        }
        ret.append("}");
        return ret.toString();
    }

    public static void dbg(Object... o) {
        if (LOCAL) {
            System.err.print("Line #" + Thread.currentThread().getStackTrace()[2].getLineNumber() + ": [");
            for (int i = 0; i < o.length; i++) {
                if (i != 0) {
                    System.err.print(", ");
                }
                System.err.print(ts(o[i]));
            }
            System.err.println("]");
        }
    }

    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;
        }
    }

    static class Pair implements Comparable<Pair> {
        private final int key;
        private final int value;

        public Pair(int key, int value) {
            this.key = key;
            this.value = value;
        }

        public int second() {
            return value;
        }

        @Override
        public int compareTo(Pair o) {
            return -Integer.compare(key, o.key);
        }

        @Override
        public String toString() {
            return "Pair{" + "x=" + key + ", y=" + value + '}';
        }
    }

}