#include <iostream>
#include <iomanip>
#include <ostream>
#include <istream>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <bitset>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <array>
#include <algorithm>
#include <functional>
#include <cmath>
#include <time.h>
#include <random>
#include <chrono>
#include <cassert>
#include <cstring>
#include <limits>

using namespace std;

#define pb push_back
#define ppb pop_back
#define all(a) (a).begin(), (a).end()
#define pii pair<int, int>
#define ld long double

typedef long long ll;

istream& operator>> (istream& in, pii& b) {
    in >> b.first >> b.second;
    return in;
}

ostream& operator<< (ostream& out, const pii& b) {
    out << "{" << b.first << ", " << b.second << "}";
    return out;
}

template<typename T> ostream& operator<< (ostream& out, const vector<T>& a) {
    for (auto k : a) out << k << " ";
    return out;
}

template <typename T1, typename T2> inline bool chkmin(T1 &x, const T2 &y) {if (x > y) {x = y; return 1;} return 0;}
template <typename T1, typename T2> inline bool chkmax(T1 &x, const T2 &y) {if (x < y) {x = y; return 1;} return 0;}

#ifdef LOCAL
    #define dbg(x) cout << #x << " : " << (x) << endl;
    // const long long mod = 2600000069;
    // const long long p = 10;
#else
    #define dbg(x) 57
    // const long long mod = 2600000069;
    // const long long p = 179;
#endif

const ld PI = 4 * atan(1);

#define time clock() / (double) CLOCKS_PER_SEC

// #pragma GCC optimize("Ofast,no-stack-protector")
// #pragma GCC target("sse,sse2,sse3,sse3,sse4")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC optimize("fast-math")
// #pragma GCC target("avx2")

mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());

#define int long long

struct node {
    int l, r;
    int diff, uniq, mx;
    node(int l_ = -1, int r_ = -1, int diff_ = 0, int uniq_ = 0, int mx_ = 0) {
        l = l_, r = r_, diff = diff_, uniq = uniq_ = 0, mx = mx_ = 0;
    }
    node(const node& a, const node& b) {
        l = r = -1;
        diff = a.diff + b.diff;
        uniq = a.uniq + b.uniq;
        mx = max(a.mx, b.mx);
    }
};

const int N = (int)3e5 + 10;

int ptr = 0;
node t[22 * N];

int sz = 0;
int root[N];

int init() {
    t[ptr] = node();
    return ptr++;
}

void recalc(int v) {
    int l = t[v].l;
    int r = t[v].r;
    assert(l != -1 && r != -1);
    t[v].diff = t[l].diff + t[r].diff;
    t[v].uniq = t[l].uniq + t[r].uniq;
    t[v].mx = max(t[l].mx, t[r].mx);
}

int build(int v, int l, int r) {
    if (l + 1 == r) {
        t[v] = node();
        return v;
    }
    int m = (l + r) / 2;
    build(t[v].l = init(), l, m);
    build(t[v].r = init(), m, r);
    recalc(v);
    return v;
}

void print(int v) {
    cout << "node " << v << " : " << t[v].l << " " << t[v].r << " " << t[v].mx << "\n";
}

int add(int v, int l, int r, int pos, int val) {
    int u = init();
    t[u] = t[v];
    if (l + 1 == r) {
        t[u].mx += val;
        if (t[u].mx > 0) {
            t[u].diff = 1;
        } else {
            t[u].diff = 0;
        }
        if (t[u].mx == 1) {
            t[u].uniq = 1;
        } else {
            t[u].uniq = 0;
        }
        return u;
    }
    int m = (l + r) / 2;
    if (pos < m) {
        t[u].l = add(t[u].l, l, m, pos, val);
    } else {
        t[u].r = add(t[u].r, m, r, pos, val);
    }
    recalc(u);
    return u;
}

node ask(int v, int l, int r, int askl, int askr) {
    // print(v);
    if (l >= askr || r <= askl) {
        return node();
    }
    if (askl <= l && r <= askr) {
        return t[v];
    }
    int m = (l + r) / 2;
    return node(ask(t[v].l, l, m, askl, askr), ask(t[v].r, m, r, askl, askr));
}

void print(int v, int l, int r) {
    if (l + 1 == r) {
        cout << t[v].mx << " ";
        return;
    }
    int m = (l + r) / 2;
    print(t[v].l, l, m);
    print(t[v].r, m, r);
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    cin >> n >> m;
    m++;
    root[0] = init();
    build(root[0], 0, m);
    int s = 0;
    for (int i = 1; i <= n; i++) {
        string type;
        cin >> type;
        root[i] = root[i - 1];
        if (type == "add") {
            int x;
            cin >> x;
            root[i] = add(root[i - 1], 0, m, x, 1);
        } else if (type == "remove") {
            int x;
            cin >> x;
            root[i] = add(root[i - 1], 0, m, x, -1);
        } else if (type == "different") {
            int v;
            cin >> v;
            v = (v + s) % i;
            int ans = ask(root[v], 0, m, 0, m).diff;
            s += ans;
            cout << ans << "\n";
        } else if (type == "unique") {
            int v;
            cin >> v;
            v = (v + s) % i;
            int ans = ask(root[v], 0, m, 0, m).uniq;
            s += ans;
            cout << ans << "\n";
        } else if (type == "count") {
            int x, v;
            cin >> x >> v;
            v = (v + s) % i;
            int ans = ask(root[v], 0, m, x, x + 1).mx;
            s += ans;
            cout << ans << "\n";
        }
    }
}
/*
2 3
add 2
count 2 1
*/