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

//------------------------------------
// LazySegTree: 区間加算＋区間min/max＋1点更新対応
//------------------------------------
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>=1; i--) pull(i);
    }

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

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

    inline 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) {
        function<void(int,int,int)> dfs = [&](int idx, int nl, int nr){
            if (r < nl || nr < l) return;
            if (l <= nl && nr <= r) {
                apply(idx, val);
                return;
            }
            push(idx);
            int mid = (nl + nr) / 2;
            dfs(idx*2, nl, mid);
            dfs(idx*2+1, mid+1, nr);
            pull(idx);
        };
        dfs(1, 1, size);
    }

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

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

    void point_set(int pos, ll val) {
        function<void(int,int,int)> dfs = [&](int idx, int nl, int nr){
            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) dfs(idx*2, nl, mid);
            else dfs(idx*2+1, mid+1, nr);
            pull(idx);
        };
        dfs(1, 1, size);
    }

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

//------------------------------------
// main (Python版そのまま再現)
//------------------------------------
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, Q;
    cin >> N >> Q;
    vector<ll> A(N);
    for (int i = 0; i < N; i++) cin >> A[i];

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

    vector<array<ll,3>> L;
    for (int i = 0; i < N; i++) {
        L.push_back({mem[i][0], mem[i][1], 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;
    while (Q--) {
        int c; ll X;
        cin >> c >> X;

        array<ll,3> key = {X+1, -100, -100};
        int idx = lower_bound(L.begin(), L.end(), key) - L.begin();

        if (idx == (int)L.size()) {
            ans.push_back(-1);
            continue;
        }

        auto [num, j, sidx] = L[idx];

        if (c == 1) {
            auto [res, seg_idx] = segm.range_min(sidx, N);
            if (res == -1 || 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 || res == 1000000000) 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";
}