///https://infoarena.ro/problema/cutii
#include <bits/stdc++.h>
#include <algorithm>
#include <fstream>

#define ok cout << "OK!" << endl
#define fox f

using namespace std;

vector <int> graph[3501];
vector <int> influence;

struct Box
{
    int x, y, z;
    int index;
    void view() { cout << x << " " << y << " " << z << " (" << index << ")"<< endl; }
};

bool compX(Box a, Box b) { return a.x < b.x; }

bool compY(Box a, Box b) { return a.y < b.y; }

bool compZ(Box a, Box b) { return a.z < b.z; }

void setInfluence(int v)
{
    if (influence[v] == -1)
    {
        int f = 0;
        int bonus = -1;
        bool state = 0;

        queue <int> nodes[2];
        nodes[0].push(v);

        while (! (nodes[0].empty() && nodes[1].empty()))
        {
            if (nodes[state].empty())
            {
                state = ! state;
                f++;
            }

            for (int i = 0; i < graph[nodes[state].front()].size(); i++)
            {
                if (influence[nodes[state].front()] == -1)
                    nodes[!state].push(graph[nodes[state].front()][i]);
                else bonus = max(bonus, influence[nodes[state].front()]);
            }

            nodes[state].pop();
        }
        f = max(f, bonus + 1);
        influence[v] = f;
    }
}

int main()
{
    ifstream f("cutii.in");
    ofstream g("cutii.out");
    int n, t;
    influence.resize(3501);

    fox >> n >> t;

    for (int k = 1; k <= t; k++)
    {
        vector <Box> boxes;
        vector <Box> sortX, sortY, sortZ;
        Box associated[3501];

        //Setup and reading
        for (int i = 0; i <= n; i++) influence[i] = -1;

        for (int i = 1; i <= 3500; i++) graph[i].clear();
        boxes.clear();
        Box a;
        for (int i = 1; i <= n; i++)
        {
            fox >> a.x >> a.y >> a.z;
            a.index = i;
            boxes.push_back(a);
        }

        //Preparing sorted data structures
        sortX = sortY = sortZ = boxes;

        sort(sortX.begin(), sortX.end(), compX);
        sort(sortY.begin(), sortY.end(), compY);
        sort(sortZ.begin(), sortZ.end(), compZ);

        for (int i = 1; i <= n; i++)
        {
            associated[sortX[i - 1].index].x = i;
            associated[sortY[i - 1].index].y = i;
            associated[sortZ[i - 1].index].z = i;
        }

        for (int i = 1; i <= n; i++)
        {

            vector <int> indeces1, indeces2, indeces3;
            vector <int> v, remaining;

            indeces1.clear();
            indeces2.clear();
            indeces3.clear();
            v.clear();
            remaining.clear();

            for (int j = 0; j < associated[i].x - 1; j++)
                indeces1.push_back(sortX[j].index);

            for (int j = 0; j < associated[i].y - 1; j++)
                indeces2.push_back(sortY[j].index);

            for (int j = 0; j < associated[i].z - 1; j++)
                indeces3.push_back(sortZ[j].index);

            sort(indeces1.begin(), indeces1.end());
            sort(indeces2.begin(), indeces2.end());
            sort(indeces3.begin(), indeces3.end());

            set_intersection(indeces1.begin(), indeces1.end(),
                indeces2.begin(), indeces2.end(), back_inserter(v));


            set_intersection(v.begin(), v.end(),
                              indeces3.begin(), indeces3.end(), back_inserter(remaining));

            for (int j = 0; j < remaining.size(); j++)
            {
                //cout << i << " " << remaining[j] << endl;
                graph[i].push_back(remaining[j]);
            }
        }

        //Solving a graph problem
        int maxInfluence = 0;
        for (int i = 1; i <= n; i++)
            setInfluence(i);
        for (int i = 1; i <= n; i++) maxInfluence = max(maxInfluence, influence[i]);

        //The answer
        g << maxInfluence + 1 << endl;
    }

    f.close();
    g.close();
    return 0;
}