#include <iostream>
#include <cstring>

using namespace std;

struct DataCenter {
    long long id;
    long long countAliveServers;
    long long countRestarts;
    bool *servers;
    DataCenter() = default;
    DataCenter(long long id, long long m){
        this->id = id;
        this->countAliveServers = m;
        this->countRestarts = 0;
        this->servers = new bool[m];
        memset(servers, false, m);
    }
    bool operator==(const DataCenter &dc) const{
        return this->id == dc.id;
    }
};

struct Node{
    DataCenter dataCenter;
    Node *left;
    Node *right;
    Node *parent;
    bool color; //false - black, true - red
};

typedef Node *NodePtr;

class RedBlackTree {
private:
    NodePtr root;
    NodePtr TNULL;

    static unsigned long long multiply(DataCenter &dataCenter){
        return dataCenter.countAliveServers * dataCenter.countRestarts;
    }

    static bool compare(DataCenter &dc1, DataCenter &dc2) {
        if (dc1.countAliveServers * dc1.countRestarts < dc2.countAliveServers * dc2.countRestarts) {
            return true;
        } else if (dc1.countAliveServers * dc1.countRestarts > dc2.countAliveServers * dc2.countRestarts) {
            return false;
        } else {
            return dc1.id < dc2.id;
        }
    }

    void rbTransplant(NodePtr u, NodePtr v) {
        if (u->parent == nullptr) {
            root = v;
        } else if (u == u->parent->left) {
            u->parent->left = v;
        } else {
            u->parent->right = v;
        }
        v->parent = u->parent;
    }

    void deleteNodeHelper(NodePtr node, DataCenter &key) {
        NodePtr z = TNULL;
        NodePtr x, y;
        while (node != TNULL) {
            if (node->dataCenter == key) {
                z = node;
            }

            if (compare(node->dataCenter, key)) {
                node = node->right;
            } else {
                node = node->left;
            }
        }

        if (z == TNULL) {
            cout << "Key not found in the tree" << endl;
            return;
        }

        y = z;
        int y_original_color = y->color;
        if (z->left == TNULL) {
            x = z->right;
            rbTransplant(z, z->right);
        } else if (z->right == TNULL) {
            x = z->left;
            rbTransplant(z, z->left);
        } else {
            y = minimum(z->right);
            y_original_color = y->color;
            x = y->right;
            if (y->parent == z) {
                x->parent = y;
            } else {
                rbTransplant(y, y->right);
                y->right = z->right;
                y->right->parent = y;
            }

            rbTransplant(z, y);
            y->left = z->left;
            y->left->parent = y;
            y->color = z->color;
        }
        delete z;
        if (y_original_color == 0) {
            deleteFix(x);
        }
    }

    void leftRotate(NodePtr x) {
        NodePtr y = x->right;
        x->right = y->left;
        if (y->left != TNULL) {
            y->left->parent = x;
        }
        y->parent = x->parent;
        if (x->parent == nullptr) {
            this->root = y;
        } else if (x == x->parent->left) {
            x->parent->left = y;
        } else {
            x->parent->right = y;
        }
        y->left = x;
        x->parent = y;
    }

    void rightRotate(NodePtr x) {
        NodePtr y = x->left;
        x->left = y->right;
        if (y->right != TNULL) {
            y->right->parent = x;
        }
        y->parent = x->parent;
        if (x->parent == nullptr) {
            this->root = y;
        } else if (x == x->parent->right) {
            x->parent->right = y;
        } else {
            x->parent->left = y;
        }
        y->right = x;
        x->parent = y;
    }

    void deleteFix(NodePtr x) {
        NodePtr s;
        while (x != root && !x->color) {
            if (x == x->parent->left) {
                s = x->parent->right;
                if (s->color) {
                    s->color = false;
                    x->parent->color = true;
                    leftRotate(x->parent);
                    s = x->parent->right;
                }
                if (!s->left->color && !s->right->color) {
                    s->color = true;
                    x = x->parent;
                } else {
                    if (!s->right->color) {
                        s->left->color = false;
                        s->color = true;
                        rightRotate(s);
                        s = x->parent->right;
                    }
                    s->color = x->parent->color;
                    x->parent->color = false;
                    s->right->color = false;
                    leftRotate(x->parent);
                    x = root;
                }
            } else {
                s = x->parent->left;
                if (s->color) {
                    s->color = false;
                    x->parent->color = true;
                    rightRotate(x->parent);
                    s = x->parent->left;
                }
                if (!s->right->color && !s->left->color) {
                    s->color = true;
                    x = x->parent;
                } else {
                    if (!s->left->color) {
                        s->right->color = false;
                        s->color = true;
                        leftRotate(s);
                        s = x->parent->left;
                    }
                    s->color = x->parent->color;
                    x->parent->color = false;
                    s->left->color = false;
                    rightRotate(x->parent);
                    x = root;
                }
            }
        }
        x->color = false;
    }

    void insertFix(NodePtr k) {
        NodePtr u;
        while (k->parent->color) {
            if (k->parent == k->parent->parent->right) {
                u = k->parent->parent->left;
                if (u->color) {
                    u->color = false;
                    k->parent->color = false;
                    k->parent->parent->color = true;
                    k = k->parent->parent;
                } else {
                    if (k == k->parent->left) {
                        k = k->parent;
                        rightRotate(k);
                    }
                    k->parent->color = false;
                    k->parent->parent->color = true;
                    leftRotate(k->parent->parent);
                }
            } else {
                u = k->parent->parent->right;

                if (u->color) {
                    u->color = false;
                    k->parent->color = false;
                    k->parent->parent->color = true;
                    k = k->parent->parent;
                } else {
                    if (k == k->parent->right) {
                        k = k->parent;
                        leftRotate(k);
                    }
                    k->parent->color = false;
                    k->parent->parent->color = true;
                    rightRotate(k->parent->parent);
                }
            }
            if (k == root) {
                break;
            }
        }
        root->color = false;
    }

    NodePtr minimum(NodePtr node) {
        while (node->left != TNULL) {
            node = node->left;
        }
        return node;
    }

    NodePtr maximum(NodePtr node) {
        while (node->right != TNULL) {
            node = node->right;
        }
        return node;
    }

    void printHelper(NodePtr root, string indent, bool last) {
        if (root != TNULL) {
            cout << indent;
            if (last) {
                cout << "R----";
                indent += "   ";
            } else {
                cout << "L----";
                indent += "|  ";
            }

            string sColor = root->color ? "RED" : "BLACK";
            cout << "{id: " << root->dataCenter.id << " ,countAliveServers: "
                << root->dataCenter.countAliveServers << " ,countRestarts: "
                << root->dataCenter.countRestarts << " } "
                << "(" << sColor << ")" << endl;
            printHelper(root->left, indent, false);
            printHelper(root->right, indent, true);
        }
    }

public:
    RedBlackTree() {
        TNULL = new Node;
        TNULL->color = false;
        TNULL->left = nullptr;
        TNULL->right = nullptr;
        root = TNULL;
    }

    void insert(DataCenter key) {
        NodePtr node = new Node;
        node->parent = nullptr;
        node->dataCenter = key;
        node->left = TNULL;
        node->right = TNULL;
        node->color = true;

        NodePtr y = nullptr;
        NodePtr x = this->root;

        while (x != TNULL) {
            y = x;
            if (compare(node->dataCenter, x->dataCenter)) {
                x = x->left;
            } else {
                x = x->right;
            }
        }

        node->parent = y;
        if (y == nullptr) {
            root = node;
        } else if (compare(node->dataCenter, y->dataCenter)) {
            y->left = node;
        } else {
            y->right = node;
        }

        if (node->parent == nullptr) {
            node->color = false;
            return;
        }

        if (node->parent->parent == nullptr) {
            return;
        }

        insertFix(node);
    }

    void remove(DataCenter data) {
        deleteNodeHelper(this->root, data);
    }

    long long getMinId() {
        DataCenter dc1 = minimum(root)->dataCenter;
        DataCenter dc2 = maximum(root)->dataCenter;
        if(multiply(dc1) == multiply(dc2)){
            return min(dc1.id, dc2.id);
        }
        return dc1.id;
    }

    long long getMaxId() {
        DataCenter dc1 = minimum(root)->dataCenter;
        DataCenter dc2 = maximum(root)->dataCenter;
        cout << dc1.id << " " << dc2.id << endl;
        if(multiply(dc1) == multiply(dc2)){
            return min(dc1.id, dc2.id);
        }
        return dc2.id;
    }

    void printTree() {
        if (root) {
            printHelper(this->root, "", true);
        }
    }
};

int main() {
    long long n, m, q;
    scanf("%lld %lld %lld", &n, &m, &q);

    auto *dataCenter = new DataCenter[n];
    for (long long i = 0; i < n; ++i) {
        dataCenter[i] = DataCenter(i, m);
    }

    RedBlackTree rbTree;
    for (long long i = 0; i < n; ++i) {
        rbTree.insert(dataCenter[i]);
    }

    rbTree.printTree();

    char inputValue[10];
    long long dataCenterId, serverId;
    for (long long i = 0; i < q; ++i) {
        scanf("%s", inputValue);
        if (strcmp(inputValue, "DISABLE") == 0) {
            scanf("%lld %lld", &dataCenterId, &serverId);
            dataCenterId--; serverId--;
            if(!dataCenter[dataCenterId].servers[serverId]){
                rbTree.remove(dataCenter[dataCenterId]);
                dataCenter[dataCenterId].servers[serverId] = true;
                dataCenter[dataCenterId].countAliveServers--;
                rbTree.insert(dataCenter[dataCenterId]);
                //___________________
                rbTree.printTree();
            }
        }
        else if (strcmp(inputValue, "RESET") == 0) {
            scanf("%lld", &dataCenterId);
            dataCenterId--;
            rbTree.remove(dataCenter[dataCenterId]);
            dataCenter[dataCenterId].countAliveServers = m;
            dataCenter[dataCenterId].countRestarts++;
            memset(dataCenter[dataCenterId].servers, false, m);
            rbTree.insert(dataCenter[dataCenterId]);
            //___________________
            rbTree.printTree();
        }
        else if (strcmp(inputValue, "GETMAX") == 0) {
            printf("%lld\n", rbTree.getMaxId() + 1);
        }
        else if (strcmp(inputValue, "GETMIN") == 0){
            printf("%lld\n", rbTree.getMinId() + 1);
        }
    }
    return 0;
}