There are n piles of stones, where the i-th pile has a_i stones. Two people play a game, where they take alternating turns removing stones.

In a move, a player may remove a positive number of stones from the first non-empty pile (the pile with the minimal index, that has at least one stone). The first player who cannot make a move (because all piles are empty) loses the game. If both players play optimally, determine the winner of the game.

Input

The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.

The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the number of piles.

The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 10^9) — a_i is equal to the number of stones in the i-th pile.

It is guaranteed that the sum of n for all test cases does not exceed 10^5.

Output

For each test case, if the player who makes the first move will win, output "First". Otherwise, output "Second".

Example

Input


7
3
2 5 4
8
1 1 1 1 1 1 1 1
6
1 2 3 4 5 6
6
1 1 2 1 2 2
1
1000000000
5
1 2 2 1 1
3
1 1 1


Output


First
Second
Second
First
First
Second
First

Note

In the first test case, the first player will win the game. His winning strategy is: 

  1. The first player should take the stones from the first pile. He will take 1 stone. The numbers of stones in piles will be [1, 5, 4]. 
  2. The second player should take the stones from the first pile. He will take 1 stone because he can't take any other number of stones. The numbers of stones in piles will be [0, 5, 4]. 
  3. The first player should take the stones from the second pile because the first pile is empty. He will take 4 stones. The numbers of stones in piles will be [0, 1, 4]. 
  4. The second player should take the stones from the second pile because the first pile is empty. He will take 1 stone because he can't take any other number of stones. The numbers of stones in piles will be [0, 0, 4]. 
  5. The first player should take the stones from the third pile because the first and second piles are empty. He will take 4 stones. The numbers of stones in piles will be [0, 0, 0]. 
  6. The second player will lose the game because all piles will be empty. 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
//import com.google.common.collect.HashMultiset; 
//import com.google.common.collect.Multiset;



public class code6 {

	static int ans = 0;
	static int[] arr;
	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;
		}
		public int[] nextIntArray(int n) {
	    	int[] a = new int[n];
	    	for(int i = 0; i < n; i ++)
	    		a[i] = nextInt();
	    	return a;
	    }
	    
	    public long[] nextLongArray(int n) {
	    	long[] a = new long[n];
	    	for(int i = 0; i < n; i ++)
	    		a[i] = nextLong();
	    	return a;
	    }
	    
	    public double[] nextDoubleArray(int n) {
	    	double[] a = new double[n];
	    	for(int i = 0; i < n; i ++)
	    		a[i] = nextDouble();
	    	return a;
	    }
	}
	public static void main(String[] args) throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		FastReader scn = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		int t = scn.nextInt();
		//int p = t;
		while(t-->0) {
			int n = scn.nextInt();
			int[] arr = scn.nextIntArray(n);
			if(n == 1) {
				System.out.println("First");
				continue;
			}
			int flag = 0;
			for(int i=0; i<n; i++) {
				if(arr[i] != 1) {
					if(i%2 == 0)
						System.out.println("First");
					else
						System.out.println("Second");
					flag = 1;
					break;
				}
			}
			if(flag == 0) {
				if(n%2 == 0)
					System.out.println("Second");
				else
					System.out.println("First");
			}
		}
		out.flush();
	}
	
	
public static void topologicalSortUtil( int v, boolean visited[], Stack<Integer> stack, ArrayList<Integer>[] graph)  
			    {  
			        // Mark the current node as visited.  
			        visited[v] = true;  
			        Integer i;  
			    
			        // Recur for all the vertices adjacent  
			        // to thisvertex  
			        Iterator<Integer> it = graph[v].iterator();  
			        while (it.hasNext())  
			        {  
			            i = it.next();  
			            if (!visited[i])  
			                topologicalSortUtil(i, visited, stack, graph);  
			        }  
			    
			      
			        stack.push(new Integer(v));  
			    }  
			    
			    
public static int[] topologicalSort(int V, ArrayList<Integer>[] graph)  
			    {  
			        Stack<Integer> stack = new Stack<Integer>();  
			    
			      
			        boolean visited[] = new boolean[V];  
			        for (int i = 0; i < V; i++)  
			            visited[i] = false;  
			     
			        for (int i = 0; i < V; i++)  
			            if (visited[i] == false)  
			                topologicalSortUtil(i, visited, stack, graph);  
			     
			        int[] arr = new int[V];
			        int i = 0;
			        Arrays.fill(arr, -1);
			        while (stack.empty()==false) {
			        	arr[stack.pop()] = i;
			        	i++;
			        }
			        return arr;
			    }  
	public static int rec(String str, char a) {
		if(str.length() == 1) {
			if(str.charAt(0) == a)
				return 0;
			else
				return 1;
		}
		int n = str.length()/2;
		int c = 0;
		for(int i=0; i<n; i++) {
			if(str.charAt(i) != a)
				c++;
		}
		int ans1 = c+rec(str.substring(n), (char)(a+1));
		c = 0;
		for(int i=n; i<2*n; i++) {
			if(str.charAt(i) != a)
				c++;
		}
		int ans2 = c + rec(str.substring(0,n), (char)(a+1));
		return Math.min(ans1, ans2);
		
	}
	
	public static class stud{
		private int roll;
		String name;
	}
	
	public static void dfs(ArrayList<Integer>[] tree, int i, int l, int[] level) {
		level[i] = l;
		for(int j=0; j<tree[i].size(); j++) {
			dfs(tree, tree[i].get(j), l+1, level);
		}
	}
	public static void dfs(int i, boolean[] vis, int[] parent, int[] level, int a, int last) {
		if(i == -1)
			return;
		if(level[last]-level[i] == a) {
			if(!vis[i])
				ans++;
			vis[i] = true;
			last = i;
		}
		dfs(parent[i], vis, parent, level, a, last);
	}
	public static int[] PossibleKey(int[] arr) {
		int[] ans = new int[4];
		for(int i=0; i<4; i++)
			arr[i] = 1;
		int[] help = new int[4];
		int i = 0;
		int ch = 0;
		int cl = 0;
		for(i = 1; i<4; i++) {
			if(arr[i]>arr[i-1]) {
				for(int j=0; j<4; j++)
					help[j]++;
			}
			if(arr[i]<arr[i-1]) {
				for(int j=0; j<4; j++)
					help[j]--;
			}
			for(int j=0; j<4; j++) {
				if(help[j]+j<0 || help[j]+j>4)
					ans[j] = 0;
			}
		}
		return ans;
		
	}
	
//	public static int dfs(ArrayList<Integer>[] graph, boolean[] vis, int i) {
//		int s= 1;
//		vis[i] = true;
//		for(int j=0; j<graph[i].size(); j++) {
//			if(!vis[graph[i].get(j)])
//				s += dfs(graph, vis, graph[i].get(j));
//		}
//		if(s%2 == 0)
//			ans++;
//		return s;
//	}
	
  
	public static boolean check(int mid, int c, int[] arr, int k) {
		int ans = 0;
		for(int i=0; i<arr.length; i++) {
			if(c==0) {
				ans++;
				c = (c+1)%2;
			}else {
				if(arr[i]<=mid) {
					ans++;
					c = (c+1)%2;
				}
			}
		}
		return ans>=k;
	}
	public static long power(long x, long y, int p) 
    { 
       
        long res = 1;      
         
        x = x % p;  
  
       if (x == 0) return 0;     
  
        while (y > 0) 
        { 
            
            if((y & 1)==1) 
                res = (res * x) % p; 
 
            y = y >> 1;  
            x = (x * x) % p;  
        } 
        return res; 
    } 
	
	public static int[] nextG(int[] arr, int n) {
		int[] ans = new int[n];
		Stack<Integer> stack = new Stack<Integer>();
		stack.push(0);
		for(int i=1; i<n; i++) {
			while(!stack.isEmpty() && arr[stack.peek()]<=arr[i])
				ans[stack.pop()] = i;
			stack.push(i);
		}
		while(!stack.isEmpty())
			ans[stack.pop()] = n;
		return ans;
	}
	public static int[] nextGRev(int[] arr, int n) {
		int[] ans = new int[n];
		Stack<Integer> stack = new Stack<Integer>();
		stack.push(n-1);
		for(int i=n-2; i>=0; i--) {
			while(!stack.isEmpty() && arr[stack.peek()]<=arr[i])
				ans[stack.pop()] = i;
			stack.push(i);
		}
		while(!stack.isEmpty())
			ans[stack.pop()] = -1;
		return ans;
	}
	
	static int largestPower(int n, int p) { 
       
        int x = 0; 
 
        while (n > 0) { 
            n /= p; 
            x += n; 
        } 
        return x; 
    } 
  

    static int power(int x, int y, int p) { 
        int res = 1;  
        x = x % p;  
      
        while (y > 0) { 
            
            if (y % 2 == 1) { 
                res = (res * x) % p; 
            } 
  
             
            y = y >> 1;
            x = (x * x) % p; 
        } 
        return res; 
    }
	
	static int Fact(int n, int p) { 
        if (n >= p) { 
            return 0; 
        } 
  
        int res = 1; 
 
        boolean isPrime[] = new boolean[n + 1]; 
        Arrays.fill(isPrime, true); 
        for (int i = 2; i * i <= n; i++) { 
            if (isPrime[i]) { 
                for (int j = 2 * i; j <= n; j += i) { 
                    isPrime[j] = false; 
                } 
            } 
        } 

        for (int i = 2; i <= n; i++) { 
            if (isPrime[i]) { 

                int k = largestPower(n, i); 
  
        
                res = (int) ((res * power((long)i, (long)k, p)) % p); 
            } 
        } 
        return res; 
    } 
	
	public static class Pair implements Comparable<Pair>{
		int i;
		int n;
		Pair(int x, int z){
			i = x;
			n = z;
		}
		public int compareTo(Pair p) {
			return this.n-p.n;
		}

	}
	public static boolean isCyclicUtil(int i, boolean[] visited, 
            boolean[] recStack, ArrayList<Integer>[] graph)  
{ 

// Mark the current node as visited and 
// part of recursion stack 
if (recStack[i]) 
	return true; 

if (visited[i]) 
	return false; 

visited[i] = true; 

recStack[i] = true; 
List<Integer> children = graph[i]; 

for (Integer c: children) 
	if (isCyclicUtil(c, visited, recStack, graph)) 
		return true; 

recStack[i] = false; 

return false; 
} 


public static boolean isCyclic(int V, ArrayList<Integer>[] graph)  
{ 


boolean[] visited = new boolean[V]; 
boolean[] recStack = new boolean[V]; 

for (int i = 0; i < V; i++) 
	if (isCyclicUtil(i, visited, recStack, graph)) 
		return true; 

return false; 
} 
    
}

