#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <cmath>
#include <numeric>
#include <unordered_map>
#include <random>

//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma target("sse, sse2, sse3, ssse3, sse4, popcnt, abm, mmx, avx, avx2, tune=native")
//#pragma GCC optimize ("unroll-loops")
//#pragma GCC optimize ("fast-math")
//#pragma GCC optimize ("section-anchors")
//#pragma GCC optimize ("profile-values, profile-reorder-functions, tracer")
//#pragma GCC optimize ("vpt")
//#pragma GCC optimize ("rename-registers")
//#pragma GCC optimize ("move-loop-invariants")
//#pragma GCC optimize ("unswitch-loops")
//#pragma GCC optimize ("functions-sections")
//#pragma GCC optimize ("data-sections")
//#pragma GCC optimize ("branch-target-load-optimize")
//#pragma GCC optimize ("branch-target-load-optimize2")
//#pragma GCC optimize ("btr-bb-exclusive")
//#pragma GCC optimize ("O3")

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef unsigned int uint;
typedef vector<uint> vuint;
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define INF 2*0x3f3f3f3f
#define INFLL (ll)(1e18)
#define EPS 1e-9
#define MOD 1000000007

template<class T>
istream &operator>>(istream &is, vector<T> &a) {
    for (int i = 0; i < a.size(); ++i)
        is >> a[i];
    return is;
}

mt19937 rand_engine;

struct item {
    int key, l, r, cnt;
    ll prior;

    item() {};

    item(int key) : key(key), prior((ll) rand_engine() % MOD), l(0), r(0), cnt(1) {};
};

vector<item> tree;

int size(int root) {
    if (root == 0)
        return 0;
    return tree[root].cnt;
}

void update(int root) {
    if (root)
        tree[root].cnt = size(tree[root].l) + size(tree[root].r) + 1;
}

void split(int root, int key, int &l, int &r) {
    if (root == 0)
        l = r = 0;
    else if (tree[root].key > key)
        split(tree[root].l, key, l, tree[root].l), r = root;
    else
        split(tree[root].r, key, tree[root].r, r), l = root;
    update(root);
}

int merge(int l, int r) {
    if (!l || !r)
        return max(l, r);
    if (tree[l].prior > tree[r].prior) {
        tree[l].r = merge(tree[l].r, r);
        update(l);
        return l;
    }
    tree[r].l = merge(l, tree[r].l);
    update(r);
    return r;
}

bool find(int root, int x) {
    if (root) {
        if (tree[root].key == x)
            return true;
        if (tree[root].key > x)
            return find(tree[root].l, x);
        else
            return find(tree[root].r, x);
    }
    return false;
}

void insert(int &root, int x) {
    tree.push_back(item(x));
    int l, r;
    split(root, x, l, r);
    root = merge(merge(l, tree.size() - 1), r);
}

int order_of_key(int root, int x) {
    int l, r;
    split(root, x, l, r);
    int a = size(l);
    root = merge(l, r);
    return a;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n, m;
    cin >> n >> m;
    map<int, int> del;
    int root = 0;
    for (int i = 0; i < m; ++i) {
        char c;
        cin >> c;
        int x;
        cin >> x;
        --x;
        if (c == 'D') {
            int left = 0, right = n;
            while (left + 1 < right) {
                int mid = (left + right) / 2;
                int k = order_of_key(root, mid);
                if (mid - k == x) {
                    insert(root, mid);
                    ++del[mid];
                    // cout << mid << "\n";
                    break;
                }
                if (mid - k < x)
                    left = mid;
                else
                    right = mid;
            }
        } else {
            int left = 0, right = n;
            while (left + 1 < right) {
                int mid = (left + right) / 2;
                int k = order_of_key(root, mid);
                if (mid - k == x && del[mid] == 0) {
                    cout << mid + 1 << "\n";
                    break;
                }
                if (mid - k <= x)
                    left = mid;
                else
                    right = mid;
            }
        }
    }
}