#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = (ll)1e18;

//------------------- Lazy Segment Tree -------------------//
struct LazySegTree {
    int N, size;
    vector<pair<ll,int>> minv, maxv;
    vector<ll> lazy;

    LazySegTree(int n) {
        N = n;
        size = 1;
        while (size < n) size <<= 1;
        minv.assign(2 * size, {INF, -1});
        maxv.assign(2 * size, {-INF, -1});
        lazy.assign(2 * size, 0);

        for (int i = 0; i < n; i++) {
            int pos = i + 1;
            minv[size + i] = {INF, pos};
            maxv[size + i] = {-INF, pos};
        }
        for (int i = size - 1; i > 0; i--) pull(i);
    }

    void pull(int idx) {
        minv[idx] = min(minv[idx*2], minv[idx*2+1]);
        maxv[idx] = max(maxv[idx*2], maxv[idx*2+1]);
    }

    void apply(int idx, ll val) {
        minv[idx].first += val;
        maxv[idx].first += val;
        if (idx < size) lazy[idx] += val;
    }

    void push(int idx) {
        if (lazy[idx] != 0) {
            apply(idx*2, lazy[idx]);
            apply(idx*2+1, lazy[idx]);
            lazy[idx] = 0;
        }
    }

    void range_add(int l, int r, ll val) { _range_add(1, 1, size, l, r, val); }
    void _range_add(int idx, int nl, int nr, int l, int r, ll val) {
        if (r < nl || nr < l) return;
        if (l <= nl && nr <= r) {
            apply(idx, val);
            return;
        }
        push(idx);
        int mid = (nl + nr) / 2;
        _range_add(idx*2, nl, mid, l, r, val);
        _range_add(idx*2+1, mid+1, nr, l, r, val);
        pull(idx);
    }

    pair<ll,int> range_min(int l, int r) {
        pair<ll,int> res = {INF, -1};
        _range_min(1, 1, size, l, r, res);
        return res;
    }
    void _range_min(int idx, int nl, int nr, int l, int r, pair<ll,int>& res) {
        if (r < nl || nr < l) return;
        if (l <= nl && nr <= r) {
            res = min(res, minv[idx]);
            return;
        }
        push(idx);
        int mid = (nl + nr) / 2;
        _range_min(idx*2, nl, mid, l, r, res);
        _range_min(idx*2+1, mid+1, nr, l, r, res);
    }

    pair<ll,int> range_max(int l, int r) {
        pair<ll,int> res = {-INF, -1};
        _range_max(1, 1, size, l, r, res);
        return res;
    }
    void _range_max(int idx, int nl, int nr, int l, int r, pair<ll,int>& res) {
        if (r < nl || nr < l) return;
        if (l <= nl && nr <= r) {
            res = max(res, maxv[idx]);
            return;
        }
        push(idx);
        int mid = (nl + nr) / 2;
        _range_max(idx*2, nl, mid, l, r, res);
        _range_max(idx*2+1, mid+1, nr, l, r, res);
    }

    void point_set(int pos, ll val) { _set(1, 1, size, pos, val); }
    void _set(int idx, int nl, int nr, int pos, ll val) {
        if (nl == nr) {
            minv[idx] = {val, pos};
            maxv[idx] = {val, pos};
            lazy[idx] = 0;
            return;
        }
        push(idx);
        int mid = (nl + nr) / 2;
        if (pos <= mid) _set(idx*2, nl, mid, pos, val);
        else _set(idx*2+1, mid+1, nr, pos, val);
        pull(idx);
    }

    ll point_get(int pos) { return _get(1, 1, size, pos); }
    ll _get(int idx, int nl, int nr, int pos) {
        if (nl == nr) return minv[idx].first;
        push(idx);
        int mid = (nl + nr) / 2;
        if (pos <= mid) return _get(idx*2, nl, mid, pos);
        else return _get(idx*2+1, mid+1, nr, pos);
    }
};

//------------------- Main -------------------//
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, Q;
    cin >> N >> Q;
    vector<ll> A(N);
    for (auto &x : A) cin >> x;

    vector<array<ll,3>> L;
    vector<pair<ll,int>> mem;
    for (int i = 0; i < N; i++) mem.push_back({A[i], i+1});
    sort(mem.begin(), mem.end());

    for (int i = 0; i < N; i++)
        L.push_back({mem[i].first, mem[i].second, i+1});

    LazySegTree segm(N), segM(N);
    for (int i = 0; i < N; i++) {
        segm.point_set(i+1, L[i][1]);
        segM.point_set(i+1, L[i][1]);
    }

    vector<ll> ans;
    for (int qi = 0; qi < Q; qi++) {
        int c;
        ll X;
        cin >> c >> X;

        int idx = lower_bound(L.begin(), L.end(), array<ll,3>{X+1, -1, -1}) - L.begin();
        if (idx == (int)L.size()) {
            ans.push_back(-1);
            continue;
        }

        auto [num, j, sidx] = L[idx];
        L.erase(L.begin() + idx);

        if (c == 1) {
            auto [res, seg_idx] = segm.range_min(sidx, N);
            if (res == 1000000000) ans.push_back(-1);
            else {
                ans.push_back(res);
                segm.point_set(seg_idx, 1000000000);
                segM.point_set(seg_idx, -1);
            }
        } else {
            auto [res, seg_idx] = segM.range_max(sidx, N);
            if (res == -1) ans.push_back(-1);
            else {
                ans.push_back(res);
                segm.point_set(seg_idx, 1000000000);
                segM.point_set(seg_idx, -1);
            }
        }
    }

    for (auto x : ans) cout << x << "\n";
}