description: Mocha is a young girl from high school. She has learned so much interesting knowledge from her teachers, especially her math teacher. Recently, Mocha is learning about binary system and very interested in bitwise operation.
  
  This day, Mocha got a sequence a of length n. In each operation, she can select an arbitrary interval [l, r] and for all values i (0≤ i ≤ r-l), replace a_{l+i} with a_{l+i}  \&  a_{r-i} at the same time, where \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND). This operation can be performed any number of times.
  
  For example, if n=5, the array is [a_1,a_2,a_3,a_4,a_5], and Mocha selects the interval [2,5], then the new array is [a_1,a_2 \&  a_5, a_3 \&  a_4, a_4 \&  a_3, a_5 \&  a_2].
  
  Now Mocha wants to minimize the maximum value in the sequence. As her best friend, can you help her to get the answer?
  
  Input
  
  Each test contains multiple test cases. 
  
  The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. Each test case consists of two lines.
  
  The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the length of the sequence.
  
  The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9).
  
  Output
  
  For each test case, print one integer — the minimal value of the maximum value in the sequence.
  
  Example
  
  Input
  
  
  4
  2
  1 2
  3
  1 1 3
  4
  3 11 3 7
  5
  11 7 15 3 7
  
  
  Output
  
  
  0
  1
  3
  3
  
  Note
  
  In the first test case, Mocha can choose the interval [1,2], then the sequence becomes [ 0, 0], where the first element is 1 \& 2, and the second element is 2 \& 1.
  
  In the second test case, Mocha can choose the interval [1,3], then the sequence becomes [ 1,1,1], where the first element is 1 \& 3, the second element is 1 \& 1, and the third element is 3 \& 1.
solution: //Utilities
  import java.io.*;
  import java.util.*;
  
  public class A {
  	static int t;
  	static int n;
  	static int[] a;
  	static int res;
  	
  	public static void main(String[] args) throws IOException {
  		t = in.iscan();
  		while (t-- > 0) {
  			n = in.iscan(); a = new int[n];
  			for (int i = 0; i < n; i++) {
  				a[i] = in.iscan();
  			}
  			res = 0;
  			for (int i = 0; i < 31; i++) {
  				int tmp = 1 << i;
  				boolean flag = true;
  				for (int j = 0; j < n; j++) {
  					if ((a[j] & tmp) == 0) {
  						flag = false;
  						break;
  					}
  				}
  				if (flag) {
  					res |= tmp;
  				}
  			}
  			out.println(res);
  		}
  		out.close();
  	} 
  	
  	static INPUT in = new INPUT(System.in);
  	static PrintWriter out = new PrintWriter(System.out);
  	private static class INPUT {
  
  		private InputStream stream;
  		private byte[] buf = new byte[1024];
  		private int curChar, numChars;
  
  		public INPUT (InputStream stream) {
  			this.stream = stream;
  		}
  
  		public INPUT (String file) throws IOException {
  			this.stream = new FileInputStream (file);
  		}
  
  		public int cscan () throws IOException {
  			if (curChar >= numChars) {
  				curChar = 0;
  				numChars = stream.read (buf);
  			}
  			
  			if (numChars == -1)
  				return numChars;
  
  			return buf[curChar++];
  		}
  
  		public int iscan () throws IOException {
  			int c = cscan (), sgn = 1;
  			
  			while (space (c))
  				c = cscan ();
  
  			if (c == '-') {
  				sgn = -1;
  				c = cscan ();
  			}
  
  			int res = 0;
  
  			do {
  				res = (res << 1) + (res << 3);
  				res += c - '0';
  				c = cscan ();
  			}
  			while (!space (c));
  
  			return res * sgn;
  		}
  
  		public String sscan () throws IOException {
  			int c = cscan ();
  			
  			while (space (c))
  				c = cscan ();
  
  			StringBuilder res = new StringBuilder ();
  
  			do {
  				res.appendCodePoint (c);
  				c = cscan ();
  			}
  			while (!space (c));
  
  			return res.toString ();
  		}
  
  		public double dscan () throws IOException {
  			int c = cscan (), sgn = 1;
  			
  			while (space (c))
  				c = cscan ();
  
  			if (c == '-') {
  				sgn = -1;
  				c = cscan ();
  			}
  
  			double res = 0;
  
  			while (!space (c) && c != '.') {
  				if (c == 'e' || c == 'E')
  					return res * UTILITIES.fast_pow (10, iscan ());
  				
  				res *= 10;
  				res += c - '0';
  				c = cscan ();
  			}
  
  			if (c == '.') {
  				c = cscan ();
  				double m = 1;
  
  				while (!space (c)) {
  					if (c == 'e' || c == 'E')
  						return res * UTILITIES.fast_pow (10, iscan ());
  
  					m /= 10;
  					res += (c - '0') * m;
  					c = cscan ();
  				}
  			}
  
  			return res * sgn;
  		}
  
  		public long lscan () throws IOException {
  			int c = cscan (), sgn = 1;
  			
  			while (space (c))
  				c = cscan ();
  
  			if (c == '-') {
  				sgn = -1;
  				c = cscan ();
  			}
  
  			long res = 0;
  
  			do {
  				res = (res << 1) + (res << 3);
  				res += c - '0';
  				c = cscan ();
  			}
  			while (!space (c));
  
  			return res * sgn;
  		}
  
  		public boolean space (int c) {
  			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  		}
  	}
  
  	public static class UTILITIES {
  
  		static final double EPS = 10e-6;
  		
  		public static void sort(int[] a, boolean increasing) {
  			ArrayList<Integer> arr = new ArrayList<Integer>();
  			int n = a.length;
  			for (int i = 0; i < n; i++) {
  				arr.add(a[i]);
  			}
  			Collections.sort(arr);
  			for (int i = 0; i < n; i++) {
  				if (increasing) {
  					a[i] = arr.get(i);
  				}
  				else {
  					a[i] = arr.get(n-1-i);
  				}
  			}
  		}
  		
  		public static void sort(long[] a, boolean increasing) {
  			ArrayList<Long> arr = new ArrayList<Long>();
  			int n = a.length;
  			for (int i = 0; i < n; i++) {
  				arr.add(a[i]);
  			}
  			Collections.sort(arr);
  			for (int i = 0; i < n; i++) {
  				if (increasing) {
  					a[i] = arr.get(i);
  				}
  				else {
  					a[i] = arr.get(n-1-i);
  				}
  			}
  		}
  		
  		public static void sort(double[] a, boolean increasing) {
  			ArrayList<Double> arr = new ArrayList<Double>();
  			int n = a.length;
  			for (int i = 0; i < n; i++) {
  				arr.add(a[i]);
  			}
  			Collections.sort(arr);
  			for (int i = 0; i < n; i++) {
  				if (increasing) {
  					a[i] = arr.get(i);
  				}
  				else {
  					a[i] = arr.get(n-1-i);
  				}
  			}
  		}
  
  		public static int lower_bound (int[] arr, int x) {
  			int low = 0, high = arr.length, mid = -1;
  
  			while (low < high) {
  				mid = (low + high) / 2;
  
  				if (arr[mid] >= x)
  					high = mid;
  				else
  					low = mid + 1;
  			}
  
  			return low;
  		}
  
  		public static int upper_bound (int[] arr, int x) {
  			int low = 0, high = arr.length, mid = -1;
  
  			while (low < high) {
  				mid = (low + high) / 2;
  
  				if (arr[mid] > x)
  					high = mid;
  				else
  					low = mid + 1;
  			}
  
  			return low;
  		}
  
  		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 * b / gcd (a, b);
  		}
  
  		public static long fast_pow_mod (long b, long x, int mod) {
  			if (x == 0) return 1;
  			if (x == 1) return b;
  			if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;
  
  			return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
  		}
  
  		public static int fast_pow (int b, int x) {
  			if (x == 0) return 1;
  			if (x == 1) return b;
  			if (x % 2 == 0) return fast_pow (b * b, x / 2);
  
  			return b * fast_pow (b * b, x / 2);
  		}
  
  		public static long choose (long n, long k) {
  			k = Math.min (k, n - k);
  			long val = 1;
  
  			for (int i = 0; i < k; ++i)
  				val = val * (n - i) / (i + 1);
  
  			return val;
  		}
  
  		public static long permute (int n, int k) {
  			if (n < k) return 0;
  			long val = 1;
  
  			for (int i = 0; i < k; ++i)
  				val = (val * (n - i));
  
  			return val;
  		}
  		
  		// start of permutation and lower/upper bound template
  		public static void nextPermutation(int[] nums) {
  		    //find first decreasing digit
  		    int mark = -1;
  		    for (int i = nums.length - 1; i > 0; i--) {
  		        if (nums[i] > nums[i - 1]) {
  		            mark = i - 1;
  		            break;
  		        }
  		    }
  		 
  		    if (mark == -1) {
  		        reverse(nums, 0, nums.length - 1);
  		        return;
  		    }
  		 
  		    int idx = nums.length-1;
  		    for (int i = nums.length-1; i >= mark+1; i--) {
  		        if (nums[i] > nums[mark]) {
  		            idx = i;
  		            break;
  		        }
  		    }
  		 
  		    swap(nums, mark, idx);
  		 
  		    reverse(nums, mark + 1, nums.length - 1);
  		}
  		 
  		public static void swap(int[] nums, int i, int j) {
  		    int t = nums[i];
  		    nums[i] = nums[j];
  		    nums[j] = t;
  		}
  		 
  		public static void reverse(int[] nums, int i, int j) {
  		    while (i < j) {
  		        swap(nums, i, j);
  		        i++;
  		        j--;
  		    }
  		}
  		
  		static int lower_bound (int[] arr, int hi, int cmp) {
  			int low = 0, high = hi, mid = -1;
  			while (low < high) {
  				mid = (low + high) / 2;
  				if (arr[mid] >= cmp) high = mid;
  				else low = mid + 1;
  			}
  			return low;
  		}
  	 
  		static int upper_bound (int[] arr, int hi, int cmp) {
  			int low = 0, high = hi, mid = -1;
  			while (low < high) {
  				mid = (low + high) / 2;
  				if (arr[mid] > cmp) high = mid;
  				else low = mid + 1;
  			}
  			return low;
  		}
  		// end of permutation and lower/upper bound template
  	}
  }
  