#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>

using namespace std;

int nnode, root;
vector<int> P, DEG;
vector<vector<int> > neighbors;

int heapSize;
vector<int> H, REF;

void downHeapify( int n ) {
	while ( true ) {
		const int l = n * 2;
		const int r = n * 2 + 1;

		int m = n;
		if ( l <= heapSize && (DEG[H[l]] < DEG[H[m]] || (DEG[H[l]] == DEG[H[m]] && H[l] < H[m])) ) m = l;
		if ( r <= heapSize && (DEG[H[r]] < DEG[H[m]] || (DEG[H[r]] == DEG[H[m]] && H[r] < H[m])) ) m = r;
		if ( m == n ) break;

		const int cid = H[m];
		const int pid = H[n];
		H[n] = cid; REF[cid] = n;
		H[m] = pid; REF[pid] = m;
		n = m;
	}
}

void makeHeap() {
	heapSize = nnode;
	H.resize(nnode+1), REF.resize(nnode+1);
	for ( int u = 1; u <= nnode; u++ ) H[u] = REF[u] = u;
	for ( int u = heapSize/2; u >= 1; u-- ) downHeapify(u);
}

void decreaseKey( int u ) {
	int n = REF[u];
	int p = n / 2;

	while ( n > 1 && (DEG[H[n]] < DEG[H[p]] || DEG[H[n]] == DEG[H[p]] && H[n] < H[p]) ) {
		const int cid = H[n];
		const int pid = H[p];
		H[p] = cid, REF[cid] = p;
		H[n] = pid, REF[pid] = n;
		n = p, p = n / 2;
	}
}

int extractMin() {
	const int result = H[1];
	H[1] = H[heapSize];
	REF[H[1]] = 1;
	heapSize--;
	downHeapify(1);
	return result;
}


int main() {
	int n;

	while ( cin >> n ) P.push_back(n);
	nnode = P.size() + 1;

	neighbors.resize(nnode+1);
	DEG.assign(nnode+1, 0);

	root = P.back();
	for ( int i = 0; i < P.size(); i++ ) DEG[P[i]]++;
	for ( int u = 1; u <= nnode; u++ )
		if ( u != root ) DEG[u]++;

	makeHeap();
	for ( int i = 0; i < P.size(); i++ ) {
		const int cid = extractMin();
		const int pid = P[i];
		neighbors[cid].push_back(pid);
		neighbors[pid].push_back(cid);
		DEG[pid]--;
		decreaseKey(pid);
	}
	assert( extractMin() == root );

	for ( int u = 1; u <= nnode; u++ )
		sort(neighbors[u].begin(), neighbors[u].end());

	for ( int u = 1; u <= nnode; u++ ) {
		cout << u << ":";
		for ( int i = 0; i < neighbors[u].size(); i++ )
		cout << " " << neighbors[u][i];
		cout << endl;
	}

	return 0;
}