#include<iostream> // 引入标准输入输出库

using namespace std;

const int N = 3, INF = 1e8; // 定义棋盘大小为 3x3，INF 表示一个很大的数（用来标识棋局未结束）

int n; // 存储测试用例个数
int g[N][N]; // 棋盘，每个格子可能是 0（空），1（Alice），2（Bob）

// 检查玩家 u（1代表Alice，2代表Bob）是否赢了
bool check(int u)
{
    for(int i = 0; i < 3; i ++)
    {
        int s = 0;
        for(int j = 0; j < 3; j ++)
        {
            if(g[i][j] == u) s ++; // 检查第 i 行是否全是 u 的棋子
        }
        if(s == 3) return true; // 找到一行全是 u，胜利

        s = 0;
        for(int j = 0; j < 3; j ++)
        {
            if(g[j][i] == u) s ++; // 检查第 i 列是否全是 u 的棋子
        }
        if(s == 3) return true; // 找到一列全是 u，胜利
    }

    // 检查两条对角线是否都是 u 的棋子
    if(g[0][0] == u && g[1][1] == u && g[2][2] == u) return true;
    if(g[0][2] == u && g[1][1] == u && g[2][0] == u) return true;

    return false; // 没有任何胜利条件成立
}

// 评估当前局面的得分，如果还没结束就返回 INF
int evaluate()
{
    int blank = 0; // 统计空格的数量

    for(int i = 0; i < 3; i ++)
        for(int j = 0; j < 3; j ++)
        {
            if(g[i][j] == 0) blank ++; // 统计空格数量
        }

    if(check(1)) return blank + 1; // Alice 赢了，得分 = 空格数 + 1
    if(check(2)) return -(blank + 1); // Bob 赢了，得分 = -(空格数 + 1)
    if(blank == 0) return 0; // 平局，得分为 0

    return INF; // 棋局还没结束
}

// 使用递归搜索（极小极大算法），模拟双方都采用最优策略的结果
int dfs(int u) // u = 0 表示轮到 Alice，u = 1 表示轮到 Bob
{
    int t = evaluate(); // 先检查当前棋局是否已结束
    if(t != INF) return t; // 如果不是 INF，说明已经结束，直接返回得分

    if(u == 0) // Alice 下棋，她希望得分最大
    {
        int res = -INF; // 初始化为最小值，寻找最大可能得分
        for(int i = 0; i < 3; i ++)
            for(int j = 0; j < 3; j ++)
            {
                if(g[i][j] == 0) // 找到空格
                {
                    g[i][j] = 1; // Alice 在这里下棋
                    res = max(res, dfs(1)); // 模拟 Bob 接下来下棋，选择得分最高的情况
                    g[i][j] = 0; // 恢复棋盘
                }
            }
        return res; // 返回 Alice 当前策略下的最大得分
    }
    else // Bob 下棋，他希望得分最小（即对 Alice 最差）
    {
        int res = INF; // 初始化为最大值，寻找最小可能得分
        for(int i = 0; i < 3; i ++)
            for(int j = 0; j < 3; j ++)
            {
                if(g[i][j] == 0) // 找到空格
                {
                    g[i][j] = 2; // Bob 在这里下棋
                    res = min(res, dfs(0)); // 模拟 Alice 接下来下棋，Bob 希望得分最小
                    g[i][j] = 0; // 恢复棋盘
                }
            }
        return res; // 返回 Bob 当前策略下的最小得分
    }
}

int main()
{
    scanf("%d", &n); // 读取测试数据组数

    while(n --)
    {
        // 读取当前棋盘状态
        for(int i = 0; i < 3; i ++)
            for(int j = 0; j < 3; j ++)
                scanf("%d", &g[i][j]);

        printf("%d\n", dfs(0)); // 输出当前棋局的最终得分（从 Alice 开始）
    }

    return 0;
}