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

class Parser {
  private:
    static const int SIZE = 1e5;
    char str[SIZE];

    int ptr;
    FILE *fin;

    char getChar() {
        if (ptr == SIZE) {
            fread(str, sizeof(char), SIZE, fin);
            ptr = 0;
        }
        return str[ptr++];
    }

    int getInt() {
        char chr = getChar();
        while (!isdigit(chr) && chr != '-')
            chr = getChar();

        int sgn = +1;
        if (chr == '-') {
            sgn = -1;
            chr = getChar();
        }

        int nr = 0;
        while (isdigit(chr)) {
            nr = nr * 10 + chr - '0';
            chr = getChar();
        }
        return nr * sgn;
    }

  public:
    Parser(const char* str) :
        ptr(SIZE), fin(fopen(str, "r")) { }

    ~Parser() {
        fclose(fin);
    }

    friend Parser& operator>>(Parser& in, int& nr) {
        nr = in.getInt();
        return in;
    }
};

Parser fin("cutii.in");
ofstream fout("cutii.out");

class FenTree2D {
  private:
    int m, n;
    vector<vector<int>> bit;

  public:
    FenTree2D(int m, int n) :
        m(m), n(n), bit(m + 1, vector<int>(n + 1)) { }

    void update(int x, int y, int val) {
        for (int i = x; i <= m; i += i & -i)
            for (int j = y; j <= n; j += j & -j)
                bit[i][j] = max(bit[i][j], val);
    }

    int query(int x, int y) {
        int mx = 0;
        for (int i = x; i >= 1; i -= i & -i)
            for (int j = y; j >= 1; j -= j & -j)
                mx = max(mx, bit[i][j]);
        return mx;
    }

    void clear() {
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                bit[i][j] = 0;
    }
};

int main() {
    int n; fin >> n;
    FenTree2D dp(n, n);

    int t; fin >> t;
    while (t--) {
        vector<vector<int>> v(n, vector<int>(3));
        for (int i = 0; i < n; i++)
            fin >> v[i][0] >> v[i][1] >> v[i][2];
        sort(v.begin(), v.end());

        for (int i = 0; i < n; i++)
            dp.update(v[i][1], v[i][2], dp.query(v[i][1] - 1, v[i][2] - 1) + 1);
        fout << dp.query(n, n) << '\n';
        dp.clear();
    }

    fout.close();
    return 0;
}