#include <stdio.h>
#include <stdlib.h>

// Implementacija atp List
//
// Potrebno je prvo pozvati initialize().
//
// Error kodovi:
// 101 - Nema više mjesta.
// 102 - Pokušaj pristupa poziciji koja ne postoji.

#define MAXLEN 10000

typedef int elementtype;
typedef int List;
typedef int position;

struct cellstruct {
    elementtype element;
    int next;
} space[MAXLEN];
int first_available;

void initialize() {
    int i;
    first_available = 0;
    for (i = 0; i < MAXLEN - 1; i++) {
        space[i].next = i + 1;
    }
    space[MAXLEN - 1].next = -1;
}

position LiEnd(List L) {
    int p = L;
    while (space[p].next != -1)
        p = space[p].next;
    return p;
}

position LiMakeNull(List* Lp) {
    int p = first_available;
    if (first_available == -1) exit(101);
    first_available = space[first_available].next;
    *Lp = p;
    space[p].next = -1;
    return p;
}

void LiInsert(elementtype x, position p, List* Lp) {
    int q = space[p].next;
    if (first_available == -1) exit(101);
    space[p].next = first_available;
    first_available = space[first_available].next;
    space[space[p].next].element = x;
    space[space[p].next].next = q;
}

void LiDelete(position p, List* Lp) {
    int q = space[p].next;
    space[p].next = space[q].next;
    space[q].next = first_available;
    first_available = q;
}

position LiFirst(List L) {
    return L;
}

position LiNext(position p, List L) {
    if (space[p].next == -1) exit(102);
    return space[p].next;
}

position LiPrevious(position p, List L) {
    int q = L;
    if (q == p) exit(102);
    while (space[p].next != q) {
        if (space[p].next == -1) exit(102);
        p = space[p].next;
    }
    return p;
}

elementtype LiRetrieve(position p, List L) {
    if (space[p].next == -1) exit(102);
    return space[space[p].next].element;
}

// Kraj implementacije List.


#define MAXN 10

void input(int* n, List lists[], int lens[]) {
    int i;
    elementtype x;
    position p;

    scanf("%d", n);
    for (i = 0; i < *n; i++) {
        p = LiMakeNull(&lists[i]);
        lens[i] = 0;
        while (1) {
            scanf("%d", &x);
            if (x == -1) break;
            LiInsert(x, p, &lists[i]);
            p = LiEnd(lists[i]);
            lens[i]++;
        }
    }
}

void output_lists(int n, List lists[], int lens[]) {
    int i;
    position p;

    for (i = 0; i < n; i++) {
        if (lens[i] == 0) continue;
        printf("L%d: ", i + 1);
        for (p = LiFirst(lists[i]); p != LiEnd(lists[i]); p = LiNext(p, lists[i]))
            printf("%d ", LiRetrieve(p, lists[i]));
        printf("\n");
    }
}

List merge_lists(List a, List b) {
    List c;
    position p, q, r = LiMakeNull(&c);

    while (1) {
        p = LiFirst(a);
        q = LiFirst(b);
        if (p == LiEnd(a) && q == LiEnd(b)) break;

        if (p == LiEnd(a)) {
            LiInsert(LiRetrieve(q, b), r, &c);
            LiDelete(q, &b);
        } else if (q == LiEnd(b)) {
            LiInsert(LiRetrieve(p, a), r, &c);
            LiDelete(p, &a);
        } else if (LiRetrieve(p, a) > LiRetrieve(q, b)) {
            LiInsert(LiRetrieve(q, b), r, &c);
            LiDelete(q, &b);
        } else {
            LiInsert(LiRetrieve(p, a), r, &c);
            LiDelete(p, &a);
        }
        r = LiEnd(c);
    }

    return c;
}

void huffmann(int n, List lists[], int lens[]) {
    int i, j, a, b, tmp;

    for (i = 0; i < n - 1; i++) {
        a = b = -1;
        for (j = 0; j < n; j++) {
            if (lens[j] == 0) continue;
            if (a == -1 || lens[j] < lens[a]) {
                b = a;
                a = j;
            } else if (b == -1 || lens[j] < lens[b]) {
                b = j;
            }
        }
        if (b == -1) break;
        if (a > b) {
            tmp = a;
            a = b;
            b = tmp;
        }
        lists[a] = merge_lists(lists[a], lists[b]);
        lens[a] += lens[b];
        lens[b] = 0;

        printf("Spajam L%d i L%d.\n", a + 1, b + 1);
        output_lists(n, lists, lens);
    }
}

int main() {
    int n, lens[MAXN];
    List lists[MAXN];

    initialize();
    input(&n, lists, lens);
    output_lists(n, lists, lens);
    huffmann(n, lists, lens);

    return 0;
}