#include <iostream>
#include <fstream>
#include <stdlib.h>

const int MOD = 666013;

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

void pow_matrix(int** matrix, int ***rez, int n) {
    if (n == 0) {
        return;
    }

    int** temp = (int **)malloc(3 * sizeof(int*));
    for (int i = 0; i < 3; ++i) {
        temp[i] = (int *)malloc(3 * sizeof(int));
    }

    if (n % 2 == 0) {
        pow_matrix(matrix, rez, n / 2);
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                temp[i][j] = 0;
                for (int k = 0; k < 3; ++k) {
                    temp[i][j] += ((*rez)[i][k] * (*rez)[k][j]) % MOD;
                    temp[i][j] %= MOD;
                }
            }
        }
    } else {
        pow_matrix(matrix, rez, n - 1);
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                temp[i][j] = 0;
                for (int k = 0; k < 3; ++k) {
                    temp[i][j] += ((*rez)[i][k] * matrix[k][j]) % MOD;
                    temp[i][j] %= MOD;
                }
            }
        }
    }

    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            (*rez)[i][j] = temp[i][j] % MOD;
        }
    }

    for (int i = 0; i < 3; ++i) {
        free(temp[i]);
    }
    free(temp);
}

int main() {
    int T;
    fin >> T;

    int** matrix = (int **)malloc(3 * sizeof(int*));
    for (int i = 0; i < 3; ++i) {
        matrix[i] = (int *)malloc(3 * sizeof(int));
    }

    int **powered_matrix = (int **)malloc(3 * sizeof(int*));
    for (int i = 0; i < 3; ++i) {
        powered_matrix[i] = (int *)malloc(3 * sizeof(int));
    }
    
    while (T--) {
        int ans = 0, x, y, z;
        fin >> x >> y >> z;
    
        int a, b, c, n;
        fin >> a >> b >> c >> n;
    
        matrix[0][0] = a;
        matrix[0][1] = b;
        matrix[0][2] = c;
        matrix[1][0] = 1;
        matrix[1][1] = 0;
        matrix[1][2] = 0;
        matrix[2][0] = 0;
        matrix[2][1] = 1;
        matrix[2][2] = 0;

        powered_matrix[0][0] = 1;
        powered_matrix[0][1] = 0;
        powered_matrix[0][2] = 0;
        powered_matrix[1][0] = 0;
        powered_matrix[1][1] = 1;
        powered_matrix[1][2] = 0;
        powered_matrix[2][0] = 0;
        powered_matrix[2][1] = 0;
        powered_matrix[2][2] = 1;

        pow_matrix(matrix, &powered_matrix, n - 2);
        fout << ((powered_matrix[0][0] * z) % MOD
                + (powered_matrix[0][1] * y) % MOD
                + (powered_matrix[0][2] * x) % MOD) % MOD << '\n';
    }
    return 0;
}