fn run<W: Write>(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<W>) {
    //test();
    let t: u32 = sc.next();
    for _ in 0..t {
        let n = sc.next::<usize>();
        let a = sc.next_vec::<usize>(n);
        if fast(a) {
            writeln!(out, "First").ok();
        } else {
            writeln!(out, "Second").ok();
        }
    }
}

// 実験しても何も見えん
// mod 5?
// 0, 1, 4: lose
// 2, 3: win
//
//

fn test() {
    let mut map = Map::new();
    println!("{:?}", naive(vec![1], &mut map));
    println!("{:?}", naive(vec![2], &mut map));
    println!("{:?}", naive(vec![4], &mut map));
    println!("{:?}", naive(vec![2, 3, 7], &mut map));
    let mut set = Set::new();
    for _ in 0..10000 {
        let n = rand() % 3 + 1;
        let mut a = (0..n).map(|_| rand() % 10 + 2).collect::<Vec<_>>();
        a.sort();
        if set.insert(a.clone()) {
            let res = naive(a.clone(), &mut map);
            assert_eq!(res, fast(a.clone()), "{:?}", a);
            let cnt = a.iter().filter(|a| **a % 5 == 2 || **a % 5 == 3).count();
            if cnt % 2 == 1 {
                assert!(res, "{:?}", a);
            } else if res {
                println!("{:?}: {} {}", a, res, cnt);
            }
        }
    }
    for i in 1..40 {
        println!("{}: {}", i, naive(vec![i], &mut map));
    }
}

fn fast(a: Vec<usize>) -> bool {
    let c = a.iter().filter(|a| **a % 5 == 3).count();
    let d = a.iter().filter(|a| **a % 5 == 2).count();
    let e = a.iter().filter(|a| **a == 3).count();
    (c + d) % 2 == 1 || e % 2 == 1
}

fn naive(mut a: Vec<usize>, map: &mut Map<Vec<usize>, bool>) -> bool {
    a.sort();
    a.retain(|a| *a > 1);
    if a.is_empty() {
        return false;
    }
    let a = a;
    let res = (0..a.len()).any(|i| {
        let mut a = a.clone();
        let v = a.remove(i);
        let a = a;
        (1..v).all(|j| {
            let mut b = a.clone();
            let mut c = a.clone();
            b.push(j);
            c.push(v - j);
            !naive(b, map) || !naive(c, map)
        })
    });
    map.insert(a, res);
    res
}

// ---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std::str::FromStr;
    pub struct Scanner<'a> {
        it: std::str::SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace(),
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            self.it.next().unwrap().parse::<T>().ok().unwrap()
        }
        pub fn next_bytes(&mut self) -> Vec<u8> {
            self.it.next().unwrap().bytes().collect()
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.it.next().unwrap().chars().collect()
        }
        pub fn next_vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
            (0..len).map(|_| self.next()).collect()
        }
    }
}
// ---------- end scannner ----------

use std::collections::*;
use std::io::Write;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut sc = scanner::Scanner::new(&s);
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    run(&mut sc, &mut out);
}
fn rand_memory() -> usize {
    Box::into_raw(Box::new("I hope this is a random number")) as usize
}

fn rand() -> usize {
    static mut X: usize = 0;
    unsafe {
        if X == 0 {
            X = rand_memory();
        }
        X ^= X << 13;
        X ^= X >> 17;
        X ^= X << 5;
        X
    }
}

fn shuffle<T>(a: &mut [T]) {
    for i in 1..a.len() {
        let p = rand() % (i + 1);
        a.swap(i, p);
    }
}