#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")

#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#pragma GCC target("avx2")

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")



int OP[3][3];
int N;
vector<int> THR, FIV;
vector<int> A, B;

int P[5], Q[5], S[3][5];

vector<int> as, bs;
vector<Int> cs;
void rec(int i, int h0) {
  if (i) {
    --i;
    for (int h = h0; h < h0 + FIV[i]; ++h) {
      int tmp[5] = {};
      // for (int k = 0; k < 5; ++k) for (int x = 0; x < 3; ++x) if (P[k] >> x & 1) tmp[k] += as[h + x * FIV[i]];
      for (int x = 0; x < 3; ++x) {
        const int a = as[h + x * FIV[i]];
        if (a) {
          for (int k = 0; k < 5; ++k) if (P[k] >> x & 1) tmp[k] += a;
        }
      }
      for (int k = 0; k < 5; ++k) as[h + k * FIV[i]] = tmp[k];
    }
    for (int h = h0; h < h0 + FIV[i]; ++h) {
      int tmp[5] = {};
      // for (int k = 0; k < 5; ++k) for (int y = 0; y < 3; ++y) if (Q[k] >> y & 1) tmp[k] += bs[h + y * FIV[i]];
      for (int y = 0; y < 3; ++y) {
        const int b = bs[h + y * FIV[i]];
        if (b) {
          for (int k = 0; k < 5; ++k) if (Q[k] >> y & 1) tmp[k] += b;
        }
      }
      for (int k = 0; k < 5; ++k) bs[h + k * FIV[i]] = tmp[k];
    }
    for (int k = 0; k < 5; ++k) {
      rec(i, h0 + k * FIV[i]);
    }
    for (int h = h0; h < h0 + FIV[i]; ++h) {
      Int tmp[5] = {};
      for (int z = 0; z < 3; ++z) for (int k = 0; k < 5; ++k) tmp[z] += S[z][k] * cs[h + k * FIV[i]];
      for (int z = 0; z < 5; ++z) cs[h + z * FIV[i]] = tmp[z];
    }
  } else {
    cs[h0] = (Int)as[h0] * bs[h0];
  }
}

int main() {
  for (; ; ) {
    for (int x = 0; x < 3; ++x) for (int y = 0; y < 3; ++y) {
      if (!~scanf("%d", &OP[x][y])) return 0;
    }
    scanf("%d", &N);
    THR.resize(N + 1);
    FIV.resize(N + 1);
    THR[0] = 1;
    FIV[0] = 1;
    for (int i = 1; i <= N; ++i) THR[i] = THR[i - 1] * 3;
    for (int i = 1; i <= N; ++i) FIV[i] = FIV[i - 1] * 5;
    A.resize(THR[N]); for (int g = 0; g < THR[N]; ++g) scanf("%d", &A[g]);
    B.resize(THR[N]); for (int g = 0; g < THR[N]; ++g) scanf("%d", &B[g]);
    
    for (int r1 = 0; r1 < 48; ++r1) for (int r2 = 0; r2 < r1; ++r2) for (int r3 = 0; r3 < r2; ++r3) for (int r4 = 0; r4 < r3; ++r4) {
      const int rs[5] = {48, r1, r2, r3, r4};
      for (int k = 0; k < 5; ++k) {
        P[k] = 1 + rs[k] / 7;
        Q[k] = 1 + rs[k] % 7;
      }
      bool oks[3] = {};
#define reps(s) for (int s = -1; s <= +1; ++s)
      reps(s0) reps(s1) reps(s2) reps(s3) reps(s4) {
        const int ss[5] = {s0, s1, s2, s3, s4};
        int coef[3][3] = {};
        for (int k = 0; k < 5; ++k) {
          for (int x = 0; x < 3; ++x) if (P[k] >> x & 1)
          for (int y = 0; y < 3; ++y) if (Q[k] >> y & 1)
          {
            coef[x][y] += ss[k];
          }
        }
        for (int z = 0; z < 3; ++z) {
          bool ok = true;
          for (int x = 0; x < 3; ++x) for (int y = 0; y < 3; ++y) {
            // ok = ok && (coef[x][y] == ((OP[x][y] == z) ? 1 : 0));
            if (!(coef[x][y] == ((OP[x][y] == z) ? 1 : 0))) { ok = false; break; }
          }
          if (ok) {
            oks[z] = true;
            copy(ss, ss + 5, S[z]);
          }
          if (!oks[z]) break;
        }
      }
#undef reps
      if (oks[0] && oks[1] && oks[2]) {
        goto found;
      }
    }
cerr<<"not found"<<endl;
    assert(false);
   found:{}
cerr<<"P = ";pv(P,P+5);
cerr<<"Q = ";pv(Q,Q+5);
for(int z=0;z<3;++z){cerr<<"S["<<z<<"] = ";pv(S[z],S[z]+5);}
    
    as.assign(FIV[N], 0);
    bs.assign(FIV[N], 0);
    cs.assign(FIV[N], 0);
    for (int g = 0; g < THR[N]; ++g) {
      int h = 0;
      for (int i = 0; i < N; ++i) h += (g / THR[i] % 3) * FIV[i];
      as[h] = A[g];
      bs[h] = B[g];
    }
    rec(N, 0);
    for (int g = 0; g < THR[N]; ++g) {
      int h = 0;
      for (int i = 0; i < N; ++i) h += (g / THR[i] % 3) * FIV[i];
      if (g) printf(" ");
      printf("%lld", cs[h]);
    }
    puts("");
  }
  return 0;
}