Squirrel Liss loves nuts. Liss asks you to plant some nut trees.

There are n positions (numbered 1 to n from west to east) to plant a tree along a street. Trees grow one meter per month. At the beginning of each month you should process one query. The query is one of the following types:

  1. Plant a tree of height h at position p. 
  2. Cut down the x-th existent (not cut) tree from the west (where x is 1-indexed). When we cut the tree it drops down and takes all the available place at the position where it has stood. So no tree can be planted at this position anymore. 



After processing each query, you should print the length of the longest increasing subsequence. A subset of existent trees is called an increasing subsequence if the height of the trees in the set is strictly increasing from west to east (for example, the westmost tree in the set must be the shortest in the set). The length of the increasing subsequence is the number of trees in it.

Note that Liss don't like the trees with the same heights, so it is guaranteed that at any time no two trees have the exactly same heights.

Input

The first line contains two integers: n and m (1 ≤ n ≤ 105; 1 ≤ m ≤ 2·105) — the number of positions and the number of queries.

Next m lines contains the information of queries by following formats:

  * If the i-th query is type 1, the i-th line contains three integers: 1, pi, and hi (1 ≤ pi ≤ n, 1 ≤ hi ≤ 10), where pi is the position of the new tree and hi is the initial height of the new tree. 
  * If the i-th query is type 2, the i-th line contains two integers: 2 and xi (1 ≤ xi ≤ 10), where the xi is the index of the tree we want to cut. 



The input is guaranteed to be correct, i.e.,

  * For type 1 queries, pi will be pairwise distinct. 
  * For type 2 queries, xi will be less than or equal to the current number of trees. 
  * At any time no two trees have the exactly same heights. 



In each line integers are separated by single spaces.

Output

Print m integers — the length of the longest increasing subsequence after each query. Separate the numbers by whitespaces.

Examples

Input

4 6
1 1 1
1 4 4
1 3 4
2 2
1 2 8
2 3


Output

1
2
3
2
2
2

Note

States of street after each query you can see on the following animation:

<image>

If your browser doesn't support animation png, please see the gif version here: http://212.193.37.254/codeforces/images/162/roadtree.gif
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = ~0LLU >> 1;
int rd() { return RAND_MAX == 32767 ? ((rand() << 15) ^ rand()) : rand(); }
const int maxn = 200010;
const int maxt = 2000000;
int n, tt;
int s[maxt], mx[maxt], key[maxt], val[maxt], ch[maxt][2];
int h[maxn], t[maxn];
set<pair<int, int> > S;
set<int> T;
int Calc(int t, int x) {
  int res = 0;
  while (t != 0) {
    if (key[t] > x) {
      res = max(res, max(mx[ch[t][1]], val[t]));
      t = ch[t][0];
    } else
      t = ch[t][1];
  }
  return res;
}
void Fresh(int t) { mx[t] = max(val[t], max(mx[ch[t][0]], mx[ch[t][1]])); }
void Rotate(int &t, int x) {
  int k = ch[t][x];
  ch[t][x] = ch[k][1 - x];
  ch[k][1 - x] = t;
  s[k] = s[t];
  mx[k] = mx[t];
  s[t] = s[ch[t][0]] + s[ch[t][1]] + 1;
  Fresh(t);
  t = k;
}
void Maintain(int &t, int x) {
  if (s[ch[ch[t][x]][x]] > s[ch[t][1 - x]])
    Rotate(t, x);
  else if (s[ch[ch[t][x]][1 - x]] > s[ch[t][1 - x]]) {
    Rotate(ch[t][x], 1 - x);
    Rotate(t, x);
  } else
    return;
  Maintain(ch[t][0], 0);
  Maintain(ch[t][1], 1);
  Maintain(t, 0);
  Maintain(t, 1);
}
void Insert(int &t, int x, int y) {
  if (t == 0) {
    t = ++tt;
    key[t] = x;
    mx[t] = val[t] = y;
    s[t] = 1;
    ch[t][0] = ch[t][1] = 0;
    return;
  }
  s[t]++;
  Insert(ch[t][x > key[t]], x, y);
  Fresh(t);
  Maintain(t, x > key[t]);
}
void Change(int t, int x, int y) {
  if (key[t] == x) {
    val[t] = y;
    Fresh(t);
  } else {
    Change(ch[t][x > key[t]], x, y);
    Fresh(t);
  }
}
void Delete(int &t, int x) {
  if (key[t] == x) {
    if (ch[t][0] == 0 || ch[t][1] == 0) {
      t = ch[t][0] + ch[t][1];
      return;
    }
    Rotate(t, 0);
    s[t]--;
    Delete(ch[t][1], x);
    Fresh(t);
    Maintain(t, 1);
  } else {
    s[t]--;
    Delete(ch[t][x > key[t]], x);
    Fresh(t);
  }
}
int Query(int x, int y) {
  int res = 0;
  for (int i = x; i; i -= (i & -i)) res = max(res, Calc(t[i], y));
  return res;
}
void Add(int x, int y) {
  for (int i = x; i <= n; i += (i & -i)) Insert(t[i], h[n - x], y);
}
void Fre(int x, int y) {
  for (int i = x; i <= n; i += (i & -i)) Change(t[i], h[n - x], y);
}
void Del(int x) {
  for (int i = x; i <= n; i += (i & -i)) Delete(t[i], h[n - x]);
}
int main() {
  int m;
  scanf("%d%d", &n, &m);
  tt = s[0] = mx[0] = key[0] = val[0] = ch[0][0] = ch[0][1] = 0;
  for (int i = 0; i <= n; i++) t[i] = 0;
  S.clear();
  for (int i = 0; i < m; i++) {
    int opt, pos, hei, rk;
    scanf("%d", &opt);
    if (opt == 1) {
      scanf("%d%d", &pos, &hei);
      pos--;
      hei -= i;
      h[pos] = hei;
      vector<pair<int, int> > tmp;
      while (!S.empty() && (*S.begin()).first < hei) {
        tmp.push_back(*S.begin());
        S.erase(S.begin());
      }
      int ret = Query(n - pos - 1, hei);
      Add(n - pos, ret + 1);
      S.insert(make_pair(hei, pos));
      for (int j = 0; j < tmp.size(); j++) S.insert(tmp[j]);
      T.insert(pos);
      sort(tmp.begin(), tmp.end());
      for (int j = tmp.size() - 1; j >= 0; j--) {
        int hi = tmp[j].first;
        int ps = tmp[j].second;
        int ret = Query(n - ps - 1, hi);
        Fre(n - ps, ret + 1);
      }
    } else {
      scanf("%d", &rk);
      set<int>::iterator it = T.begin();
      for (int j = 1; j < rk; j++) it++;
      int ps = *it;
      int hi = h[ps];
      S.erase(make_pair(hi, ps));
      T.erase(ps);
      Del(n - ps);
      it = T.begin();
      for (int j = 1; j < rk; j++, it++)
        ;
      for (int j = 1; j < rk; j++) {
        it--;
        int ps = *it;
        int ret = Query(n - ps - 1, h[ps]);
        Fre(n - ps, ret + 1);
      }
    }
    int res = 0;
    for (int j = n; j; j -= (j & -j)) res = max(res, mx[t[j]]);
    cout << res << endl;
  }
  return 0;
}
