#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXQ = 1000000;
const int MAXN = 100000 + 5;
const int MOD = 1000000000 + 7;
const int MAX_NODES = 50000000;
const int LARGE = 316;
const int PRIMES_SMALLER_LARGE = 67;
const int MAX_LOG = 17;

struct node {
    int l, r, prod;
    node *hL;
    node *hR;
} nodes[MAX_NODES];

int hp;
int Tn, N1, K1, A, B, M, C[MAXQ + 10], D[MAXQ + 10], prev_ans;
node* tree[MAXN + 10];

node* create (int l, int r) {
    node* me = &nodes[hp++];
    me->l = l;
    me->r = r;
    me->prod = 1;
    if (l < r) {
        me->hL = create(l, (l + r) / 2);
        me->hR = create((l + r) / 2 + 1, r);
    }
    return me;
}

node* change (node *anc, int pos, int val) {
    node* me = &nodes[hp++];
    me->l = anc->l;
    me->r = anc->r;
    me->prod = anc->prod;
    me->hL = anc->hL;
    me->hR = anc->hR;
    if (me->l == me->r) {
        me->prod = (me->prod * 1LL * val) % MOD;
        return me;
    } else {
        if (pos <= me->hL->r)
            me->hL = change(me->hL, pos, val);
        else
            me->hR = change(me->hR, pos, val);
        me->prod = (me->hL->prod * 1LL * me->hR->prod) % MOD;
        return me;
    }
}

int query (node *cur, int l, int r) {
    if (cur->l == l && cur->r == r)
        return cur->prod;
    int ret = 1;
    if (l <= min(r, cur->hL->r))
        ret = query(cur->hL, l, min(r, cur->hL->r));
    if (max(l, cur->hR->l) <= r)
        ret = (ret * 1LL * query(cur->hR, max(l, cur->hR->l), r)) % MOD;
    return ret;
}

int last_used[MAXN + 10], pd[MAXN + 10], inverse[MAXN + 10];
int w[MAX_LOG + 10], wp[MAX_LOG + 10], wa[MAX_LOG + 10];
pair<int, int> stack[MAXN + 10][MAX_LOG + 10]; // (power, postition)
int sp[MAXN + 10];

inline int binpow (int a, int b) {
    if (b == 1)
        return a;
    int q = binpow(a, b / 2);
    q = (q * 1LL * q) % MOD;
    if (b % 2 == 0)
        return q;
    else
        return (q * 1LL * a) % MOD;
}

inline void precalc_large_part () {
    tree[1] = create(1, M + 1);
    for(int i = 2; i <= M + 1; i++) {
        node* current_version = tree[i - 1];
        int j = i;
        int wn = 0;
        while (j > 1) {
            if (wn > 0 && w[wn] == pd[j]) {
                wp[wn]++;
                wa[wn] *= pd[j];
            } else {
                w[++wn] = pd[j];
                wa[wn] = pd[j];
                wp[wn] = 1;
            }
            j /= pd[j];
        }
        
        for(int j = 1; j <= wn; j++) {
            while (sp[w[j]] > 0 && stack[w[j]][sp[w[j]]].first <= wp[j]) {
                int pow = stack[w[j]][sp[w[j]]].first;
                current_version = change(current_version, stack[w[j]][sp[w[j]]].second, inverse[binpow(w[j], pow)]);
                --sp[w[j]];
                if (sp[w[j]] > 0)
                    current_version = change(current_version, stack[w[j]][sp[w[j]]].second, binpow(w[j], pow));
            }
            if (sp[w[j]] > 0) {
                int pos = stack[w[j]][sp[w[j]]].second;
                current_version = change(current_version, pos, inverse[wa[j]]);
            }
            ++sp[w[j]];
            stack[w[j]][sp[w[j]]] = make_pair(wp[j], i);
            current_version = change(current_version, i, wa[j]);
        }
        
        tree[i] = current_version;
    }
}

void precalc_primes () {
    pd[1] = 1;
    for(int i = 2; i <= MAXN; i++) {
        if (!pd[i])
            for(int j = i; j <= MAXN; j += i)
                if (!pd[j])
                    pd[j] = i;
        inverse[i] = binpow(i, MOD - 2);
    }
}

inline int solve (int Ni, int Ki) {
    int L = Ni + 1 - Ki, R = Ni;
    int ret = query(tree[R], L, R);
    return ret;
}

inline int fastio () {
    int ret = 0, fl = 0, ch;
    while (true) {
        ch = getchar();
        if (ch < 48) {
            if (fl)
                return ret;
            continue;
        }
        ret = 10 * ret + ch - 48;
        fl = 1;
    }
}

int main () {
    //    freopen("input.txt", "r", stdin);
    
    scanf("%d", &Tn);
    scanf("%d %d", &N1, &K1);
    scanf("%d %d %d", &A, &B, &M);
    
    precalc_primes();
    precalc_large_part();
    
    printf("%d\n", (prev_ans = solve(N1, K1)));
    
    for(int i = 1; i < Tn; i++)
        C[i] = fastio();
    for(int i = 1; i < Tn; i++)
        D[i] = fastio();
    
    for(int i = 1; i < Tn; i++) {
        int Ni = 1 + (A * 1LL * prev_ans + C[i]) % M;
        int Ki = 1 + (B * 1LL * prev_ans + D[i]) % Ni;
        printf("%d\n", (prev_ans = solve(Ni, Ki)));
    }
    
    return 0;
}