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.*;
    import java.util.*;




    public class CodeForce {
     static ArrayList<Integer> inputarrlist(String s){
         String[] str=s.split(" ");
         ArrayList<Integer> arr=new ArrayList<>();
         for(int i=0;i<str.length;i++)
             arr.add(Integer.parseInt(str[i]));

         return arr;
     }
     static long[] inputarrlong(String s){
         String[] str=s.split(" ");
         long[] arr=new long[str.length];
         for(int i=0;i<str.length;i++)
             arr[i]=(Long.parseLong(str[i]));

         return arr;
     }

     static int[] inputarrint(String s){
         String[] str=s.split(" ");
         int[] arr=new int[str.length];
         for(int i=0;i<str.length;i++)
             arr[i]=Integer.parseInt(str[i]);

         return arr;
     }

     static int powermod(long x, long y, long mod){
      long ans = 1;
      while(y>0){
          if (y%2==1)
               ans = (ans*x)%mod;
               x = (x*x)%mod;
               y/=2;
                }
       return (int)(ans);
            }

     static int power(long x, long y){
      long ans = 1;
      while(y>0){
          if (y%2==1)
               ans=ans*x;
               x=(x*x);
               y/=2;
                }
       return (int)(ans);
            }

     static StringBuffer rrotatestring(StringBuffer sb,int a){
         int len=sb.length();
         StringBuffer temp;
          temp=new StringBuffer(sb.substring(len-a, len));
          sb.delete(len-a,len);
          sb.insert(0,temp);
          return sb;
     }

     static StringBuffer lrotatestring(StringBuffer sb,int a){
         int len=sb.length();
         StringBuffer temp;
          temp=new StringBuffer(sb.substring(0,a));
          sb.delete(0,a);
          sb.append(temp);
          return sb;
     }
     static long gcd(long a, long b) 
        { 
          if (b==0) 
            return a; 
          return gcd(b, a % b);  
        } 

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


     static ArrayList<Long> allfactorsofn(long n) 
        { 
            ArrayList<Long> a=new ArrayList<>();
            ArrayList<Long> b=new ArrayList<>();
            for (long i=1; i<=Math.sqrt(n); i++) 
            { if (n%i==0) 
                {  
                    if (n/i == i) 
                        a.add(i); 

                    else 
                    {
                        a.add(i);
                        b.add(n/i);
                    }
                } 
            } 

            for(int i=b.size()-1;i>=0;i--){
                a.add(b.get(i));
            }

            return a;
        } 

        public static void main(String[] args) throws IOException {

            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int t;

            //t=1;

            t=Integer.parseInt(br.readLine());

            while(t-->0){
                int n=Integer.parseInt(br.readLine());
                int[] arr=inputarrint(br.readLine());

               Set<Integer> set=new HashSet<>();
               int c=0;
               int f=0;
               for(int i=0;i<n;i++){
                   if(arr[i]==1 && f==0)
                       c++;
                   else
                       f=1;

                   set.add(arr[i]);
               }
               // System.out.println(set+" "+set.size());
               if(c==n){
                   if(n%2==0)
                       System.out.println("Second");
                   else
                       System.out.println("First");
               }
               else{
                   if(arr[0]!=1)
                       System.out.println("First");
                   else{
                       if(c%2==0)
                           System.out.println("First");
                       else
                           System.out.println("Second");
                   }
               }

            }
        }

    class Sample{
                int x;
                int y;
                Sample(int x, int y){
                    this.x= x;
                    this.y=y;
                }
            }
            class SortSample implements Comparator<Sample>{
                public int compare(Sample a ,Sample b){
                    if(a.x!=b.x)
                    return a.x-b.x;
                    else
                        return a.y-b.y;
                }
            }
    }