#include <iostream>
#include <vector>

using namespace std;

class Node{
public:
    int different, unique, count;
    Node *l, *r;

    Node(int x = 0) {
        different = unique = count = x;
        l = r = nullptr;
    }

    Node(Node* node) {
        different = node->different;
        unique = node->unique;
        count = node->count;
        l = node->l;
        r = node->r;
    }
};

vector<Node*> versions;
int m;

Node* build(int tl, int tr) {
    if (tl == tr) {
        return new Node();
    } else {
        int mid = (tl + tr) / 2;

        Node* tmp = new Node();

        tmp->l = build(tl, mid);
        tmp->r = build(mid + 1, tr);

        return tmp;
    }
}

void recalc(Node* node) {
    if (!node) return;

    node->different = (node->l ? node->l->different : 0) + (node->r ? node->r->different : 0);
    node->unique = (node->l ? node->l->unique : 0) + (node->r ? node->r->unique : 0);
}

Node* update(Node* v, int tl, int tr, int x, int delta) {
    if (tl == tr) {
        Node* tmp = new Node(v);

        tmp->count += delta;
        tmp->different = (tmp->count > 0);
        tmp->unique = (tmp->count == 1);

        return tmp;
    } else {
        int mid = (tl + tr) / 2;

        Node* tmp = new Node(v);

        if (x <= mid) {
            tmp->l = update(tmp->l, tl, mid, x, delta);
        } else {
            tmp->r = update(tmp->r, mid + 1, tr, x, delta);
        }

        recalc(tmp);

        return tmp;
    }
}

int get(Node* v, int tl, int tr, int x) {
    if (tl == tr) {
        return v->count;
    } else {
        int mid = (tl + tr) / 2;

        if (x <= mid) {
            return get(v->l, tl, mid, x);
        } else {
            return get(v->r, mid + 1, tr, x);
        }
    }
}

int different(int v) {
    versions.push_back(versions.back());
    return versions[v]->different;
}

int unique(int v) {
    versions.push_back(versions.back());
    return versions[v]->unique;
}

int count(int v, int x) {
    versions.push_back(versions.back());
    return get(versions[v], 1, m, x);
}

int main() {
    int n, s = 0;

    cin >> n >> m;

    versions.push_back(build(1, m));

    for (int i = 0; i != n; ++i) {
        string com;

        cin >> com;

        if (com == "different") {
            int v, ans;

            cin >> v;

            v = (v + s) % versions.size();

            ans = different(v);
            s += ans;

            cout << ans << '\n';
        } else if (com == "unique") {
            int v, ans;

            cin >> v;

            v = (v + s) % versions.size();

            ans = unique(v);
            s += ans;

            cout << ans << '\n';
        } else if (com == "count") {
            int v, x, ans;

            cin >> v >> x;

            v = (v + s) % versions.size();

            ans = count(v, x);
            s += ans;

            cout << ans << '\n';
        } else if (com == "add") {
            int x;

            cin >> x;

            versions.push_back(update(versions.back(), 1, m, x, 1));
        } else if (com == "remove") {
            int x;

            cin >> x;

            if (count(versions.size() - 1, x) != 0) {
                versions.push_back(update(versions.back(), 1, m, x, -1));
            }
        }
    }

    return 0;
}