#include <bits/stdc++.h> 
#define assert(x) 
using namespace std;
//typedef long double db;
typedef double db;

// CP
// Function to compute the outer product of three vectors
vector<vector<vector<db>>> outer(const vector<db>& a, const vector<db>& b, const vector<db>& c) {
    int I = a.size();
    int J = b.size();
    int K = c.size();
    vector<vector<vector<db>>> result(I, vector<vector<db>>(J, vector<db>(K, 0)));

    for (int i = 0; i < I; ++i)
        for (int j = 0; j < J; ++j)
            for (int k = 0; k < K; ++k)
                result[i][j][k] = a[i] * b[j] * c[k];
    return result;
}

// Function to reconstruct the tensor from factor matrices
vector<vector<vector<db>>> reconstruct(const vector<vector<db>>& A, const vector<vector<db>>& B, const vector<vector<db>>& C, int I, int J, int K, int R) {
    vector<vector<vector<db>>> tensor_reconstructed(I, vector<vector<db>>(J, vector<db>(K, 0)));
    
    for (int r = 0; r < R; ++r) {
        auto outer_product = outer(A[r], B[r], C[r]);
        for (int i = 0; i < I; ++i)
            for (int j = 0; j < J; ++j)
                for (int k = 0; k < K; ++k)
                    tensor_reconstructed[i][j][k] += outer_product[i][j][k];
    }
    return tensor_reconstructed;
}

// Function to compute the Frobenius norm
db frobeniusNorm(const vector<vector<vector<db>>>& tensor1, const vector<vector<vector<db>>>& tensor2, int I, int J, int K) {
    db norm = 0.0;
    for (int i = 0; i < I; ++i)
        for (int j = 0; j < J; ++j)
            for (int k = 0; k < K; ++k)
                norm += (tensor1[i][j][k] - tensor2[i][j][k]) * (tensor1[i][j][k] - tensor2[i][j][k]);
    assert(norm>=0);
    return sqrt(norm);
}

// Gradient descent for CP decomposition
db mn=1e100;
vector<vector<db>>mA,mB,mC;
mt19937 rnd(342356);
bool CPDecomposition(const vector<vector<vector<db>>>& tensor, int I, int J, int K, int R, vector<vector<db>>& A, vector<vector<db>>& B, vector<vector<db>>& C, db learning_rate = 0.01, int max_iter = 30000) {
	int w=0;

    // Initialize factor matrices randomly
    A.resize(R, vector<db>(I));
    B.resize(R, vector<db>(J));
    C.resize(R, vector<db>(K));
     
    for (int r = 0; r < R; ++r) {
        for (int i = 0; i < I; ++i) A[r][i] = static_cast<db>(rnd()&524287) / 524288;
        for (int j = 0; j < J; ++j) B[r][j] = static_cast<db>(rnd()&524287) / 524288;
        for (int k = 0; k < K; ++k) C[r][k] = static_cast<db>(rnd()&524287) / 524288;
    }
	db zz=0;
    for (int iter = 0; iter <= max_iter; ++iter) {
        // Reconstruct the tensor
        auto tensor_reconstructed = reconstruct(A, B, C, I, J, K, R);

        // Calculate the error tensor
        db error = frobeniusNorm(tensor, tensor_reconstructed, I, J, K);
		learning_rate=0.1*exp(-sqrtl(iter/max_iter));

        // Update A, B, C using gradients
        for (int r = 0; r < R; ++r) {
            for (int i = 0; i < I; ++i)
                for (int j = 0; j < J; ++j)
                    for (int k = 0; k < K; ++k) {
                        db gradient = (tensor_reconstructed[i][j][k] - tensor[i][j][k]) * B[r][j] * C[r][k];
                        assert(gradient>=0 || gradient <= 0);
                        A[r][i] -= learning_rate * gradient;
                        if (fabs(A[r][i]) > 1e2) // Too large
							return false;
                    }

            for (int j = 0; j < J; ++j)
                for (int i = 0; i < I; ++i)
                    for (int k = 0; k < K; ++k) {
                        db gradient = (tensor_reconstructed[i][j][k] - tensor[i][j][k]) * A[r][i] * C[r][k];
                        assert(gradient>=0 || gradient <= 0);
                        B[r][j] -= learning_rate * gradient;
                        if (fabs(B[r][j]) > 1e2) // Too large
							return false;
                    }

            for (int k = 0; k < K; ++k)
                for (int i = 0; i < I; ++i)
                    for (int j = 0; j < J; ++j) {
                        db gradient = (tensor_reconstructed[i][j][k] - tensor[i][j][k]) * A[r][i] * B[r][j];
                        assert(gradient>=0 || gradient <= 0);
                        C[r][k] -= learning_rate * gradient;
                        if (fabs(C[r][k]) > 1e2) // Too large
                            return false;
                    }
        }
        if(fabs(zz - error) / error < 1e-6)
            if(error > 1e-11)return false;
        zz = error;
        if (iter == 7000 && error > 1e-6) return false;
        if (iter % 5000 == 0 )
            cerr << "Iteration " << iter << ", Loss: " << error << endl;
    }
    return true;
}


const int V = 3;
const int I = V, J = V, K = V, R = 4;
int OP[V][V];
db A[R][V],B[R][V],C[R][V];
const int N=6e5+10,M=1e8+10;
db a[N],b[N],c[N];
db tmp[M],*O=tmp;
inline db*create(int len){db*x=O;O+=len;assert(O-tmp<M);return x;}

//The major function
void trans(db*a,db*b,db*c,int n)
{
	fill(c,c+n,0);
	if(n==1)
	{
		*c=*a* *b;
		return;
	}
	if(n==V)
	{
		for(int i=0;i<V;++i)for(int j=0;j<V;++j)
			if(OP[i][j]>=0)c[OP[i][j]]+=a[i]*b[j];
		return;
	}
	int m=n/V;
	db *_a=create(m),*_b=create(m),*_c=create(m); 
	for(int _=0;_<R;++_)
	{
		for(int i=0;i<m;++i){_a[i]=0;for(int j=0;j<V;++j)_a[i]+=A[_][j]*a[i*V+j];}
		for(int i=0;i<m;++i){_b[i]=0;for(int j=0;j<V;++j)_b[i]+=B[_][j]*b[i*V+j];}
		trans(_a,_b,_c,m);for(int i=0;i<m;++i)for(int j=0;j<V;++j)c[i*V+j]+=C[_][j]*_c[i];
	}
}


int main()
{
    cin.tie(0)->sync_with_stdio(0);
    for(int i=0;i<V;++i)
    	for(int j=0;j<V;++j)
    		cin>>OP[i][j];
    vector<vector<vector<db>>> tensor(I, vector<vector<db>>(J, vector<db>(K)));
    for(int i=0;i<I;++i)
        for(int j=0;j<J;++j)
            for(int k=0;k<K;++k)
            	tensor[i][j][k]=OP[i][j]==k; 

    vector<vector<db>>A,B,C;
    while(!CPDecomposition(tensor, I, J, K, R, A, B, C));

    for(int i=0;i<R;++i)for(int j=0;j<V;++j)
    	::A[i][j]=A[i][j],::B[i][j]=B[i][j],::C[i][j]=C[i][j];
    
    int base;cin>>base;
    int U=pow(V,base);
    for(int i=0;i<U;++i)cin>>a[i];
    for(int i=0;i<U;++i)cin>>b[i];
    trans(a,b,c,U);
    for(int i=0;i<U;++i)cout<<(long long)(c[i]+0.5)<<" ";cerr<<endl;
}