#include <bits/stdc++.h>

using namespace std;

ifstream f("atac.in");
ofstream g("atac.out");

#define nod first
#define level second

int val[32001],parent[32001];
vector <pair <int, int>> euler;
vector <int> sons[32001];
int first_app[32001];
pair <int, int> rmq[64001][17];
int nivel[32001];
int unc[32001][17];
int minup[32001][17];
int lg[64001];

void dfs ( int nod, int lvl )
{
    euler.push_back({ nod, lvl });
    first_app[nod] = euler.size();
    nivel[nod] = lvl;
    unc[nod][0] = parent[nod];
    minup[nod][0] = val[nod];
    for ( int k = 1; k < 16; k ++ )
    {
        unc[nod][k] = unc[unc[nod][k - 1]][k - 1];
        minup[nod][k] = min ( minup[nod][k - 1], minup[unc[nod][k-1]][k - 1] );
    }
    for ( int i = 0; i < sons[nod].size(); i ++ )
    {
        dfs( sons[nod][i], lvl + 1 );
        euler.push_back({ nod, lvl });
    }
}

void compute_rmq ( int n )
{
    for ( int i = 2; i <= 2 * n - 1; i ++ )
        lg[i] = lg[i / 2] + 1;
    for ( int i = 1; i <  2 * n; i ++ )
        rmq[i][0] = euler[i - 1];
    for ( int j = 1; j <= lg[2 * n - 1]; j ++ )
        for ( int i = 1; i + ( 1 << j ) - 1 < 2 * n; i ++ )
        {
            if ( rmq[i][j-1].level < rmq[i + (1 << (j-1))][j-1].level )
                rmq[i][j] = rmq[i][j-1];
            else rmq[i][j] = rmq[i + (1 << (j-1))][j-1];
        }
}

int lca ( int a, int b )
{
    if ( a > b )
        swap ( a, b );
    int loggy = lg[b - a + 1];
    if ( rmq[a][loggy].level < rmq[b - ( 1 << loggy ) + 1][loggy].level )
        return rmq[a][loggy].nod;
    return rmq[b - ( 1 << loggy ) + 1][loggy].nod;
}

int min_to_unc ( int nod, int ancestor )
{
    int rez = INT_MAX, diff = nivel[nod] - nivel[ancestor];
    for ( int k = 15; k >= 0; k -- )
    {
        if ( diff >= ( 1 << k ) )
        {
            rez = min ( rez, minup[nod][k] );
            nod = unc[nod][k];
            diff -= ( 1 << k );
        }
    }
    return rez;
}

int respond ( int st, int dr )
{
    if ( st == dr )
        return 0;
    int ancestor = lca ( first_app[st], first_app[dr] );
    return min ( min_to_unc ( st, ancestor ), min_to_unc( dr, ancestor ) );
}

void newxy ( int &x, int &y, int z, int a, int b, int c, int d, int n )
{
    x = ( x * a + y * b ) % n + 1;
    y = ( y * c + z * d ) % n + 1;
}

int main()
{
    int n, m, p;
    f >> n >> m >> p;
    for ( int i = 2; i <= n; i ++ )
    {
        f >> parent[i] >> val[i];
        sons[parent[i]].push_back(i);
    }
    for ( int k = 0; k < 17; k ++ )
        minup[0][k] = INT_MAX;
    dfs( 1, 1 );
    compute_rmq(n);
    int x, y, z, a, b, c, d;
    f >> x >> y >> a >> b >> c >> d;
    while ( m -- )
    {
        z = respond( x, y );
        if ( m < p )
            g << z << '\n';
        newxy ( x, y, z, a, b, c, d, n );
    }
    return 0;
}