#include <iostream>
#include <queue>
#include <cstdint>
#include <set>
#include <string>
#include <tuple>
#include <vector>

using namespace std;

struct Datacenter {
    int reboots_count = 0;
    vector<bool> is_server_enable;
    vector<int> disabled_servers_idxs;
    Datacenter(int servers_count) : is_server_enable(servers_count + 1, true) {}
};

/*
//подумать, как использовать одну структуру и два разных компаратора. Наследование?
    struct ScoreMax {
        int64_t score;
        int idx;
        int reboots_count;
    };

    struct ScoreMin {
        int64_t score;
        int idx;
        int reboots_count;
    };

    bool operator < (const ScoreMax& lhs, const ScoreMax& rhs) {
        if (lhs.score != rhs.score) {
            return lhs.score > rhs.score;
        }
        return lhs.idx < rhs.idx;
    }

    bool operator < (const ScoreMin& lhs, const ScoreMin& rhs) {
        return tie(lhs.score, lhs.idx) < tie(rhs.score, rhs.idx);
    }

void Solution1(int datacenters_count, int servers_count, int requests_count) {
    vector<Datacenter> datacenters(datacenters_count + 1, Datacenter(servers_count));

    set<MaxScoreIdx> max_idx;
    set<MinScoreIdx> min_idx;
    for (int i = 1; i <= datacenters_count; i++) {
        max_idx.insert({ 0, i });
        min_idx.insert({ 0, i });
    }

    auto get_score = [&datacenters, servers_count](int idx) {
        return (int64_t)datacenters[idx].reboots_count *
            (int64_t)(servers_count - (int64_t)datacenters[idx].disabled_servers_idxs.size());
    };

    for (int i = 0; i < requests_count; ++i) {
        string operation;
        cin >> operation;
        if (operation == "GETMAX") {
            cout << max_idx.begin()->idx << '\n';
            continue;
        }

        if (operation == "GETMIN") {
            cout << min_idx.begin()->idx << '\n';
            continue;
        }

        int datacenter_idx;
        cin >> datacenter_idx;
        int64_t last_score = get_score(datacenter_idx);

        auto& datacenter = datacenters[datacenter_idx];
        if (operation == "RESET") {
            datacenter.reboots_count++;
            for (auto idx : datacenter.disabled_servers_idxs) {
                datacenter.is_server_enable[idx] = true;
            }
            datacenter.disabled_servers_idxs.clear();
        } else {
            int server_idx;
            cin >> server_idx;
            if (datacenter.is_server_enable[server_idx]) {
                datacenter.is_server_enable[server_idx] = false;
                datacenter.disabled_servers_idxs.push_back(server_idx);
            }
        }

        int64_t new_score = get_score(datacenter_idx);
        max_idx.erase({ last_score, datacenter_idx });
        min_idx.erase({ last_score, datacenter_idx });
        max_idx.insert({ new_score, datacenter_idx });
        min_idx.insert({ new_score, datacenter_idx });
    }
}
*/

struct ScoreIdxReboots {
    int64_t score;
    int idx;
    int reboots_count;
};

int64_t GetScore(vector<Datacenter>& datacenters, int idx) {
    const auto& datacenter = datacenters[idx];
    int servers_count = datacenter.is_server_enable.size() - 1;
    return (int64_t)datacenter.reboots_count *
        ((int64_t)servers_count - datacenter.disabled_servers_idxs.size());
}

template <typename PQ>
bool IsScoreUpToDate(vector<Datacenter>& datacenters, const PQ& scores) {
    int idx = scores.top().idx;
    return GetScore(datacenters, idx) == scores.top().score;
}

template <typename PQ>
bool IsRebootsCountUpToDate(vector<Datacenter>& datacenters, const PQ& scores) {
    int idx = scores.top().idx;
    return datacenters[idx].reboots_count == scores.top().reboots_count;
}


template <typename PQ>
void DeleteExpiredScores(vector<Datacenter>& datacenters, PQ& scores) {
    while (!IsScoreUpToDate(datacenters, scores) || !IsRebootsCountUpToDate(datacenters, scores)) {
        scores.pop();
    }
}

void Solution2(int datacenters_count, int servers_count, int requests_count) {
    vector<Datacenter> datacenters(datacenters_count + 1, Datacenter(servers_count));

    auto scores_max_cmp = [] (const auto& lhs, const auto& rhs) {
        if (lhs.score != rhs.score) {
            return lhs.score < rhs.score;
        }
        return lhs.idx > rhs.idx;
    };

    auto scores_min_cmp = [](const auto& lhs, const auto& rhs) {
        return tie(lhs.score, lhs.idx) > tie(rhs.score, rhs.idx);
    };

    priority_queue<ScoreIdxReboots,vector<ScoreIdxReboots>, decltype(scores_max_cmp)> scores_max(scores_max_cmp); //score, idx, reboots_count
    priority_queue<ScoreIdxReboots,vector<ScoreIdxReboots>, decltype(scores_min_cmp)> scores_min(scores_min_cmp); //score, idx, reboots_count
    for (int i = 1; i <= datacenters_count; i++) {
        scores_max.push({ 0, i, 0 });
        scores_min.push({ 0, i, 0 });
    }

    for (int i = 0; i < requests_count; ++i) {
        string operation;
        cin >> operation;
        if (operation == "GETMAX") {
            DeleteExpiredScores(datacenters, scores_max);
            cout << scores_max.top().idx << '\n';
            continue;
        }

        if (operation == "GETMIN") {
            DeleteExpiredScores(datacenters, scores_min);
            cout << scores_min.top().idx << '\n';
            continue;
        }

        int datacenter_idx;
        cin >> datacenter_idx;
        int64_t last_score = GetScore(datacenters, datacenter_idx);

        auto& datacenter = datacenters[datacenter_idx];
        if (operation == "RESET") {
            datacenter.reboots_count++;
            for (auto idx : datacenter.disabled_servers_idxs) {
                datacenter.is_server_enable[idx] = true;
            }
            datacenter.disabled_servers_idxs.clear();
        } else {
            int server_idx;
            cin >> server_idx;
            if (datacenter.is_server_enable[server_idx]) {
                datacenter.is_server_enable[server_idx] = false;
                datacenter.disabled_servers_idxs.push_back(server_idx);
            }
        }
        int64_t new_score = GetScore(datacenters, datacenter_idx);
        scores_max.push({ new_score, datacenter_idx, datacenter.reboots_count });
        scores_min.push({ new_score, datacenter_idx, datacenter.reboots_count });
    }
}

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

    int datacenters_count, servers_count, requests_count;
    cin >> datacenters_count >> servers_count >> requests_count;
    //Solution1(datacenters_count, servers_count, requests_count);
    Solution2(datacenters_count, servers_count, requests_count);

    return 0;
}