#include <algorithm>
#include <cstdio>

#define ls(o) o * 2
#define rs(o) o * 2 + 1

constexpr int MAXN = 250000 + 2;
constexpr long long LINF = 1000000000000000000ll;

int a[MAXN], b[MAXN], p[MAXN], s1[MAXN];

bool vis[MAXN];

long long s2[MAXN];

class FenwickTree {
  public:
    int n, t[MAXN << 1];

    void init(int _n, int v) {
        n = _n;

        for (int i = 1; i <= n + 1; i ++) {
            t[i] = v;
        }
    }

    void add(int x, int v) {
        for (x ++; x <= n + 1; x += x & -x) {
            t[x] += v;
        }
    }

    int query(int x) {
        int ret = 0;
        for (x ++; x; x &= x - 1) {
            ret += t[x];
        }

        return ret;
    }
} fenTree;

class SegmentTree {
  public:
    int n;

    long long t[MAXN << 2];

    void pushUp(int o) {
        long long val = std::min(t[o << 1], t[o << 1 | 1]);

        t[o << 1] -= val;
        t[o << 1 | 1] -= val;

        t[o] += val;
    }

    void init(int _n, int m) {
        for (n = 1; n <= _n + 1; n <<= 1);

        for (int i = 1; i <= _n; i ++) {
            t[i + n + 1] = t[i + n] + p[i];
        }

        for (int i = 0; i <= _n; i ++) {
            t[i + n + 1] += s2[_n - i]
              + (long long){m - s1[_n - i]} * (_n - i);
        }

        for (int i = n; i; i --) {
            pushUp(i);
        }
    }

    void add(int l, int r, int v) {
        if (l > r) {
            return;
        }

        for (l += n, r += n + 2; l ^ r ^ 1;
          pushUp(l >>= 1), pushUp(r >>= 1)) {
            if (~l & 1) {
                t[l ^ 1] += v;
            }
            if (r & 1) {
                t[r ^ 1] += v;
            }
        }

        while (l >>= 1) {
            pushUp(l);
        }
    }

    long long query(int l, int r) {
        long long ansL = LINF, ansR = LINF;

        for (l += n, r += n + 2; l ^ r ^ 1;
          ansL += t[l >>= 1], ansR += t[r >>= 1]) {
            if (~l & 1) {
                ansL = std::min(ansL, t[l ^ 1]);
            }
            if (r & 1) {
                ansR = std::min(ansR, t[r ^ 1]);
            }
        }

        ansL = std::min(ansL, ansR);

        while (l >>= 1) {
            ansL += t[l];
        }

        return ansL;
    }
} segTree;

int main() {
    int n, m, q;
    scanf("%d%d", &n, &m);

    long long sumA = 0;

    for (int i = 1; i <= n; i ++) {
        scanf("%d", &a[i]);

        sumA += a[p[i] = i];
        vis[a[i]] = true;
    }

    for (int i = 1; i <= m; i ++) {
        scanf("%d", &b[i]);

        s1[b[i]] ++;
        s2[b[i]] += b[i];
    }

    for (int i = 1; i <= n; i ++) {
        s1[i] += s1[i - 1];
        s2[i] += s2[i - 1];
    }

    for (int i = 0, j = 0; i < MAXN; i ++) {
        if (vis[i]) {
            p[++ j] = i;
        }
    }

    segTree.init(n, m);
    fenTree.init((MAXN - 2) << 1, 0);

    for (int i = 1; i <= n; i ++) {
        fenTree.add(a[i], 1);
    }

    scanf("%d", &q);

    while (q --) {
        int op, x;
        scanf("%d%d", &op, &x);

        if (op == 1) {
            segTree.add(fenTree.query(a[x]), n, 1);

            fenTree.add(a[x], -1);
            fenTree.add(++ a[x], 1);

            sumA ++;
        }

        if (op == 2) {
            fenTree.add(a[x], -1);
            fenTree.add(-- a[x], 1);

            segTree.add(fenTree.query(a[x]), n, -1);

            sumA --;
        }

        if (op == 3) {
            segTree.add(0, n - (++ b[x]), 1);
        }

        if (op == 4) {
            segTree.add(0, n - (b[x] --), -1);
        }

        putchar('0' ^ (sumA == segTree.query(0, n)));
        putchar('\n');
    }

    return 0;
}