#include <iostream>
#include <vector>
#include <cmath>
#include <stack>
#include <set>
#include <algorithm>
using namespace std;



class ConvexHull {
public:
    ConvexHull(size_t num) {
        dots.clear();
        num_dots = num;
    }

    void read_dots() {
        // Считываем все точки
        for(int i = 0; i < num_dots; i++) {
            double x = 0;
            double y = 0;
            double z = 0;
            cin >> x >> y >> z;
            Point tmp(x,y,z,i);
            dots.push_back(tmp);
        }
    }

    void print_convex() {
        vector<Triangle> ans;
        Triangle first_triangle = Initialize();
        stack<Triangle> edges;
        edges.push(first_triangle);

        vector<vector<bool>> edges_proceed;

        edges_proceed.resize(num_dots);
        for(int i = 0; i < num_dots; i++){
            edges_proceed[i].resize(num_dots);
        }


        while(!edges.empty()) {
            Triangle tmp_trinagle = edges.top(); edges.pop();
            Edge e = tmp_trinagle.edge;
            Point p1 = e.first;
            Point p2 = e.second;

            if(!edges_proceed[p1.num][p2.num]) {
                Point p3 = find_dot(tmp_trinagle);
                set<int> s_tmp = {p1.num, p2.num, p3.num};

                Triangle new_Triange(p1,p2,p3);

                Edge tmp_edge(p2,p3);
                new_Triange.edge = tmp_edge;
                new_Triange.first = p2; new_Triange.second = p3;
                edges.push(new_Triange);

                tmp_edge.first = p3; tmp_edge.second = p1;
                new_Triange.edge = tmp_edge;
                new_Triange.first = p3; new_Triange.second = p1;
                edges.push(new_Triange);

                edges_proceed[p1.num][p2.num] = true;
                edges_proceed[p2.num][p1.num] = true;

                if (new_Triange.first.num != 0 && new_Triange.second.num != 0 && new_Triange.third.num != 0) {
                    new_Triange.sort_dots(dots[0]);
                }
                else if (new_Triange.first.num != 1 && new_Triange.second.num != 1 && new_Triange.third.num != 1) {
                    new_Triange.sort_dots(dots[1]);
                }
                else if (new_Triange.first.num != 2 && new_Triange.second.num != 2 && new_Triange.third.num != 2) {
                    new_Triange.sort_dots(dots[2]);
                }
                else {
                    new_Triange.sort_dots(dots[3]);
                }

                ans.push_back(new_Triange);
            }
        }


        std::sort(ans.begin(), ans.end(), compare_triangle);

        cout << ans.size() << "\n";  // Вывод данных
        for(auto i:ans) {
            cout << "3 " << i.first.num << " " << i.second.num << " " << i.third.num << "\n";
        }
    }
private:
    const double MAX_COORDINATE = 1000000;

    // Структура, описывающая точку
    struct Point{
        double x;   // Координата точки по x
        double y;   // Координата точки по y
        double z;   // Координата точки по z
        int num;    // Номер точки

        Point(double X, double Y, double Z, int Number) : x(X), y(Y), z(Z), num(Number) {}
    };

    // Векторное умножение
    Point static CrossProduct (const Point& A,const Point& B) {
        return Point{.x = A.z*B.y-A.y*B.z,
                .y = A.x*B.z-A.z*B.x,
                .z = A.y*B.x-A.x*B.y,
                .num = -1};
    }

    // Скалярное умножение
    double static Scalar(const Point& A,const Point& B) {
        return(A.x*B.x+A.y*B.y+A.z*B.z);
    }

    // Структура, описывающая плоскость
    struct Flat { // Ax + By + Cz + D = 0
        double A;
        double B;
        double C;
        double D;

        // Конструктор плоскости от значений чисел
        Flat(double a, double b, double c, double d) : A(a), B(b), C(c), D(d) {}

        // Констуктор плоскости от значений точек
        Flat(Point p, Point p0, Point tmp) {
            double a2 = p0.x - p.x; double b2 = p0.y - p.y; double c2 = p0.z - p.z;
            double a3 = tmp.x - p.x; double b3 = tmp.y - p.y; double c3 = tmp.z - p.z;

            A = b2*c3-c2*b3;
            B = c2*a3-a2*c3;
            C = a2*b3-b2*a3;
            D = -1*p.x*A -p.y*B - p.z*C;
        }
    };

    // Угол между плоскостями
    double get_angle(const Flat& First,const Flat& Second) {
        double numerator = abs(First.A*Second.A + First.B*Second.B + First.C*Second.C);
        double denominator = sqrt(First.A*First.A + First.B*First.B + First.C*First.C);
        denominator *= sqrt(Second.A*Second.A + Second.B*Second.B + Second.C*Second.C);
        return acos(numerator/denominator);
    }

    // Ребро задается двумя точками
    struct Edge {
        Point first;    // Первая точка
        Point second;   // Вторая

        Edge(Point F,Point S): first(F), second(S) {}
    };

    // Треугольник задается тремя точками
    struct Triangle {
        Point first;    // Первая точка
        Point second;   // Вторая точка
        Point third;    // Третья точка
        Edge edge;      // Опорное ребро


        void sort_dots(const Point& help){
            if(first.num < second.num && first.num < third.num) {
                Point u1(second.x - first.x,second.y - first.y,second.z - first.z,-1);
                Point u2(third.x - first.x,third.y - first.y,third.z - first.z,-1);
                Point u3(help.x - first.x,help.y - first.y,help.z - first.z,-1);

                if(Scalar(CrossProduct(u1,u2),u3) < 0) {
                    Point T = second; second = third; third = T;
                }
            }
            else if(second.num < first.num && second.num < third.num) {
                Point T = second; second = first; first = T;

                Point u1(second.x - first.x,second.y - first.y,second.z - first.z,-1);
                Point u2(third.x - first.x,third.y - first.y,third.z - first.z,-1);
                Point u3(help.x - first.x,help.y - first.y,help.z - first.z,-1);

                if(Scalar(CrossProduct(u1,u2),u3) < 0) {
                    T = second; second = third; third = T;
                }
            }
            else {
                Point T = third; third = first; first = T;
                Point u1(second.x - first.x,second.y - first.y,second.z - first.z,-1);
                Point u2(third.x - first.x,third.y - first.y,third.z - first.z,-1);
                Point u3(help.x - first.x,help.y - first.y,help.z- first.z,-1);

                if(Scalar(CrossProduct(u1,u2),u3) < 0) {
                    T = second; second = third; third = T;
                }
            }
        }

        Triangle(Point F,Point S,Point T) : first(F), second(S), third(T), edge(F, S) {}
    };

    // Для сортировки треугольников
    static bool compare_triangle(const Triangle& First,const Triangle& Second) {
        if(First.first.num < Second.first.num) {
            return true;
        }
        if(First.first.num > Second.first.num) {
            return false;
        }
        if(First.second.num < Second.second.num) {
            return true;
        }
        if(First.second.num > Second.second.num) {
            return false;
        }
        if(First.third.num <= Second.third.num) {
            return true;
        }
        return false;
    }

    // Инициализация первых двух точек - первого ребра
    Triangle Initialize() {
        Point first_point(MAX_COORDINATE, MAX_COORDINATE, MAX_COORDINATE, -1); // Первая точка инициализации

        for (int i = 0; i < num_dots; i++) {  // Находим эту самую точку first_point
            if (dots[i].z < first_point.z) {
                first_point = dots[i];
            } else if (dots[i].z == first_point.z) {
                if (dots[i].x < first_point.x) {
                    first_point = dots[i];
                } else if (dots[i].x == first_point.x) {
                    if (dots[i].y < first_point.y) {
                        first_point = dots[i];
                    }
                }
            }
        }

        Flat H(0, 0, 1, -1 * first_point.z); // z - first_point.z = 0 - уравнение плоскости перпендекулярной Oz и проходящий через first_point

        // В качестве l возьмем  прямую проходящую через first_point и какую-то случайную точку
        Point l_point(rand() % 100 + 1985, rand() % 30 + 1985, first_point.z, -1);

        Point second_point(MAX_COORDINATE, MAX_COORDINATE, MAX_COORDINATE, -1); // Вторая точка первого треугольника
        double max_angle = M_PI;

        for (int i = 0; i < num_dots; i++) {  // Находим точку second_point, через которую пройдет H
            if (i != first_point.num) {
                Point tmp = dots[i];
                Flat tmp_G(first_point, l_point, tmp);
                double angle = get_angle(H, tmp_G);
                if (angle < max_angle) {
                    max_angle = angle;
                    second_point = tmp;
                }
            }
        }
        Triangle to_return(first_point,second_point,l_point);
        return to_return;
    }

    Point find_dot(Triangle T) {
        Point first_point = T.first;
        Point second_point = T.second;

        Flat G(first_point,second_point,T.third);
        double max_angle = M_PI;

        Point the_new_point(MAX_COORDINATE, MAX_COORDINATE, MAX_COORDINATE, -1);
        for(int i = 0; i < num_dots; i++) {
            if(i != first_point.num && i != second_point.num ){
                Point tmp_point = dots[i];
                Flat tmp_flat(first_point, second_point, tmp_point);
                double angle = get_angle(G, tmp_flat);
                if(angle < max_angle){
                    the_new_point = tmp_point;
                    max_angle = angle;
                }
            }
        }
        return the_new_point;
    }


    vector<Point> dots;
    size_t num_dots;
};

int main() {
    int num_tests = 0;   // Количество тестов
    cin >> num_tests;

    for(int test = 0; test < num_tests; test++) {
        size_t num_dots = 0;   // Количество точек в тесте
        cin >> num_dots;

        ConvexHull algo(num_dots);
        algo.read_dots();
        algo.print_convex();
    }
    return 0;
}