#include <bits/stdc++.h>
 
using namespace std;

#define int long long
#define fir first
#define sec second
#define mkp make_pair 
#define pb push_back
#define lep( i, l, r ) for ( int i = ( l ); i <= ( r ); ++ i )
#define rep( i, r, l ) for ( int i = ( r ); i >= ( l ); -- i )
 
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair < int, int > pii;
 
char _c; bool _f; template < class type > inline void read ( type &x ) {
	_f = 0, x = 0;
	while ( _c = getchar (), !isdigit ( _c ) ) if ( _c == '-' ) _f = 1;
	while ( isdigit ( _c ) ) x = x * 10 + _c - '0', _c = getchar (); if ( _f ) { x = -x; }
}

template < class type > inline void chkmin ( type &x, type y ) { x = ( x <= y ? x : y ); }
template < class type > inline void chkmax ( type &x, type y ) { x = ( x >= y ? x : y ); }
mt19937 rnd ( time ( 0 ) );

const int N = 3e5 + 5;

int n, m, rt;

struct Node {
  int ls, rs, fa, val, siz, key;
} tree[N];

void pushup ( int node ) {
  tree[node].val = min ( min ( tree[tree[node].ls].val, tree[tree[node].rs].val ), tree[node].val );
  tree[node].siz = tree[tree[node].ls].siz + tree[tree[node].rs].siz + 1;
}

void split ( int node, int &r1, int &r2, int siz ) {
  if ( !node ) {
    r1 = r2 = 0;
    return ;
  }
  if ( tree[tree[node].ls].siz + 1 <= siz ) {
    r1 = node, tree[tree[node].rs].fa = 0;
    split ( tree[node].rs, tree[node].rs, r2, siz - tree[tree[node].ls].siz - 1 );
    if ( tree[node].rs ) {
      tree[tree[node].rs].fa = node;
    }
  }
  else {
    r2 = node, tree[tree[node].ls].fa = 0;
    split ( tree[node].ls, r1, tree[node].ls, siz );
    if ( tree[node].ls ) {
      tree[tree[node].ls].fa = node;
    }
  }
}

int merge ( int x, int y ) {
  if ( !x || !y ) {
    return x + y;
  }
  if ( tree[x].key < tree[y].key ) {
    tree[tree[x].rs].fa = 0;
    tree[x].rs = merge ( tree[x].rs, y );
    if ( tree[x].rs ) {
      tree[tree[x].rs].fa = x;
    }
    pushup ( x );
    return x;
  }
  else {
    tree[tree[y].ls].fa = 0;
    tree[y].ls = merge ( x, tree[y].ls );
    if ( tree[y].ls ) {
      tree[tree[y].ls].fa = y;
    }
    pushup ( y );
    return y;
  }
}

int rnk ( int x ) {
  int res = tree[tree[x].ls].siz + 1;
  while ( x != rt ) {
    if ( tree[tree[x].fa].rs == x ) {
      res += tree[tree[tree[x].fa].ls].siz + 1;
    }
    x = tree[x].fa;
  }
  return res;
}

int find ( int x, int v ) {
  if ( !x ) {
    return 0;
  }
  if ( v > tree[tree[x].ls].val || v > x ) {
    return find ( tree[x].ls, v );
  }
  return tree[tree[x].ls].siz + 1 + find ( tree[x].rs, v );
}

int newnode ( int x ) {
  tree[x].val = x, tree[x].key = rnd (), tree[x].siz = 1;
  return x;
}

void insert ( int x ) {
  x = rnk ( x );
  int t1, t2;
  split ( rt, t1, t2, x );
  rt = merge ( merge ( t1, newnode ( ++ n ) ), t2 );
}

void Solve () {
  cin >> m >> m;
  while ( m -- ) {
    int op;
    cin >> op;
    if ( op == 1 ) {
      int x;
      cin >> x;
      insert ( x );
    }
    else if ( op == 2 ) {
      int x, y;
      cin >> x >> y;
      int a, b, c;
      split ( rt, a, b, rnk ( x ) - 1 );
      split ( b, b, c, find ( b, x ) );
      rt = merge ( a, c );
      int d, e, f;
      split ( rt, d, e, y == 0 ? 0 : rnk ( y ) );
      split ( e, e, f, find ( e, x ) );
      rt = merge ( merge ( d, e ), merge ( b, f ) );
    }
    else {
      int x;
      cin >> x;
      cout << rnk ( x ) << '\n';
    }
  }
}

signed main () {
#ifdef judge
  freopen ( "Code.in", "r", stdin );
  freopen ( "Code.out", "w", stdout );
  freopen ( "Code.err", "w", stderr );
#endif
	Solve ();
	return 0;
}