#include <bits/stdc++.h>

using namespace std;

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

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

struct Pt
{
	int x, y;
	Pt operator+ (const Pt& p) const
	{
		return {x + p.x, y + p.y};
	}
	Pt operator- (const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
	Pt operator* (int d) const
	{
		return {x * d, y * d};
	}
};

int sgn(LL x)
{
	return (0 < x) - (x < 0);
}

LL cross(const Pt& p, const Pt& q)
{
	return (LL)p.x * q.y - (LL)p.y * q.x;
}

LL orient(Pt p, Pt q, Pt r)
{
	return cross(q - p, r - p);
}

bool properInter(const Pt& a, const Pt& b, const Pt& c, const Pt& d)
{
	LL oa = orient(c, d, a);
	LL ob = orient(c, d, b);
	LL oc = orient(a, b, c);
	LL od = orient(a, b, d);
	return sgn(oa) * sgn(ob) == -1
		&& sgn(oc) * sgn(od) == -1;
}

LL divFloor(LL a, LL b)
{
	assert(b != 0);
	if (b < 0)
	{
		a *= -1;
		b *= -1;
	}
	a--;
	LL res = a / b;
	if (b * res > a)
		res--;
	assert(b * res <= a && b * (res + 1) > a);
	return res;
}

int getX(const Pt& p1, const Pt& p2, LL y)
{
	LL res = divFloor((y - p1.y) * (p2.x - p1.x), p2.y - p1.y) + p1.x;
	assert(abs(res) <= 1e9);
	return res;
}

db getXDB(const Pt& p1, const Pt& p2, LL y)
{
	return (db)(y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y) + p1.x;
}

mt19937 rng;

int rand(int a, int b)
{
	return a + rng() % (b - a);
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int n;
	cin >> n;
	vector<Pt> p(n);
	VI a(n);
	FOR(i, 0, n)
		cin >> p[i].x >> p[i].y >> a[i];
	if (n == 1)
	{
		n++;
		p.PB({p[0].x + 4, p[0].y});
		a.PB(1);
	}
	VI sortedIndices(n);
	iota(ALL(sortedIndices), 0);
	Pt p0;
	while (true)
	{
		p0 = {rand(-1000, 1000), rand(2000, 2100)};
		sort(ALL(sortedIndices), [&](int i, int j)
		{
			return orient(p0, p[i], p[j]) > 0;
		});
		bool ok = true;
		FOR(i, 0, n - 1)
		{
			int j1 = sortedIndices[i], j2 = sortedIndices[i + 1];
			ok &= orient(p0, p[j1], p[j2]) > 0;
		}
		if (ok)
			break;
	}
	vector<vector<Pt>> ans(1);
	for (int i : sortedIndices)
	{
		ans.back().PB(p[i]);
		a[i]--;
	}
	for (int k = 1; *max_element(ALL(a)) > 0; k++)
	{
		ans.PB({});
		FOR(i, 0, 2 * n - 1)
		{
			if (i % 2 == 0)
			{
				int j = sortedIndices[i / 2];
				if (a[j] > 0)
				{
					a[j]--;
					ans.back().PB(p[j]);
				}
			}
			else
			{
				int j1 = sortedIndices[i / 2], j2 = sortedIndices[i / 2 + 1];
				ans.back().PB(p0 * (1 - 2 * k) + (p[j1] + p[j2]) * k);
			}
		}
	}
	cout << SZ(ans) << "\n";
	for (const auto& line : ans)
	{
		cout << SZ(line);
		for (const auto& [x, y] : line)
			cout << " " << x << " " << y;
		cout << "\n";
	}
	return 0;
}