Problem:
Problem J: The Incubator
サラリーマンの朝は早い。エリートコースを進み一流企業に入社して新人という肩書きからも卒業する頃、僕に下った辞令は未開の惑星における営業活動だった。辺鄙な土地での不便な生活を強いられているが、一応は左遷でなく栄転であり、その証拠に給料もぐんと上がっている - こんな場所では金なんて使いようもないのだけど。近年僕たちが直面している宇宙規模のエネルギー不足に対応するため、特定の生物種の個体から莫大なエネルギーを生成するテクノロジーが開発された。その特定の生物種というのが、この辺鄙な惑星の固有種なのだ。この生物が絶滅しないように保護しつつ、適度にエネルギーを回収していくのが僕の仕事だ。
エネルギーの回収は、いくつかのステップからなる。まずは、エネルギーの回収に使用する個体を選別する。個体によって得られるエネルギーの量は大きく異なるのだ。次に、選別された見込みのある個体に、インキュベーションという特別な処理を行う。インキュベートされた個体は膨大なエネルギーの源となる何かをを絶えず蓄えたり吐き出したりするので、個体にできるだけ多くのエネルギーの源となる何かが蓄えられている瞬間を狙って、円環の理に導く。するとお待ちかねのエネルギーが手に入る、という仕組みだ。
エリートサラリーマンに課せられるノルマは厳しい。しかし、僕にとって数十万のインキュベートされた個体を管理するのは朝飯前だ。今日は月末なので本社に月報を提出しなければならないが、今月はとても良い個体に遭遇したこともあって、過去最高の成績になりそうだ。
と喜んでいたのも束の間、最後の最後でひどいミスをやらかしてしまった。SQL文を打ち間違えて、今月の成果を記録しているデータベースのテーブル 1 つをまるごとふっ飛ばしてしまったのだ。あれがなければ、今月の成果は全く無しということになってしまう。降格、左遷、あるいは解雇もありえるかもしれない。
最後の頼みの綱は、作業のたびにこまめにつけていたログファイルだ。僕はいつも、個体をインキュベートするたびに一意な整数の番号を振り、インキュベートされた個体たちの番号を 1 つの配列に保存している。僕の営業活動は、次のような行動からなる。
個体をインキュベートし、その個体に番号 x を割り当て、その個体の番号を配列の末尾に追加する。
配列の n 番目の番号が示す個体を円環の理に導く。
番号 x の個体を円環の理に導く。
残念ながら僕は最大
lim
体の個体しか管理できない。個体をインキュベートしたとき、もしインキュベート済みの個体が
lim
を超えたならば、昔にインキュベートした個体から順に
lim
以下になるまで円環の理に導く。
僕はこれら 4 つの営業活動を行うたびに、欠かさずログファイルに記入している。しかし、4 の活動だけはログファイルに一切記入していない。そうしても特に曖昧なところは残らないためだ。
いつも僕は、個体の番号の配列の操作を愚直に行なっている。しかし今度ばかりは、愚直に操作しながらログファイルを走査していては間に合いそうにない。月報の提出期限は 5 時間後に迫っている。
そこで、君たちにお願いがあるんだ。ログファイルから僕の営業活動を再現するプログラムを書いてほしい。もし書いてくれたら、お礼に君たちの願い事を何でも 1 つ叶えてあげよう。何だって構わない。どんな願いことだって叶えてあげられるよ。
Input
入力は複数のケースからなる。
各ケースは以下のフォーマットで与えられる。
ここには入力のフォーマットを書く。
q
lim
query
0
x
0
.
.
.
query
q-1
x
q-1
query
i
が0の時、インキュベートした個体に
x
i
の番号を割り当てたことを表す。
query
i
が1の時、配列の
x
i
番目の番号が示す個体を円環の理に導く。
query
i
が2の時、その時点で配列に含まれている中で
x
i
番目の個体の番号を出力する
query
i
が3の時、番号が
x
i
の個体を円環の理に導く。
q
= 0 かつ
lim
= 0の時入力の終わりを表す。
lim
は32bit signed integerで表すことができる正の整数である。
すべてのクエリーについて、
x
i
は0以上の整数で32bit signed integerで表すことができる。
0のクエリーについて、
x
i
は32bit signed integerの範囲に収まる非負整数で表される。
1,2のクエリーについて、
x
i
の値は1以上の整数である。また存在しない配列の番号が指定されることはない
3のクエリーについて、存在しない個体番号が入力に含まれることはない。
また一度消去された個体の番号が値が同じテストケース内で、別の個体に割り当てられることはない。
ジャッジデータは次の2つのうち少なくとも片方を満たす。
1 ≤ q ≤ 400,000 かつテストケースの数が5個以下
1 ≤ q ≤ 10,000 かつテストケースの数は50個以下
Output
入力のクエリーが2の場合、x番目の個体番号を出力する
各ケースの最後には"end"を出力する
Sample input
22 5
0 0
0 1
0 2
0 3
0 4
2 1
2 2
2 3
2 4
2 5
0 5
2 1
0 6
2 2
3 3
2 2
2 2
1 2
2 2
2 1
2 2
2 3
30 5
0 383594529
1 1
0 868094164
0 708344471
0 4102559
0 944076771
0 320398558
1 1
0 949521499
0 1035499529
0 585547493
0 915496840
0 721553343
0 405934659
0 814301872
1 1
2 3
0 919753364
1 1
0 69231610
2 2
0 373477673
0 842917649
0 961543702
0 907959899
2 1
2 2
2 3
2 4
2 5
30 5
0 726736645
0 1
0 344304573
0 241734870
3 726736645
1 3
2 1
0 586879203
2 3
0 511883046
0 481344051
0 154183395
0 435126242
0 185906768
1 1
0 383123551
0 20253038
1 5
2 1
2 2
0 163044554
3 435126242
0 105612613
0 725050544
0 559442328
2 1
2 2
2 3
2 4
2 5
0 0
Sample output
0
1
2
3
4
1
3
4
4
5
2
5
6
end
405934659
405934659
69231610
373477673
842917649
961543702
907959899
end
1
586879203
154183395
435126242
383123551
163044554
105
...(truncated)

Submitted solutions:

code_snippet: #pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace::std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
// random_device rd;
// mt19937 mt(rd());
// #include <boost/numeric/interval.hpp>
// #include <boost/numeric/interval/io.hpp>
// #include <boost/intrusive/rbtree.hpp>
// #include <boost/geometry.hpp>
// #include <boost/geometry/geometries/linestring.hpp>
// #include <boost/geometry/geometries/polygon.hpp>
// #include <boost/geometry/geometries/point_xy.hpp>
// #include <boost/multiprecision/cpp_dec_float.hpp>
// #include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
// typedef mp::number<mp::cpp_dec_float<0>> cfloat;
// typedef mp::cpp_int cint;

#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
using namespace __gnu_pbds;
template<typename T=long long>using pbds=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
template<typename T=long long>using pqueue =__gnu_pbds::priority_queue<T, less<T>,rc_binomial_heap_tag>;
typedef long long lint;
typedef long long ll;
typedef long double ldouble;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<double> dvec;
typedef vector<vector<double>> dmat;
typedef vector<vector<vector<double>>> dmat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
typedef vector<vector<vector<string>>> smat3;
typedef vector<pair<lint,lint>> pvec;
typedef vector<vector<pair<lint,lint>>> pmat;
typedef vector<vector<vector<pair<lint,lint>>>> pmat3;
#define rep(i, n) for(lint i = 0; i < (lint)(n); i++)
#define irep(i) for(lint i = 0;; i++)
#define irep1(i) for(lint i = 1;; i++)
#define irep2(i) for(lint i = 2;; i++)
#define rrep(i, n) for(lint i = (lint)(n-1); i >-1; i--)
#define rrepi(i,a,b) for(lint i = (lint)(b-1); i >a-1; i--)
#define repi(i,a,b) for(lint i=lint(a);i<lint(b);i++)
#define rep2(i,a,b,c) for(lint i=lint(a);i>lint(b);i+=c)
#define all(x) (x).begin(),(x).end()
//#define PI 3.141592653589793
#define dist(x1,y1,x2,y2) (pow(pow(x2-x1,2)+pow(y2-y1,2),0.5))
#define output(v) do{bool f=0;for(auto i:v){cout<<(f?" ":"");if(i>INF/2)cout<<"INF";else cout<<i;f=1;}cout<<"\n";}while(0)
#define output2(v) for(auto j:v)output(j);
#define _output(v) do{bool f=0;rep(i,v.size()){cout<<(f?" ":"");if(v[i]>INF/2)cout<<"INF";else cout<<v[i];f=1;}cout<<"\n";}while(0)
#define _output2(v) rep(j,v.size()){_output(v[j]);}
#define input(a,n) lint n;cin>>n;vector<lint>a(n);rep(i,n)cin>>a[i];
#define SUM(v) accumulate(all(v),0LL)
#define INF (1LL<<60)
#define IINF (1<<30)
#define EPS (1e-10)
#define LINF 9223372036854775807
#define MOD 100000007
#define endl "\n"
template<typename T=lint>T in(){return *istream_iterator<T>(cin);}
inline lint gcd(lint a,lint b){return b?gcd(b,a%b):a;}
template<typename T=lint>inline T lcm(T a,T b){return a/gcd(a,b)*b;}
template<typename T=lint>inline T add(T a,T b){return a+b;}
template<typename T=lint>inline T minq(T a,T b){return min(a,b);}
inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
vector<lint> dx={-1,1,0,0,1,1,-1,-1};
vector<lint> dy={0,0,-1,1,1,-1,1,-1};



int main(){
    while(1){
        pbds<pair<lint,lint>>t;
        lint q,lim;
        cin>>q>>lim;
        if(q==0&&lim==0)break;
        map<lint,lint>log;
        rep(i,q){
            lint que,x;
            cin>>que>>x;
            if(que==0){
                t.insert(make_pair(i,x));
                log.emplace(x,i);
                if((lint)t.size()==lim+1)t.erase(t.begin());
            }
            if(que==1){
                t.erase(t.find_by_order(x-1));
            }
            if(que==2){
                cout<<(*t.find_by_order(x-1)).second<<endl;
            }
            if(que==3){
                t.erase(make_pair(log.at(x),x));
            }
        }
        cout<<"end"<<endl;
    }

}
accuracy: 1
time_ms: 490
memory_kb: 32244
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;

// 1-indexed
template <class T>
struct BIT {
  vector<T> lst;
  int treesize;
  // constructor
  BIT(int newn = 0) {
    treesize = newn;
    lst.resize(treesize + 1);
    for(int i = 0; i <= treesize; ++i) lst[i] = 0;
  }
  // a_place += num
  bool add(int place, T num) {
    while(place <= treesize) {
      lst[place] += num;
      place += place & -place;
    }
    return 1;
  }
  // add wide ver.(add num between l and r)
  bool addw(int left, int right, T num) {
    while(left <= right && left >= 1 && right <= treesize)
      add(left++, num);
    return 1;
  }
  // sum between [1,place]
  T calcsum(int place) {
    T answer = 0;
    while(place > 0) {
      answer += lst[place];
      place -= place & -place;
    }
    return answer;
  }
  // sum [l,r]
  T calcsumw(int left, int right) {
    return calcsum(right) - calcsum(left - 1);
  }
};

struct data {
  int q, x;
};

int q, lim;
vector<int> v;
BIT<int> bit;
map<int, int> mp;
vector<data> query;

void solve();
int bsearch(int x);

int main() {
  while(1) {
    cin >> q >> lim;
    if(q + lim == 0) break;
    query.resize(q);
    v.assign(1, -1);
    for(int i = 0; i < q; ++i) {
      cin >> query[i].q >> query[i].x;
      if(query[i].q == 0) {
        mp[query[i].x] = v.size();
        v.push_back(query[i].x);
      }
    }
    solve();
  }
  return 0;
}

void solve() {
  int sum = 0;
  bit = BIT<int>(v.size());
  for(int i = 0; i < q; ++i) {
    if(query[i].q == 0) {
      bit.add(mp[query[i].x], 1);
      if(bit.calcsum(v.size()) > lim + sum) ++sum;
    }
    else if(query[i].q == 1)
      bit.add(bsearch(query[i].x + sum), -1);
    else if(query[i].q == 2)
      cout << v[bsearch(query[i].x + sum)] << endl;
    else
      bit.add(mp[query[i].x], -1);
  }
  cout << "end" << endl;
}

int bsearch(int x) {
  int l = 0, r = v.size();
  while(r - l > 1) {
    int now = (l + r) / 2;
    if(bit.calcsum(now) >= x)
      r = now;
    else
      l = now;
  }
  return r;
}
accuracy: 1
time_ms: 600
memory_kb: 39492
final_rank: 9

code_snippet: #include <bits/stdc++.h>
using namespace std;

#define MAX_N (1<<19)+1

class BIT {
public:
    int limit;
    int last;
    map<int, int> m, mrev;
    vector<int> t;
    
    BIT(int l): limit(l), last(0), t(MAX_N, 0) {}

    void incubate(int rid) {
        if (t[MAX_N-1] == limit) {
            add(find(1), -1);
        }
        last ++;
        m[last] = rid;
        mrev[rid] = last;
        _add(last, 1);
    }

    void add(int rid, int x) {
        _add(mrev[rid], x);
    }

    void _add(int id, int x) {
        for (int i=id; i<MAX_N; i+=(i&-i)) {
            t[i] += x;
        }
    }

    int sum(int num) {
        int res = 0;
        for (int i=num; i>0; i-=(i&-i)) {
            res += t[i];
        }
        return res;
    }

    int find(int num) {
        if (sum(1) == num) {
            return m[1];
        }
        int l = 1, r = MAX_N;
        while (abs(r-l) > 1) {
            int mi = (l+r) / 2;
            if (sum(mi) < num) {
                l = mi;
            } else {
                r = mi;
            }
        }
        return m[l+1];
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int q, lim;
    while (cin >> q >> lim, (q || lim)) {
        int query, x;
        BIT bit(lim);

        for (int i=0; i<q; ++i) {
            cin >> query >> x;
            if (query == 0) {
                bit.incubate(x);
            } else if (query == 1) {
                bit.add(bit.find(x), -1);
            } else if (query == 2) {
                cout << bit.find(x) << endl;
            } else if (query == 3) {
                bit.add(x, -1);
            }
        }
        cout << "end" << endl;
    }
}
accuracy: 1
time_ms: 640
memory_kb: 42564
final_rank: 10

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back

struct SegTree{
    int n;
    vector<int> dat;
    //初期化
    SegTree(int _n){
        n=1;
        while(n<_n) n*=2;
        dat=vector<int>(2*n-1,0);
    }

    //k番目(0-indexed)の値をaに変更
    void update(int k, int a){
        k+=n-1;
        dat[k]=a;
        //更新
        while(k>0){
            k=(k-1)/2;
            dat[k]= dat[2*k+1]+dat[2*k+2];
        }
    }

    int find(int x){
        int now = 0;
        while(now<n-1){
            if(dat[2*now+1] < x){
                x -= dat[2*now+1];
                now = 2*now + 2;
            }
            else{
                now = 2*now + 1;
            }
        }
        return now - (n-1);
    }
};

int main(){
    int q,lim;
    while(scanf(" %d %d", &q, &lim),q){
        SegTree st(q);
        int idx = 0, num = 0;
        unordered_map<int,int> id2idx;
        vector<int> a;

        auto DEL = [&](int p){
            st.update(p,0);
            --num;
        };

        rep(i,q){
            int t,x;
            scanf(" %d %d", &t, &x);

            if(t==0){
                id2idx[x] = idx;
                st.update(idx,1);
                a.pb(x);
                ++idx;
                ++num;

                if(num == lim+1) DEL(st.find(1));
            }
            else if(t==1) DEL(st.find(x));
            else if(t==2) printf("%d\n",a[st.find(x)]);
            else DEL(id2idx[x]);
        }
        printf("end\n");
    }
    return 0;
}
accuracy: 1
time_ms: 200
memory_kb: 25296
final_rank: 2

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = double;
const ld eps = 1e-9;
//
//using Graph = vector<vector<int>>;
//
//int dfs(const Graph&g, const int now, vector<int>&ch_cnts) {
//  ch_cnts[now]++;
//  for (auto&& e : g[now]) {
//      ch_cnts[now] += dfs(g, e, ch_cnts);
//  }
//  return ch_cnts[now];
//}
//
//struct HL_Edge {
//  int from;
//  int to;
//  bool heavy;
//};
//
//void dfs2(const Graph&g, vector<vector<HL_Edge>>&hl_tree, const int now, const vector<int>&ch_cnts) {
//
//  int max_ch_id = 1;
//  {
//      int max_ch_num = -1;
//      for (auto&&e : g[now]) {
//          if (max_ch_num < ch_cnts[e]) {
//              max_ch_num = ch_cnts[e];
//              max_ch_id = e;
//          }
//      }
//  }
//  for (auto e : g[now]) {
//      bool heavy = (e == max_ch_id);
//
//      hl_tree[now].push_back(HL_Edge{ now,e,heavy });
//  }
//  return;
//}
//
//void HL(const vector<vector<int>>&ro_tree) {
//  vector<int>ch_cnts(ro_tree.size());
//
//  dfs(ro_tree, 0, ch_cnts);
//
//  vector<vector<HL_Edge>>hl_tree(ro_tree.size());
//
//  dfs2(ro_tree, hl_tree, 0, ch_cnts);
//}
//
//namespace FastFourierTransform
//{
//  using C = complex< double >;
//
//  void DiscreteFourierTransform(vector< C > &F, bool rev)
//  {
//      const int N = (int)F.size();
//      const double PI = (rev ? -1 : 1) * acos(-1);
//      for (int i = 0, j = 1; j + 1 < N; j++) {
//          for (int k = N >> 1; k > (i ^= k); k >>= 1);
//          if (i > j) swap(F[i], F[j]);
//      }
//      C w, s, t;
//      for (int i = 1; i < N; i <<= 1) {
//          for (int k = 0; k < i; k++) {
//              w = polar(1.0, PI / i * k);
//              for (int j = 0; j < N; j += i * 2) {
//                  s = F[j + k];
//                  t = C(F[j + k + i].real() * w.real() - F[j + k + i].imag() * w.imag(),
//                      F[j + k + i].real() * w.imag() + F[j + k + i].imag() * w.real());
//                  F[j + k] = s + t, F[j + k + i] = s - t;
//              }
//          }
//      }
//      if (rev) for (int i = 0; i < N; i++) F[i] /= N;
//  }
//
//  vector< int> Multiply(const vector<int > &A, const vector<int > &B)
//  {
//      int sz = 1;
//      while (sz <= A.size() + B.size()) sz <<= 1;
//      vector< C > F(sz), G(sz);
//      for (int i = 0; i < A.size(); i++) F[i] = A[i];
//      for (int i = 0; i < B.size(); i++) G[i] = B[i];
//      DiscreteFourierTransform(F, false);
//      DiscreteFourierTransform(G, false);
//      for (int i = 0; i < sz; i++) F[i] *= G[i];
//      DiscreteFourierTransform(F, true);
//      vector< int > X(A.size() + B.size() - 1);
//      for (int i = 0; i < A.size() + B.size() - 1; i++) X[i] = F[i].real() + 0.5;
//      return (X);
//  }
//};

#define Seg_Max_N (1<<19) 

using Value = int;
const Value ini = 0;
struct segtree {
	int N;
	vector<Value>dat;

	segtree() {}
	segtree(int n) :dat(2 * Seg_Max_N) {
		N = 1;
		while (N < n) N *= 2;
		for (int i = 0; i < 2 * N - 1; i++) {
			dat[i] = ini;
		}
	}
	Value connect(const Value&l, const Value&r) {
		return l+r;
	}
	// update k th element
	void update(int k, Value a) {
		k += N - 1;
		dat[k] = a;

		while (k > 0) {
			k = (k - 1) / 2;
			const Value al(dat[k * 2 + 1]);
			const Value ar(dat[k * 2 + 2]);
			dat[k] = connect(al, ar);
		}
	}
	// min [a, b)
	Value  query(int a, int b) { return query(a, b, 0, 0, N); }
	Value  query(int a, int b, int k, int l, int r) {
		if (r <= a or b <= l) return ini;
		if (a <= l and r <= b) return dat[k];
		const int m = (l + r) / 2;
		const Value al(query(a, b, k * 2 + 1, l, m));
		const Value ar(query(a, b, k * 2 + 2, m, r));
		return connect(al, ar);
	}
};


int main() {
	while (true) {
		int Q,LIM;cin>>Q>>LIM;
		if(!Q)break;

		vector<int>nums;
		map<int,int>mp;
		segtree tree(4e5);

		int nl=0;
		int sum=0;
		while (Q--) {
			int a,x;cin>>a>>x;
			if (a == 0) {
				nums.push_back(x);
				tree.update(nums.size()-1,1);
				mp[x]=nums.size()-1;

				sum++;

				if (sum > LIM) {
					while (true) {
						if (tree.query(nl, nl + 1) == 1) {
							tree.update(nl, 0);
							nl++;
							break;
						}
						else {
							nl++;
						}
					}
					sum--;
				}
				
			}
			else if (a == 1) {
				int minr=0;
				int maxr=nums.size();

				while (minr + 1 != maxr) {
					int midr((minr+maxr+1)/2);
					if (tree.query(0, midr) >= x) {
						maxr=midr;
					}
					else {
						minr=midr;
					}
				}
				tree.update(maxr-1,0);
				sum--;
			}
			else if (a == 3) {
				assert(tree.query(mp[x],mp[x]+1)==1);
				tree.update(mp[x],0);
				sum--;
			}
			else {
				int minr = 0;
				int maxr = nums.size();

				while (minr + 1 != maxr) {
					int midr((minr + maxr + 1) / 2);
					if (tree.query(0, midr) >= x) {
						maxr = midr;
					}
					else {
						minr = midr;
					}
				}
				cout<<nums[maxr-1]<<endl;
			}
		}
		cout<<"end"<<endl;
	}
	return 0;
}
accuracy: 1
time_ms: 680
memory_kb: 27260
final_rank: 7

code_snippet: #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <iostream>
#include <unordered_map>
#include <queue>
#include <string>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> ipair;
typedef tuple<int, int, int> ituple;

// const int INF = INT_MAX;
// const ll INF = LLONG_MAX;
// const int MOD = ((int)1e9 + 7);
// const ld EPS = (1e-10);
#define PI acosl(-1)
#define MAX_N (500000)

class BitSum{
protected:
  static const int max_value = 500000 + 2;
  ll bit[max_value + 1];

public:
  BitSum(int size) {
    assert(size < max_value);
    init();
  }
  void init(){
    for (int i = 0; i < max_value; i++){
      bit[i] = 0;
    }
  }
  void add(int idx, ll val){
    int p = idx+1;
    while(p < max_value){
      bit[p] += val;
      p += p & -p;
    }
  }
  /**
   * [0, idx]のsumを求める
   */
  ll calc(int idx){
    ll res = 0;
    int p = idx+1;
    while(0 < p){
      res += bit[p];
      p -= p & -p;
    }
    return res;
  }
  /**
   * [idx1, idx2]のsumを求める
   */
  ll range(int idx1, int idx2) {
    return calc(idx2) - calc(idx1 - 1);
  }
};

ll getNth(BitSum &bs, int index, int max_size){
  ll l = 1, h = max_size;

  while (l < h) {
    ll m = (l + h) / 2;
    ll res = bs.calc(m);
    // printf("l = %lld, h = %lld: calc(%lld) = %lld\n", l, h, m, res);
    if (res < index) {
      l = m + 1;
    }
    else {
      h = m;
    }
  }

  return (l + h) / 2;
}

void exec(int q, int lim){
  unordered_map<int, int> number2index;
  unordered_map<int, int> index2number;
  VI incubated;
  BitSum bs = BitSum(MAX_N);
  int index;
  int count = 0;

  for (int i = 0; i < q; i++){
    int query, x;
    scanf("%d%d", &query, &x);
    // printf("query = (%d, %d)\n", query, x);

    switch (query) {
      case 0:
        incubated.push_back(x);
        bs.add(incubated.size(), 1);
        number2index[x] = incubated.size();
        index2number[incubated.size()] = x;
        count++;

        if (count > lim) {
          index = getNth(bs, 1, incubated.size());
          // printf("0: overflow. delete (%d, %d)\n", index, index2number[index]);
          bs.add(index, -1);
          count--;
        }
        break;
      case 1:
        index = getNth(bs, x, incubated.size());
        // printf("1: delete by index = (%d, %d)\n", index, index2number[index]);
        bs.add(index, -1);
        count--;
        break;
      case 2:
        index = getNth(bs, x, incubated.size());
        // printf("DEBUG 2: index = %d\n", index);
        // printf("DEBUG 2: range = %lld\n", bs.range(index, index));
        printf("%d\n", index2number[index]);
        break;
      case 3:
        bs.add(number2index[x], -1);
        // printf("3: delete by number = (%d, %d)\n", x, number2index[x]);
        count--;
        break;
    }
  }

  printf("end\n");

}

void solve(){
  while (true){
    int q, lim;
    scanf("%d%d", &q, &lim);

    if (q + lim == 0) {
      break;
    }

    exec(q, lim);
  }
}

int main(){
  solve();
  return 0;
}
accuracy: 1
time_ms: 330
memory_kb: 41688
final_rank: 8

code_snippet: #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <iostream>
#include <unordered_map>
#include <queue>
#include <string>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> ipair;
typedef tuple<int, int, int> ituple;

// const int INF = INT_MAX;
// const ll INF = LLONG_MAX;
// const int MOD = ((int)1e9 + 7);
// const ld EPS = (1e-10);
#define PI acosl(-1)
#define MAX_N (500000)

class BitSum{
protected:
  static const int max_value = 500000 + 2;
  ll bit[max_value + 1];

public:
  BitSum(int size) {
    assert(size < max_value);
    init();
  }
  void init(){
    for (int i = 0; i < max_value; i++){
      bit[i] = 0;
    }
  }
  void add(int idx, ll val){
    int p = idx+1;
    while(p < max_value){
      bit[p] += val;
      p += p & -p;
    }
  }
  /**
   * [0, idx]のsumを求める
   */
  ll calc(int idx){
    ll res = 0;
    int p = idx+1;
    while(0 < p){
      res += bit[p];
      p -= p & -p;
    }
    return res;
  }
  /**
   * [idx1, idx2]のsumを求める
   */
  ll range(int idx1, int idx2) {
    return calc(idx2) - calc(idx1 - 1);
  }
};

ll getNth(BitSum &bs, int index, int max_size){
  ll l = 1, h = max_size;
  ll prev = max_size;

  // printf("getNth; index = %d\n", index);

  while (l < h) {
    ll m = (l + h) / 2 + (l + h) % 2;
    ll res = bs.calc(m);
    // printf("l = %lld, h = %lld: calc(%lld) = %lld\n", l, h, m, res);
    if (res == index) {
      h = m;
    }
    else if (res < index) {
      l = m + 1;
    }
    else {
      h = m - 1;
    }

    if (abs(h - l) == prev) {
      break;
    }
    prev = abs(h - l);
  }

  return (l + h) / 2 + (l + h) % 2;
}

void exec(int q, int lim){
  unordered_map<int, int> number2index;
  unordered_map<int, int> index2number;
  VI incubated;
  BitSum bs = BitSum(MAX_N);
  int index;
  int count = 0;

  for (int i = 0; i < q; i++){
    int query, x;
    scanf("%d%d", &query, &x);
    // printf("query = (%d, %d)\n", query, x);

    switch (query) {
      case 0:
        incubated.push_back(x);
        bs.add(incubated.size(), 1);
        number2index[x] = incubated.size();
        index2number[incubated.size()] = x;
        count++;

        if (count > lim) {
          index = getNth(bs, 1, incubated.size());
          // printf("0: overflow. delete (%d, %d)\n", index, index2number[index]);
          bs.add(index, -1);
          count--;
        }
        break;
      case 1:
        index = getNth(bs, x, incubated.size());
        // printf("1: delete by index = (%d, %d)\n", index, index2number[index]);
        bs.add(index, -1);
        count--;
        break;
      case 2:
        index = getNth(bs, x, incubated.size());
        // printf("DEBUG: index = %d\n", index);
        printf("%d\n", index2number[index]);
        break;
      case 3:
        bs.add(number2index[x], -1);
        // printf("1: delete by number = (%d, %d)\n", x, number2index[x]);
        count--;
        break;
    }
  }

  printf("end\n");

}

void solve(){
  while (true){
    int q, lim;
    scanf("%d%d", &q, &lim);

    if (q + lim == 0) {
      break;
    }

    exec(q, lim);
  }
}

int main(){
  solve();
  return 0;
}
accuracy: 0.3333333333333333
time_ms: 130
memory_kb: 7336
final_rank: 18

code_snippet: #include <stdio.h>
#include <cmath>
#include <math.h>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

int Q,limit,N;
int current_pos;
int BIT[500000],number[500000];

map<int,int> MAP;

void add(int loc,int value){

	BIT[loc] += value;

	loc += loc & -loc;

	while(loc <= N){
		BIT[loc] += value;
		loc += loc & -loc;
	}
}

int getSum(int loc){

	int sum = BIT[loc];

	loc -= loc & -loc;

	while(loc > 0){
		sum += BIT[loc];
		loc -= loc & -loc;
	}
	return sum;
}

int getLoc(int sum){

	int left = 1,right = current_pos-1,m = (left+right)/2;
	int ret;

	while(left <= right){
		if(getSum(m) >= sum){
			ret = m;
			right = m-1;
		}else{
			left = m+1;
		}
		m = (left+right)/2;
	}
	return ret;
}

void func(){

	N = Q;

	for(int i = 0; i <= N; i++)BIT[i] = 0;
	MAP.clear();

	int command,num = 0,del_pos,print_pos;
	current_pos = 1;
	int x;

	for(int loop = 0; loop < Q; loop++){
		scanf("%d %d",&command,&x);

		switch(command){
		case 0:
			add(current_pos,1);
			number[current_pos] = x;
			MAP[x] = current_pos;
			num++;
			current_pos++;
			if(num > limit){
				del_pos = getLoc(1);
				add(del_pos,-1);
				num--;
			}
			break;
		case 1:
			del_pos = getLoc(x);
			add(del_pos,-1);
			num--;
			break;
		case 2:
			print_pos = getLoc(x);
			printf("%d\n",number[print_pos]);
			break;
		case 3:
			del_pos = MAP[x];
			add(del_pos,-1);
			num--;
			break;
		}
	}
	printf("end\n");
}

int main(){

	while(true){
		scanf("%d %d",&Q,&limit);
		if(Q == 0 && limit == 0)break;

		func();
	}
	return 0;
}
accuracy: 1
time_ms: 330
memory_kb: 25064
final_rank: 5

code_snippet: #include <bits/stdc++.h>
using namespace std;

template <typename T>
class fenwick_tree {
public:
    fenwick_tree(int n) : n(n), dat(n, 0) {}

    void add(int i, T value) {
        for(; i<n; i |= i + 1) {
            dat[i] += value;
        }
    }

    // [0..r]
    T sum(int i) const {
        T res = 0;
        for(; i>=0; i = (i & (i+1)) - 1) {
            res += dat[i];
        }
        return res;
    }
    // [l, r)
    T sum(int l, int r) const {
        return sum(r-1) - sum(l-1);
    }

private:
    const int n;
    std::vector<T> dat;
};

int main() {
    int q, lim;
    while(cin >> q >> lim, q) {
        vector<int> query(q), x(q);
        map<int, int> pos;
        map<int, int> unzip;
        for(int i = 0; i < q; ++i) {
            cin >> query[i] >> x[i];
            if(query[i] == 0 && pos.count(x[i]) == 0) {
                int idx = pos.size();
                pos[x[i]] = idx;
                unzip[idx] = x[i];
            }
        }

        fenwick_tree<int> bit(pos.size());
        auto get_idx = [&](int cnt) {
            int lb = -1, ub = pos.size() - 1;
            while(ub - lb > 1) {
                int m = (ub + lb) / 2;
                if(bit.sum(m) >= cnt) {
                    ub = m;
                } else {
                    lb = m;
                }
            }
            return ub;
        };
        for(int i = 0; i < q; ++i) {
            if(query[i] == 0) {
                bit.add(pos[x[i]], 1);
                if(bit.sum(pos.size() - 1) > lim) {
                    bit.add(get_idx(1), -1);
                }
            } else if(query[i] == 1) {
                bit.add(get_idx(x[i]), -1);
            } else if(query[i] == 2) {
                cout << unzip[get_idx(x[i])] << endl;
            } else {
                bit.add(pos[x[i]], -1);
            }
        }
        cout << "end" << endl;
    }
}
accuracy: 1
time_ms: 910
memory_kb: 44820
final_rank: 12

code_snippet: #include <bits/stdc++.h>
using namespace std;

template <typename T>
class fenwick_tree {
public:
    fenwick_tree(int n) : n(n), dat(n, 0) {}

    void add(int i, T value) {
        for(; i<n; i |= i + 1) {
            dat[i] += value;
        }
    }

    // [0..r]
    T sum(int i) const {
        T res = 0;
        for(; i>=0; i = (i & (i+1)) - 1) {
            res += dat[i];
        }
        return res;
    }
    // [l, r)
    T sum(int l, int r) const {
        return sum(r-1) - sum(l-1);
    }

private:
    const int n;
    std::vector<T> dat;
};

int main() {
    int q, lim;
    while(cin >> q >> lim, q) {
        vector<int> query(q), x(q);
        map<int, int> pos;
        map<int, int> unzip;
        for(int i = 0; i < q; ++i) {
            cin >> query[i] >> x[i];
            if(pos.count(x[i]) == 0) {
                int idx = pos.size();
                pos[x[i]] = idx;
                unzip[idx] = x[i];
            }
        }

        fenwick_tree<int> bit(pos.size());
        auto get_idx = [&](int cnt) {
            int lb = -1, ub = pos.size() - 1;
            while(ub - lb > 1) {
                int m = (ub + lb) / 2;
                if(bit.sum(m) >= cnt) {
                    ub = m;
                } else {
                    lb = m;
                }
            }
            return ub;
        };
        for(int i = 0; i < q; ++i) {
            if(query[i] == 0) {
                bit.add(pos[x[i]], 1);
                if(bit.sum(pos.size() - 1) > lim) {
                    bit.add(get_idx(1), -1);
                }
            } else if(query[i] == 1) {
                bit.add(get_idx(x[i]), -1);
            } else if(query[i] == 2) {
                cout << unzip[get_idx(x[i])] << endl;
            } else {
                bit.add(pos[x[i]], -1);
            }
        }
        cout << "end" << endl;
    }
}
accuracy: 0.3333333333333333
time_ms: 330
memory_kb: 3756
final_rank: 19

code_snippet: #include <bits/stdc++.h>
using namespace std;

template <typename T>
class fenwick_tree {
public:
    fenwick_tree(int n) : n(n), dat(n, 0) {}

    void add(int i, T value) {
        for(; i<n; i |= i + 1) {
            dat[i] += value;
        }
    }

    // [0..r]
    T sum(int i) const {
        T res = 0;
        for(; i>=0; i = (i & (i+1)) - 1) {
            res += dat[i];
        }
        return res;
    }
    // [l, r)
    T sum(int l, int r) const {
        return sum(r-1) - sum(l-1);
    }

private:
    const int n;
    std::vector<T> dat;
};

int main() {
    int q, lim;
    while(cin >> q >> lim, q) {
        vector<int> query(q), x(q);
        map<int, int> pos;
        map<int, int> unzip;
        for(int i = 0; i < q; ++i) {
            cin >> query[i] >> x[i];
            if(pos.count(x[i]) == 0) {
                int idx = pos.size();
                pos[x[i]] = idx;
                unzip[idx] = x[i];
            }
        }

        fenwick_tree<int> bit(pos.size());
        auto get_idx = [&](int cnt) {
            int lb = -1, ub = pos.size();
            while(ub - lb > 1) {
                int m = (ub + lb) / 2;
                if(bit.sum(m) >= cnt) {
                    ub = m;
                } else {
                    lb = m;
                }
            }
            return ub;
        };
        for(int i = 0; i < q; ++i) {
            if(query[i] == 0) {
                bit.add(pos[x[i]], 1);
                if(bit.sum(pos.size() - 1) > lim) {
                    bit.add(get_idx(1), -1);
                }
            } else if(query[i] == 1) {
                bit.add(get_idx(x[i]), -1);
            } else if(query[i] == 2) {
                cout << unzip[get_idx(x[i])] << endl;
            } else {
                bit.add(pos[x[i]], -1);
            }
        }
        cout << "end" << endl;
    }
}
accuracy: 0.3333333333333333
time_ms: 340
memory_kb: 3756
final_rank: 20

code_snippet: #include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x)  cerr << #x << " = " << (x) << endl;
//const int INF = 1e8;
using namespace std;

const int MAX_N = 400010;

class segTree{
    public:
        int n, dat[4 * MAX_N];
        void init(int n_, int value, int dat_b[4 * MAX_N] = NULL){
            n = 1;
            while(n <= n_) n *= 2;
            rep(i,2 * n){
                dat[i] = value;
                if(dat_b != NULL) dat_b[i] = value;
            }
        }
        void initArray(int n_, int a[MAX_N]){ //??????a??§????????????
            n = 1;
            while(n <= n_) n *= 2;
            for(int i = n; i < n + n_; i++){
                dat[i] = a[i - n];
            }
            for(int i = n - 1; i >= 1; i--){
                dat[i] = min(dat[i * 2], dat[i * 2 + 1]);
                //dat[i] = dat[i * 2] + dat[i * 2 + 1];
            }
        }
        void output(int a[4 * MAX_N]){
            show("print");
            range(i,1,n * 2) cout << (a[i] == INT_MAX ? 0 : a[i]) << ' ';
            cout << endl;
        }
};

class rangeAddQuery : public segTree{
    //dat : ???????????????????§???????????????????????????????
    //dat_add : ????§???§?????????????????????????????????
    private:
        int dat_add[4 * MAX_N];
        int query(int a, int b, int k, int l, int r){
            if(b <= l || r <= a) return 0;
            if(a <= l && r <= b) return dat[k] * (r - l) + dat_add[k];

            int res = (min(b, r) - max(a, l)) * dat[k];
            res += query(a, b, k * 2, l, (l + r) / 2);
            res += query(a, b, k * 2 + 1, (l + r) / 2, r);
            return res;
        }
        void add(int a, int b, int k, int l, int r, int x){
            if(a <= l && r <= b){
                dat[k] += x;
            }else if(l < b && a < r){
                dat_add[k] += (min(b, r) - max(a, l)) * x;
                add(a, b, k * 2, l, (l + r) / 2, x);
                add(a, b, k * 2 + 1, (l + r) / 2, r, x);
            }
        }
    public:
        rangeAddQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_, 0, dat_add); }
        int query(int a, int b){ return query(a,b,1,0,n); }
        void add(int s, int t, int x){ add(s, t, 1, 0, n, x); }
        void add(int i, int x){ add(i, i + 1, 1, 0, n, x); }
        int get(int a){ return query(a, a + 1); }
};

class rangeSumQuery : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            if(r <= a || b <= l) return 0;
            if(a <= l && r <= b) return dat[k];

            int vl = query(a, b, k * 2, l, ( l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return vl + vr;
        }
    public:
        rangeSumQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_, 0); }
        void update(int i, int x){
            i += n; //????????????
            dat[i] += x;
            while(i > 0){ //?????????????????´??°
                dat[i / 2] = dat[i] + dat[i^1];
                i = i / 2;
            }
        }
        int query(int a, int b){ return query(a,b,1,0,n); }
        int get(int a){ return query(a, a + 1); }
        bool C(int mid, int x){
            return query(0, mid) < x;
        }
        int pos(int x){
            //show(x)
            int right = n, left = 0;
            rep(i,25){
                int mid = (right + left ) / 2;
                if(C(mid,x)) left = mid;
                else right = mid;
            }
            return left;
        }
};

class rangeMinimumQuery : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            //[a, b) ??¨[l, r)???????????????????????°???INT_MAX
            if(r <= a || b <= l) return INT_MAX;
            //[a,b)???[l,r)????????¨???????????§????????°?????????????????????
            if(a <= l && r <= b) return dat[k];

            //????????§???????????°??????????????????????°????
            int vl = query(a, b, k * 2, l, ( l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return min(vl, vr);
        }
    public:
        rangeMinimumQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_,INT_MAX); }
        void update(int i, int x){
            i += n; //????????????
            dat[i] = x;
            while(i > 0){ //?????????????????´??°
                dat[i / 2] = min(dat[i], dat[i^1]);
                i = i / 2;
            }
        }
        //[a, b)???????°????????±???????
        int query(int a, int b){ return query(a,b,1,0,n); }
};

class rangeUpdateQuery : public segTree{ //??????????????????update??§?????????min??¨???sum???????????????
    private:
        int dat_lazy[4 * MAX_N]; //?????¶???????????????????????????
        int query(int a, int b, int k, int l, int r){
            //???????£?
            evaluate(k);

            if(b <= l || r <= a) return INT_MAX;
            else if(a <= l && r <= b) return dat[k];

            int vl = query(a, b, k * 2, l, (l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return min(vl, vr);
        }
        inline void evaluate(int k){
            if(dat_lazy[k] == INT_MAX) return;
            dat[k] = dat_lazy[k];
            if(k < n){
                dat_lazy[2 * k] = dat_lazy[k]; //?????¶????????¬????????¨???
                dat_lazy[2 * k + 1] = dat_lazy[k];
            }
            dat_lazy[k] = INT_MAX;
        }
        void update(int a, int b, int k, int l, int r, int x){
            evaluate(k);

            if(b <= l || r <= a ) return;

            if(a <= l && r <= b){
                dat_lazy[k] = x;
            }else{
                evaluate(k);
                update(a, b, k * 2, l, (l + r) / 2, x);
                update(a, b, k * 2 + 1, (l + r) / 2, r, x);
            }
        }
    public:
        rangeUpdateQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_,INT_MAX,dat_lazy); }
        int query(int a, int b){ return query(a,b,1,0,n); }
        void update(int s, int t, int x){ update(s, t, 1, 0, n, x); }
        void update(int i, int x){ update(i, i + 1, 1, 0, n, x); }
        int get(int a){ return query(a, a + 1); };
};

class starrySky : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            if(b <= l || r <= a) return 0;
            if(a <= l && r <= b) return dat[k] + dat_add[k];

            int vl = query(a, b, k * 2, l, (l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return max(vl, vr) + dat_add[k];
        }
        void add(int a, int b, int k, int l, int r, int x){
            if(b <= l || r <= a) return;
            if(a <= l && r <= b){
                dat_add[k] += x;
            }else{
                add(a, b, k * 2, l, (l + r) / 2, x);
                add(a, b, k * 2 + 1, (l + r) / 2, r, x);
                dat[k] = max(dat[k * 2] + dat_add[k * 2], dat[k * 2 + 1] + dat_add[k * 2 + 1]);
            }
        }
        void init(int n_){ segTree::init(n_,0,dat_add); }
    public:
        int dat_add[4 * MAX_N];
        starrySky(int n){ init(n); }
        int query(int a, int b){ return query(a, b, 1, 0, n); }
        void add(int s, int t, int x){ add(s, t, 1, 0, n, x); }
        void add(int i, int x){ add(i, i + 1, 1, 0, n, x); }
};

map<int,int> m, s; //id, pos / pos, id

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);

    int q, lim;
    while(cin >> q >> lim, q){
        //show(q)
        rangeSumQuery seg(q + 1);
        m.clear(); s.clear();
        int total = 0;
        rep(i,q){
            int com, x;
            cin >> com >> x;

            switch (com) {
                int pos;
                case 0:
                    pos = m.size();
                    m[x] = pos;
                    s[pos] = x;
                    seg.update(pos, 1);
                    total++;
                    if(total > lim){
                        seg.update(seg.pos(0), -1);
                        total--;
                    }
                    break;
                case 1:
                    pos = seg.pos(x);
                    seg.update(pos, -1);
                    total--;
                    break;
                case 2:
                    //show(seg.pos(x));
                    cout << s[seg.pos(x)] << endl;
                    break;
                case 3:
                    seg.update(m[x], -1);
                    total--;
                    break;
            }
        }
        cout << "end" << endl;
    }
}
accuracy: 1
time_ms: 970
memory_kb: 44720
final_rank: 13

code_snippet: #include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x)  cerr << #x << " = " << (x) << endl;
//const int INF = 1e8;
using namespace std;

const int MAX_N = 200010;

class segTree{
    public:
        int n, dat[4 * MAX_N];
        void init(int n_, int value, int dat_b[4 * MAX_N] = NULL){
            n = 1;
            while(n <= n_) n *= 2;
            rep(i,2 * n){
                dat[i] = value;
                if(dat_b != NULL) dat_b[i] = value;
            }
        }
        void initArray(int n_, int a[MAX_N]){ //??????a??§????????????
            n = 1;
            while(n <= n_) n *= 2;
            for(int i = n; i < n + n_; i++){
                dat[i] = a[i - n];
            }
            for(int i = n - 1; i >= 1; i--){
                dat[i] = min(dat[i * 2], dat[i * 2 + 1]);
                //dat[i] = dat[i * 2] + dat[i * 2 + 1];
            }
        }
        void output(int a[4 * MAX_N]){
            show("print");
            range(i,1,n * 2) cout << (a[i] == INT_MAX ? 0 : a[i]) << ' ';
            cout << endl;
        }
};

class rangeAddQuery : public segTree{
    //dat : ???????????????????§???????????????????????????????
    //dat_add : ????§???§?????????????????????????????????
    private:
        int dat_add[4 * MAX_N];
        int query(int a, int b, int k, int l, int r){
            if(b <= l || r <= a) return 0;
            if(a <= l && r <= b) return dat[k] * (r - l) + dat_add[k];

            int res = (min(b, r) - max(a, l)) * dat[k];
            res += query(a, b, k * 2, l, (l + r) / 2);
            res += query(a, b, k * 2 + 1, (l + r) / 2, r);
            return res;
        }
        void add(int a, int b, int k, int l, int r, int x){
            if(a <= l && r <= b){
                dat[k] += x;
            }else if(l < b && a < r){
                dat_add[k] += (min(b, r) - max(a, l)) * x;
                add(a, b, k * 2, l, (l + r) / 2, x);
                add(a, b, k * 2 + 1, (l + r) / 2, r, x);
            }
        }
    public:
        rangeAddQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_, 0, dat_add); }
        int query(int a, int b){ return query(a,b,1,0,n); }
        void add(int s, int t, int x){ add(s, t, 1, 0, n, x); }
        void add(int i, int x){ add(i, i + 1, 1, 0, n, x); }
        int get(int a){ return query(a, a + 1); }
};

class rangeSumQuery : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            if(r <= a || b <= l) return 0;
            if(a <= l && r <= b) return dat[k];

            int vl = query(a, b, k * 2, l, ( l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return vl + vr;
        }
    public:
        rangeSumQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_, 0); }
        void update(int i, int x){
            i += n; //????????????
            dat[i] += x;
            while(i > 0){ //?????????????????´??°
                dat[i / 2] = dat[i] + dat[i^1];
                i = i / 2;
            }
        }
        int query(int a, int b){ return query(a,b,1,0,n); }
        int get(int a){ return query(a, a + 1); }
        bool C(int mid, int x){
            return query(0, mid) < x;
        }
        int pos(int x){
            //show(x)
            int right = n, left = 0;
            rep(i,25){
                int mid = (right + left ) / 2;
                if(C(mid,x)) left = mid;
                else right = mid;
            }
            return left;
        }
};

class rangeMinimumQuery : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            //[a, b) ??¨[l, r)???????????????????????°???INT_MAX
            if(r <= a || b <= l) return INT_MAX;
            //[a,b)???[l,r)????????¨???????????§????????°?????????????????????
            if(a <= l && r <= b) return dat[k];

            //????????§???????????°??????????????????????°????
            int vl = query(a, b, k * 2, l, ( l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return min(vl, vr);
        }
    public:
        rangeMinimumQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_,INT_MAX); }
        void update(int i, int x){
            i += n; //????????????
            dat[i] = x;
            while(i > 0){ //?????????????????´??°
                dat[i / 2] = min(dat[i], dat[i^1]);
                i = i / 2;
            }
        }
        //[a, b)???????°????????±???????
        int query(int a, int b){ return query(a,b,1,0,n); }
};

class rangeUpdateQuery : public segTree{ //??????????????????update??§?????????min??¨???sum???????????????
    private:
        int dat_lazy[4 * MAX_N]; //?????¶???????????????????????????
        int query(int a, int b, int k, int l, int r){
            //???????£?
            evaluate(k);

            if(b <= l || r <= a) return INT_MAX;
            else if(a <= l && r <= b) return dat[k];

            int vl = query(a, b, k * 2, l, (l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return min(vl, vr);
        }
        inline void evaluate(int k){
            if(dat_lazy[k] == INT_MAX) return;
            dat[k] = dat_lazy[k];
            if(k < n){
                dat_lazy[2 * k] = dat_lazy[k]; //?????¶????????¬????????¨???
                dat_lazy[2 * k + 1] = dat_lazy[k];
            }
            dat_lazy[k] = INT_MAX;
        }
        void update(int a, int b, int k, int l, int r, int x){
            evaluate(k);

            if(b <= l || r <= a ) return;

            if(a <= l && r <= b){
                dat_lazy[k] = x;
            }else{
                evaluate(k);
                update(a, b, k * 2, l, (l + r) / 2, x);
                update(a, b, k * 2 + 1, (l + r) / 2, r, x);
            }
        }
    public:
        rangeUpdateQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_,INT_MAX,dat_lazy); }
        int query(int a, int b){ return query(a,b,1,0,n); }
        void update(int s, int t, int x){ update(s, t, 1, 0, n, x); }
        void update(int i, int x){ update(i, i + 1, 1, 0, n, x); }
        int get(int a){ return query(a, a + 1); };
};

class starrySky : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            if(b <= l || r <= a) return 0;
            if(a <= l && r <= b) return dat[k] + dat_add[k];

            int vl = query(a, b, k * 2, l, (l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return max(vl, vr) + dat_add[k];
        }
        void add(int a, int b, int k, int l, int r, int x){
            if(b <= l || r <= a) return;
            if(a <= l && r <= b){
                dat_add[k] += x;
            }else{
                add(a, b, k * 2, l, (l + r) / 2, x);
                add(a, b, k * 2 + 1, (l + r) / 2, r, x);
                dat[k] = max(dat[k * 2] + dat_add[k * 2], dat[k * 2 + 1] + dat_add[k * 2 + 1]);
            }
        }
        void init(int n_){ segTree::init(n_,0,dat_add); }
    public:
        int dat_add[4 * MAX_N];
        starrySky(int n){ init(n); }
        int query(int a, int b){ return query(a, b, 1, 0, n); }
        void add(int s, int t, int x){ add(s, t, 1, 0, n, x); }
        void add(int i, int x){ add(i, i + 1, 1, 0, n, x); }
};

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);

    int q, lim;
    while(cin >> q >> lim, q){
        //show(q)
        rangeSumQuery seg(q);
        map<int,int> m, s; //id, pos / pos, id
        int total = 0;
        rep(i,q){
            int com, x;
            cin >> com >> x;

            switch (com) {
                int pos;
                case 0:
                    pos = m.size();
                    m[x] = pos;
                    s[pos] = x;
                    seg.update(pos, 1);
                    total++;
                    if(total > lim){
                        seg.update(seg.pos(0), -1);
                        total--;
                    }
                    break;
                case 1:
                    pos = seg.pos(x);
                    seg.update(pos, -1);
                    total--;
                    break;
                case 2:
                    //show(seg.pos(x));
                    cout << s[seg.pos(x)] << endl;
                    break;
                case 3:
                    seg.update(m[x], -1);
                    total--;
                    break;
            }
        }
        cout << "end" << endl;
    }
}
accuracy: 0.6666666666666666
time_ms: 390
memory_kb: 11856
final_rank: 14

code_snippet: #include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x)  cerr << #x << " = " << (x) << endl;
//const int INF = 1e8;
using namespace std;

const int MAX_N = 200010;

class segTree{
    public:
        int n, dat[4 * MAX_N];
        void init(int n_, int value, int dat_b[4 * MAX_N] = NULL){
            n = 1;
            while(n <= n_) n *= 2;
            rep(i,2 * n){
                dat[i] = value;
                if(dat_b != NULL) dat_b[i] = value;
            }
        }
        void initArray(int n_, int a[MAX_N]){ //??????a??§????????????
            n = 1;
            while(n <= n_) n *= 2;
            for(int i = n; i < n + n_; i++){
                dat[i] = a[i - n];
            }
            for(int i = n - 1; i >= 1; i--){
                dat[i] = min(dat[i * 2], dat[i * 2 + 1]);
                //dat[i] = dat[i * 2] + dat[i * 2 + 1];
            }
        }
        void output(int a[4 * MAX_N]){
            show("print");
            range(i,1,n * 2) cout << (a[i] == INT_MAX ? 0 : a[i]) << ' ';
            cout << endl;
        }
};

class rangeAddQuery : public segTree{
    //dat : ???????????????????§???????????????????????????????
    //dat_add : ????§???§?????????????????????????????????
    private:
        int dat_add[4 * MAX_N];
        int query(int a, int b, int k, int l, int r){
            if(b <= l || r <= a) return 0;
            if(a <= l && r <= b) return dat[k] * (r - l) + dat_add[k];

            int res = (min(b, r) - max(a, l)) * dat[k];
            res += query(a, b, k * 2, l, (l + r) / 2);
            res += query(a, b, k * 2 + 1, (l + r) / 2, r);
            return res;
        }
        void add(int a, int b, int k, int l, int r, int x){
            if(a <= l && r <= b){
                dat[k] += x;
            }else if(l < b && a < r){
                dat_add[k] += (min(b, r) - max(a, l)) * x;
                add(a, b, k * 2, l, (l + r) / 2, x);
                add(a, b, k * 2 + 1, (l + r) / 2, r, x);
            }
        }
    public:
        rangeAddQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_, 0, dat_add); }
        int query(int a, int b){ return query(a,b,1,0,n); }
        void add(int s, int t, int x){ add(s, t, 1, 0, n, x); }
        void add(int i, int x){ add(i, i + 1, 1, 0, n, x); }
        int get(int a){ return query(a, a + 1); }
};

class rangeSumQuery : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            if(r <= a || b <= l) return 0;
            if(a <= l && r <= b) return dat[k];

            int vl = query(a, b, k * 2, l, ( l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return vl + vr;
        }
    public:
        rangeSumQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_, 0); }
        void update(int i, int x){
            i += n; //????????????
            dat[i] += x;
            while(i > 0){ //?????????????????´??°
                dat[i / 2] = dat[i] + dat[i^1];
                i = i / 2;
            }
        }
        int query(int a, int b){ return query(a,b,1,0,n); }
        int get(int a){ return query(a, a + 1); }
        bool C(int mid, int x){
            return query(1, mid) < x;
        }
        int pos(int x){
            //show(x)
            int right = n, left = 0;
            rep(i,50){
                int mid = (right + left ) / 2;
                if(C(mid,x)) left = mid;
                else right = mid;
            }
            return left;
        }
};

class rangeMinimumQuery : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            //[a, b) ??¨[l, r)???????????????????????°???INT_MAX
            if(r <= a || b <= l) return INT_MAX;
            //[a,b)???[l,r)????????¨???????????§????????°?????????????????????
            if(a <= l && r <= b) return dat[k];

            //????????§???????????°??????????????????????°????
            int vl = query(a, b, k * 2, l, ( l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return min(vl, vr);
        }
    public:
        rangeMinimumQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_,INT_MAX); }
        void update(int i, int x){
            i += n; //????????????
            dat[i] = x;
            while(i > 0){ //?????????????????´??°
                dat[i / 2] = min(dat[i], dat[i^1]);
                i = i / 2;
            }
        }
        //[a, b)???????°????????±???????
        int query(int a, int b){ return query(a,b,1,0,n); }
};

class rangeUpdateQuery : public segTree{ //??????????????????update??§?????????min??¨???sum???????????????
    private:
        int dat_lazy[4 * MAX_N]; //?????¶???????????????????????????
        int query(int a, int b, int k, int l, int r){
            //???????£?
            evaluate(k);

            if(b <= l || r <= a) return INT_MAX;
            else if(a <= l && r <= b) return dat[k];

            int vl = query(a, b, k * 2, l, (l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return min(vl, vr);
        }
        inline void evaluate(int k){
            if(dat_lazy[k] == INT_MAX) return;
            dat[k] = dat_lazy[k];
            if(k < n){
                dat_lazy[2 * k] = dat_lazy[k]; //?????¶????????¬????????¨???
                dat_lazy[2 * k + 1] = dat_lazy[k];
            }
            dat_lazy[k] = INT_MAX;
        }
        void update(int a, int b, int k, int l, int r, int x){
            evaluate(k);

            if(b <= l || r <= a ) return;

            if(a <= l && r <= b){
                dat_lazy[k] = x;
            }else{
                evaluate(k);
                update(a, b, k * 2, l, (l + r) / 2, x);
                update(a, b, k * 2 + 1, (l + r) / 2, r, x);
            }
        }
    public:
        rangeUpdateQuery(int n){ init(n); }
        void init(int n_){ segTree::init(n_,INT_MAX,dat_lazy); }
        int query(int a, int b){ return query(a,b,1,0,n); }
        void update(int s, int t, int x){ update(s, t, 1, 0, n, x); }
        void update(int i, int x){ update(i, i + 1, 1, 0, n, x); }
        int get(int a){ return query(a, a + 1); };
};

class starrySky : public segTree{
    private:
        int query(int a, int b, int k, int l, int r){
            if(b <= l || r <= a) return 0;
            if(a <= l && r <= b) return dat[k] + dat_add[k];

            int vl = query(a, b, k * 2, l, (l + r) / 2);
            int vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
            return max(vl, vr) + dat_add[k];
        }
        void add(int a, int b, int k, int l, int r, int x){
            if(b <= l || r <= a) return;
            if(a <= l && r <= b){
                dat_add[k] += x;
            }else{
                add(a, b, k * 2, l, (l + r) / 2, x);
                add(a, b, k * 2 + 1, (l + r) / 2, r, x);
                dat[k] = max(dat[k * 2] + dat_add[k * 2], dat[k * 2 + 1] + dat_add[k * 2 + 1]);
            }
        }
        void init(int n_){ segTree::init(n_,0,dat_add); }
    public:
        int dat_add[4 * MAX_N];
        starrySky(int n){ init(n); }
        int query(int a, int b){ return query(a, b, 1, 0, n); }
        void add(int s, int t, int x){ add(s, t, 1, 0, n, x); }
        void add(int i, int x){ add(i, i + 1, 1, 0, n, x); }
};

int main(){
    int q, lim;

    while(cin >> q >> lim, q){
        //show(q)
        assert(q <= 100000);
        rangeSumQuery seg(q);
        vector<int> v;
        v.emplace_back(-1);
        map<int,int> m; //id, pos
        set<pair<int, int>> s; //pos, id
        int total = 0;
        rep(i,q){
            int com, x;
            cin >> com >> x;

            switch (com) {
                int pos;
                case 0:
                pos = v.size();
                v.emplace_back(x);
                m[x] = pos;
                s.insert(make_pair(pos, x));
                seg.update(pos, 1);
                total++;
                break;
                case 1:
                pos = seg.pos(x);
                seg.update(pos, -1);
                s.erase(*lower_bound(all(s), make_pair(pos,0)));
                total--;
                break;
                case 2:
                //show(seg.pos(x));
                cout << v[seg.pos(x)] << endl;
                break;
                case 3:
                pos = m[x];
                seg.update(pos, -1);
                s.erase(make_pair(pos, x));
                total--;
                break;
            }
            if(total > lim){
                pair<int, int> old = *s.begin();
                //show(old.first)
                seg.update(old.first, -1);
                s.erase(old);
                total--;
            }
        }
        cout << "end" << endl;
    }
}
accuracy: 0.6666666666666666
time_ms: 1560
memory_kb: 3676
final_rank: 17

code_snippet: #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <sstream>

using namespace std;

int N; // ???????????°???????????§??????2^n???????????§????????°?????\????????¨??????
int BIT[1000000];

void add(int a, int w){
	
	// a?????????????´????w????¶???? O(log N)
	
	for(int x = a; x <= N; x += x & -x){
		BIT[x] += w;
	}
}

int sum(int a){
	
	// 1??????a?????§???????´????????¨?????????? O(log N)
	
	int ret = 0;
	for(int x = a; x > 0; x -= x & -x){
		ret += BIT[x];
	}
	return ret;
}

void init(){
	for(int i = 0; i < N; i++){
		BIT[i] = 0;
	}
}

// BIT ??????????¢?????????????????????????????´???????????????§????????¨???????????????
int lowerBound(int w){
	if(w <= 0){
		return 0;
	}
	int x = 0;
	for (int k = 262144; k > 0; k /= 2) { // k ??????????????? N ??\???????????§??? 2 ????????¨????????¨??????????°??????§?????????????????????
		if (x + k <= N && BIT[x + k] < w) {
			w -= BIT[x + k];
			x += k;
		}
	}
	return x + 1;
}

int main(){
	
	int q, lim;
	
	while(true){
		
		cin >> q >> lim;
		
		if(q == 0 && lim == 0){
			break;
		}
		
		N = 1000000 - 1;
		
		init();
		
		map<int, int> m1; // ID -> index
		map<int, int> m2; // index -> ID
		
		int index_ref = 1;
		int count = 0;
		
		for(int loop = 0; loop < q; loop++){
			int query, x;
			cin >> query >> x;
			if(query == 0){
				add(index_ref, 1);
				m1[x] = index_ref;
				m2[index_ref] = x;
				index_ref++;
				count++;
			}else if(query == 1){
				int index = lowerBound(x);
				add(index, -1);
				count--;
			}else if(query == 2){
				int index = lowerBound(x);
				cout << m2[index] << endl;
			}else{
				add(m1[x], -1);
				count--;
			}
			if(count > lim){
				int index = lowerBound(1);
				add(index, -1);
				count--;
			}
		}
		cout << "end" << endl;
	}
	
	return 0;
}
accuracy: 1
time_ms: 680
memory_kb: 44488
final_rank: 11

code_snippet: /*
	For the part of BIT's binary search see below.
	http://hos.ac/slides/20140319_bit.pdf
*/
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
#define ALL(A) A.begin(), A.end()

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

template<class T> class bit{
public:
	vector<T> dat;
	int N, M;
	
	bit(){}
	bit(int _N): N(_N){
		dat.assign(_N,0);
		M = 0;
		int p = 0;
		while(_N >= (1<<p)){
			M = (1<<p);
			++p;
		} // end while
	}
	
	// sum [0,i)
	T sum(int i){
		T ret = 0;
		for (--i; i >= 0; i = (i & (i + 1)) - 1){
			ret += dat[i];
		} // end for
		return ret;
	}

	// sum [i,j)
	T sum(int i, int j){
		return sum(j) - sum(i);
	}

	// add x to i
	void add(int i, T x){
		for (; i < N; i |= i + 1) dat[i] += x;
	}

	// return w-th smallest index (0-indexed)
	int lowerBound(int w){
		if (w < 0) return -1;
		int x = 0;
		for (int k = M; k > 0; k /= 2){
			if (x + k < N && dat[x + k - 1] <= w){
				w -= dat[x + k - 1];
				x += k;
			} // end if
		} // end for
		return x;
	}
};

bit<int> bs;
map<int,int> id;
int q, lim, l, r, vs[400010];
bool done[400010];

void normalize(void){
	if (bs.sum(r) > lim){
		while(done[l]) ++l;
		done[l] = 1;
		bs.add(l++, -1);
	} // end if
}

void solve(void){
	memset(vs, 0, sizeof(vs));
	memset(done, false, sizeof(done));

	id.clear();
	l = r = 0;

	bs = bit<int>(q);
	while(q--){
		int v, x, p;
		cin >> v >> x;
		switch(v){
			case 0:
				id[x] = r;
				vs[r] = x;
				bs.add(r++, 1);
				break;
			case 1:
				p = bs.lowerBound(x-1);
				bs.add(p, -1);
				done[p] = true;
				break;
			case 2:
				p = bs.lowerBound(x-1);
				cout << vs[p] << endl;
				break;
			case 3:
				p = id[x];
				bs.add(p, -1);
				done[p] = true;
				break;
		} // end switch
		normalize();
	} // end while 
}

bool input(void){
	cin >> q >> lim;
	return (q || lim);
}

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	
	for(; input(); ){
		solve();
		cout << "end" << endl;
	} // end for

	return 0;
}
accuracy: 1
time_ms: 310
memory_kb: 25168
final_rank: 4

code_snippet: /*
	BIT ???????????¢?´¢?????¨??????
	http://hos.ac/slides/20140319_bit.pdf
	????????§???
*/
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
#define ALL(A) A.begin(), A.end()

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

template<class T> class bit{
public:
	vector<T> dat;
	int N, M;
	
	bit(){}
	bit(int _N): N(_N){
		dat.assign(_N,0);
		M = 0;
		int p = 0;
		while(_N >= (1<<p)){
			M = (1<<p);
			++p;
		} // end while
	}
	
	// sum [0,i)
	T sum(int i){
		T ret = 0;
		for (--i; i >= 0; i = (i & (i + 1)) - 1){
			ret += dat[i];
		} // end for
		return ret;
	}

	// sum [i,j)
	T sum(int i, int j){
		return sum(j) - sum(i);
	}

	// add x to i
	void add(int i, T x){
		for (; i < N; i |= i + 1) dat[i] += x;
	}

	// w ??????????°????????????????????????????0-indexed????????????
	int lowerBound(int w){
		if (w < 0) return -1;
		int x = 0;
		for (int k = M; k > 0; k /= 2){
			if (x + k < N && dat[x + k - 1] <= w){
				w -= dat[x + k - 1];
				x += k;
			} // end if
		} // end for
		return x;
	}
};

bit<int> bs;
map<int,int> id;
int q, lim, l, r, vs[400010];
bool done[400010];

void normalize(void){
	if (bs.sum(r) > lim){
		while(done[l]) ++l;
		done[l] = 1;
		bs.add(l++, -1);
	} // end if
}

void solve(void){
	memset(vs, 0, sizeof(vs));
	memset(done, false, sizeof(done));

	id.clear();
	l = r = 0;

	bs = bit<int>(q);
	while(q--){
		int v, x, p;
		cin >> v >> x;
		switch(v){
			case 0:
				id[x] = r;
				vs[r] = x;
				bs.add(r++, 1);
				break;
			case 1:
				p = bs.lowerBound(x-1);
				bs.add(p, -1);
				done[p] = true;
				break;
			case 2:
				p = bs.lowerBound(x-1);
				cout << vs[p] << endl;
				break;
			case 3:
				p = id[x];
				bs.add(p, -1);
				done[p] = true;
				break;
		} // end switch
		normalize();
	} // end while 
}

bool input(void){
	cin >> q >> lim;
	return (q || lim);
}

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	
	for(; input(); ){
		solve();
		cout << "end" << endl;
	} // end for

	return 0;
}
accuracy: 1
time_ms: 300
memory_kb: 25232
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;

template <class T>
struct BIT {
	int n;
	vector<T> x;
	BIT(int n_ = 0) : n(n_), x(n + 1, 0) {}
	int size() const { return n; }
	T sum(int r) const {
		T S = 0;
		for(r = r - 1; r >= 0; r = (r & (r + 1)) - 1) S += x[r];
		return S;
	}
	T sum(int l, int r) const { return sum(r) - sum(l); }
	void add(int k, const T &a) {
		for(; k < n; k |= k + 1) x[k] += a;
	}
	void set(int k, const T &a) { add(k, a - sum(k, k + 1)); }
};

typedef pair<int, int> P;

int x[500000];
int q, lim;

int f(BIT<int>& b, int x) {
	int ng = -1, ok = q - 1;
	while(abs(ng - ok) > 1) {
		int mid = (ng + ok) / 2;
		if(b.sum(0, mid + 1) >= x) ok = mid;
		else ng = mid;
	}
	return ok;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	while(cin >> q >> lim, q | lim) {
		BIT<int> b(q + 10);
		set<P> s;
		map<int, int> tmap;
		for(int i = 0; i < q; i++) {
			int type;
			cin >> type >> x[i];
			//cerr << "type : " << type << ", x : " << x[i] << endl;
			if(type == 0) {
				if(s.size() == lim) {
					b.add(s.begin()->first, -1);
					tmap.erase(s.begin()->second);
					s.erase(s.begin());
				}
				b.add(i, 1);
				tmap[x[i]] = i;
				s.insert({ i, x[i] });
			}
			else if(type == 1) {
				int t = f(b, x[i]);
				//assert(b.sum(t, t + 1) == 1);
				b.add(t, -1);
				s.erase({ t, x[t] });
				tmap.erase(x[t]);
			}
			else if(type == 2) {
				int t = f(b, x[i]);
				//assert(b.sum(t, t + 1) == 1);
				cout << x[t] << endl;
			}
			else {
				b.add(tmap[x[i]], -1);
				s.erase({ tmap[x[i]], x[i] });
				tmap.erase(x[i]);
			}
		}
		cout << "end" << endl;
	}
}
accuracy: 1
time_ms: 470
memory_kb: 12128
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;

template <class T>
struct BIT {
	int n;
	vector<T> x;
	BIT(int n_ = 0) : n(n_), x(n + 1, 0) {}
	int size() const { return n; }
	T sum(int r) const {
		T S = 0;
		for(r = r - 1; r >= 0; r = (r & (r + 1)) - 1) S += x[r];
		return S;
	}
	T sum(int l, int r) const { return sum(r) - sum(l); }
	void add(int k, const T &a) {
		for(; k < n; k |= k + 1) x[k] += a;
	}
	void set(int k, const T &a) { add(k, a - sum(k, k + 1)); }
};

typedef pair<int, int> P;

int x[500000];
int q, lim;

int f(BIT<int>& b, int x) {
	int ng = -1, ok = q - 1;
	while(abs(ng - ok) > 1) {
		int mid = (ng + ok) / 2;
		if(b.sum(0, mid + 1) >= x) ok = mid;
		else ng = mid;
	}
	return ok;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	while(cin >> q >> lim, q | lim) {
		BIT<int> b(q + 10);
		set<P> s;
		map<int, int> tmap;
		for(int i = 0; i < q; i++) {
			int type;
			cin >> type >> x[i];
			//cerr << "type : " << type << ", x : " << x[i] << endl;
			if(type == 0) {
				if(s.size() == lim) {
					b.add(s.begin()->first, -1);
					tmap.erase(s.begin()->first);
					s.erase(s.begin());
				}
				b.add(i, 1);
				tmap[x[i]] = i;
				s.insert({ i, x[i] });
			}
			else if(type == 1) {
				int t = f(b, x[i]);
				//assert(b.sum(t, t + 1) == 1);
				b.add(t, -1);
				s.erase({ t, x[t] });
				tmap.erase(x[t]);
			}
			else if(type == 2) {
				int t = f(b, x[i]);
				//assert(b.sum(t, t + 1) == 1);
				cout << x[t] << endl;
			}
			else {
				b.add(tmap[x[i]], -1);
				s.erase({ tmap[x[i]], x[i] });
				tmap.erase(x[i]);
			}
		}
		cout << "end" << endl;
	}
}
accuracy: 0.6666666666666666
time_ms: 470
memory_kb: 23020
final_rank: 16

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;

template <class T>
struct BIT {
	int n;
	vector<T> x;
	BIT(int n_ = 0) : n(n_), x(n + 1, 0) {}
	int size() const { return n; }
	T sum(int r) const {
		T S = 0;
		for(r = r - 1; r >= 0; r = (r & (r + 1)) - 1) S += x[r];
		return S;
	}
	T sum(int l, int r) const { return sum(r) - sum(l); }
	void add(int k, const T &a) {
		for(; k < n; k |= k + 1) x[k] += a;
	}
	void set(int k, const T &a) { add(k, a - sum(k, k + 1)); }
};

typedef pair<int, int> P;

int x[400000];
int q, lim;

int f(BIT<int>& b, int x) {
	int ng = -1, ok = q - 1;
	while(abs(ng - ok) > 1) {
		int mid = (ng + ok) / 2;
		if(b.sum(0, mid + 1) >= x) ok = mid;
		else ng = mid;
	}
	return ok;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	while(cin >> q >> lim, q | lim) {
		BIT<int> b(q);
		set<P> s;
		map<int, int> tmap;
		for(int i = 0; i < q; i++) {
			int type;
			cin >> type >> x[i];
			//cerr << "type : " << type << ", x : " << x[i] << endl;
			if(type == 0) {
				if(s.size() == lim) {
					b.add(s.begin()->first, -1);
					tmap.erase(s.begin()->first);
					s.erase(s.begin());
				}
				b.add(i, 1);
				tmap[x[i]] = i;
				s.insert({ i, x[i] });
			}
			else if(type == 1) {
				int t = f(b, x[i]);
				//assert(b.sum(t, t + 1) == 1);
				b.add(t, -1);
				s.erase({ t, x[t] });
				tmap.erase(x[t]);
			}
			else if(type == 2) {
				int t = f(b, x[i]);
				//assert(b.sum(t, t + 1) == 1);
				cout << x[t] << endl;
			}
			else {
				b.add(tmap[x[i]], -1);
				s.erase({ tmap[x[i]], x[i] });
				tmap.erase(x[i]);
			}
		}
		cout << "end" << endl;
	}
}
accuracy: 0.6666666666666666
time_ms: 470
memory_kb: 22948
final_rank: 15