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:
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f

#include <iostream>
#include <cstdio>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
  
using namespace std;
  
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
  
static const double EPS = 1e-8;

static const int tx[] = {0,1,0,-1};
static const int ty[] = {-1,0,1,0};

int main(){
  int total_students;
  int total_queries;
  while(~scanf("%d %d",&total_students,&total_queries)){
    vector<int> student_scores;
    vector<int> sorted_student_scores;
    for(int student_i = 0; student_i < total_students; student_i++){
      int score;
      scanf("%d",&score);
      student_scores.push_back(score);
      sorted_student_scores.push_back(score);;
    }

    sort(sorted_student_scores.begin(),sorted_student_scores.end());

    set<int> leaders;
    for(int query_i = 0; query_i < total_queries; query_i++){
      string operation;
      int num;
      cin >> operation >> num;
      if(operation == "ADD"){
        leaders.insert(num - 1);
      }
      else if(operation == "REMOVE"){
        leaders.erase(lower_bound(leaders.begin(),leaders.end(),num - 1));
      }
      else if(operation == "CHECK"){
        vector<int> leader_scores;

        for(set<int>::iterator leader_it = leaders.begin(); leader_it != leaders.end(); leader_it++){
          leader_scores.push_back(student_scores[*leader_it]);

        }
        sort(leader_scores.begin(),leader_scores.end());
        
        int rhs = INF;
        int lhs = 0;

        for(int round = 0; round < 50; round++){
          int mid = lhs + (rhs - lhs) / 2;
          int prev = 0;
          int fail_sum = 0;
          for(int leader_i = 0; leader_i < leader_scores.size(); leader_i++){
            int score = leader_scores[leader_i];
            int current= lower_bound(sorted_student_scores.begin(),
                                 sorted_student_scores.end(),
                                 score - mid)
              - sorted_student_scores.begin();
            int fail = max(0,current - prev);
            fail_sum += fail;
            prev = upper_bound(sorted_student_scores.begin(),
                               sorted_student_scores.end(),score)
              - sorted_student_scores.begin();
          }
          fail_sum += max(total_students - prev,0);

          if(fail_sum > num){
            lhs = mid;
          }
          else{
            rhs = mid;
          }
        }

        if(rhs < INF){
          printf("%d\n",rhs);
        }
        else{
          printf("NA\n");
        }
      }
    }
  }
}