#include <vector>
#include <algorithm>
#include <functional>
#include <memory>
#include <fstream>

std::ifstream fi("cutii.in");
std::ofstream fo("cutii.out");

template<int D, int Sz, int... SzArgs>
class FenwickTree {
 private:
  FenwickTree<D - 1, SzArgs...> tree[Sz];

 public:
  template<typename T = int, typename... Args>
  inline void update(int val, int x, Args... args) {
    for(int i = x; i < Sz; i += (i & -i)) {
      tree[i].update(val, args...);
    }
  }

  template<typename T = int, typename... Args>
  inline int query(int x, Args... args) {
    int ret = 0;
    for(int i = x; i > 0; i -= (i & -i))
      ret = std::max(ret, tree[i].query(args...));
    return ret;
  }

  template<typename T = int, typename... Args>
  void reset(int x, Args... args) {
    for(int i = x; i < Sz; i += (i & -i)) {
      tree[i].reset(args...);
    }
  }
};

template<int Sz>
class FenwickTree<1, Sz> {
 private:
  int tree[Sz] = {0};

 public:
  template<typename T = int>
  inline void update(int val, int x) {
    for(int i = x; i < Sz; i += (i & -i)) {
      tree[i] = std::max(tree[i], val);
    }
  }

  template<typename T = int>
  inline int query(int x) {
    int ret = 0;
    for (int i = x; i > 0; i -= (i & -i))
      ret = std::max(ret, tree[i]);
    return ret;
  }

  template<typename T = int>
  inline void reset(int x) {
    for (int i = x; i < Sz; i += (i & -i)) {
      tree[i] = 0;
    }
  }
};

// This is the tree we are working with: 2 dimensions,
// each one with 3501 entries (0 based).
typedef FenwickTree<2, 3501, 3501> FenwickTree2D;

struct Box {
  int x, y, z;
};

std::istream& operator >> (std::istream& s, Box& box) {
  s >> box.x >> box.y >>box.z;
  return s;
}

template<typename T>
std::vector<T> read_vector(int N) {
  std::vector<T> v(N);
  for(int i = 0; i < N; ++i) {
    fi >> v[i];
  }
  return v;
}

template<typename T>
T next() {
  T x;
  fi >> x;
  return x;
}

void solve_test(int N, const std::unique_ptr<FenwickTree2D>& fenwickTree) {
  auto boxes = read_vector<Box>(N);

  std::sort(boxes.begin(), boxes.end(),
    [] (const Box& a, const Box& b) -> bool { return a.x < b.x; });

  int best = 0;
  for(const auto& box : boxes) {
    int q = 1 + fenwickTree->query(box.y - 1, box.z - 1);
    best = std::max(best, q);
    fenwickTree->update(q, box.y, box.z);
  }

  for(const auto& box : boxes) {
    fenwickTree->reset(box.y, box.z);
  }

  printf("%d\n", best);
}

int main(int argc, char *argv[]) {
  int N = next<int>();
  int T = next<int>();

  std::unique_ptr<FenwickTree<2, 3501, 3501>> fenwickTree(
    new FenwickTree<2, 3501, 3501>());

  while(T--) {
    solve_test(N, fenwickTree);
  }

  return 0;
}