#include <fstream>
#include <vector>

using namespace std;

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

const int inf= 1<<30;
const int nmax= 32000;
const int logmax= 16;

int n, m, p, k;

bool u[nmax+1];
int l[nmax*2+1], e[nmax*2+1], lvl[nmax+1], ind[nmax+1], d[nmax*2+1][logmax+1];
int v[nmax+1], nr[nmax+1][logmax+1], o[nmax+1][logmax+1];

struct str {
    int x, y;
};

vector <str> g[nmax+1];

inline str mp( int x, int y ) {
    str sol;
    sol.x= x, sol.y= y;

    return sol;
}

void dfs( int x ) {
    u[x]= 1;
    e[++k]= x;
    for ( vector <str>::iterator it= g[x].begin(); it!=g[x].end(); ++it ) {
        if ( u[(*it).x]==0 ) {
            lvl[(*it).x]= lvl[x]+1;
            v[(*it).x]= (*it).y;
            nr[(*it).x][0]= (*it).x, nr[(*it).x][1]= x;
            o[(*it).x][0]= v[(*it).x], o[(*it).x][1]= min(v[(*it).x], v[x]);
            for ( int p= 1; (1<<p)<=lvl[(*it).x]+1; ++p ) {
                nr[(*it).x][p]= nr[nr[nr[(*it).x][p-1]][1]][p-1];
                o[(*it).x][p]= min(o[(*it).x][p-1], o[nr[nr[(*it).x][p-1]][1]][p-1]);
            }
            dfs((*it).x);
            e[++k]= x;
        }
    }
}

int query( int a, int b ) {
    int x= min(ind[a], ind[b]), y= max(ind[a], ind[b]), k= 0;
    for ( int p= 1; p*2<=y-x+1; p*= 2, ++k ) ;

    if ( l[d[x][k]]<l[d[y-(1<<k)+1][k]] ) {
        return e[d[x][k]];
    } else {
        return e[d[y-(1<<k)+1][k]];
    }
}

int get_min( int x, int y ) {
    int ans= inf, aux= lvl[x]-lvl[y], step;
    for ( step= 0; (1<<(step+1))<=aux; ++step ) ;
    for ( ; step>=0 && aux>0; --step ) {
        if ( lvl[nr[x][step]]>lvl[y] ) {
            ans= min(ans, o[x][step]);
            x= nr[x][step];
        }
    }

    return ans;
}

int main(  ) {
    fin>>n>>m>>p;
    for ( int i= 1, x, y; i<=n-1; ++i ) {
        fin>>x>>y;
        g[x].push_back(mp(i+1, y));
        g[i+1].push_back(mp(x, y));
    }

    nr[1][0]= 1;
    dfs(1);
    for ( int i= 1; i<=k; ++i ) {
        d[i][0]= i;
        l[i]= lvl[e[i]];
        if ( ind[e[i]]==0 ) {
            ind[e[i]]= i;
        }
    }

    for ( int j= 1; (1<<j)<=k; ++j ) {
        for ( int i= 1; i+(1<<j)-1<=k; ++i ) {
            if ( l[d[i][j-1]]<l[d[i+(1<<(j-1))][j-1]] ) {
                d[i][j]= d[i][j-1];
            } else {
                d[i][j]= d[i+(1<<(j-1))][j-1];
            }
        }
    }

    int x, y, a, b, c, d, z, lca;
    fin>>x>>y>>a>>b>>c>>d;
    lca= query(x, y);
    z= min(get_min(x, lca), get_min(y, lca));
    if ( z==inf ) {
        z= 0;
    }
    for ( int cnt= 2; cnt<=m; ++cnt ) {
        x= (x*a+y*b)%n+1;
        y= (y*c+z*d)%n+1;
        lca= query(x, y);
        z= min(get_min(x, lca), get_min(y, lca));
        if ( z==inf ) {
            z= 0;
        }

        if ( cnt>=m-p+1 ) {
            fout<<z<<"\n";
        }
    }

    return 0;
}