#include <bits/stdc++.h>

using namespace std;

#define int long long

struct Fenwick {
    vector<int> t;

    Fenwick(int n) {
        t.resize(n + 1, 0);
    }

    void upd(int i, int add) {
        for (; i < t.size(); i += i & -i) t[i] += add;
    }

    int get(int len) {
        int ans = 0;
        for (; len > 0; len -= len & -len) ans += t[len];
        return ans;
    }

    int get(int l, int r) {
        return max(0LL, get(r) - get(l - 1));
    }
};

int inv(int x) {
    return x == 1 ? -1 : 1;
}

const int INF = INT_MAX * 100LL;

int32_t main() {
    int n, k, m, q;
    cin >> n >> k >> m >> q;
    Fenwick fenw_round(n);
    vector<int> pref_round(n + 1, 0), t_round(n + 1, 0);
    for (int i = 1, x; i <= n; ++i) {
        cin >> x;
        pref_round[i] = pref_round[i - 1] + x;
        fenw_round.upd(i, 1);
        t_round[i] = 1;
    }
    ++m;
    vector<int> pref_dick(m + 1), t_dick(m + 1);
    Fenwick fenw_dick(m);
    for (int i = 1, x; i <= m; ++i) {
        cin >> x;
        pref_dick[i] = pref_dick[i - 1] + x;
        fenw_dick.upd(i, 1);
        t_dick[i] = 1;
    }
    auto get_dist_1_k = [&]() -> int {
        int mn = INF;
        if (fenw_dick.get(1, m) == m) mn = min(mn, pref_dick[m]);
        if (fenw_round.get(1, k - 1) == k - 1) mn = min(mn, pref_round[k - 1]);
        if (fenw_round.get(k, n) == n - k + 1) mn = min(mn, pref_round[n] - pref_round[k - 1]);
        return mn;
    };
    auto check_in_round = [&](int v) -> bool {
        return v <= n;
    };
    auto dist_in_dick = [&](int u, int v) -> int {
        if (u > v) swap(u, v);
        return (fenw_dick.get(u, v - 1) == v - u ? pref_dick[v - 1] - pref_dick[u - 1] : INF);
    };
    int sm_in_round = pref_round[n];
    while (q--) {
        char s;
        cin >> s;
        if (s == 'q') {
            int u, v;
            cin >> u >> v;
            if (u > v) swap(u, v);
            if (u == v) {
                cout << "0\n";
                continue;
            }
            int dst1k = get_dist_1_k();
            int ans = INF;
            int distu1 = INF, distuk = INF, distv1 = INF, distvk = INF;
            for (int tt = 0; tt < 4; ++tt) {
                if (check_in_round(u)) {
                    if (fenw_round.get(1, u - 1) == u - 1) distu1 = min(distu1, pref_round[u - 1]);
                    if (fenw_round.get(u, n) == n - u + 1) distu1 = min(distu1, sm_in_round - pref_round[u - 1]);
                    if (u < k) {
                        if (fenw_round.get(u, k - 1) == k - u)
                            distuk = min(distuk, pref_round[k - 1] - pref_round[u - 1]);
                        if (fenw_round.get(1, u - 1) + fenw_round.get(k, n) == n - (k - u))
                            distuk = min(distuk, sm_in_round - (pref_round[k - 1] - pref_round[u - 1]));
                    } else {
                        swap(u, k);
                        if (fenw_round.get(u, k - 1) == k - u)
                            distuk = min(distuk, pref_round[k - 1] - pref_round[u - 1]);
                        if (fenw_round.get(1, u - 1) + fenw_round.get(k, n) == n - (k - u))
                            distuk = min(distuk, sm_in_round - (pref_round[k - 1] - pref_round[u - 1]));
                        swap(u, k);
                    }
                } else {
                    u -= n, ++u;
                    distu1 = min(distu1, dist_in_dick(1, u));
                    int sm = fenw_dick.get(1, m);
                    if (sm - fenw_dick.get(1, u - 1) == m + 1 - u) {
                        distuk = min(distuk, pref_dick[m] - pref_dick[u - 1]);
                    }
                    distuk = min(distuk, distu1 + dst1k);
                    distu1 = min(distu1, distuk + dst1k);
                    u += n, --u;
                }
                if (check_in_round(v)) {
                    if (fenw_round.get(1, v - 1) == v - 1) distv1 = min(distv1, pref_round[v - 1]);
                    if (fenw_round.get(v, n) == n - v + 1) distv1 = min(distv1, sm_in_round - pref_round[v - 1]);
                    if (v < k) {
                        if (fenw_round.get(v, k - 1) == k - v)
                            distvk = min(distvk, pref_round[k - 1] - pref_round[v - 1]);
                        if (fenw_round.get(1, v - 1) + fenw_round.get(k, n) == n - (k - v))
                            distvk = min(distvk, sm_in_round - (pref_round[k - 1] - pref_round[v - 1]));
                    } else {
                        swap(v, k);
                        if (fenw_round.get(v, k - 1) == k - v)
                            distvk = min(distvk, pref_round[k - 1] - pref_round[v - 1]);
                        if (fenw_round.get(1, v - 1) + fenw_round.get(k, n) == n - (k - v))
                            distvk = min(distvk, sm_in_round - (pref_round[k - 1] - pref_round[v - 1]));
                        swap(v, k);
                    }
                } else {
                    v -= n, ++v;
                    distv1 = min(distv1, dist_in_dick(1, v));
                    int sm = fenw_dick.get(1, m);
                    if (sm - fenw_dick.get(1, v - 1) == m + 1 - v) {
                        distvk = min(distvk, pref_dick[m] - pref_dick[v - 1]);
                    }
                    distvk = min(distvk, distv1 + dst1k);
                    distv1 = min(distv1, distvk + dst1k);
                    v += n, --v;
                }
                for (int qq = 0; qq < 4; ++qq) {
                    distu1 = min(distu1, distuk + dst1k);
                    distv1 = min(distv1, distvk + dst1k);
                    distuk = min(distuk, distu1 + dst1k);
                    distvk = min(distvk, distv1 + dst1k);
                }
            }
            ans = min(ans, min(distu1 + distv1, distvk+ distuk));
            ans = min(ans, min(distuk + distv1, distvk+ distu1) + dst1k);
            if (check_in_round(v)) {
                int len = v - u;
                if (fenw_round.get(u, v - 1) == len) ans = min(ans, pref_round[v - 1] - pref_round[u - 1]);
                if (fenw_round.get(1, u - 1) + fenw_round.get(v, n) == n - len) ans = min(ans, sm_in_round - (pref_round[v - 1] - pref_round[u - 1]));
            } else if (min(u, v) > n) {
                ans = min(ans, dist_in_dick(u - n, v - n));
            }
            cout << (ans == INF ? "impossible" : to_string(ans)) << "\n";
        } else if (s == 'c') {
            int x;
            cin >> x;
            if (t_round[x] == 1) {
                fenw_round.upd(x, -1);
            } else {
                fenw_round.upd(x, 1);
            }
            t_round[x] = inv(t_round[x]);
        } else {
            int x;
            cin >> x;
            ++x;
            if (t_dick[x] == 1) {
                fenw_dick.upd(x, -1);
            } else {
                fenw_dick.upd(x, 1);
            }
            t_dick[x] = inv(t_dick[x]);
        }
    }
}