#include <bits/stdc++.h>

using namespace std;
#define matrix_type vector<vector<unsigned long long>>

const long long MOD = 1e7 + 7;
const int MAX_POW = 2022;

bitset <2022 * 4> bin_n;
int len_bin_n = 0;

int char_to_int(char c){
    return (int)c - 48;
}

char int_to_char(int d){
    return (char)(d + 48);
}

void count_bit_1_str(string s){
    int ind = 0;
    bin_n.reset();

    while (s != ""){
        int last_digit = char_to_int(s[s.length() - 1]);
        if (last_digit & 1){
            s[s.length() - 1] = int_to_char(last_digit - 1);
            bin_n[ind] = 1;
        }

        int current_digit;
        for (int i=s.length() - 1; i>=0; i--){
            current_digit = char_to_int(s[i]);

            s[i] = int_to_char(current_digit / 2);
            if (current_digit & 1){
                s[i + 1] = int_to_char(char_to_int(s[i + 1]) + 5);
            }
        }

        if (s[0] == '0'){
            s.erase(0, 1);
        }
        ind++;
    }
    len_bin_n = ind - 1;
}

matrix_type mul_matrix(matrix_type matrix_1, matrix_type matrix_2){
    matrix_type result_matrix(matrix_1.size(), vector<unsigned long long>(matrix_2[0].size(), 0));

    for (int a=0; a<matrix_1.size(); a++){
        for (int b=0; b<matrix_2[0].size(); b++){
            unsigned long long s = 0;
            for (int c=0; c<matrix_1[0].size(); c++){
                s += matrix_1[a][c] * matrix_2[c][b];
            }
            result_matrix[a][b] = s;
        }
    }

    return result_matrix;
}

void mod_matrix(matrix_type &matrix){
    for (int i=0; i<matrix.size(); i++){
        for (int j=0; j<matrix[i].size(); j++){
            matrix[i][j] %= MOD;
        }
    }
}

void print_matrix(matrix_type matrix){
    for (int i=0; i<matrix.size(); i++){
        for (int j=0; j<matrix[i].size(); j++){
            cerr << matrix[i][j] << ' ';
        }
        cerr << '\n';
    }
    cerr << '\n';
}

matrix_type pow_matrix(int current_ind, matrix_type &base_matrix, matrix_type &unit_matrix){
    if (current_ind == len_bin_n){
        if (bin_n[len_bin_n]){
            return base_matrix;
        }
        else{
            return unit_matrix;
        }
    }
    else{
        matrix_type result_matrix;
        matrix_type pow_2 = pow_matrix(current_ind + 1, base_matrix, unit_matrix);

        if (bin_n[current_ind]){
            result_matrix = mul_matrix(mul_matrix(pow_2, pow_2), base_matrix);
            mod_matrix(result_matrix);
            return result_matrix;
        }
        else{
            result_matrix = mul_matrix(pow_2, pow_2);
            mod_matrix(result_matrix);
            return result_matrix;
        }
    }
}

int main(){
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);

    string n;
    unsigned long long ta, tb, tc;
    unsigned long long pa, pb, pc;
    cin >> n;
    cin >> ta >> tb >> tc;
    cin >> pa >> pb >> pc;

    matrix_type base_matrix = {
        {pa - 2, 1, 1},
        {1, pb - 2, 1},
        {1, 1, pc - 2}
    };

    matrix_type unit_matrix = {
        {1, 0, 0},
        {0, 1, 0},
        {0, 0, 1}
    };

    matrix_type t_matrix = {
        {ta},
        {tb},
        {tc}
    };

    count_bit_1_str(n);

    matrix_type result_matrix = mul_matrix(pow_matrix(0, base_matrix, unit_matrix), t_matrix);
    mod_matrix(result_matrix);

    cout << result_matrix[0][0] << ' ' << result_matrix[1][0] << ' ' << result_matrix[2][0];
}