2024

#include "bits/stdc++.h"
using namespace std;

#define nl "\n"
#define ll long long
#define mod  1'000'000'007
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define sz(v) (int) v.size()

template<typename T = int>
istream &operator>>(istream &in, vector<T> &v) {
    for (auto &x: v) in >> x;
    return in;
}

template<typename T = int>
ostream &operator<<(ostream &out, const vector<T> &v) {
    for (const T &x: v) out << x << " ";
    return out;
}

void Sira() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
#endif
}
struct node {
    int mini;

    node(){
        mini = INT_MAX;
    }

    node(int val){
        mini = val;
    }


};

struct SegTree{
    int seg_size = 1;
    vector < node > tree;

    SegTree(int n){
        while(seg_size < n) seg_size *= 2;
        tree.assign(2 * seg_size, node());
    }

    node merge(node a, node b){
        node res = node();
        res.mini = min(a.mini, b.mini);
        return res;
    }

    void build(vector < int > &a, int x, int lx, int rx){
        if(rx - lx == 1){
            if(lx < sz(a)){
                tree[x] = node(a[lx]);
            }
            return;
        }
        int m = (lx + rx) / 2;
        build(a, 2 * x + 1, lx, m);
        build(a, 2 * x + 2, m, rx);
        tree[x] = merge(tree[2 * x + 1], tree[2 * x + 2]);
    }

    void build(vector < int > &a){
        build(a, 0, 0, seg_size);
    }

    void update(int idx , int val , int ni , int lx , int rx){
        if(rx - lx == 1){
            tree[ni] = node(val);
            return;
        }
        int m = (lx + rx) / 2;
        if(idx < m){
            update(idx, val, 2 * ni + 1, lx, m);
        }else{
            update(idx, val, 2 * ni + 2, m, rx);
        }
        tree[ni] = merge(tree[2 * ni + 1], tree[2 * ni + 2]);
    }

    void update(int idx, int val){
        update(idx, val, 0, 0, seg_size);
    }

    node query(int l, int r, int ni, int lx, int rx){
        if(lx >= r || l >= rx) return node();
        if(lx >= l && rx <= r) return tree[ni];
        int m = (lx + rx) / 2;
        node s1 = query(l, r, 2 * ni + 1, lx, m);
        node s2 = query(l, r, 2 * ni + 2, m, rx);
        return merge(s1, s2);
    }

    node query(int l, int r){
        return query(l, r, 0, 0, seg_size);
    }
};

vector < int > p , a;
int n;

void makePer(int k) {
    vector < int > vis(n, 0);
    vector < int > res(n);


    for (int i = 0; i < n; i++) {
        if (!vis[i]) {
            vector < int > cycle;

            int curr = i;

            while (!vis[curr]) {
                vis[curr] = 1;
                cycle.push_back(curr);
                curr = p[curr] - 1;
            }


            int x = sz(cycle);
            // cout << "cycle: " <<cycle << nl;
            k %= x;


            for (int j = 0; j < x ; j++) {
                res[cycle[j]] = a[cycle[(j + k) % x]];
            }
        }
    }

    a = res;
}

void solve() {
    cin >> n;
    p.resize(n);
    a.resize(n);

    cin >> a >> p;

    int q;
    cin >> q;

    while(q--) {
        int op;
        cin >> op;


        if(op == 1) {
            ll k;
            cin >> k;

            makePer(k);

        }else if(op == 2) {
            SegTree st(n);
            st.build(a);


            int m;
            cin >> m;

            while(m--) {
                int l, r;
                cin >> l >> r;
                l--;
                // cout << a << nl;
                node res = st.query(l, r);
                cout << res.mini << nl;
            }
        }
    }
}

int main() {
    Sira();
    int t = 1;
    //    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}