//  ↘ ⬇ ⬇ ⬇ ⬇ ⬇ ↙
//  ➡ @roadfromroi ⬅
//  ↗ ⬆ ⬆ ⬆ ⬆ ⬆ ↖
#include <iostream>
#include "vector"
#include "algorithm"
#include "numeric"
#include "climits"
#include "iomanip"
#include "bitset"
#include "cmath"
#include "map"
#include "deque"
#include "array"
#include "set"
#define all(x) x.begin(), x.end()
using namespace std;
#include "circuit.h"
vector<vector<int>> g;
vector<int> calcoba;
int nya;
vector<vector<int>> tocalc;
vector<int> allmult;
int mod = 1000002022;
int mult(int a, int b) {
    return (long long)a * (long long) b % mod;
}
int dfsall(int v) {
    if (v >= nya)
        return 1;
    allmult[v] = g[v].size();
    for (auto i : g[v])
        allmult[v] = mult(allmult[v], dfsall(i));
    //cout << v << ' ' << allmult[v] << endl;
    return allmult[v];
}
void dfstocalc(int v) {
    if (v >= nya)
        return;
    int m = g[v].size();
    vector<int> prf(m + 1, 1);
    vector<int> suf(m + 1, 1);
    for (int i = 0; i < g[v].size(); ++i) {
        //cout << "da" << endl;
        int vl = allmult[g[v][i]];
        //cout << "2" << endl;
        dfstocalc(g[v][i]);
        prf[i + 1] = vl;
        suf[i] = vl;
    }
    for (int i = 0; i < m; ++i) {
        prf[i + 1] = mult(prf[i], prf[i + 1]);
    }
    for (int i = m - 1; i >= 0; --i) {
        suf[i] = mult(suf[i + 1], suf[i]);
    }
    tocalc[v].assign(m, {});
    for (int i = 0; i < m; ++i) {
        tocalc[v][i] = mult(prf[i], suf[i + 1]);
        //cout << v << ' ' << tocalc[v][i] << endl;
    }
}
vector<int> resba;
vector<int> a;
int K = 500;
int pls(int a, int b) {
    if (a + b >= mod)
        return a + b - mod;
    return a + b;
}

struct kornek{
    vector<int> prc;
    vector<int> ex;
    int sm;
    int notsm;
    int realsvp;
    void init(vector<int> pr, vector<int> exa) {
        ex = exa;
        prc = pr;
        realsvp = 0;
        sm = 0;
        notsm = 0;
        for (int i = 0; i < ex.size(); ++i) {
            if (ex[i])
                sm = pls(sm, prc[i]);
            else
                notsm = pls(notsm, prc[i]);
        }
    }
    int getv() {
        if (realsvp)
            return notsm;
        return sm;
    }
    void swp() {
        if (realsvp) {
            for (int i = 0; i < ex.size(); ++i) {
                ex[i] ^= 1;
            }
            swap(sm, notsm);
            realsvp = 0;
        }
    }
    void xorall() {
        realsvp ^= 1;
    }
    void chseg(int l, int r) {
        swp();
        for (int i = l; i < r; ++i) {
            ex[i] ^= 1;
        }
        sm = 0;
        notsm = 0;
        for (int i = 0; i < ex.size(); ++i) {
            if (ex[i])
                sm = pls(sm, prc[i]);
            else
                notsm = pls(notsm, prc[i]);
        }
    }

};
void calcresba(int v, int rb) {
    if (v >= nya) {
        resba[v - nya] = rb;
        return;
    }
    for (int i = 0; i < g[v].size(); ++i) {
        calcresba(g[v][i], mult(rb, tocalc[v][i]));
    }
}
vector<kornek> arbik;
void init(int N, int M, std::vector<int> P, std::vector<int> A) {
    nya = N;
    tocalc.assign(N, {});
    allmult.assign(N + M, 1);
    resba.assign(M, 0);
    g.assign(N, {});
    for (int i = 1; i < P.size(); ++i) {
        g[P[i]].push_back(i);
    }
    a = A;
    dfsall(0);
    dfstocalc(0);
    calcresba(0, 1);
    vector<vector<int>> boba1((M+K-1)/K), boba2=boba1;
    arbik.assign((M+K-1)/K, {});
    for (int i = 0; i < M; ++i) {
        boba1[i/K].push_back(a[i]);
        boba2[i/K].push_back(resba[i]);
    }
    for (int i = 0; i < boba1.size(); ++i) {
        arbik[i].init(boba2[i], boba1[i]);
    }
}
int nxt(int v) {
    return (v+K-1) / K * K;
}
int count_ways(int L, int R) {
    L -= nya;
    R -= nya;
    R++;
    if (L / K == R / K) {
        arbik[L/K].chseg(L%K, R%K);
    } else {
        if (nxt(L) != L) {
            arbik[L/K].chseg(L % K, K);
            L = nxt(L);
        }
        while (nxt(L + 1) <= R) {
            //cerr << L / K << endl;
            arbik[L/K].xorall();
            L = nxt(L + 1);
        }
        if (L / K < arbik.size())
            arbik[L/K].chseg(L % K, R % K);
    }
    int res = 0;
    for (int i = 0; i < arbik.size(); ++i) {
        res = pls(res, arbik[i].getv());
    }
    return res;
}
#ifdef __APPLE__

int main() {
    int N, M, Q;
    assert(3 == scanf("%d %d %d", &N, &M, &Q));
    std::vector<int> P(N + M), A(M);
    for (int i = 0; i < N + M; ++i) {
        assert(1 == scanf("%d", &P[i]));
    }
    for (int j = 0; j < M; ++j) {
        assert(1 == scanf("%d", &A[j]));
    }
    init(N, M, P, A);

    for (int i = 0; i < Q; ++i) {
        int L, R;
        assert(2 == scanf("%d %d", &L, &R));
        printf("%d\n", count_ways(L, R));
    }
    return 0;
}

#endif