#include <bits/stdc++.h>

#define inf 0x3f3f3f3f

#define F first
#define S second
#define PII pair < int , int >

using namespace std;

const int Nmax = 32000 + 10;

int n , m , p , i , cost , k , x;
int node1 , node2 , z , A , B , C , D;
int first[Nmax] , Log[Nmax] , lvl[Nmax];
int dp[Nmax][17] , tata[Nmax][17];

vector < PII > g[Nmax];
vector < PII > d[18];

void euler(int node , int lvl , int dad)
{
    d[0].push_back({lvl , node});
    first[node] = d[0].size() - 1;

    for (auto &it : g[node])
    {
        if (it.F == dad) continue;
        euler(it.F , lvl+1 , node);
        d[0].push_back({lvl , node});
    }
}

void makeRmq()
{
    int i , j , n = d[0].size() - 1;

    for (i = 2; i <= n; ++i) Log[i] = Log[i>>1] + 1;

    for (i = 1; i <= Log[n]; ++i)
    {
        d[i].push_back({0,0});
        for (j = 1; j <= n - (1<<i) + 1; ++j)
        {
            d[i].push_back({0,0});
            d[i][j] = (d[i-1][j].F <= d[i-1][j+(1<<(i-1))].F) ? d[i-1][j] : d[i-1][j+(1<<(i-1))];
        }
    }
}

void dfs(int node ,  int price , int level , int dad)
{
    lvl[node] = level;

    ///dinamica
    int nr;
    dp[node][0] = price; tata[node][0] = dad;
    for (nr = 1; (1 << nr) <= level; nr++)
        dp[node][nr] = min(dp[node][nr-1] , dp[tata[node][nr-1]][nr-1]),
        tata[node][nr] = tata[tata[node][nr-1]][nr-1];
    ///

    for (auto &it : g[node])
    {
        if (it.F == dad) continue;
        dfs(it.F , it.S , level + 1 , node);
    }
}

int ans(int x , int y)
{
    if (x == y) return inf;
    int k = Log[lvl[x]-lvl[y]];
    return (min(dp[x][k] , ans(tata[x][k] , y)));
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("atac.in","r",stdin);
    freopen("atac.out","w",stdout);
    #endif

    scanf("%d %d %d", &n, &m, &p);
    for (i = 2; i <= n; ++i)
    {
        scanf("%d %d", &x, &cost);
        g[x].push_back({i , cost});
        g[i].push_back({x , cost});

    }
    scanf("%d %d %d %d %d %d", &node1, &node2, &A, &B, &C, &D);

    d[0].push_back({0,0});
    euler(1 , 1 , 0); makeRmq();
    memset(dp[1] , inf , sizeof(dp[1]));
    dfs(1 , 1 , 1 , 0);

    for (i = 1; i <= m; ++i)
    {
        ///lca
        int left = first[node1]; int right = first[node2];
        if (left > right) swap(left , right);
        k = Log[right - left + 1];
        int lca = (d[k][left].F < d[k][right-(1<<k)+1].F) ? d[k][left].S : d[k][right-(1<<k)+1].S;
        ///

        z = (node1 != node2) * min(ans(node1 , lca) , ans(node2 , lca));

        if (m - i + 1 <= p) printf("%d\n", z);

        node1 = (node1 * A + node2 * B) % n + 1;
        node2 = (node2 * C + z * D) % n + 1;
    }

    return 0;
}