#include <bits/stdc++.h>

#define MOD  666013
#define llg  long long

template <int Dimm, typename Data> struct MatrixLine {
    Data& operator [] (int Index) {
        return Value[Index];
    }   Data Value[Dimm];
};

template <int Lines, int Colls, typename Data> class Matrix {
public:
    MatrixLine <Colls, Data>& operator [] (int Index) {
        return Values[Index];
    }

    bool operator == (Matrix <Lines, Colls, Data> Other) {
        for (int i=0, j; i<Lines; ++i)
            for (j=0; j<Colls; ++j)
                if (Values[i][j] != Other[i][j])
                    return false;
        return true;
    }

protected:
    MatrixLine <Colls, Data> Values[Lines];
};

template <int DimmPatratic, typename Data>
Matrix <DimmPatratic, DimmPatratic, Data>& operator * (Matrix <DimmPatratic, DimmPatratic, Data> M, Matrix <DimmPatratic, DimmPatratic, Data> Other) {
    Matrix <DimmPatratic, DimmPatratic, Data> Result;

    for (int i=0, j, k; i<DimmPatratic; ++i)
        for (j=0; j<DimmPatratic; ++j) {
            Result[i][j] = 0;
            for (k=0; k<DimmPatratic; ++k)
                Result[i][j] = (Result[i][j] + M[i][k] * Other[k][j]) % MOD;
        }   return Result;
}

class Matrix3x3 : public Matrix <3, 3, llg> {
public:
    Matrix3x3(llg a11 = 1, llg a12 = 0, llg a13 = 0, llg a21 = 0, llg a22 = 1, llg a23 = 0, llg a31 = 0, llg a32 = 0, llg a33 = 1) {
        Values[0][0] = a11; Values[0][1] = a12; Values[0][2] = a13;
        Values[1][0] = a21; Values[1][1] = a22; Values[1][2] = a23;
        Values[2][0] = a31; Values[2][1] = a32; Values[2][2] = a33;
    }
};

Matrix3x3 operator * (Matrix3x3 M, Matrix3x3 Other) {
    Matrix3x3 Result;

    for (int i=0, j, k; i<3; ++i)
        for (j=0; j<3; ++j) {
            Result[i][j] = 0;
            for (k=0; k<3; ++k)
                Result[i][j] = (Result[i][j] + M[i][k] * Other[k][j]) % MOD;
        }   return Result;
}

std::ifstream In("iepuri.in");
std::ofstream Out("iepuri.out");

template <typename Data>
Data FastPow(Data Baza, int Exp) {
    if (Exp == 0) return Data();
    Data V = FastPow(Baza, Exp/2);

    if (Exp%2) return V * V * Baza;
    return V * V;
}

int X, Y, Z, A, B, C, N;

void Citire() {
    In >> X >> Y >> Z >> A >> B >> C >> N;
}

void Rezolvare() {
    Matrix3x3 MatrixRec(A, B, C, 1, 0, 0, 0, 1, 0);
    MatrixRec = FastPow(MatrixRec, N-2);

    Out << (MatrixRec[0][0] * Z + MatrixRec[0][1] * Y + MatrixRec[0][2] * X) % MOD << '\n';
}

int main()
{
    int T; In >> T;
    while (T--) {
        Citire();
        Rezolvare();
    }

    return 0;
}