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

using ll = long long;

const ll oo = 2e18;
const int N = 2e5+5;
const int M = 3e4+5;

struct Cand {
    ll dist;
    int r, c;
    int u, v;
    bool operator<(const Cand& o) const {
        if (dist != o.dist) return dist > o.dist;
        if (r != o.r) return r < o.r;
        return c < o.c;
    } 
};

int n, m, mask[N];
pair<int, int> history[M];

set<int> rows;
set<Cand> pool;
Cand gap[N], partial[N];

ll get_dist(int r, int c, int idx) {
    if (idx <= 0 || idx > n) return oo;
    ll d = oo;
    if (mask[idx] & 1) d = min(d, 1LL * (r - idx) * (r - idx) + 1LL * (c - 1) * (c - 1));
    if (mask[idx] & 2) d = min(d, 1LL * (r - idx) * (r - idx) + 1LL * (c - 2) * (c - 2));
    return d;
}

Cand calc(int u, int v) {
    Cand best = {-1, -1, -1, u, v};
    if (u == v) {
        if (__builtin_popcount(mask[u]) == 1) {
            best.r = u;
            best.c = (mask[u] & 1) ? 2 : 1;
            best.dist = 1;
        }
        return best;
    }
    if (u == 0 && v == n + 1) return {oo, 1, 1, 0, n + 1};
    if (u + 1 > v - 1) return best;

    auto update = [&](int r, int c) {
        ll d = min(get_dist(r, c, u), get_dist(r, c, v));
        Cand cur = {d, r, c, u, v};
        if (best.dist == -1 || cur < best) best = cur;
    };

    if (u == 0) {
        for (int c = 1; c <= 2; c++) update(1, c);
    } else if (v == n + 1) {
        for (int c = 1; c <= 2; c++) update(n, c);
    } else {
        int mid = (u + v) / 2;
        for (int r = max(u + 1, mid - 1); r <= min(v - 1, mid + 1); r++)
            for (int c = 1; c <= 2; c++) update(r, c);
    }
    return best;
}

void remove(int u, int v) {
    Cand &temp = (u == v) ? partial[u] : gap[u];
    if (temp.dist != -1) {
        pool.erase(temp);
        temp.dist = -1;
    }
}

void add(int u, int v) {
    Cand res = calc(u, v);
    if (res.dist != -1) {
        pool.insert(res);
        if (u == v) partial[u] = res;
        else gap[u] = res;
    }
}

void solve() {
    cin >> n >> m;

    rows.insert(0);
    rows.insert(n + 1);
    for (int i = 0; i <= n + 1; i++) {
        gap[i].dist = -1;
        partial[i].dist = -1;
    }
    add(0, n + 1);

    for (int i = 1; i <= m; i++) {
        char op; cin >> op;
        if (op == 'E') {
            Cand best = *pool.begin();
            int r = best.r, c = best.c;
            cout << r << ' ' << c << '\n';

            history[i] = {r, c};
            int u = best.u, v = best.v;
            remove(u, v);
            if (u == v) {
                auto it = rows.find(r);
                int prv = *prev(it), nxt = *next(it);
                remove(prv, r); remove(r, nxt);

                mask[r] |= (1 << (c - 1));

                add(prv, r); add(r, nxt);
            } else {
                auto it = rows.upper_bound(r);
                int prv = *prev(it), nxt = *it;

                mask[r] |= (1 << (c - 1));
                rows.insert(r);

                add(prv, r); add(r, nxt); add(r, r);
            }
        } else if (op == 'L') {
            int p; cin >> p;
            int r = history[p].first, c = history[p].second;

            auto it = rows.find(r);
            int prv = *prev(it), nxt = *next(it);
            remove(prv, r); remove(r, nxt); remove(r, r);

            mask[r] &= ~(1 << (c - 1));
            if (__builtin_popcount(mask[r]) == 0) {
                rows.erase(it); add(prv, nxt);
            } else {
                add(prv, r); add(r, nxt); add(r, r);
            }
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);

    #define TASK "XLH"
    if (fopen(TASK".INP", "r")) {
        freopen(TASK".INP", "r", stdin);
        freopen(TASK".OUT", "w", stdout);
    }

    int tests = 1; // cin >> tests;
    while (tests--) solve();

    #ifdef LOCAL
    cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
    #endif
    return 0;
}