#include <bits/stdc++.h>


#define ull unsigned long long
#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()


using namespace std;

const ll inf = 1e18;
mt19937 rnd(234);


#ifdef LOCAL
bool local = true;
#else
bool local = false;
#endif

struct biba {
    ull x = 0;
    bool bad = true;

    biba() {}
    biba(ull x) : x(x), bad(false) {}
    biba(ull x, bool bad) : x(x), bad(bad) {}
};


int query_count = 0;


biba operator+(const biba& a, const biba& b) {
    if (a.bad) {
        return a;
    }
    if (b.bad) {
        return b;
    }
    if (a.x == 0) {
        return b;
    }
    if (b.x == 0) {
        return a;
    }
    if (local) {
        return biba{ a.x + b.x, false };
    }
    if (query_count >= 1.5e6) {
        assert(0);
    }
    query_count += 1;
    cout << "A " << a.x << " " << b.x << endl;
    ull x;
    cin >> x;
    return biba{ x, false };
}


biba min(const biba& a, const biba& b) {
    if (a.bad) {
        return b;
    }
    if (b.bad) {
        return a;
    }
    if (a.x == 0) {
        return a;
    }
    if (b.x == 0) {
        return b;
    }
    if (local) {
        return biba{ min(a.x, b.x), false };
    }
    if (query_count >= 1.5e6) {
        assert(0);
    }
    query_count += 1;
    cout << "C " << a.x << " " << b.x << endl;
    ull x;
    cin >> x;
    return biba{ x, false };
}


bool operator==(const biba& a, const biba& b) {
    return a.x == b.x and a.bad == b.bad;
}


bool operator<=(const biba& a, const biba& b) {
    return min(a, b) == a;
}


biba max(const biba& a, const biba& b) {
    if (a <= b) {
        return b;
    } else {
        return a;
    }
}


istream& operator>>(istream& in, biba& a) {
    ull x;
    in >> x;
    a = biba{ x, false };
    return in;
}


ostream& operator<<(ostream& out, const biba& a) {
    return (out << a.x);
}


struct query {
    int type;
    int t, pos;
    biba x;
    int k;
};


istream& operator>>(istream& in, query& a) {
    in >> a.type;
    if (a.type == 1) {
        in >> a.t >> a.pos >> a.x;
        a.pos -= 1;
        assert(a.t == 1 or a.t == 2);
    } else if (a.type == 2) {
        in >> a.k;
    } else {
        assert(0);
    }
    return in;
}

int n, q;
int m;
ll B;

vector<biba> a, b;
vector<biba> ta, tb;
vector<query> f;
vector<biba> rs;


biba get_kth_old(int k) {
    assert(1 <= k and k <= 2 * n);
    int i = 0;
    int j = 0;
    biba last;
    biba sa = a[i], sb = b[j];
    while (k > 0) {
        k -= 1;
        if (sa <= sb) {
            last = sa;
            i += 1;
            sa = sa + a[i];
        } else {
            last = sb;
            j += 1;
            sb = sb + b[j];
        }
    }
    return last;
}


biba get_kth(int k) {
    assert(1 <= k and k <= 2 * n);
    biba sa = 0;
    biba sb = 0;
    int i = 0;
    int j = 0;
    while (k > 0) {
        int bits = __lg((k + 1) / 2);
        int u = i + m;
        int v = j + m;
        for (int x = 0; x < bits; x += 1) {
            u /= 2;
            v /= 2;
        }
        if (i == m) {
            sb = sb + tb[v];
            j += (1 << bits);
            k -= (1 << bits);
            continue;
        }
        if (j == m) {
            sa = sa + ta[u];
            i += (1 << bits);
            k -= (1 << bits);
            continue;
        }
        auto dsa = ta[u];
        auto dsb = tb[v];
        auto nsa = sa + dsa;
        auto nsb = sb + dsb;
        if (nsa <= nsb) {
            sa = nsa;
            i += (1 << bits);
            k -= (1 << bits);
        } else {
            sb = nsb;
            j += (1 << bits);
            k -= (1 << bits);
        }
    }
    return max(sa, sb);
}


void solve() {
    m = 1;
    while (m < n) {
        m *= 2;
    }
    ta.assign(2 * m, biba());
    tb.assign(2 * m, biba());
    for (int i = 0; i < n; i += 1) {
        ta[m + i] = a[i];
        tb[m + i] = b[i];
    }
    for (int i = m - 1; i >= 1; i -= 1) {
        ta[i] = ta[i + i] + ta[i + i + 1];
        tb[i] = tb[i + i] + tb[i + i + 1];
    }
    rs.clear();
    for (auto d : f) {
        if (d.type == 1) {
            if (d.t == 1) {
                a[d.pos] = d.x;
                int v = m + d.pos;
                ta[v] = d.x;
                for (v /= 2; v >= 1; v /= 2) {
                    ta[v] = ta[v + v] + ta[v + v + 1];
                }
            } else {
                b[d.pos] = d.x;
                int v = m + d.pos;
                tb[v] = d.x;
                for (v /= 2; v >= 1; v /= 2) {
                    tb[v] = tb[v + v] + tb[v + v + 1];
                }
            }
        } else {
            auto val = get_kth(d.k);
            rs.push_back(val);
        }
    }
}


int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n >> q >> B;
    a.assign(n + 1, biba());
    b.assign(n + 1, biba());
    for (int i = 0; i < n; i += 1) {
        cin >> a[i];
    }
    for (int i = 0; i < n; i += 1) {
        cin >> b[i];
    }
    f.resize(q);
    for (int i = 0; i < q; i += 1) {
        cin >> f[i];
    }
    solve();
    cout << "! " << (int)rs.size() << endl;
    for (auto x : rs) {
        cout << x << " ";
    }
    cout << endl;
    return 0;
}


/*
2 3 2
1 3
5 7
2 3
1 2 2 9
2 3

*/