Problem: At Akabe High School, a programmer training school, there is a unique study session run by the students themselves. It is important for programmers to constantly adopt new technologies, so the aim of this activity is to develop the habit of self-study through this study session.

There are a total of N students, each with a score obtained as a result of the programming contest at the time of admission. At the study session, some of the N students will become leaders, and each leader will run their own group and join the group they run.

Students other than the leader cannot join a group run by a leader with a score lower than their own. In addition, one value r that is 0 or more is decided so that the difference between the scores of the students participating in the group and the leader is within r. That is, if the leader of a group has a score of s and your score is greater than or less than s --r, you will not be able to join the group.

You are the executive committee chair of the study session and decided to do a simulation to prepare for the operation. In the simulation, start with no leader and repeat the following operations several times.

* Add students as leaders.
* Remove the student from the leader.
* For the combination of leaders at the time of request, find the minimum r such that the number of students who cannot participate in any group is x or less.



Create a program that performs such a simulation.



input

The input consists of one dataset. The input is given in the following format.


N Q
s1
s2
::
sN
QUERY1
QUERY2
::
QUERYQ


The first line gives the number of students N (1 ≤ N ≤ 1000000) and the number of processing requests Q (0 ≤ Q ≤ 1000).

The following N lines are given the integer si (0 ≤ si ≤ 1,000,000,000) indicating the score of the i-th student. Students shall be numbered 1,2, ..., N.

The processing request QUERYi is given to the following Q line. Processing requests are given in chronological order. There are three types of processing requests: ADD, REMOVE, and CHECK, and each QUERYi is given in one of the following formats.


ADD a


Or


REMOVE a


Or


CHECK x


ADD a stands for adding a student with the number a (1 ≤ a ≤ N) to the leader.

REMOVE a represents removing the student with the number a (1 ≤ a ≤ N) from the leader.

CHECK x represents an output request. An upper limit on the number of students who cannot join any group x (0 ≤ x ≤ N) is given.

The input shall satisfy the following conditions.

* At any given time, the number of leaders will not exceed 100.
* Do not add students who are leaders at that time to leaders.
* Students who are not leaders at that time will not be removed from the leader.

output

At the time of each output request in chronological order, the minimum r is output on one line so that the number of students who cannot join any group is x or less. However, if it is impossible to reduce the number of people to x or less no matter what r is selected, NA is output.

Example

Input

5 8
5
10
8
7
3
ADD 1
ADD 3
CHECK 0
CHECK 1
CHECK 2
CHECK 3
CHECK 4
CHECK 5


Output

NA
2
1
0
0
0

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <climits>
#include <iomanip>
#include <algorithm>
#include <queue>
#include <map>
#include <tuple>
#include <iostream>
#include <deque>
#include <array>
#include <set>
#include <functional>
#include <memory>
#include <stack>
#include <numeric>
#include <climits>
#include <cfloat>

template<typename F>
int upper_bound(int from, int until, const F& vec, const int target) {
	while (from < until) {
		const auto mid = (from + until) / 2;
		if (vec(mid) <= target) from = mid + 1;
		else until = mid;
	}
	return from;
}
template<typename F>
int lower_bound(int from, int until, const F &vec, const int target) {
	while (from < until) {
		const auto mid = (from + until) / 2;
		if (vec(mid) < target) from = mid + 1;
		else until = mid;
	}
	return from;
}
class Bit {
	std::vector<int> array;
public:
	Bit(const int size) : array(size, 0) {}
	int count(const int from, const int until) const {
		return count_to(until - 1) - count_to(from - 1);
	}
	int count_to(const int to) const {
		return (to >= 0) ? array[to] + count_to(to - (~to & (to + 1))) : 0;
	}
	void increment(const int position) {
		if (position < array.size()) {
			++array[position];
			increment(position + (~position & (position + 1)));
		}
	}
	void decrement(const int position) {
		if (position < array.size()) {
			--array[position];
			decrement(position + (~position & (position + 1)));
		}
	}
};
int main() {
	constexpr int max_leader_count = 100;
	int n, q; std::cin >> n >> q;
	std::vector<int> scores(n); for (auto& s : scores) std::cin >> s;
	std::vector<int> sorted(n); for (auto i = 0; i < n; ++i) sorted[i] = i; std::sort(sorted.begin(), sorted.end(), [&scores](const int a, const int b) {return scores[a] < scores[b]; });
	std::vector<int> index_to_rank(n); for (auto i = 0; i < n; ++i) index_to_rank[sorted[i]] = i;
	std::set<int> leader_set;
	Bit non_leader(n); for (auto i = 0; i < n; ++i) non_leader.increment(i);
	std::vector<int> leader; leader.reserve(max_leader_count);
	auto converter = [&scores, &sorted](const int pos) {return scores[sorted[pos]]; };
	for (auto _i = 0; _i < q; ++_i) {
		std::string op; int a; std::cin >> op >> a;
		if (op == "ADD") {
			leader_set.insert(index_to_rank[a - 1]);
			non_leader.decrement(index_to_rank[a - 1]);
		}
		else if (op == "REMOVE") {
			leader_set.erase(index_to_rank[a - 1]);
			non_leader.increment(index_to_rank[a - 1]);
		}
		else if (op == "CHECK") {
			if (n - leader_set.size() <= a) {
				std::cout << "0\n";
			}
			else if (leader_set.empty()) {
				std::cout << "NA\n";
			}
			else {
				leader.clear(); std::transform(leader_set.begin(), leader_set.end(), std::back_inserter(leader), converter);
				std::sort(leader.begin(), leader.end());
				int min = 0;
				int max = scores[sorted.back()] + 1;
				while (min < max) {
					auto mid = (min + max) / 2;
					auto count = non_leader.count(lower_bound(0, n, converter, leader.front() - mid), upper_bound(0, n, converter, leader.front()));
					for (auto i = 1; i < leader.size(); ++i) {
						if (leader[i] - mid > leader[i - 1]) {
							count += non_leader.count(lower_bound(0, n, converter, leader[i] - mid), upper_bound(0, n, converter, leader[i]));
						}
						else {
							count += non_leader.count(upper_bound(0, n, converter, leader[i - 1]), upper_bound(0, n, converter, leader[i]));
						}
					}
					if (n - leader.size() - count > a) min = mid + 1;
					else max = mid;
				}
				if (max == scores[sorted.back()] + 1) std::cout << "NA\n";
				else std::cout << max << "\n";
			}
		}
	}
}