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.util.HashSet;
import java.util.Scanner;
import java.util.Set;


public class Main {

    static void solve() {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        for (int i = 0; i < t; i++) {
            int n = scan.nextInt();
            int[] arr1 = new int[n];
            for(int j=0;j<n;j++) {
                arr1[j] = scan.nextInt();
            }
            scase2(n, arr1);
        }


//        long t = scan.nextLong();

//        for (int i = 0; i < t; i++) {
//            int n = scan.nextInt();
////            scase(n);
//        }
    }


    static void solveCase(int t, int x, String s) {

    }

    static void scase(int[] arr1, int[] arr2) {
        Set<Integer>s1 = new HashSet<>();
        for(int v:arr1) {
            s1.add(v);
        }
        Set<Integer>s2 = new HashSet<>();
        for(int v:arr2) {
            if(s1.contains(v)) {
                System.out.println("YES");
                System.out.println("1 " + v);
                return;
            }
        }
        System.out.println("NO");
    }


    static void scase2(int n, int[] arr) {
        boolean first = true;
        int i=0;
        boolean ones = false;
        while(i<n && arr[i] == 1) {
            ones = true;
            first = !first;
            i++;
        }
        if(ones && i == n) {
            if(first) {
                System.out.println("Second");
            }else {
                System.out.println("First");
            }
        } else if(ones && i != n) {
            if(first) {
                System.out.println("First");
            }else {
                System.out.println("Second");
            }
        } else {
            System.out.println("First");
        }
    }

//    static int widthOfBinaryTree(TreeNode root) {
//        if(root == null) {
//            return 0;
//        }
//        Queue<TreeNode> q = new LinkedList<>();
//        int w = 1;
//        q.add(root);
//        while(!q.isEmpty()) {
//            int qsize = q.size();
//            int f = -1;
//            int l = 0;
//            while(qsize > 0) {
//                TreeNode node = q.remove();
//                if(f == -1) {
//                    f = node.val;
//                }
//                l = node.val;
//                if(node.left != null) {
//                    node.left.val = node.val*2;
//                    q.add(node.left);
//                }
//                if(node.right != null) {
//                    node.right.val = node.val*2 + 1;
//                    q.add(node.right);
//                }
//                qsize--;
//            }
//            w = Math.max(w, l - f + 1);
//        }
//        return w;
//    }


    public static void main(String[] args) {

        solve();

    }


//
//    class Counter extends HashMap<Integer, Integer> {
//        public int get(int k) {
//            return containsKey(k) ? super.get(k) : 0;
//        }
//
//        public void add(int k, int v) {
//            put(k, get(k) + v);
//        }
//    }

    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

    static class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
}