#include <fstream>
#include <vector>
#include <utility>
#define INF 0x3f3f3f3f

using namespace std;

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

vector<pair<int, int> > v[32001];
bool used[32001];
int euler[3*32001],n,m,p,A,B,C,D,X,Y,nre;
int nivel[32001];
int lg[3*32001];
int f[32001];
int arbore[32001];
int rmq[3*32001][23];
int bomba_minima[32001][16];


void dfs(int nod, int niv)
{
    used[nod] = true;
    arbore[niv] = nod;
    euler[++nre] = nod;
    nivel[nod] = niv;
    f[nod] = nre;

    int l = lg[niv];
    for(int i=1;i<=l;i++)
        bomba_minima[nod][i] = min(bomba_minima[nod][i-1],bomba_minima[nod+(1<<(i-1))][i-1]);

    for(unsigned int i=0;i<v[nod].size();i++)
        if(!used[v[nod][i].first])
        {
            bomba_minima[v[nod][i].first][0] = v[nod][i].second;
            dfs(v[nod][i].first,niv+1);
            euler[++nre] = nod;
            //nivel[nre] = niv;
        }
}

int get_min(int nod, int ancestor)
{
    int l = lg[nivel[ancestor] - nivel[nod]+1];
    return min(bomba_minima[nod][l],bomba_minima[ancestor - (1<<l)+1][l]);
}


int main()
{
    fin>>n>>m>>p;
    int an = n;
    int x,y;
    for(int i=2;i<=n;i++)
    {
        fin>>x>>y;
        v[i].push_back(make_pair(x,y));
        v[x].push_back(make_pair(i,y));
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=16;j++)
            bomba_minima[i][j] = INF;
        rmq[i][0] = i;
        if(i>1)
            lg[i] = lg[i>>1] + 1;
    }
    dfs(1,0);
    n=nre;

    for(int k=1;(1<<k)<=n;k++)
        for(int i=0;i+(1<<(k-1)) - 1<=n;i++)
            if(nivel[euler[rmq[i][k-1]]] < nivel[ euler[rmq[i+(1<<(k-1))][k-1]] ] )
                rmq[i][k] = rmq[i][k-1];
            else rmq[i][k] = rmq[i+(1<<(k-1))][k-1];

    fin>>X>>Y>>A>>B>>C>>D;

    for(int q=1;q<=m;q++)
    {
        int i = f[X];
        int j = f[Y];
        //fout<<X<<' '<<Y<<' ';
        if(i > j)
            swap(i,j);
        int l=lg[j-i+1],nod;
        if(nivel[euler[rmq[i][l]]]<nivel[euler[rmq[y-(1<<l)+1][l]]])
            nod = euler[rmq[i][l]];
        else nod = euler[rmq[y-(1<<l)+1][l]];
        int Z;
        if(X == Y)
            Z = 0;
        else Z = min(get_min(x,nod),get_min(y,nod));
        if(q>=m-p+1)
            fout<<Z<<'\n';
        X = (X*A + Y*B) % an + 1;
        Y = (Y*C + Z*D) % an + 1;
    }
    fin.close();
    fout.close();
    return 0;
}