use std::ascii::AsciiExt;
use std::ops::DivAssign;
use std::ops::MulAssign;
use std::ops::SubAssign;
use std::collections::BinaryHeap;
use std::str::FromStr;
use std::collections::HashSet;
use std::collections::BTreeMap;
use std::fmt::Display;
use std::ops::Neg;
use std::ops::Div;
use std::ops::Mul;
use std::ops::Add;
use std::ops::{AddAssign, Sub};
use std::cmp::max;
use std::collections::VecDeque;
use std::cmp::min;
use std::collections::{HashMap, BTreeSet};
use std::cmp::Ordering;
use std::fmt::Debug;

fn read_line() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).expect("No Line");
    buffer.trim().to_owned()
}
fn read_lines<T: std::str::FromStr>(count: usize) -> Vec<T> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(buffer.trim().parse().ok().expect("Can't Parse"));
        buffer.clear();
    }
    vec
}
fn read_tabulate<R, T: Fn(&str)->R> (count: usize, transformer: T) -> Vec<R> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(transformer(buffer.trim()));
        buffer.clear();
    }
    vec
}
fn read_value<T: std::str::FromStr>() -> T {
    read_line().trim().parse().ok().unwrap()
}
fn read_values<T: std::str::FromStr>() -> Vec<T> {
    read_line().trim().split_whitespace().map(|x| x.parse().ok().expect("Can't Parse")).collect::<Vec<T>>()
}
macro_rules! freeze {
    ($($id:ident), *) => {
        $(let $id = $id;)*
    };
}
macro_rules! read_map {
    ($ident: ident: [$block: block; $size: expr]) => {
        let $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
    (mut $ident: ident: [$block: block; $size: expr]) => {
        let mut $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
}
macro_rules! read {
    (mut $ident: ident: String) => {
        let mut $ident = read_value::<String>();
    };
    ($ident: ident: String) => {
        let $ident = read_value::<String>();
    };
    (mut $ident: ident: [$ty:ty]) => {
        let mut $ident = read_values::<$ty>();
    };
    ($ident: ident: [$ty:ty]) => {
        let $ident = read_values::<$ty>();
    };
    (mut $ident: ident: [[$ty:ty]; $size: expr]) => {
        let mut $ident = (0 .. $size).into_iter().map(|_| read_values::<$ty>()).collect::<Vec<_>>();
    };
    ($ident: ident: [[$ty:ty]; $size: expr]) => {
        let $ident = (0 .. $size).into_iter().map(|_| read_values::<$ty>()).collect::<Vec<_>>();
    };
    (mut $ident: ident: [$ty:ty; $size:expr]) => {
        let mut $ident = read_lines::<$ty>($size);
    };
    ($ident: ident: [$ty:ty; $size:expr]) => {
        let $ident = read_lines::<$ty>($size);
    };
    ($ident: ident: [$block: block; $size: expr]) => {
        let $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
    (mut $ident: ident: [$block: block; $size: expr]) => {
        let mut $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
    ($($token: tt)*) => {
        let mut iter = read_values::<String>().into_iter();
        read_from_iter!(iter; $($token)*);
    };
}
macro_rules! read_from_iter {
    ($iter:expr; mut $ident:ident:$ty:ty, $($rest:tt)*) => {
        let mut $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
        read_from_iter!($iter; $($rest)*);
    };
    ($iter:expr; $ident:ident:$ty:ty, $($rest:tt)*) => {
        let $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
        read_from_iter!($iter; $($rest)*);
    };
    ($iter:expr; mut $ident:ident:$ty:ty) => {
        let mut $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
    };
    ($iter:expr; $ident:ident:$ty:ty) => {
        let $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
    };
    ($iter: expr; ) => {};
}
struct KeyValue<K, V> {
    key: K,
    value: V
}
impl <K: PartialOrd, V> PartialEq for KeyValue<K, V> {
    fn eq(&self, other: &Self) -> bool {
        self.key.eq(&other.key)
    }
}
impl <K: PartialOrd, V> Eq for KeyValue<K, V> {}
impl <K: PartialOrd, V> PartialOrd for KeyValue<K, V> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.key.partial_cmp(&other.key)
    }
}
impl <K: PartialOrd, V> Ord for KeyValue<K, V> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.key.partial_cmp(&other.key).ok_or("Can't Compare").unwrap()
    }
}
#[derive(Copy, Clone, Debug)]
struct Position {
    x: i32, y: i32
}
impl Position {
    fn right(&self) -> Position {
        Position{x: self.x + 1, y: self.y}
    }
    fn left(&self) -> Position {
        Position{x: self.x - 1, y: self.y}
    }
    fn up(&self) -> Position {
        Position{x: self.x, y: self.y - 1}
    }
    fn down(&self) -> Position {
        Position{x: self.x, y: self.y + 1}
    }
}
#[derive(Copy, Clone, Debug)]
struct Dice {
    top: usize, up: usize, right: usize,
    position: Position
}
impl Dice {
    fn all_type(position: Position) -> Vec<Dice> {
        vec![Dice{top: 1, up: 2, right: 3, position: position}, Dice{top: 1, up: 3, right: 2, position: position}]
    }
    fn all_faces(&self) -> Vec<Dice> {
        let mut result = vec![*self];
        for i in 0 .. 5 {
            let l = if i & 1 == 0 {
                Dice{top: 7 - result[i].right, up: result[i].up, right: result[i].top, position: self.position}
            }else {
                Dice{top: 7 - result[i].up, up: result[i].top, right: result[i].right, position: self.position}
            };
            result.push(l);
        }
        result
    }
    fn twisted(&self) -> Vec<Dice> {
        let mut result = vec![*self];
        for i in 0 .. 3 {
            let l = result[i].rotate_clockwise();
            result.push(l);
        }
        result
    }
    fn new(top: usize, position: Position) -> Vec<Dice> {
        Dice::all_type(position).into_iter().flat_map(|dice| dice.all_faces().into_iter().filter(|d| d.top == top)).into_iter().flat_map(|d| d.twisted()).collect()
    }
    fn all_next(&self) -> Vec<Dice> {
        vec![self.rotate_up(), self.rotate_right(), self.rotate_left(), self.rotate_down()]
    }
    fn rotate_up(&self) -> Dice {
        Dice{top: 7 - self.up, up: self.top, right: self.right, position: self.position.up()}
    }
    fn rotate_right(&self) -> Dice {
        Dice{top: 7 - self.right, up: self.up, right: self.top, position: self.position.right()}
    }
    fn rotate_down(&self) -> Dice {
        Dice{top: self.up, up: 7 - self.top, right: self.right, position: self.position.down()}
    }
    fn rotate_left(&self) -> Dice {
        Dice{top: self.right, up: self.up, right: 7 - self.top, position: self.position.left()}
    }
    fn rotate_clockwise(&self) -> Dice {
        Dice{top: self.top, up: 7 - self.right, right: self.up, position: self.position}
    }
}
fn exists_all_face_once(state: &Vec<Vec<usize>>) -> bool {
    let mut count = vec![0usize; 7];
    for line in state {
        for &c in line {
            count[c] += 1;
        }
    }
    count[1..].iter().all(|&c| c == 1)
}

fn can_put(state: &Vec<Vec<usize>>) -> bool {
    if !exists_all_face_once(state) {return false;}
    let &(r, c) = (0 .. state.len()).into_iter().flat_map(|y| (0 .. state[y].len()).into_iter().map(|x| (y, x)).find(|&(y, x)| state[y][x] == 1)).collect::<Vec<_>>().first().unwrap();
    for start in Dice::new(1, Position{x: c as i32, y: r as i32}) {
        let mut stack = vec![start];
        let mut is_appear = vec![vec![false; state[0].len()]; state.len()];
        is_appear[r][c] = true;
        while let Some(top) = stack.pop() {
            for next in top.all_next() {
                if next.position.y < 0 || state.len() as i32 <= next.position.y || next.position.x < 0 || state[next.position.y as usize].len() as i32 <= next.position.x {continue;}
                if is_appear[next.position.y as usize][next.position.x as usize] {continue;}
                if state[next.position.y as usize][next.position.x as usize] != next.top { continue; }
                is_appear[next.position.y as usize][next.position.x as usize] = true;
                stack.push(next);
            }
        }
        if is_appear.into_iter().map(|line| line.into_iter().filter(|&b| b).count()).sum::<usize>() == 6 {
            return true
        }
    }
    false
}

fn main() {
    read!(n: usize);
    for _ in 0 .. n {
        read!(state: [[usize]; 5]);
        println!("{}", if can_put(&state) {"true"} else {"false"});
    }
}


Measured memory_bytes: 5048