#include <fstream>
#include <algorithm>

using namespace std;

ifstream fin ("sortare.in"); ofstream fout ("sortare.out");

const int nmax = 5000;
int d[nmax + 1], u[nmax + 1];
int p[nmax + 1][ 3 ];

int ind, A, B, C, aux;
vector< int > v[nmax + 1];

void intercls (int dst, int x, int y, int loc_piv) {
    aux = 0;
    for (auto i : v[ x ]) {
        if (aux == loc_piv)
            ++ aux;

        v[ dst ][ aux ] = i;
        ++ aux;
    }
    v[ x ].clear();

    for (auto i : v[ y ]) {
        if (aux == loc_piv)
            ++ aux;

        v[ dst ][ aux ] = i;
        ++ aux;
    }
    v[ y ].clear();
}

int reconst (int lg) {
    if (lg == 0) return 0;
    if (lg == 1) {
        v[ ++ ind ].push_back( 1 );
        return ind;
    }

    int piv = u[ lg ];

    int u1 = reconst(piv - 1), u2 = reconst(lg - piv);
    for (auto &i : v[ u2 ]) {
        i += piv;
    }

    ++ ind;
    v[ ind ].resize( lg );
    A = p[ lg ][ 0 ]; B = p[ lg ][ 1 ]; C = p[ lg ][ 2 ];
    -- A, -- B, -- C;

    intercls (ind, u1, u2, B);
    v[ ind ][ B ] = piv;

    if (A < B && B < C) { // nu castiga prin majoritate, vreau v[A] < piv si piv < v[C]
        if (v[ ind ][ A ] > piv) {
            aux = v[ ind ][piv - 2];

            for (int i = piv - 1; i <= A; ++ i) {
                v[ ind ][i - 1] = v[ ind ][ i ];
            }
            v[ ind ][ A ] = aux;
        } else if (v[ ind ][ C ] < piv) {
            aux = v[ ind ][ piv ];

            for (int i = C + 1; i <= piv; ++ i) {
                v[ ind ][ i ] = v[ ind ][i - 1];
            }
            v[ ind ][ C ] = aux;
        }
    }

    return ind;
}

int main() {
    int n;

    fin >> n;
    for (int i = 2; i <= n; ++ i) {
        fin >> p[ i ][ 0 ] >> p[ i ][ 1 ] >> p[ i ][ 2 ];
        sort(p[ i ], p[ i ] + 3);
    }

    d[ 1 ] = d[ 0 ] = 1;
    for (int i = 2; i <= n; ++ i) {
        d[ i ] = 0;
        u[ i ] = -1;

        int l1 = 1, l2 = i;
        if (p[ i ][ 0 ] < p[ i ][ 1 ] && p[ i ][ 1 ] < p[ i ][ 2 ]) {
            l1 = 2; l2 = i - 1;
        }

        for (int j = l1; j <= l2; ++ j) {
            if (max(d[j - 1], d[i - j]) + 1 > d[ i ]) {
                u[ i ] = j;
                d[ i ] = max(d[j - 1], d[i - j]) + 1;
            }
        }
    }

    fout << d[ n ] << "\n";

    int unde = reconst( n );
    for (auto i : v[ unde ]) {
        fout << i << " ";
    }
    fout << "\n";

    fin.close();
    fout.close();
    return 0;
}