// chat gpt's code
#include <bits/stdc++.h>
using namespace std;
static const int MX = 2000000000;
const int N = 300000 + 5;
array<int, 2> id[N];
struct TNode {
uint32_t key;
int l, r;
int pr;
int cnt;
int sz;
};
struct SNode {
int lef, rig;
int rt;
};
vector<TNode> tr(1);
vector<SNode> seg(2);
static uint64_t rng_state = 88172645463393265ULL;
static inline uint32_t rng32() {
rng_state ^= rng_state << 7;
rng_state ^= rng_state >> 9;
return (uint32_t)rng_state;
}
static inline uint32_t enc(int tp, int v) {
return (uint32_t(tp) << 31) | (uint32_t)v;
}
static inline int getsz(int u) {
return u ? tr[u].sz : 0;
}
static inline void pull(int u) {
tr[u].sz = tr[u].cnt + getsz(tr[u].l) + getsz(tr[u].r);
}
int newTreapNode(uint32_t key) {
tr.push_back({key, 0, 0, (int)rng32(), 1, 1});
return (int)tr.size() - 1;
}
void rotateLeft(int &u) {
int v = tr[u].r;
tr[u].r = tr[v].l;
tr[v].l = u;
pull(u);
pull(v);
u = v;
}
void rotateRight(int &u) {
int v = tr[u].l;
tr[u].l = tr[v].r;
tr[v].r = u;
pull(u);
pull(v);
u = v;
}
void insertKey(int &u, uint32_t key) {
if (!u) {
u = newTreapNode(key);
return;
}
if (tr[u].key == key) {
tr[u].cnt++;
pull(u);
return;
}
if (key < tr[u].key) {
insertKey(tr[u].l, key);
if (tr[tr[u].l].pr > tr[u].pr) rotateRight(u);
} else {
insertKey(tr[u].r, key);
if (tr[tr[u].r].pr > tr[u].pr) rotateLeft(u);
}
pull(u);
}
void eraseKey(int &u, uint32_t key) {
if (!u) return;
if (tr[u].key == key) {
if (tr[u].cnt > 1) {
tr[u].cnt--;
pull(u);
return;
}
if (!tr[u].l || !tr[u].r) {
u = tr[u].l ? tr[u].l : tr[u].r;
return;
}
if (tr[tr[u].l].pr > tr[tr[u].r].pr) {
rotateRight(u);
eraseKey(tr[u].r, key);
} else {
rotateLeft(u);
eraseKey(tr[u].l, key);
}
if (u) pull(u);
return;
}
if (key < tr[u].key) eraseKey(tr[u].l, key);
else eraseKey(tr[u].r, key);
if (u) pull(u);
}
int countLess(int u, uint32_t key) {
if (!u) return 0;
if (key <= tr[u].key) return countLess(tr[u].l, key);
return getsz(tr[u].l) + tr[u].cnt + countLess(tr[u].r, key);
}
int C = 1;
void update(int u, int l, int r, int x, int v, int t) {
uint32_t k1 = enc(0, v);
uint32_t k2 = enc(1, v - x + 1);
if (t == 1) {
insertKey(seg[u].rt, k1);
insertKey(seg[u].rt, k2);
} else {
eraseKey(seg[u].rt, k1);
eraseKey(seg[u].rt, k2);
}
if (l == r) return;
int m = l + ((r - l) >> 1);
if (x <= m) {
if (!seg[u].lef) {
seg.push_back({0, 0, 0});
seg[u].lef = ++C;
}
update(seg[u].lef, l, m, x, v, t);
} else {
if (!seg[u].rig) {
seg.push_back({0, 0, 0});
seg[u].rig = ++C;
}
update(seg[u].rig, m + 1, r, x, v, t);
}
}
int getTag0(int u, int l, int r, int x, int y, int v) {
if (!u || y < l || x > r) return 0;
if (x <= l && r <= y) {
uint32_t bound0 = enc(0, v);
uint32_t bound1 = enc(1, 0);
return countLess(seg[u].rt, bound1) - countLess(seg[u].rt, bound0);
}
int m = l + ((r - l) >> 1);
return getTag0(seg[u].lef, l, m, x, y, v) + getTag0(seg[u].rig, m + 1, r, x, y, v);
}
int getTag1(int u, int l, int r, int x, int y, int v) {
if (!u || y < l || x > r) return 0;
if (x <= l && r <= y) {
uint32_t bound = enc(1, v);
return getsz(seg[u].rt) - countLess(seg[u].rt, bound);
}
int m = l + ((r - l) >> 1);
return getTag1(seg[u].lef, l, m, x, y, v) + getTag1(seg[u].rig, m + 1, r, x, y, v);
}
void add(int l, int r) {
update(1, 0, MX, l, r, 1);
}
void remove(int l, int r) {
update(1, 0, MX, l, r, 0);
}
int cnt(int l, int r) {
if (l < 0) return 0;
return getTag0(1, 0, MX, 0, l, r);
}
int cnt_sz(int l, int r, int k) {
if (l > r) return 0;
return getTag1(1, 0, MX, l, r, k);
}
void solve() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q, t;
cin >> q >> t;
int ID = 1;
int last = 0;
while (q--) {
int tip;
cin >> tip;
if (tip == 1) {
int a, b;
cin >> a >> b;
int l = a ^ (t * last);
int r = b ^ (t * last);
if (l > r) swap(l, r);
add(l, r);
id[ID++] = {l, r};
} else if (tip == 2) {
int rem;
cin >> rem;
int l = id[rem][0];
int r = id[rem][1];
remove(l, r);
} else {
int a, b, k;
cin >> a >> b >> k;
int l = a ^ (t * last);
int r = b ^ (t * last);
if (l > r) swap(l, r);
if (r - l + 1 < k) {
last = 0;
cout << 0 << '\n';
continue;
}
last = cnt(l - 1, l + k - 1) + cnt_sz(l, r - k + 1, k);
cout << last << '\n';
}
}
}
int main() {
solve();
return 0;
}
