#include <bits/stdc++.h>

using namespace std;

const int maxn = 400100, vc = 3 * maxn;

typedef struct edge {
    int u, v, bt, et = -1;

    edge() {}

    edge(int u, int v, int bt) : u(u), v(v), bt(bt) {}
};

int p[vc], sz[vc], nm[vc];
stack<pair<int, pair<bool, int> > > st;

int getp(int x) {
    if (p[x] == -1)
        return x;
    return getp(p[x]);
}

void merges(int u, int v) {
    u = getp(u);
    v = getp(v);
    if (u == v) {
        st.push({-1, {-1, -1}});
        return;
    }
    if (sz[u] < sz[v])
        swap(u, v);
    st.push({v, {(sz[u] == sz[v]), nm[u]}});
    if (sz[v] == sz[u])
        ++sz[u];
    p[v] = u;
    nm[u] = max(nm[v], nm[u]);
}

void unmerge() {
    int v = st.top().first, fg = st.top().second.first, stn = st.top().second.second;
    st.pop();
    if (v == -1)
        return;
    int u = p[v];
    sz[u] -= fg;
    nm[u] = stn;
    p[v] = -1;
}

int lb[4 * maxn], rb[4 * maxn];
vector<int> t[4 * maxn];
vector<edge> ed;

void build(int x, int cl, int cr) {
    lb[x] = cl;
    rb[x] = cr;
    if (cr - cl == 1)
        return;
    build(2 * x, cl, (cl + cr) / 2);
    build(2 * x + 1, (cl + cr) / 2, cr);
}

int up(int x, int pos) {
    while (1) {
        for (int i = 0; i < t[x].size(); i++)
            unmerge();
        if (lb[x] <= pos && pos < rb[x])
            return x;
        x /= 2;
    }
}

int down(int x, int pos) {
    for (int i = 0; i < t[x].size(); i++)
        merges(ed[t[x][i]].u, ed[t[x][i]].v);
    if (rb[x] - lb[x] == 1)
        return x;
    if ((lb[x] + rb[x]) / 2 <= pos)
        return down(2 * x + 1, pos);
    return down(2 * x, pos);
}

void add_edge(int x, int cl, int cr, int _l, int _r, int i) {
    if (_r <= cl || cr <= _l)
        return;
    if (_l <= cl && cr <= _r) {
        t[x].push_back(i);
        return;
    }
    add_edge(2 * x, cl, (cl + cr) / 2, _l, _r, i);
    add_edge(2 * x + 1, (cl + cr) / 2, cr, _l, _r, i);
}

int main(){
    cin.tie(0);
    cout.tie(0);
    ios_base::sync_with_stdio(0);
    int n, m;
    cin >> n >> m;
    vector<int> a(m);
    for (int i = 0; i < m; i++) {
        cin >> a[i];
    }
    for (int i = 0; i < n; i++) {
        p[i] = -1; sz[i] = 1; nm[i] = -1;
    }
    for (int i = n; i < n + 2 * m; i++) {
        p[i] = -1; sz[i] = 1; nm[i] = -1;
    }
    vector<int> lws(n);
    for (int i = 0; i < n; i++)
        lws[i] = i;
    int nt = n;
    pair<int, int> pr[m];
    for (int i = 0; i < m; i++) {
        --a[i];
        pr[i] = {lws[a[i]], lws[a[i] + 1]};
        ed.push_back(edge(lws[a[i]], nt + 2 * i + 1, 0));
        ed.push_back(edge(lws[a[i] + 1], nt + 2 * i, 0));
        lws[a[i]] = nt + 2 * i;
        lws[a[i] + 1] = nt + 2 * i + 1;
    }
    for (int i = 0; i < n; i++)
        nm[lws[i]] = i;
    int pes = ed.size();
    int q;
    cin >> q;
    vector<pair<int, int> > ans;
    int cnt = 0;
    for (int i = 0; i < q; i++) {
        char cd;
        int x;
        cin >> cd >> x;
        if (cd == 'A') {
            --x;
            if (a[x] == -1)
                continue;
            a[x] = -1;
            ++cnt;
            ed.push_back(edge(pr[x].first, nt + 2 * x, cnt));
            ed.push_back(edge(pr[x].second, nt + 2 * x + 1, cnt));
            int e1 = 2 * x;
            int e2 = 2 * x + 1;
            ed[e1].et = cnt;
            ed[e2].et = cnt;
        } else {
            ans.push_back({cnt, x});
        }
    }
    build(1, 0, maxn);
    for (int i = 0; i < ed.size(); i++) {
        if (ed[i].et == -1) {
            ed[i].et = maxn;
            if (ed[i].bt == 0) {
                merges(ed[i].u, ed[i].v);
                continue;
            }
        }
        add_edge(1, 0, maxn, ed[i].bt, ed[i].et, i);
    }
    int ls = 1;
    for (int i = 0; i < ans.size(); i++) {
        if (i != 0)
            ls = up(ls, ans[i].first);
        ls = down(ls, ans[i].first);
        int gg = getp(ans[i].second - 1);
        cout << nm[gg] + 1 << '\n';
    }
    exit(0);
}