#include <bits/stdc++.h>

using namespace std;

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

const int NMAX = 32000;
const int LOG = 17;
const int INF = 2000000000;

int first[NMAX + 1], euler[2 * NMAX + 1], level[NMAX + 1], LOGS[2 * NMAX + 1];
int M[2 * NMAX + 1][LOG], dp[LOG][NMAX + 1], T[LOG][NMAX + 1];

struct Edge{
  int dest, cost;
};

vector<Edge> G[NMAX + 1];
int poz, n;

void dfs( int node, int depth, int father ) {
  euler[poz] = depth;
  level[node] = depth;
  first[node] = poz;
  M[poz][0] = poz;
  poz ++;

  for( const auto &it : G[node] ) {
    if( it.dest != father ) {
      T[0][it.dest] = node;
      dp[0][it.dest] = it.cost;
      dfs(it.dest, depth + 1, node);
      M[poz][0] = poz;
      euler[poz] = depth;
      poz ++;
    }
  }
}

void build_RMQ( int d ) {
  int i, j;
  for( j = 1; (1<<j) <= d; j ++ ) {
    for( i = 0; i + (1<<j) <= d; i ++ ) {
      if( euler[M[i][j-1]] < euler[M[i + (1<<(j - 1))][j-1]] )
         M[i][j] = M[i][j-1];
      else
        M[i][j] = M[i + (1<<(j - 1))][j-1];
    }
  }

  for( int i = 2; i <= 2 * NMAX; i ++ )
    LOGS[i] = 1 + LOGS[i / 2];
}

int querry(int a, int b) {
  int k = LOGS[b - a + 1];
  if( euler[M[a][k]] < euler[M[b-(1<<k)+1][k]] )
    return euler[M[a][k]];
  else
    return euler[M[b-(1<<k)+1][k]];
}

int ans( int x, int levely ) {
  int rez = INF;
  int levelx = level[x];
  while( levelx > levely ) {
    int i;
    for( i = 0; levelx - (1<<i) >= levely; i ++ );
    rez = min( rez, dp[i - 1][x] );
    x = T[i - 1][x];
    levelx = level[x];
  }
  return rez;
}

int bombe( int u, int v ) {
  int st = min(first[u], first[v]);
  int dr = max(first[u], first[v]);
  int lcalevel = querry(st, dr);
  return min( ans(u, lcalevel), ans(v, lcalevel) );
}

int main() {
    int m, p;
    fin>>n>>m>>p;
    for( int i = 2; i <= n; i ++ ) {
      int x, c;
      fin>>x>>c;
      G[x].push_back({i, c});
      G[i].push_back({x, c});
    }
    dfs(1, 0, 0);
    build_RMQ(2*n - 1);
    T[0][1] = 1;
    dp[0][1] = INF;
    for( int i = 1; (1<<i) <= n; i ++ ) {
      for( int j = 1; j <= n; j ++ ) {
        T[i][j] = T[i - 1][T[i-1][j]];
        dp[i][j] = min( dp[i - 1][j], dp[i - 1][T[i - 1][j]] );
      }
    }
    int x, y, a, b, c, d, u, v;
    fin>>x>>y>>a>>b>>c>>d;
    for( int i = 1; i <= m; i ++ ) {
      int z = bombe(x, y);
      u = ( x * a + y * b ) % n + 1;
      v = ( y * c + z * d ) % n + 1;
      x = u;
      y = v;
      if( i > m - p )
        fout<<z<<"\n";
    }
    return 0;
}