#include <bits/stdc++.h>

using namespace std;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VL = vector<LL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;

#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define F first
#define S second
#define FOR(i, a, b) for (int i = (a); i<(b); ++i)
#define RFOR(i, b, a) for (int i = (b)-1; i>=(a); --i)
#define FILL(a, b) memset(a, b, sizeof(a))

typedef double db;

const db EPS = 1e-9;

struct Point {
	db x, y, z;
	Point() {}
	Point(db _x, db _y, db _z): x(_x), y(_y), z(_z) {}
	Point operator+(const Point& p) const {
		return {x + p.x, y + p.y, z + p.z};
	}
	Point operator-(const Point& p) const {
		return {x - p.x, y - p.y, z - p.z};
	}
	Point operator*(db k) const {
		return {k * x, k * y, k * z};
	}
	Point operator*(const Point& p) const {
		return {y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x};
	}
	db d2() const {
		return x * x + y * y + z * z;
	}
	db len() const {
		return sqrt(d2());
	}
};

db findArea(const Point& p1, const Point& p2, const Point& p3) {
	return ((p3 - p1) * (p2 - p1)).len();
}

db mixedProduct(const Point& p1, const Point& p2, const Point& p3) {
	return p1.x * p2.y * p3.z + p1.y * p2.z * p3.x + p1.z * p2.x * p3.y
		- p1.z * p2.y * p3.x - p1.x * p2.z * p3.y - p1.y * p2.x * p3.z;
}

int sgn(db x) {
	return x > EPS ? 1 : (x < -EPS ? -1 : 0);
}

bool strictlyInside(const vector<Point>& tr, const Point& p, db area) {
	db sumArea = 0;
	FOR(j, 0, 3) {
		db curArea = findArea(p, tr[j], tr[(j + 1) % 3]);
		if (curArea / area < EPS) {
			return false;
		}
		sumArea += curArea;
	}
	return sgn(sumArea / area - 1) == 0;
}

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	vector<Point> p(6);
	for (Point& pi : p) {
		cin >> pi.x >> pi.y >> pi.z;
	}
	vector<pair<int, int>> ans;
	FOR(m, 1, 6) FOR(n, m + 1, 6) {
		vector<Point> tr1 = {p[0], p[m], p[n]}, tr2;
		FOR(i, 1, 6) {
			if (i != m && i != n) {
				tr2.push_back(p[i]);
			}
		}
		db area = findArea(tr2[0], tr2[1], tr2[2]);
		if (findArea(tr1[0], tr1[1], tr1[2]) < EPS || area < EPS) {
			continue;
		}
		int cntEdges = 0, cntVertices = 0;
		FOR(i, 0, 3) {
			const Point& q1 = tr1[i], q2 = tr1[(i + 1) % 3], q3 = tr1[(i + 2) % 3];
			db prod1 = mixedProduct(tr2[0] - q1, tr2[1] - q1, tr2[2] - q1),
				prod2 = mixedProduct(tr2[0] - q2, tr2[1] - q2, tr2[2] - q2);
			int s1 = sgn(prod1 / area), s2 = sgn(prod2 / area);
			if (s1 * s2 != -1) {
				continue;
			}
			double alpha = prod2 / (prod2 - prod1);
			assert(alpha > EPS && alpha < 1 - EPS);
			Point q = q1 * alpha + q2 * (1 - alpha);
			assert(sgn(mixedProduct(tr2[0] - q, tr2[1] - q, tr2[2] - q) / area) == 0);
			if (strictlyInside(tr2, q, area)) {
				cntEdges++;
			}
			if (strictlyInside(tr2, q3, area)) {
				cntVertices++;
			}
		}
		if (cntEdges + cntVertices == 1) {
			ans.emplace_back(m, n);
		}
	}
	cout << SZ(ans) << "\n";
	for (auto [m, n] : ans) {
		cout << m + 1 << " " << n + 1 << "\n";
	}
}