#include<bits/stdc++.h>
using std::cin;
using std::cout;
using ll = long long;
using u64 = unsigned long long;
void IOinit() {
	std::ios::sync_with_stdio(false), cin.tie(0);
#ifdef zqj
	freopen("1.in", "r", stdin);
#endif
}
const int N = 300005;
const int M = N * 2;

int fa[M], son[M][2], min[M], val[M], add[M];
int size[M];

std::vector<int> chk;

void put(int x, int v) {
	if(!x) return ;
	min[x] += v;
	val[x] += v;
	add[x] += v;
}
int get(int x) {
	return son[fa[x]][1] == x;
}
void update(int x) {
	min[x] = val[x];
	size[x] = size[son[x][0]] + 1 + size[son[x][1]];
	if(son[x][0] && min[son[x][0]] < min[x]) min[x] = min[son[x][0]];
	if(son[x][1] && min[son[x][1]] < min[x]) min[x] = min[son[x][1]];
}
void pushdown(int x) {
	put(son[x][0], add[x]);
	put(son[x][1], add[x]);
	add[x] = 0;
}
void rotate(int x) {
	int y = fa[x], z = fa[y], b = get(x);
	if(z) son[z][get(y)] = x;
	son[y][b] = son[x][!b], son[x][!b] = y;
	fa[son[y][b]] = y, fa[y] = x, fa[x] = z;
	update(y);
}
void down(int x) {
	if(!x) return ;
	down(fa[x]), pushdown(x);
}
void splay(int x) {
	down(x);
	for(;fa[x];rotate(x)) if(fa[fa[x]])
		rotate(get(x) ^ get(fa[x]) ? x : fa[x]);
	update(x);
}
void dfs(int x) {
	if(!x || min[x] > 0) return ;
	pushdown(x);
	dfs(son[x][0]);
	if(val[x] <= 0) {
		chk.push_back(x / 2);
	}
	dfs(son[x][1]);
}
int sub(int x) {
	splay(x), val[x] -= 1, update(x);
	if(val[x] <= 0) chk.push_back(x / 2);
	int ans = 1 + size[son[x][1]];
	put(son[x][1], -1);
	dfs(son[x][1]);
	return ans;
}
std::unordered_map<int, std::map<int, int>> map[3];

int dead[N], r[N], c[N];
void set(int a, int b) {
	if(a) {
		splay(a);
		fa[son[a][1]] = 0;
		son[a][1] = 0;
		update(a);
	}
	if(b) {
		splay(b);
		fa[son[b][0]] = 0;
		son[b][0] = 0;
		update(b);
	}
	if(a && b) {
		son[a][1] = b;
		fa[b] = a;
		update(a);
	}
}
void ins(std::map<int, int> & m, int p, int v) {
	auto [iter, succ] = m.emplace(p, v);
	if(next(iter) != m.end()) {
		set(v, next(iter) -> second ^ 1);
	}
	if(iter != m.begin()) {
		set(prev(iter) -> second, v ^ 1);
	}
}
void del(std::map<int, int> & m, int p, int v) {
	auto iter = m.find(p);
	int x = 0, y = 0;
	if(next(iter) != m.end()) {
		y = next(iter) -> second ^ 1;
	}
	if(iter != m.begin()) {
		x = prev(iter) -> second;
	}
	set(x, y);
	m.erase(iter);
}
void kill(int x) {
	int r = ::r[x], c = ::c[x];
	dead[x] = 1;
	del(map[1][r + c], -r + c, x * 2);
	del(map[2][-r + c], r + c, x * 2 + 1);
}
using pr = std::pair<int, int>;

std::priority_queue<pr, std::vector<pr>, std::greater<pr>> Q;

int main() {
#ifdef zqj
	freopen("1.in", "r", stdin);
#endif
	std::ios::sync_with_stdio(false), cin.tie(0);
	for(auto & x : map) x.rehash(N * 2);
	int M, N, q, sum_t = 0, id = 0;
	cin >> M >> N >> q;
	cout << "stdout ducks" << '\n';
	for(int i = 0;i < q;++i) {
		std::string s;
		cin >> s;
		if(s == "time") {
			int t;
			cin >> t;
			sum_t += t;
			int leave = 0;
			for(;Q.size() && Q.top().first <= sum_t;) {
				auto [_, id] = Q.top(); Q.pop();
				if(!dead[id]) {
					kill(id);
					leave += 1;
				}
			}
			cout << leave << '\n';
		}
		if(s == "deliver") {
			int r, c, s;
			cin >> r >> c >> s;
			c += sum_t;
			auto & mp = map[0][r];
			for(;;) {
				auto iter = mp.lower_bound(c);
				if(iter == mp.end()) {
					cout << 0 << ' ' << 0 << '\n';
					break;
				}
				if(dead[iter -> second]) {
					mp.erase(iter);
					continue;
				}
				int kill_c = 0;
				int bounce = sub(iter -> second * 2 ^ (s > 0));
				for(int x : chk) {
					splay(x * 2);
					splay(x * 2 + 1);
					int hp = val[x * 2] + val[x * 2 + 1];
					if(hp == 1) {
						kill_c += 1;
						kill(x);
					} else {
						val[x * 2] = hp / 2;
						val[x * 2 + 1] = (hp + 1) / 2;
						update(x * 2);
						update(x * 2 + 1);
					}
				}
				chk.clear();
				cout << bounce << ' ' << kill_c << '\n';
				break;
			}
		}
		if(s == "add") {
			int r, c, h;
			cin >> r >> c >> h, h += 1;
			c += sum_t;
			int x = ++ id;
			::r[x] = r;
			::c[x] = c;
			val[x * 2 + 0] = h / 2, update(x * 2);
			val[x * 2 + 1] = (h + 1) / 2, update(x * 2 + 1);
			map[0][r][c] = x;
			ins(map[1][r + c], -r + c, x * 2);
			ins(map[2][-r + c], r + c, x * 2 + 1);
			Q.emplace(c, x);
		}
	//	std::cerr << "finish : " << i << std::endl;
	}
}