Problem: 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. 

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.sql.ResultSetMetaData;
import java.util.*;


public class Main {

    public static void main(String[] args) throws IOException
    {
        Reader.init(System.in);
        int t  = Reader.nextInt();
        while ( t > 0){
            int n = Reader.nextInt();
            int array[]  = new int[n];
            int i = 0;
            while ( i < n){
                array[i] = Reader.nextInt();
                i++;
            }
            if ( n == 1){
                System.out.println("First");
            }
            else{
                int mark []  = new int[n];
                i--;
                mark[i] = 1;
                i--;
                while ( i >= 0){
                    if ( mark[i+1] == 1){
                        if ( array[i] == 1){
                            mark[i] = 0;
                        }
                        else{
                            mark[i] = 1;
                        }
                    }
                    else{
                        mark[i] =1;
                    }
                    i--;
                }
                if ( mark[0] == 1){
                    System.out.println("First");
                }
                else{
                    System.out.println("Second");
                }
            }
            t--;
        }

    }
    public static int upperBound(int[] array,int low,int high,int find,int ans){
        if ( low <= high){
            int mid = low + (high-low)/2;
            if (array[mid] > find){
                high = mid-1;
                ans = mid+1;
                return upperBound(array,low,high,find,ans);
            }
            else{
                low = mid+1;
                return upperBound(array,low,high,find,ans);
            }

        }
        return ans;
    }
    public static boolean checkDefeat(int i,int j,int[][] array){
        int k = 0;
        int count = 0;
        while ( k < 5){
            if ( array[i][k] < array[j][k] ){
                count++;
            }
            k++;
        }
        if ( count >= 3){
            return true;
        }
        else{
            return false;
        }
    }
    public static long solve(int n,int start,long[][] weight,ArrayList<ArrayList<Integer>> list){
        PriorityQueue<Distance> priorityQueue = new PriorityQueue<>(n,new distanceComparator());
        Distance[] dist = new Distance[n];
        int visited[] = new int[n];
        for (int j = 0; j < n;j++){
            if ( weight[start][j] == 0){
                dist[j] = new Distance(j,Integer.MAX_VALUE);
            }
            else{
                dist[j] = new Distance(j,weight[start][j]);
                priorityQueue.add(dist[j]);
            }

        }
        visited[start] = 0;
        while (priorityQueue.size()!= 0){
            int  u = priorityQueue.poll().vertex;
            priorityQueue.remove(dist[u]);
            if ( visited[u] == 0){
                int j = 0;
                int size = list.get(u).size();
                while ( j < size){
                    int v = list.get(u).get(j);
                    if ( dist[v].distance > dist[u].distance+weight[u][v]){
                        priorityQueue.remove(dist[v]);
                        dist[v].distance = dist[u].distance+weight[u][v];
                        if ( visited[v] == 0) {
                            priorityQueue.add(dist[v]);
                        }
                    }
                    j++;
                }
            }
            visited[u] = 1;


        }
        if ( dist[start].distance == Integer.MAX_VALUE){
            return -1;
        }
        else{
            return dist[start].distance;
        }

    }

}

class Distance{
    int vertex;
    long distance;
    Distance(int v,long d){
        vertex = v;
        distance = d;
    }
}

class distanceComparator implements Comparator<Distance>{
    @Override
    public int compare(Distance o1,Distance o2){
        if ( o1.distance > o2.distance){
            return 1;
        }
        else if ( o1.distance < o2.distance){
            return -1;
        }
        else{
            return 0;
        }
    }
}


class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input));
        tokenizer = new StringTokenizer("");
    }
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
}