#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define mp make_pair
#define si(x) int(x.size())
const int mod=1000000007,MAX=305,INF=1<<30;

int ri(int u,int f){
    if(u==1){
        if(f==2) return 3;
        if(f==3) return 5;
        if(f==5) return 4;
        if(f==4) return 2;
    }
    if(u==2){
        if(f==1) return 4;
        if(f==4) return 6;
        if(f==6) return 3;
        if(f==3) return 1;
    }
    if(u==3){
        if(f==1) return 2;
        if(f==2) return 6;
        if(f==6) return 5;
        if(f==5) return 1;
    }
    if(u==4){
        if(f==1) return 5;
        if(f==5) return 6;
        if(f==6) return 2;
        if(f==2) return 1;
    }
    if(u==5){
        if(f==1) return 3;
        if(f==3) return 6;
        if(f==6) return 4;
        if(f==4) return 1;
    }
    if(u==6){
        if(f==2) return 4;
        if(f==4) return 5;
        if(f==5) return 3;
        if(f==3) return 2;
    }
    
    return -1000;
}//uとfが与えられた時にrを返す(u==1,f==2,r==3型のサイコロ)

struct dice{
    int u,f,r,b,l,d;
    
    void init(int uu,int ff){
        u=uu;
        f=ff;
        r=ri(u,f);
        b=7-f;
        l=7-r;
        d=7-u;
    }
    
    void turnF(){
        int save=f;
        f=u;
        u=b;
        b=d;
        d=save;
    }
    
    void turnR(){
        int save=r;
        r=u;
        u=l;
        l=d;
        d=save;
    }
    
    void turnB(){
        int save=b;
        b=u;
        u=f;
        f=d;
        d=save;
    }
    
    void turnL(){
        int save=l;
        l=u;
        u=r;
        r=d;
        d=save;
    }
    
    void turn1(){
        int save=r;
        r=b;
        b=l;
        l=f;
        f=save;
    }//時計回り
    
    void turn2(){
        int save=r;
        r=f;
        f=l;
        l=b;
        b=save;
    }//反時計回り
};

int A[3][3],B[3][3];
set<int> ans;

vector<int> X;

void DFS(){
    if(si(X)==8){
        if(A[0][0]&&A[0][0]!=X[0]) return;
        if(A[1][0]&&A[1][0]!=X[1]) return;
        if(A[2][0]&&A[2][0]!=X[2]) return;
        if(A[2][1]&&A[2][1]!=X[3]) return;
        if(A[2][2]&&A[2][2]!=X[4]) return;
        if(B[0][0]&&B[0][0]!=X[5]) return;
        if(B[1][0]&&B[1][0]!=X[6]) return;
        if(B[2][0]&&B[2][0]!=X[7]) return;
        
        if(X[2]+X[5]==7) return;
        
        vector<vector<vector<dice>>> Y(3,vector<vector<dice>>(3,vector<dice>(3)));
        
        Y[0][2][0].init(X[2],X[5]);
        Y[0][2][1].init(X[3],7-Y[0][2][0].r);
        Y[0][2][1].turn1();
        Y[0][2][2].init(X[4],7-Y[0][2][1].r);
        Y[0][2][2].turn1();
        
        Y[0][1][0].init(X[1],7-Y[0][2][0].b);
        Y[0][1][1].init(7-Y[0][1][0].r,7-Y[0][2][1].b);
        Y[0][1][1].turnL();
        Y[0][1][2].init(7-Y[0][1][1].r,7-Y[0][2][2].b);
        Y[0][1][2].turnL();
        
        Y[0][0][0].init(X[0],7-Y[0][1][0].b);
        Y[0][0][1].init(7-Y[0][0][0].r,7-Y[0][1][1].b);
        Y[0][0][1].turnL();
        Y[0][0][2].init(7-Y[0][0][1].r,7-Y[0][1][2].b);
        Y[0][0][2].turnL();
        
        //
        
        Y[1][2][0].init(7-Y[0][2][0].d,X[6]);
        Y[1][2][1].init(7-Y[0][2][1].d,7-Y[1][2][0].r);
        Y[1][2][1].turn1();
        Y[1][2][2].init(7-Y[0][2][2].d,7-Y[1][2][1].r);
        Y[1][2][2].turn1();
        
        Y[1][1][0].init(7-Y[0][1][0].d,7-Y[1][2][0].b);
        Y[1][1][1].init(7-Y[0][1][1].d,7-Y[1][2][1].b);
        Y[1][1][2].init(7-Y[0][1][2].d,7-Y[1][2][2].b);
        
        Y[1][0][0].init(7-Y[0][0][0].d,7-Y[1][1][0].b);
        Y[1][0][1].init(7-Y[0][0][1].d,7-Y[1][1][1].b);
        Y[1][0][2].init(7-Y[0][0][2].d,7-Y[1][1][2].b);
        
        //
        
        Y[2][2][0].init(7-Y[1][2][0].d,X[7]);
        Y[2][2][1].init(7-Y[1][2][1].d,7-Y[2][2][0].r);
        Y[2][2][1].turn1();
        Y[2][2][2].init(7-Y[1][2][2].d,7-Y[2][2][1].r);
        Y[2][2][2].turn1();
        
        Y[2][1][0].init(7-Y[1][1][0].d,7-Y[2][2][0].b);
        Y[2][1][1].init(7-Y[1][1][1].d,7-Y[2][2][1].b);
        Y[2][1][2].init(7-Y[1][1][2].d,7-Y[2][2][2].b);
        
        Y[2][0][0].init(7-Y[1][0][0].d,7-Y[2][1][0].b);
        Y[2][0][1].init(7-Y[1][0][1].d,7-Y[2][1][1].b);
        Y[2][0][2].init(7-Y[1][0][2].d,7-Y[2][1][2].b);
        
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                if(A[i][j]&&A[i][j]!=Y[0][i][j].u) return;
                if(B[i][j]&&B[i][j]!=Y[i][2][j].f) return;
            }
        }
        
        for(int z=0;z<3;z++){
            for(int x=0;x<3;x++){
                for(int y=0;y<3;y++){
                    if(abs(Y[z][x][y].u)>=7) return;
                    if(abs(Y[z][x][y].f)>=7) return;
                    if(abs(Y[z][x][y].r)>=7) return;
                    if(abs(Y[z][x][y].b)>=7) return;
                    if(abs(Y[z][x][y].l)>=7) return;
                    if(abs(Y[z][x][y].d)>=7) return;
                }
            }
        }
        
        int sum=0;
        
        for(int z=0;z<3;z++){
            for(int x=0;x<3;x++){
                sum+=Y[z][x][2].r;
            }
        }
        
        ans.insert(sum);
        
        return;
    }
    
    for(int i=1;i<=6;i++){
        X.push_back(i);
        DFS();
        X.pop_back();
    }
}

int main(){
    
    std::ifstream in("text.txt");
    std::cin.rdbuf(in.rdbuf());
    cin.tie(0);
    ios::sync_with_stdio(false);
    
    int Q;cin>>Q;
    while(Q--){
        ans.clear();
        for(int i=0;i<3;i++) for(int j=0;j<3;j++) cin>>A[i][j];
        for(int i=0;i<3;i++) for(int j=0;j<3;j++) cin>>B[i][j];
        
        DFS();
        
        if(si(ans)==0) cout<<0<<endl;
        else{
            for(auto it=ans.begin();it!=ans.end();it++){
                if(it!=ans.begin()) cout<<" ";
                cout<<*it;
            }
            cout<<endl;
        }
    }
}



Measured memory_bytes: 3188