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

using ll = long long;
#define int ll
#define all(v) v.begin(),v.end()
#define pb push_back

#define endl '\n'

void dbg_out() {cerr << endl; }
template< typename H, typename... T> 
void dbg_out(H h, T... t) { cerr << ' ' << h; dbg_out(t...); }
#define dbg(...) //{ cerr << #__VA_ARGS__ << ':'; dbg_out(__VA_ARGS__); }

struct Bit {
	int total_sum;
	vector<int> bit;

	Bit(int n): total_sum(0), bit(n) {}

	int query(int id) {
		int res = 0;
		for(id++;id>0;id-=id&-id) res += bit[id-1];
		return res;
	}

	void update(int id, int val) {
		total_sum += val;
		for(id++;id<=int(bit.size());id+=id&-id) bit[id-1] += val;
	}

	int query_range(int l, int r) {
		return query(r) - ((l == 0) ? 0 : query(l-1));
	}
};

void solve() {
	int n, k, m, q; cin >> n >> k >> m >> q;
	--k;
	Bit cyc(n), path(m+1);
	vector<int> c(n), p(m+1);
	vector<bool> okc(n, true), okp(m+1, true);
	for(int i=0;i<n;i++) {
		cin >> c[i];
		cyc.update(i, c[i]);
	}
	for(int i=0;i<=m;i++) {
		cin >> p[i];
		path.update(i, p[i]);
	}

	dbg(cyc.total_sum, path.total_sum);
	dbg(cyc.query(0));
	dbg(cyc.query(1));
	dbg(cyc.query_range(0, 1));

	const int INF = 1e10;

	auto cyc_dist = [&](int u, int v)  -> int {
		assert(u < n && v < n);
		if(u > v) swap(u, v);
		if(u == v) return 0;
		int ans = cyc.query_range(u, v-1);
		return min<int>(ans, cyc.total_sum - ans);
	};

	// transform in path coordinates
	auto transform = [&](int x) -> int {
		if(x == 0) return 0;
		else if(x == k) return m + 1;
		else {
			assert(x >= n);
			return x - n + 1;
		}
	};

	auto path_dist = [&](int u, int v) {
		u = transform(u);
		v = transform(v);
		if(u > v) swap(u, v);
		return path.query_range(u, v);
	};

	auto out_path_dist = [&](int u, int v) {
		return path.total_sum - path.query_range(u, v);
	};

	function<int(int,int)> query = [&](int u, int v) {
		assert(u <= v);
		int ans = INF;
		if(u < n && v < n) { 
			// both outside
			ans = min(ans, cyc_dist(u, v));
			ans = min(ans, cyc_dist(u, 0) + path.total_sum + cyc_dist(k, v));
			ans = min(ans, cyc_dist(u, k) + path.total_sum + cyc_dist(0, v));
		} else if(u < n && v >= n) {
			// v is inside
			ans = min(ans, cyc_dist(u, 0) + path_dist(v, 0));
			ans = min(ans, cyc_dist(u, k) + path_dist(v, k));
		} else {
			assert(u >= n && v >= n);
			ans = min(ans, path_dist(u, v));
			ans = min(ans, cyc_dist(0, k) + out_path_dist(u, v));
		}
		return ans;
	};

	while(q--) {
		char cc; cin >> cc;
		if(cc == 'q') {
			int u, v; cin >> u >> v;
			--u; --v;
			if(u > v) swap(u,v);
			int ans = query(u, v);
			if(ans >= INF) {
				cout << "impossible" << endl;
			} else {
				cout << ans << endl;
			}
		} else if(cc == 'c') { // cycle
			int i; cin >> i;
			--i;
			if(okc[i]) {
				cyc.update(i, INF - c[i]);
			} else {
				cyc.update(i, c[i] - INF);
			}
			okc[i] = !okc[i];
		} else if(cc == 'x') {
			int i; cin >> i;
			if(okp[i]) {
				path.update(i, INF - p[i]);
			} else {
				path.update(i, p[i] - INF);
			}
			okp[i] = !okp[i];
		} else {
			assert(false);
		}
	}
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	solve();
}