#include <bits/stdc++.h>

using namespace std;

ifstream fin("iepuri.in");
ofstream fout("iepuri.out");

#define MOD 666013

// dp[0] = X, dp[1] = Y, dp[2] = Z.
// dp[i] = A * dp[i - 1] + B * dp[i - 2] + C * dp[i - 3], daca i>=3.
// Starea la pasul initial (dp[0], dp[1], dp[2]) = S(2).
// Starea la pasul i: (dp[i-2] dp[i-1] dp[i]) = S(i).
// Starea la pasul i+1 : (dp[i-1] dp[i] dp[i+1]) = S(i+1).

// S(i+1) = S_i * A,
// unde A = 0 0 C
//          1 0 B
//          0 1 A
// Avem nevoie de S(N).
// S(N) = S(N-1) * A = S(N-2) * A^2 = ... = S(2) * A^(N - 2).

// E suficient sa calculam A^(N-2) si apoi afisam (X * A[1][3] + Y * A[2][3] + Z
// * A[3][3]) % MOD, daca facem indexarea lin. si col. lui A de la 1.

// Daca N = 0 sau 1 sau 2, afisam, respectiv, X, Y sau Z.

void inmultire_matrice(int A[3][3], int B[3][3], int C[3][3]) {
  int temp[3][3];

  memset(temp, 0, sizeof(temp));

  for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++)
      for (int k = 0; k < 3; k++)
        temp[i][j] =
            (temp[i][j] % MOD + (A[i][k] % MOD * B[k][j] % MOD) % MOD) % MOD;

  memcpy(C, temp, sizeof(temp));
}

void putere_matrice(int A[3][3], int exponent, int B[3][3]) {
  if (exponent == 0) {  // A^0 = I3
    memset(B, 0, sizeof(int) * 9);
    for (int i = 0; i < 3; i++) B[i][i] = 1;
    return;
  }

  if (exponent == 1) {
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++) B[i][j] = A[i][j] % MOD;
    return;
  }

  int temp[3][3], val = exponent / 2;

  putere_matrice(A, val, temp);
  inmultire_matrice(temp, temp, temp);

  if (exponent % 2) inmultire_matrice(temp, A, temp);

  memcpy(B, temp, sizeof(temp));
}

int main() {
  int t, x, y, z, a, b, c, n, putere[3][3],
      A[3][3] = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}};

  fin >> t;

  for (int i = 1; i <= t; i++) {
    fin >> x >> y >> z >> a >> b >> c >> n;

    A[0][2] = c;
    A[1][2] = b;
    A[2][2] = a;

    switch (n) {
      case 0:
        fout << x << '\n';
        break;
      case 1:
        fout << y << '\n';
        break;
      case 2:
        fout << z << '\n';
        break;
      default:
        putere_matrice(A, n - 2, putere);
        fout << (x * putere[0][2] + y * putere[1][2] + z * putere[2][2])
             << '\n';
    }
  }
  
  return 0;
}