#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <ctime>

#define pb push_back
#define ll long long
#define mp make_pair
#define f first
#define s second
#define pii pair < int, int >
#define ull unsigned long long
#define pll pair < ll, ll >
#define forit(it, s) for(__typeof(s.begin()) it = s.begin(); it != s.end(); it ++)
#define all(s) s.begin(), s.end()
#define sz(a) (int)a.size()

const int inf = (1ll << 30) - 1;
const int maxn = (int) 1e5 + 10;

using namespace std;

int A[544][544];
int B[544][544];
int L_pos[200200];
int R_pos[200200];
int pos[200200];
int K = 455;
vector<int> G[544];
vector<int> L[544];
vector<int> R[544];
int l[200200];
int r[200200];

void insA(int x, int id){
    G[x].pb(id);
    for(int i = (int)G[x].size()-1; i > 0; i--){
        int a = G[x][i];
        int b = G[x][i-1];
        if(r[a] - l[a] > r[b] - l[b]) swap(G[x][i], G[x][i-1]);
    }
}
void insB(int x, int id){
    L[x].pb(id);

    for(int i = (int)L[x].size()-1; i > 0; i--){
        int a = L[x][i];
        int b = L[x][i-1];
        if(l[a] > l[b])swap(L[x][i], L[x][i-1]);
    }
}
void insC(int x, int id){
    R[x].pb(id);

    for(int i = (int)R[x].size()-1; i > 0; i--){
        int a = R[x][i];
        int b = R[x][i-1];
        if(r[a] < r[b]) swap(R[x][i], R[x][i-1]);
    }
}

void add(int id){
    L_pos[id] = K-1;
    for(int i = 1; i < K; i++){
        if(L[i+1].size() > 0 && l[L[i+1][0]] >= l[id]) continue;
        L_pos[id] = i;
        break;
    }
    R_pos[id] = K-1;
    for(int i = 1; i < K; i++){
        if(R[i+1].size() > 0 && r[R[i+1][0]] <= r[id]) continue;
        R_pos[id] = i;
        break;
    }
    pos[id] = K-1;
    for(int i = 1; i < K; i++){
        if(G[i+1].size() > 0 && r[G[i+1][0]] - l[G[i+1][0]] >= r[id] - l[id]) continue;
        pos[id] = i;
        break;
    }
    insA(pos[id], id);
    insB(L_pos[id], id);
    insC(R_pos[id], id);
    for(int i = L_pos[id]; i < K; i++)
        A[pos[id]][i]++;

    for(int i = R_pos[id]; i < K; i++)
        B[pos[id]][i]++;
}
int T;

void del(int id){
    for(int i = L_pos[id]; i < K; i++){
        A[pos[id]][i]--;
    }
    for(int i = R_pos[id]; i < K; i++){
        B[pos[id]][i]--;
    }
    forit(it, L[L_pos[id]]) {
        if(*it == id){
            L[L_pos[id]].erase(it);
            break;
        }
    }
    forit(it, R[R_pos[id]]) {
        if(*it == id){
            R[R_pos[id]].erase(it);
            break;
        }
    }
    forit(it, G[pos[id]]) {
        if(*it == id){
            G[pos[id]].erase(it);
            break;
        }
    }
}

int was[200200];
int get(int a, int b, int k){
    if(b - a + 1 < k) return 0;
    int c = 1;
    int ans = 0;
    while(c+1 < K && G[c+1].size()>0 && r[G[c+1][0]] - l[G[c+1][0]] + 1 >= k) {
        ans += G[c].size();
        c++;
    }
    int d = 1;
    while(d + 1< K && R[d+1].size() > 0 && r[R[d+1][0]] < a + k - 1){
        d++;
    }
    int e = 1;
    while(e + 1 < K && L[e+1].size() > 0 && l[L[e+1][0]] > b - k + 1){
        e++;
    }
    for(int i = 1; i < c; i++){
        ans -= A[i][e-1];
    }
    for(int i = 1; i < c; i++){
        ans -= B[i][d-1];
    }
    ++T;
    for(int i = 0; i < G[c].size(); i++){
        int id = G[c][i];
        if(min(r[id], b) - max(a, l[id]) + 1 >= k) ans++;
    }
    for(int i = 0; i < L[e].size(); i++){
        int id = L[e][i];
        if(pos[id] >= c) continue;
        if(R_pos[id] < d) continue;
        if(min(r[id], b) - max(a, l[id]) + 1 < k) --ans;
        was[id] = T;
    }
    for(int i = 0; i < R[d].size(); i++){
        int id = R[d][i];
        if(pos[id] >= c || was[id] == T) continue;
        if(L_pos[id] < e) continue;
        if(min(r[id], b) - max(a, l[id]) + 1 < k) --ans;
    }
    return ans;
}

void recalc(){
    vector<int> a, b, c;
    for(int i = 1; i < K; i++){
        forit(it, G[i]) a.pb(*it);
        G[i].clear();
    }
    for(int i = 1; i < K; i++){
        forit(it, R[i]) b.pb(*it);
        R[i].clear();
    }
    for(int i = 1; i < K; i++){
        forit(it, L[i]) c.pb(*it);
        L[i].clear();
    }
    for(int i = 1; i < K; i++){
        for(int j = 1; j < K; j++){
            A[i][j] = 0;
            B[i][j] = 0;
        }
    }
    for(int i = 0 ; i < b.size(); i++){
        int ind = i/K + 1;
        R_pos[b[i]] = ind;
        R[ind].pb(b[i]);
    }
    for(int i = 0 ; i < c.size(); i++){
        int ind = i/K + 1;
        L_pos[c[i]] = ind;
        L[ind].pb(c[i]);
    }
    for(int i = 0; i < a.size(); i++){
        int ind = i/K + 1;
        pos[a[i]] = ind;
        G[ind].pb(a[i]);
        A[ind][L_pos[a[i]]]++;
        B[ind][R_pos[a[i]]]++;
    }

    for(int i = 1; i < K; i++){
        for(int j = 1; j < K; j++){
            A[i][j] += A[i][j-1];
            B[i][j] += B[i][j-1];
        }
    }
}
void solve(){
    int q;
    scanf("%d", &q);
    int id = 1;
    vector<int> ans;
    for(int i = 0, ty, a, b, k; i < q; i++){
        scanf("%d", &ty);
        if(i % K == K-2) recalc();
        if(ty == 1){
            scanf("%d%d", &l[id], &r[id]);
            add(id);
            ++id;
        }
        else if(ty==2){
            scanf("%d", &a);
            del(a);
        }
        else if(ty == 3){
            scanf("%d%d%d", &a, &b, &k);
            int g = get(a, b, k);
            ans.pb(g);
        }
    }
    forit(it, ans){
        printf("%d\n", *it);
    }
}

int main () {
    #ifdef LOCAL
    freopen("a.in", "r", stdin);
    freopen("a.out", "w", stdout);
    #endif
    int t=1;
    //scanf("%d", &t);
    for(int i=1; i <= t; i++){
      //printf("Case #%d\n", i);
      solve();
    }

    return 0;
}