#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

ifstream fin("atac.in");
ofstream fout("atac.out");

const int INF = 0x3f3f3f3f;

int N, M, P, X, Y, A, B, C, D, K;
int Euler[70005], First[35005], Lvl[70005], logaritm[70005];
int RMQ[17][70005];
int str[17][35005], min_bomb[17][35005];
vector<pair<int, int> > V[35005];

void make_euler(int nod, int lvl)
{
    Euler[++K] = nod;
    Lvl[K] = lvl;
    First[nod] = K;

    for (vector<pair<int, int> >::iterator it = V[nod].begin(); it != V[nod].end(); ++it)
    {
        str[0][it->first] = nod;
        min_bomb[0][it->first] = it->second;

        make_euler(it->first, lvl + 1);
        Euler[++K] = nod;
        Lvl[K] = lvl;
    }

}

void make_rmq()
{
    logaritm[1] = 0;
    for (int i = 2; i <= K; ++i)
        logaritm[i] = logaritm[i / 2] + 1;

    for (int i = 1; i <= K; ++i)
        RMQ[0][i] = i;

    for (int i = 1; (1 << i) <= K; ++i)
        for (int j = 1; j + (1 << (i - 1)) <= K; ++j)
        {
            int l = (1 << (i - 1));
            if (Lvl[RMQ[i - 1][j]] <= Lvl[RMQ[i - 1][j + l]])
                RMQ[i][j] = RMQ[i - 1][j];
            else
                RMQ[i][j] = RMQ[i - 1][j + l];
        }
}

int get_lca(int a, int b)
{
    int sol;
    int start = First[a];
    int finish = First[b];
    if (start > finish)
        swap(start, finish);
    int dif = finish - start + 1;
    int l = logaritm[dif];

    if (Lvl[RMQ[l][start]] <= Lvl[RMQ[l][finish - (1 << l) + 1]])
        sol = RMQ[l][start];
    else
        sol = RMQ[l][finish - (1 << l) + 1];

    return Euler[sol];
}

void make_str()
{
    for (int i = 1; i <= logaritm[N]; ++i)
        for (int j = 1; j <= N; ++j)
        {
            str[i][j] = str[i - 1][str[i - 1][j]];
            min_bomb[i][j] = min(min_bomb[i - 1][j], min_bomb[i - 1][str[i - 1][j]]);
        }
}

int find_str(int now, int nod)
{
    int dif;

    if (nod == 0)
        return now;

    while (nod >= 1)
    {
        int l = logaritm[nod];

        now = str[l][now];
        nod -= (1 << l);
    }

    return now;
}

int main()
{
    fin >> N >> M >> P;
    for (int i = 1, nod, cost; i <= N - 1; ++i)
    {
        fin >> nod >> cost;
        V[nod].push_back(make_pair(i + 1, cost));
    }
    fin >> X >> Y >> A >> B >> C >> D;

    make_euler(1, 1);
    make_rmq();
    make_str();

    for (int i = 1; i <= M; ++i)
    {
        int lca = get_lca(X, Y);
        int sol1 = INF, sol2 = INF, nowstr, dif, l;

        if (X != lca)
        {
            dif = Lvl[First[X]] - Lvl[First[lca]];
            l = logaritm[dif];

            nowstr = find_str(X, dif - (1 << l));
            sol1 = min(min_bomb[l][X], min_bomb[l][nowstr]);
        }

        if (Y != lca)
        {
            dif = Lvl[First[Y]] - Lvl[First[lca]];
            l = logaritm[dif];

            nowstr = find_str(Y, dif - (1 << l));
            sol2 = min(min_bomb[l][Y], min_bomb[l][nowstr]);
        }

        int Z = min(sol1, sol2);

        X = (X * A + Y * B) % N + 1;
        Y = (Y * C + Z * D) % N + 1;

        if (M - i + 1 <= P)
            fout << Z << '\n';
    }

    fin.close();
    fout.close();
    return 0;
}