#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_enabled;
    vector<int> disabled_servers_idxs;
    Datacenter(int servers_count) : is_server_enabled(servers_count + 1, true) {}

    int64_t GetScore() {
        int servers_count = is_server_enabled.size() - 1;
        return (int64_t)reboots_count *
            ((int64_t)servers_count - disabled_servers_idxs.size());
    }

    void Reset() {
        reboots_count++;
        for (auto idx : disabled_servers_idxs) {
            is_server_enabled[idx] = true;
        }
        disabled_servers_idxs.clear();
    }

    void Disable(int idx) {
        if (is_server_enabled[idx]) {
            is_server_enabled[idx] = false;
            disabled_servers_idxs.push_back(idx);
        }
    }
};

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

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

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

void Solution1(vector<Datacenter>& datacenters, int requests_count) {
    set<ScoreIdxReboots, decltype(scores_max_cmp_set)> max_idx;
    set<ScoreIdxReboots, decltype(scores_min_cmp_set)> min_idx;
    for (int i = 1; i < (int)datacenters.size(); i++) {
        max_idx.insert({ 0, i, 0 });
        min_idx.insert({ 0, i, 0 });
    }

    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;
        auto& datacenter = datacenters[datacenter_idx];
        int64_t last_score = datacenter.GetScore();
        int last_reboots_count = datacenter.reboots_count;

        if (operation == "RESET") {
            datacenter.Reset();
        } else {
            int server_idx;
            cin >> server_idx;
            datacenter.Disable(server_idx);
        }

        int64_t new_score = datacenter.GetScore();
        max_idx.erase({ last_score, datacenter_idx, last_reboots_count });
        min_idx.erase({ last_score, datacenter_idx, last_reboots_count });
        max_idx.insert({ new_score, datacenter_idx, datacenter.reboots_count });
        min_idx.insert({ new_score, datacenter_idx, datacenter.reboots_count });
    }
}

bool IsScoreUpToDate(vector<Datacenter>& datacenters, const ScoreIdxReboots& elem) {
    int idx = elem.idx;
    return datacenters[idx].GetScore() == elem.score;
}

bool IsRebootsCountUpToDate(vector<Datacenter>& datacenters, const ScoreIdxReboots& elem) {
    int idx = elem.idx;
    return datacenters[idx].reboots_count == elem.reboots_count;
}

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

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

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

void Solution2(vector<Datacenter>& datacenters, int requests_count) {
    priority_queue<ScoreIdxReboots, vector<ScoreIdxReboots>, decltype(scores_max_cmp_queue)> scores_max(scores_max_cmp_queue); //score, idx, reboots_count
    priority_queue<ScoreIdxReboots, vector<ScoreIdxReboots>, decltype(scores_min_cmp_queue)> scores_min(scores_min_cmp_queue); //score, idx, reboots_count
    for (int i = 1; i < (int)datacenters.size(); 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;
        auto& datacenter = datacenters[datacenter_idx];
        int64_t last_score = datacenter.GetScore();
        if (operation == "RESET") {
            datacenter.Reset();
        } else {
            int server_idx;
            cin >> server_idx;
            datacenter.Disable(server_idx);
        }
        int64_t new_score = datacenter.GetScore();
        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;
    vector<Datacenter> datacenters(datacenters_count + 1, Datacenter(servers_count));
    //Solution1(datacenters, requests_count);
    Solution2(datacenters, requests_count);

    return 0;
}