传送门
第一行有两个整数 n n n 和 min ⁡ \min min。 n n n 表示下面有多少条命令，⁡ min ⁡ \min min 表示工资下界。

接下来的 n n n 行，每行一个字符 x x x 和一个整数 k k k，表示一条命令。命令可以是以下四种之一：

I   k I \space k I k 新建一个工资档案，初始工资为 k k k。如果某员工的初始工资低于工资下界，他将立刻离开公司。

A   k A \space k A k 把每位员工的工资加上 k k k 。

S   k S \space k S k 把每位员工的工资扣除 k k k。

F   k F \space k F k 查询第 k k k 多的工资。

分析

对于每位员工的工资加上 k k k，使用一个全局变量记录一下
之后如果某个员工需要加入的话，就构造一个相对值插入 S p l a y Splay Splay中
如果要减工资的话，找到需要离开公司工资的界限，将此界限提出（Splay经典操作，到达根节点右子树的左子树上），删除这个左子树即可达到要求，记得更新子树大小

行! 那就用 S p l a y Splay Splay

代码

//P1486
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;

struct Tr {
	int k, fa, cnt, sz;
	int son[2];
	int& l = son[0];
	int& r = son[1];
}tr[MAX_N];
int root = 0;
int indx = 0;

void push_up(int rt) {
	tr[rt].sz = tr[rt].cnt + tr[tr[rt].l].sz + tr[tr[rt].r].sz;
}

int which(int x) {
	return tr[tr[x].fa].son[1] == x;
}

void rotate(int x) {
	int p = tr[x].fa;
	int q = tr[p].fa;
	int side = which(x);
	
	tr[tr[p].son[side] = tr[x].son[side^1]].fa = p;
	tr[tr[x].son[side^1] = p].fa = x;
	tr[x].fa = q;
	if (q) tr[q].son[tr[q].son[1] == p] = x;
	
	push_up(p);
	push_up(x);
}

void splay(int x, int tar) {
	for (int p; (p = tr[x].fa) != tar; rotate(x)) {
		if (tr[p].fa != tar) rotate(which(x) == which(p) ? p : x);
	}
	if (!tar) root = x;
}

int find(int x) {
	int rt = root;
	while (tr[rt].son[x > tr[rt].k] && x != tr[rt].k) {
		rt = tr[rt].son[x > tr[rt].k];
	}
	splay(rt, 0);
	return rt;
}

int find_pre(int x) {
	int rt = find(x);
	if (tr[rt].k < x) return rt;
	rt = tr[rt].l;
	while (tr[rt].r) {
		rt = tr[rt].r;
	}
	return rt;
}

int find_nxt(int x) {
	int rt = find(x);
	if (tr[rt].k > x) return rt;
	rt = tr[rt].r;
	while (tr[rt].l) {
		rt = tr[rt].l;
	}
	return rt;
}

int fetch(int x) {
	int rt = root;
	while (x) {
		if (tr[tr[rt].r].sz >= x) {
			rt = tr[rt].r;
			continue;
		}
		x -= tr[tr[rt].r].sz;
		if (x <= tr[rt].cnt) return rt;
		x -= tr[rt].cnt;
		rt = tr[rt].l;
	}
}

void print(int rt) {
	if (!rt) return;
	cout << tr[rt].k << "**";
	print(tr[rt].l);
	print(tr[rt].r);
}

int remove(int x) {
	int pre = find(-1e9);
	int nxt = find_nxt(x);
	splay(pre, 0);
	splay(nxt, pre);
	int res = tr[tr[nxt].l].sz;
	tr[nxt].l = 0;
	splay(nxt, 0);
	return res;
}

void insert(int x) {
	int rt = root, p = 0;
	while (rt && x != tr[rt].k) {
		p = rt;
		rt = tr[rt].son[x > tr[rt].k];
	}
	if (rt) {
		++tr[rt].cnt;
		splay(rt, 0);
		return;
	}
	
	rt = ++indx;
	tr[rt].sz = tr[rt].cnt = 1;
	tr[rt].k = x;
	tr[rt].fa = p;
	if (p) tr[p].son[x > tr[p].k] = rt;
	splay(rt, 0);
}

void solve(){
	sc("%d%d", &N, &M);
	char opt[5];
	int x;
	
	insert(-1e9);
	insert(1e9);
	
	int ans = 0;
	int same = 0;
	for (int i = 1; i <= N; ++i) {
		sc("%s", opt);
		sc("%d", &x);
		if (*opt == 'I') {
			if (x < M) continue;
			insert(x-same);
		} else if (*opt == 'A') {
			same += x;
		} else if (*opt == 'S') {
			ans += remove(M+x-same-1);
			same -= x;
		} else {
			if (x > tr[root].sz - 2) {
				puts("-1");
				continue;
			}
			x = fetch(x+1);
			x = tr[x].k + same;
			pr("%d\n", x);
		}
	}
	pr("%d\n", ans);
}

signed main()
{
	#ifndef ONLINE_JUDGE
	//FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}