#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

#include <iostream>
#include <algorithm>
#include <vector>
#include <ctime>
#include <list>

using namespace std;

const int MAXMEM = 1e+8;
int mpos = 0;
char mem[MAXMEM];
inline void *operator new(size_t n)
{
	char *res = mem + mpos;
	mpos += n;
	return (void *)res;
}
inline void operator delete(void *) {}

const int BLOCK_SIZE = 500;

struct Node {
	int x, y;
	int cnt;
	int size;

	Node *l, *r;
	Node(int x) : x(x), y(rand()), cnt(1), size(1), l(0), r(0) {}
};

int sz(Node *v)
{
	return v == 0 ? 0 : v->size;
}

void upd(Node *v)
{
	v->size = sz(v->l) + v->cnt + sz(v->r);
}

pair<Node *, Node *> split(Node *v, int k)
{
	if (v == 0)
		return { 0 , 0 };

	if (v->x < k) {
		auto t = split(v->r, k);
		v->r = t.first;
		upd(v);
		return { v, t.second };
	}
	else {
		auto t = split(v->l, k);
		v->l = t.second;
		upd(v);
		return { t.first, v };
	}
}

Node *merge(Node *a, Node *b)
{
	if (a == 0)
		return b;
	if (b == 0)
		return a;

	if (a->y < b->y) {
		a->r = merge(a->r, b);
		upd(a);
		return a;
	}
	else {
		b->l = merge(a, b->l);
		upd(b);
		return b;
	}
}

Node *insert(Node *v, int x)
{
	auto a = split(v, x);
	auto b = split(a.second, x + 1);

	if (b.first == 0)
		return merge(a.first, merge(new Node(x), b.second));
	else {
		b.first->cnt++;
		b.first->size++;
		return merge(a.first, merge(b.first, b.second));
	}
}

Node *erase(Node *v, int x)
{
	auto a = split(v, x);
	auto b = split(a.second, x + 1);

	if (b.first->cnt == 1)
		return merge(a.first, b.second);
	else {
		b.first->cnt--;
		b.first->size--;
		return merge(a.first, merge(b.first, b.second));
	}
}

inline int cnt_low_k(Node *&v, int k)
{
	auto a = split(v, k + 1);
	int ans = sz(a.first);
	v = merge(a.first, a.second);
	return ans;
}

struct Bucket {
	Node *v = 0;
	list<int> a;
};

list<Bucket> a;

inline void relax(list<Bucket>::iterator block)
{
	if (block->a.size() == 2 * BLOCK_SIZE) {
		auto last_block = a.insert(block, Bucket());
		auto pos = block->a.begin();

		for (int i = 0; i < BLOCK_SIZE; i++) {
			last_block->a.insert(last_block->a.end(), *pos);
			last_block->v = insert(last_block->v, *pos);
			block->v = erase(block->v, *pos);
			pos = block->a.erase(pos);
		}
	}
	else if (block->a.size() == 0) {
		if (a.size() > 1)
			a.erase(block);
	}
}

inline void insert_elem(int pos, int x)
{
	auto block = a.begin();
	int k = 0;

	while (k + block->a.size() < pos) {
		k += block->a.size();
		block++;
	}

	auto pos_block = block->a.begin();
	for (int i = k; i < pos; i++)
		pos_block++;

	block->a.insert(pos_block, x);
	block->v = insert(block->v, x);

	relax(block);
}

inline void erase_elem(int pos)
{
	auto block = a.begin();
	int k = 0;

	while (k + block->a.size() <= pos) {
		k += block->a.size();
		block++;
	}

	auto pos_block = block->a.begin();
	for (int i = k; i < pos; i++)
		pos_block++;

	block->v = erase(block->v, *pos_block);
	block->a.erase(pos_block);

	relax(block);
}

inline int get_sum(int ql, int qr, int k)
{
	int l = 0, r = 0;

	int s = 0;

	for (auto block = a.begin(); block != a.end(); block++) {
		l = r;
		r = l + block->a.size();
		if (ql <= l && r <= qr + 1) // блок полностью в запросе
			s += cnt_low_k(block->v, k);
		else if (l <= ql && ql < r || l <= qr && qr < r) { // в блоке часть запроса
			int i = l;
			for (auto x : block->a) {
				if (ql <= i && i <= qr && x <= k)
					s++;
				i++;
			}
		}
	}

	return s;
}

int main()
{
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0), cin.tie(0);
	srand(time(0));
	int n;
	cin >> n;

	a.insert(a.begin(), Bucket());
	auto block = a.begin();
	for (int i = 0; i < n; i++) {
		if (block->a.size() == BLOCK_SIZE) {
			block = a.insert(a.end(), Bucket());
		}

		int x;
		cin >> x;
		block->a.push_back(x);
		block->v = insert(block->v, x);
	}

	char type;
	while (cin >> type && (type == '-' || type == '+' || type == '?')) {
		if (type == '-') {
			int pos;
			cin >> pos;
			erase_elem(pos);
		}
		else if (type == '+') {
			int pos, x;
			cin >> pos >> x;
			insert_elem(pos, x);
		}
		else {
			int l, r, k;
			cin >> l >> r >> k;
			cout << get_sum(l, r, k) << '\n';
		}
	}
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>

using namespace std;

const int BLOCK_SIZE = 7;
list<vector<int>> a; //blocks
list<vector<int>> s; //sort_blocks

void relax(list<vector<int>>::iterator cur_block, list<vector<int>>::iterator sort_block)
{
	if (cur_block->size() == 2 * BLOCK_SIZE) {
		auto last_cur = a.insert(cur_block, vector<int> ());
		auto last_sort = s.insert(sort_block, vector<int> ());

		*last_cur = *cur_block;

		cur_block->clear();
		sort_block->clear();

		for (int i = BLOCK_SIZE; i < 2 * BLOCK_SIZE; i++)
			cur_block->push_back((*last_cur)[i]);
		for (int i = 0; i < BLOCK_SIZE; i++)
			last_cur->pop_back();

		*last_sort = *last_cur;
		sort(last_sort->begin(), last_sort->end());
		*sort_block = *cur_block;
		sort(sort_block->begin(), sort_block->end());
	}
	else if (cur_block->size() == 0) {
		a.erase(cur_block);
		s.erase(sort_block);
	}
}

void add(int pos, int x)
{
	auto cur_block = a.begin(), sort_block = s.begin();
	int cnt = 0;

	while (cnt + cur_block->size() < pos)
		cnt += cur_block->size(), cur_block++, sort_block++;

	pos -= cnt;
	sort_block->insert(lower_bound(sort_block->begin(), sort_block->end(), x), x);
	cur_block->insert(cur_block->begin() + pos, x);

	relax(cur_block, sort_block);
}

void del(int pos)
{
	auto cur_block = a.begin(), sort_block = s.begin();
	int cnt = 0;

	while (cnt + cur_block->size() <= pos)
		cnt += cur_block->size(), cur_block++, sort_block++;

	pos -= cnt;

	sort_block->erase(lower_bound(sort_block->begin(), sort_block->end(), (*cur_block)[pos]));
	cur_block->erase(cur_block->begin() + pos);

	relax(cur_block, sort_block);
}

int cnt_low_k(int ql, int qr, int k)
{
	int l = 0, r = 0;
	int ans = 0;
	for (auto cur_block = a.begin(), sort_block = s.begin(); cur_block != a.end(); cur_block++, sort_block++) {
		l = r, r = l + cur_block->size();

		if (ql <= l && r <= qr + 1)
			ans += upper_bound(sort_block->begin(), sort_block->end(), k) - sort_block->begin();
		else if (l <= ql && ql <= r || l <= qr && qr <= r) {
			for (int i = l, j = 0; i < r; i++, j++)
				if (ql <= i && i <= qr)
					ans += (*cur_block)[j] <= k;
		}
	}

	return ans;
}

int main()
{
	ios_base::sync_with_stdio(0), cin.tie(0);

	int n;
	cin >> n;

	a.insert(a.begin(), vector<int>());
	s.insert(s.begin(), vector<int>());

	for (int i = 0; i < n; i++) {
		int t;
		cin >> t;
		add(i, t);
	}

	char type;
	while (cin >> type) {
		if (type == '+') {
			int pos, x;
			cin >> pos >> x;
			add(pos, x);
		}
		else if (type == '-') {
			int pos;
			cin >> pos;
			del(pos);
		}
		else {
			int l, r, k;
			cin >> l >> r >> k;
			cout << cnt_low_k(l, r, k) << '\n';
		}
	}
}

#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

#include <iostream>
#include <algorithm>
#include <vector>
#include <ctime>

using namespace std;

struct Node { //ДД по неявному ключу чтобы получить относительный порядок
	int x, y;
	int is_on, s;
	int add;
	int del;
	vector<int> leftq, rightq;

	Node *l, *r;

	Node(int x, int nq) : x(x), y(rand()), is_on(1), s(1), l(0), r(0), add(nq), del(-1) { leftq.reserve(100), rightq.reserve(100); }
};

inline int sum(Node *v)
{
	return v == 0 ? 0 : v->s;
}

inline void upd(Node *v)
{
	v->s = sum(v->l) + v->is_on + sum(v->r);
}

Node *merge(Node *a, Node *b)
{
	if (a == 0)
		return b;
	if (b == 0)
		return a;

	if (a->y < b->y) {
		a->r = merge(a->r, b);
		upd(a);
		return a;
	}
	else {
		b->l = merge(a, b->l);
		upd(b);
		return b;
	}
}

pair<Node *, Node *> split(Node *v, int k)
{
	if (v == 0)
		return { 0, 0 };

	if (sum(v->l) + v->is_on <= k) {
		auto t = split(v->r, k - sum(v->l) - v->is_on);
		v->r = t.first;
		upd(v);
		return { v, t.second };
	}
	else {
		auto t = split(v->l, k);
		v->l = t.second;
		upd(v);
		return { t.first, v };
	}
}

void set0(Node *v, int nq)
{
	if (v->is_on) {
		v->is_on = 0;
		v->del = nq;
		upd(v);
	}
	else if (sum(v->l) == 1) {
		set0(v->l, nq);
		upd(v);
	}
	else {
		set0(v->r, nq);
		upd(v);
	}
}

inline Node *insert(Node *v, int pos, int x, int nq)
{
	auto a = split(v, pos);
	return merge(a.first, merge(new Node(x, nq), a.second));
}

inline Node *erase(Node *v, int pos, int nq)
{
	auto a = split(v, pos);
	auto b = split(a.second, 1);
	set0(b.first, nq);
	return merge(a.first, merge(b.first, b.second));
}

Node *find1(Node *v)
{
	if (v->is_on)
		return v;
	else if (sum(v->l) == 1)
		return find1(v->l);
	else
		return find1(v->r);
}

inline void querry_cnt(Node *&v, int l, int r, int nq)
{
	auto a = split(v, l);
	auto b = split(a.second, 1);
	Node *t = find1(b.first);
	t->leftq.push_back(nq);
	v = merge(a.first, merge(b.first, b.second));

	a = split(v, r);
	b = split(a.second, 1);
	t = find1(b.first);
	t->rightq.push_back(nq);
	v = merge(a.first, merge(b.first, b.second));
}

vector<int> ord;
vector<bool> is_was;

struct querry {
	char type;
	int a, b, c;
};

vector<querry> q;

void make_array(Node *v)
{
	if (v == 0)
		return;
	make_array(v->l);

	if (v->add > -1) {
		q[v->add].a = ord.size();
		is_was.push_back(false);
	}
	else
		is_was.push_back(true);

	for (int x : v->leftq)
		q[x].a = ord.size();
	for (int x : v->rightq)
		q[x].b = ord.size();

	if (v->del > -1)
		q[v->del].a = ord.size();

	ord.push_back(v->x);
	
	make_array(v->r);

	delete v;
}

struct Node1 { //ДД для хранения в вершине ДО
	int x, y;
	int cnt, size;
	Node1 *l, *r;

	Node1(int x): x(x), y(rand()), cnt(1), size(1), l(0), r(0) {}
};

inline int sz(Node1 *v)
{
	return v == 0 ? 0 : v->size;
}

inline void upd(Node1 *v)
{
	v->size = sz(v->l) + v->cnt + sz(v->r);
}

pair<Node1 *, Node1 *> split(Node1 *v, int k)
{
	if (v == 0)
		return { 0, 0 };

	if (v->x < k) {
		auto t = split(v->r, k);
		v->r = t.first;
		upd(v);
		return { v, t.second };
	}
	else {
		auto t = split(v->l, k);
		v->l = t.second;
		upd(v);
		return { t.first, v };
	}
}

Node1 *merge(Node1 *a, Node1 *b)
{
	if (a == 0)
		return b;
	if (b == 0)
		return a;

	if (a->y < b->y) {
		a->r = merge(a->r, b);
		upd(a);
		return a;
	}
	else {
		b->l = merge(a, b->l);
		upd(b);
		return b;
	}
}

Node1 *insert(Node1 *v, int x)
{
	auto a = split(v, x);
	auto b = split(a.second, x + 1);

	if (b.first == 0)
		return merge(a.first, merge(new Node1(x), b.second));
	else {
		b.first->cnt++;
		upd(b.first);
		return merge(a.first, merge(b.first, b.second));
	}
}

Node1 *erase(Node1 *v, int x)
{
	auto a = split(v, x);
	auto b = split(a.second, x + 1);

	if (b.first->cnt == 1)
		return merge(a.first, b.second);
	else {
		b.first->cnt--;
		upd(b.first);
		return merge(a.first, merge(b.first, b.second));
	}
}

int cnt_low_k(Node1 *&v, int x)
{
	auto a = split(v, x + 1);
	int ans = sz(a.first);
	v = merge(a.first, a.second);
	return ans;
}

vector<Node1 *> t;
const int INF = 1e+9 + 2;

void build(int v, int l, int r)
{
	t[v] = 0;
	for (int i = l; i < r; i++)
		if (is_was[i])
			t[v] = insert(t[v], ord[i]);
		else
			t[v] = insert(t[v], INF);

	if (r - l > 1) {
		int m = (l + r) >> 1;
		build(2 * v + 1, l, m);
		build(2 * v + 2, m, r);
	}
}

void add(int v, int l, int r, int pos)
{
	t[v] = erase(t[v], INF);
	t[v] = insert(t[v], ord[pos]);

	if (r - l > 1) {
		int m = (l + r) >> 1;

		if (pos < m)
			add(2 * v + 1, l, m, pos);
		else
			add(2 * v + 2, m, r, pos);
	}
}

void del(int v, int l, int r, int pos)
{
	t[v] = erase(t[v], ord[pos]);
	t[v] = insert(t[v], INF);

	if (r - l > 1) {
		int m = (l + r) >> 1;

		if (pos < m)
			del(2 * v + 1, l, m, pos);
		else
			del(2 * v + 2, m, r, pos);
	}
}

int cnt_low_k(int v, int l, int r, int ql, int qr, int x)
{
	if (qr <= l || r <= ql)
		return 0;
	else if (ql <= l && r <= qr)
		return cnt_low_k(t[v], x);
	else {
		int m = (l + r) >> 1;
		return cnt_low_k(2 * v + 1, l, m, ql, qr, x) + cnt_low_k(2 * v + 2, m, r, ql, qr, x);
	}
}

int main()
{
	ios_base::sync_with_stdio(0), cin.tie(0);
	srand(time(0));

	int n;
	cin >> n;
	Node *v = 0;
	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		v = insert(v, i, x, -1);
	}

	q.reserve(1e+5 + 1);
	char type;
	int i = 0;
	while (cin >> type) {
		if (type == '+') {
			int pos, x;
			cin >> pos >> x;
			v = insert(v, pos, x, i);
			q.push_back({ type, pos, x });
		}
		else if (type == '-') {
			int pos;
			cin >> pos;
			v = erase(v, pos, i);
			q.push_back({ type, pos });
		}
		else {
			int l, r, x;
			cin >> l >> r >> x;
			querry_cnt(v, l, r, i);
			q.push_back({ type, l, r, x });
		}
		i++;
	}

	ord.reserve(n + i + 1);
	is_was.reserve(n + i + 1);

	make_array(v);
	n = ord.size();

	t.resize(4 * n);
	build(0, 0, n);

	for (int j = 0; j < i; j++) {
		if (q[j].type == '+')
			add(0, 0, n, q[j].a);
		else if (q[j].type == '-')
			del(0, 0, n, q[j].a);
		else
			cout << cnt_low_k(0, 0, n, q[j].a, q[j].b + 1, q[j].c) << '\n';
	}
}