#include <fstream>
#include <vector>
#include <queue>
#include <tuple>
using namespace std;

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

inline int min(int a, int b, int c) {
	return std::min(a, std::min(b, c));
}

inline int max(int a, int b, int c) {
	return std::max(a, std::max(b, c));
}

vector< tuple<int, int, int> > Choice;
vector< int > Perm;
priority_queue<int> Heap;

int N, depth;

inline int GetTop() {

	int x = -Heap.top();
	Heap.pop();
	return x;
}

void Solve(int st, int dr, int d) {

	int len = dr - st + 1;

	if (len <= 2) {
		for (int i = st; i <= dr; ++i){
			Perm[i] = -Heap.top();
			Heap.pop();
		}
		depth = max(depth, d + len);
		return;
	}

	int MinVal, MidVal, MaxVal;
	while (!Heap.empty()) {
		int x = get<0>(Choice[len]);
		int y = get<1>(Choice[len]);
		int z = get<2>(Choice[len]);

		MinVal = min(x, y, z);
		MaxVal = max(x, y, z);
		MidVal = x + y + z - MinVal - MaxVal;

		int dif_st = MinVal - 1;
		int dif_dr = N - MaxVal;

		if (dif_st <= dif_dr) {
			Perm[st + MidVal - 1] = GetTop();
			Perm[st + MinVal - 1] = GetTop();
			Perm[st + MaxVal - 1] = GetTop();
		}
		else {
			Perm[st + MinVal - 1] = GetTop();
			Perm[st + MaxVal - 1] = GetTop();
			Perm[st + MidVal - 1] = GetTop();
		}
	}

	Solve(st, st + MidVal - 1, d + 1);
	Solve(MidVal + 1, dr, d + 1);
}

int main() {

	fin >> N;
	Choice.resize(N + 1);
	Perm.resize(N + 1);

	Heap.push(-1);

	int x, y, z;
	for (int i = 2; i <= N; ++i) {
		fin >> x >> y >> z;
		Choice[i] = make_tuple(x, y, z);
		Heap.push(-i);
	}

	Solve(1, N, 0);

	fout << depth < "\n";
	for (int i = 1; i <= N; ++i)
		fout << Perm[i] << " ";

    return 0;
}