#include <bits/stdc++.h>
 
using namespace std;

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

const int MOD = 666013;

class matrix {
    public:
        vector< vector< int > > m_data;

        matrix() {
            m_data.resize(3, vector< int > (3));

            m_data[0][0] = 1; m_data[0][1] = 0; m_data[0][2] = 0;
            m_data[1][0] = 0; m_data[1][1] = 1; m_data[1][2] = 0;
            m_data[2][0] = 0; m_data[2][1] = 0; m_data[2][2] = 1;
        }

        matrix(int a, int b, int c) {
            m_data.resize(3, vector< int >(3));

            m_data[0][0] = 0; m_data[0][1] = 1; m_data[0][2] = 0;
            m_data[1][0] = 0; m_data[1][1] = 0; m_data[1][2] = 1;
            m_data[2][0] = a; m_data[2][1] = b; m_data[2][2] = c;
        }

        matrix(const matrix &other) {
            this->m_data.resize(3, vector< int >(3));

            for(int i = 0; i < 3; ++i) {
                for(int j = 0; j < 3; ++j) {
                    this->m_data[i][j] = other.m_data[i][j];
                }
            }
        }

        matrix& operator=(const matrix &other) {
            if(this == &other) {
                return *this;
            }

            this->m_data.resize(3, vector< int >(3));

            for(int i = 0; i < 3; ++i) {
                for(int j = 0; j < 3; ++j) {
                    this->m_data[i][j] = other.m_data[i][j];
                }
            }

            return *this;
        }

        matrix operator*(const matrix &other) const {
            matrix result;

            for(int i = 0; i < 3; ++i) {
                for(int j = 0; j < 3; ++j) {
                    int newElement = 0;
                    for(int k = 0; k < 3; ++k) {
                        newElement += (this->m_data[i][k] * other.m_data[k][j]);
                    }

                    result.m_data[i][j] = newElement;
                }
            }

            return result;
        }

        ~matrix() {
            for(int i = 0; i < 3; ++i) {
                m_data[i].clear();
            }
            m_data.clear();
        }
};

matrix modulo(const matrix &other) {
    matrix result;
    result = other;

    for(int i = 0; i < 3; ++i) {
        for(int j = 0; j < 3; ++j) {
            result.m_data[i][j] %= MOD;
        }
    }

    return result;
}

matrix lgput(matrix n, int p) {
    if(p == 0) {
        matrix identicalMatrix;
        return identicalMatrix;
    }
    if(p == 1) {
        return n;
    }

    if(p % 2 == 0) {
        return modulo(lgput(modulo(n * n), p / 2));
    } else {
        return modulo(n * lgput(modulo(n * n), p / 2));
    }
}

int main() {
    ios::sync_with_stdio(false); in.tie(0); out.tie(0);

    int t; in >> t;
    
    while(t--) {
        int x, y, z, a, b, c, n; in >> x >> y >> z >> a >> b >> c >> n;

        matrix m = matrix(c, b, a);
        matrix result = lgput(m, n - 2);

        int targetElement = (result.m_data[2][0] * x) % MOD + (result.m_data[2][1] * y) % MOD + (result.m_data[2][2] * z) % MOD;
        out << targetElement % MOD << "\n";
    }
 
    in.close(); out.close();
 
    return 0;
}