//слияние последовательнсотей
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct Elem {
	int arr_n;
	int arr_pos;
	int v;
};

typedef struct Elem Elem;

int cmp(Elem a, Elem b) {
	return b.v - a.v;
}

struct PQ {
	Elem *heap;
	int cap;
	int count;
};

typedef struct PQ PQ;

PQ *initPQ(int n) {
	PQ *q = malloc(sizeof(PQ));
	q->heap = malloc(sizeof(Elem) * n);
	q->cap = n;
	q->count = 0;
	return q;
}

void freePQ(PQ *q) {
	free(q->heap);
	free(q);
}

void addPQ(PQ *q, Elem n) {
	int i = q->count;
	if (q->count == q->cap)
		perror("overflow");
	q->count = i + 1;
	q->heap[i] = n;
	while (i > 0 && cmp(q->heap[(i - 1) / 2], q->heap[i]) < 0) {
		Elem tmp = q->heap[(i - 1) / 2];
		q->heap[(i - 1) / 2] = q->heap[i];
		q->heap[i] = tmp;
		i = (i - 1) / 2;
	}
}

void heapify(int i, int n, Elem *heap) {
	while (1) {
		int l = 2 * i;
		int r = l + 1;
		int j = i;
		if (l < n && cmp(heap[i], heap[l]) < 0)
			i = l;
		if (r < n && cmp(heap[i], heap[r]) < 0)
			i = r;
		if (i == j)
			break;
		Elem tmp = heap[i];
		heap[i] = heap[j];
		heap[j] = tmp;
	}
}

Elem popPQ(PQ *q) {
	if (q->count == 0)
		perror("empty");
	Elem p = q->heap[0];
	q->count--;
	if (q->count > 0) {
		q->heap[0] = q->heap[q->count];
		heapify(0, q->count, q->heap);
	}
	return p;
}

int emptyPQ(PQ *q) {
	return q->count == 0;
}

int main(int argc, char **argv) {
	int n;
	scanf("%d", &n);
	int dims[n];
	int *arrs[n];
	for (int i = 0; i < n; i++) {
		scanf("%d", &dims[i]);
		arrs[i] = malloc(sizeof(int) * dims[i]);
	}
	PQ *q = initPQ(n);
	for (int i = 0; i < n; i++)
		if (dims[i]) {
			for (int k = 0; k < dims[i]; k++)
				scanf("%d", &arrs[i][k]);
			addPQ(q, (Elem) { i, 0, arrs[i][0] });
		}
	while(!emptyPQ(q)) {
		Elem m = popPQ(q);
		printf("%d ", m.v);
		if(++m.arr_pos < dims[m.arr_n]) {
			m.v = arrs[m.arr_n][m.arr_pos];
			addPQ(q, m);
		}
	}
	for (int i = 0; i < n; i++)
		free(arrs[i]);
	freePQ(q);
	return 0;
}