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.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
//import net.leksi.cf.*;

public class B {

    public static void main(String[] args) throws IOException {
        new B().run();
    }

    private void load_inputs(final BufferedReader br) throws IOException {
        try (
                PrintWriter pw = select_output();
        ) {
            int t = Integer.valueOf(br.readLine().trim());
            while(t-- > 0) {
                int[] n = Arrays.stream(br.readLine().trim().split("\\s+")).mapToInt(v -> Integer.valueOf(v)).toArray();
                int[] a = Arrays.stream(br.readLine().trim().split("\\s+")).mapToInt(v -> Integer.valueOf(v)).toArray();
                solve(n[0], a, pw);
            }
        }
    }
    
    private void solve(final int n, final int[] a, final PrintWriter pw) {
        HashMap<Integer, int[]> graph = new HashMap<>();
        int next_vert = 0;
        for(int i = 0; i < a.length; i++) {
            if(a[i] > 1) {
                graph.put(next_vert, new int[]{next_vert + 1, next_vert + 2});
                graph.put(next_vert + 1, new int[]{next_vert + 2});
                next_vert += 2;
            } else {
                graph.put(next_vert, new int[]{next_vert + 1});
                next_vert++;
            }
        }
//        System.out.println(graph.entrySet().stream().map(e -> e.getKey().toString() + "=" + Arrays.stream(e.getValue()).mapToObj(v -> Integer.toString(v)).collect(Collectors.joining(", ", "[", "]"))).collect(Collectors.joining(", ", "{", "}")));
        int[] sg = new int[next_vert + 1];
        Arrays.fill(sg, -1);
        sg[next_vert] = 0;
        MEX mex = new MEX();
        for(int i = next_vert - 1; i >= 0; i--) {
            sg[i] = mex.get(Arrays.stream(graph.get(i)).map(v -> sg[v]).toArray());
        }
        pw.println(sg[0] == 0 ? "Second" : "First");
    }
    
    String nameIn = getClass().getSimpleName() + ".in";
    String nameOut = null;

    private void run() throws IOException {
        File input = null;
        if (nameIn != null && (input = new File(nameIn)).exists()) {
            try (
                    FileReader fr = new FileReader(input);
                    BufferedReader br = new BufferedReader(fr);) {
                load_inputs(br);
            }
        } else {
            try (
                    InputStreamReader fr = new InputStreamReader(System.in);
                    BufferedReader br = new BufferedReader(fr);) {
                load_inputs(br);
            }
        }
    }

    PrintWriter select_output() throws FileNotFoundException {
        if (nameOut != null) {
            return new PrintWriter(nameOut);
        }
        return new PrintWriter(System.out);
    }

    interface Updater<U> {

        void update(final U target, final U src1, final U src2);
    }

    interface Copier<U> {

        void copy(final U target, final U src);
    }

    class SegTreeEx1<U> {

        protected int len2, n2, trlen, n;
        protected U[] tree;
        final private ArrayList<int[]> queue = new ArrayList<>();
        private U get_tmp = null;
        final private Copier<U> copier;
        final private Updater<U> updater;
        final private Supplier<U> creator;

        public SegTreeEx1(final Updater<U> updater, final Copier<U> copier, final Supplier<U> creator) {
            this.updater = updater;
            this.copier = copier;
            this.creator = creator;
        }

        public void set(final int i, final Consumer<U> assigner) {
            int pos = trlen - n2 + i;
            assigner.accept(tree[pos]);
            while (pos > 0) {
                int pos1 = pos;
                int pos2 = pos + ((pos & 1) == 0 ? -1 : 1);
                pos = (pos - 2 + (pos & 1)) >> 1;
                if (tree[pos2] == null) {
                    copier.copy(tree[pos], tree[pos1]);
                } else {
                    updater.update(tree[pos], tree[pos1], tree[pos2]);
                }
            }
        }

        public void get(final U res, final int l, final int r) {
            if (get_tmp == null) {
                get_tmp = creator.get();
            }
            queue.add(new int[]{0, 0, n2});
            boolean first = true;
            while (queue.size() > 0) {
                int[] item = queue.get(0);
                queue.remove((int) 0);
                if (item[1] >= l && (item[2] <= r || r == n)) {
                    if (first) {
                        copier.copy(res, tree[item[0]]);
                        first = false;
                    } else {
                        copier.copy(get_tmp, res);
                        updater.update(res, get_tmp, tree[item[0]]);
                    }
                } else if (r < n && item[1] >= r || item[2] < l || item[0] * 2 + 1 >= trlen) {

                } else {
                    queue.add(new int[]{item[0] * 2 + 1, item[1], (item[1] + item[2]) / 2});
                    queue.add(new int[]{item[0] * 2 + 2, (item[1] + item[2]) / 2, item[2]});
                }
            }
        }

        public String toString() {
            return IntStream.range(0, tree.length).mapToObj(i -> (((i + 1) & i) == 0 ? "[" : "")
                    + (tree[i] == null ? "-" : tree[i].toString())
                    + (((i + 2) & (i + 1)) == 0 ? "]" : "")).collect(Collectors.joining(", ", "[", "]"));
        }

        public void init(final U[] a) {
            n = a.length;
            len2 = (int) Math.ceil(Math.log(n) / Math.log(2));
            n2 = 1 << len2;
            trlen = (n2 << 1) - 1;
            tree = (U[]) IntStream.range(0, trlen).mapToObj(i -> (U) null).toArray();
            System.arraycopy(a, 0, tree, trlen - n2, n);
            int start = n2 - 1;
            for (int i = len2 - 1; i >= 0; i--) {
                int stop = ((start + 1) << 1) - 1;
                for (int j = start; j < stop && tree[j] != null; j += 2) {
                    tree[(j - 1) / 2] = creator.get();
                    if (tree[j + 1] == null) {
                        copier.copy(tree[(j - 1) / 2], tree[j]);
                    } else {
                        updater.update(tree[(j - 1) / 2], tree[j], tree[j + 1]);
                    }
                }
                start = ((start + 1) >> 1) - 1;
            }
        }

    }
    public class MEX {

        private ArrayList<Integer> used = new ArrayList<>();
        private int serial = 0;

        public int get(final int[] arr) {
            serial++;
            for (int i = 0; i < arr.length; i++) {
                if (used.size() <= arr[i]) {
                    used.addAll(IntStream.range(used.size(), arr[i] + 1).mapToObj(v -> 0).collect(Collectors.toList()));
                }
                used.set(arr[i], serial);
            }
            int res = 0;
            for (; res < used.size() && used.get(res) == serial; res++) {
            }
            return res;
        }
    }
}
