#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// Link-Cut Tree
//   solid path as BST; left: root side
//   Modify update() for other data.
struct Tree {
  Tree *l, *r, *p;
  int sz;
  int id;
  Int val, sum;
  explicit Tree(int id_ = -1, Int val_ = 0) : id(id_), val(val_), sum(val_) {
    l = r = p = nullptr;
    sz = 1;
  }
  void update() {
    sz = (l ? l->sz : 0) + 1 + (r ? r->sz : 0);
    sum = (l ? l->sum : 0) + val + (r ? r->sum : 0);
  }
  bool isRoot() const {
    return (!p || (p->l != this && p->r != this));
  }
  void rotate() {
         if (p->l == this) { if (r) { r->p = p; } p->l = r; r = p; }
    else if (p->r == this) { if (l) { l->p = p; } p->r = l; l = p; }
    Tree *pp = p->p;
    if (pp) {
           if (pp->l == p) pp->l = this;
      else if (pp->r == p) pp->r = this;
    }
    p->update(); p->p = this; p = pp;
  }
  void splay() {
    for (; !isRoot(); rotate()) {
      if (!p->isRoot()) ((p->l == this) == (p->p->l == p)) ? p->rotate() : rotate();
    }
    update();
  }

  // Makes the path from v to the root solid
  // Returns the node where it entered the last solid path
  Tree *expose() {
    Tree *u = this, *v = nullptr;
    for (; u; u = u->p) { u->splay(); u->r = v; u->update(); v = u; }
    splay();
    return v;
  }

  // parent of this := u
  void link(Tree *u) {
    expose(); u->expose(); p = u; u->r = this; u->update();
  }

  // parent of this := null
  void cut() {
    expose(); l->p = nullptr; l = nullptr; update();
  }

  // the root of the tree this belongs
  Tree *root() {
    expose();
    for (Tree *u = this; ; u = u->l) if (!u->l) { u->splay(); return u; }
  }

  // LCA of this and u
  //   Assumes this->root == u->root
  Tree *lca(Tree *u) {
    expose(); return u->expose();
  }
};

////////////////////////////////////////////////////////////////////////////////


int N, M;
int C, T, Q;
vector<int> O, L, R, X;
vector<int> I, U, V;

int main() {
  for (; ~scanf("%d%d", &N, &M); ) {
    C = 1;
    O = L = R = X = I = U = V = {};
    O.push_back(1);
    L.push_back(0);
    R.push_back(N);
    X.push_back(0);
    for (int m = 0; m < M; ++m) {
      int o;
      scanf("%d", &o);
      if (o == 0) {
        int l, r;
        scanf("%d%d", &l, &r);
        --l;
        O.push_back(o);
        L.push_back(l);
        R.push_back(r);
        X.push_back(C++);
      } else if (o == 1) {
        int l, r, x;
        scanf("%d%d%d", &l, &r, &x);
        --l;
        --x;
        O.push_back(o);
        L.push_back(l);
        R.push_back(r);
        X.push_back(x);
      } else if (o == 2) {
        int i, u, v;
        scanf("%d%d%d", &i, &u, &v);
        --i;
        --u;
        --v;
        I.push_back(i);
        U.push_back(u);
        V.push_back(v);
      } else {
        assert(false);
      }
    }
    T = O.size();
    Q = I.size();
cerr<<"C = "<<C<<", T = "<<T<<", Q = "<<Q<<endl;
    
    vector<int> birth(C, -1);
    for (int t = 0; t < T; ++t) if (O[t] == 0) birth[X[t]] = t;
    birth[0] = T;
    /*
      1<----1<----1<----1
       \ \   \     \ \   
        0 0   0     0 0  
      activate O[t] = 1: link to birth[X[t]]
    */
    vector<int> par(T + 1, -1);
    {
      int last = T;
      for (int t = 0; t < T; ++t) {
        par[t] = last;
        if (O[t] == 1) last = t;
      }
    }
    vector<Tree> nodes(T + 1);
    for (int t = 0; t <= T; ++t) nodes[t] = Tree(t, (t == T || O[t] == 0) ? 1 : 0);
    for (int t = 0; t < T; ++t) nodes[t].link(&nodes[par[t]]);
    
    vector<vector<int>> addss(N), remss(N);
    for (int t = 0; t < T; ++t) if (O[t] == 1) {
      int l = L[t], r = R[t];
      if (X[t]) {
        // ignore if X[t] does not exist in a tree
        chmax(l, L[birth[X[t]]]);
        chmin(r, R[birth[X[t]]]);
      }
      if (l < r) {
        addss[l].push_back(t);
        remss[r - 1].push_back(t);
      }
    }
    vector<vector<int>> qss(N);
    for (int q = 0; q < Q; ++q) {
      qss[I[q]].push_back(q);
    }
    
    vector<int> ans(Q, 0);
    for (int i = 0; i < N; ++i) {
      for (const int t : addss[i]) {
        nodes[t].cut();
        nodes[t].link(&nodes[birth[X[t]]]);
      }
      for (const int q : qss[i]) {
        const int tU = birth[U[q]];
        const int tV = birth[V[q]];
        nodes[tU].expose(); ans[q] += (nodes[tU].sum - 1);
        nodes[tV].expose(); ans[q] += (nodes[tV].sum - 1);
        Tree *l = nodes[tU].lca(&nodes[tV]);
        l->expose();
        ans[q] -= 2 * (l->sum - 1);
      }
      for (const int t : remss[i]) {
        nodes[t].cut();
        nodes[t].link(&nodes[par[t]]);
      }
    }
    
    for (int q = 0; q < Q; ++q) {
      printf("%d\n", ans[q]);
    }
  }
  return 0;
}