#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 <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
//   Modifies 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;
vector<int> O, L, R;


namespace brute {
vector<int> run() {
  vector<int> to(M + 1, M + 1);
  vector<int> ans(N, 0);
  for (int i = 0; i < N; ++i) {
    if (O[i] == 1) {
      for (int u = L[i]; u >= 0; --u) {
        if (!chmin(to[u], R[i])) {
          break;
        }
      }
    } else {
      for (int u = L[i]; u <= R[i]; u = to[u]) {
        ++ans[i];
      }
      --ans[i];
    }
  }
  return ans;
}
}  // brute


namespace fast {
vector<int> run() {
  vector<Tree> nodes(M + 1);
  for (int u = 0; u <= M; ++u) {
    nodes[u].id = u;
  }
  for (int u = 0; u < M; ++u) {
    nodes[u].link(&nodes[u + 1]);
  }
  auto add = [&](int u, int v) -> void {
// cerr<<COLOR("91")<<"add "<<u<<" "<<v<<endl;
    nodes[u].cut();
    nodes[u].val = 1;
    nodes[u].update();
    nodes[u].link(&nodes[v]);
  };
  auto rem = [&](int u) -> void {
// cerr<<COLOR("94")<<"rem "<<u<<endl;
    nodes[u].cut();
    nodes[u].val = 0;
    nodes[u].update();
    nodes[u].link(&nodes[u + 1]);
  };
  
  set<pair<int, int>> ps;
  ps.emplace(-1, -(-1));
  ps.emplace(M + 1, -(M + 1));
  vector<int> ans(N, 0);
  for (int i = 0; i < N; ++i) {
// cerr<<COLOR("33")<<O[i]<<" "<<L[i]<<" "<<R[i]<<COLOR()<<endl;
    if (O[i] == 1) {
      const pair<int, int> key(R[i], -L[i]);
      auto it = ps.lower_bound(key);
      auto it1 = it; --it1;
      if (L[i] <= -it1->second && it1->first <= R[i]) {
        continue;
      }
      for (; -it->second <= L[i] && R[i] <= it->first; it = ps.erase(it)) {
        rem(-it->second);
      }
      add(L[i], R[i]);
      ps.insert(it, key);
    } else {
      Tree *a = &nodes[L[i]];
      a->expose();
      // max id on the path s.t. <= R[i]
      Tree *b = nullptr;
      for (; a; ) {
        if (a->id <= R[i]) {
          b = a;
          a = a->l;
        } else {
          a = a->r;
        }
      }
      assert(b);
      // sum of [L[i], b)
      b->splay();
      ans[i] = b->r ? b->r->sum : 0;
    }
  }
  return ans;
}
}  // fast


int main() {
  for (; ~scanf("%d%d", &N, &M); ) {
    O.resize(N);
    L.resize(N);
    R.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%d%d%d", &O[i], &L[i], &R[i]);
      --L[i];
    }
    
    const auto ans = fast::run();
    for (int i = 0; i < N; ++i) if (O[i] == 2) {
      printf("%d\n", ans[i]);
    }
#ifdef LOCAL
const auto brt=brute::run();
for(int i=0;i<N;++i)if(brt[i]!=ans[i]){cerr<<i<<": "<<brt[i]<<" "<<ans[i]<<endl;break;}
assert(brt==ans);
#endif
cerr<<"========"<<endl;
  }
  return 0;
}