#include <iostream>
#include <utility>
#include <vector>
#include <fstream>
using namespace std;

ifstream in("interclasari.in");
ofstream out("interclasari.out");


int parinte(int i ){
    return (i-1) /2;
}

int left(int i){
    return 2*i + 1;
}

int right(int i){
    return 2*i + 2;
}

struct Element{
    int val; // valoarea
    int direct; // directorul de unde provine
    int index; // indexul in director

    Element(int val,int direct,int index){
        this->val = val;
        this->direct =direct;
        this->index = index;
    }
};

void up(vector<Element> &a, int i ){
    while(i != 0 && a[parinte(i)].val > a[i].val){
        swap(a[parinte(i)], a[i]);
        i = parinte(i);
    }
}

void adaugaElement(vector<Element> &a,Element element){
    a.push_back(element);
    up(a,a.size()-1);
}

void down(vector<Element> &a , int i , int heapsize){
    int l = left(i);
    int r = right(i);
    int smallest = i;
    if(l < heapsize && a[l].val < a[smallest].val){
        smallest = l;
    }
    if(r < heapsize && a[r].val < a[smallest].val){
        smallest = r;
    }
    if(smallest != i ){
        swap(a[smallest], a[i]);
        down(a,smallest,heapsize);
    }
}

void removeMinim(vector<Element>&a){
    if(a.empty()){
        return;
    }
    swap(a[0] , a[a.size()-1]);
    a.pop_back();
    down(a,0,a.size());
}

Element getMinim(vector <Element> a){
    if(a.empty()){
        return Element(-1,-1,-1);
    }
    return a[0];
}

int main(){

    int k;
    in>>k;
    vector<vector<int>> directoare(k);
    int total = 0;
    for(int i = 0 ; i< k ; i++){
        int n;
        in>>n;
        total += n;
        directoare[i].resize(n);
        for(int j = 0 ; j < n ; j++){
            in>>directoare[i][j];
        }
    }
    vector<Element> heap;
    vector<int> interclasat(total);

    for(int i =0 ; i <k ; i++){
        if(!directoare[i].empty()){
            Element element = Element(directoare[i][0],i,0);
            adaugaElement(heap, element);
        }
    }
    int idx_curent = 0;
    while(!heap.empty()){
        Element curent = getMinim(heap);
        if(curent.val == -1){
            break;
        }
        interclasat[idx_curent] = curent.val;
        idx_curent ++;
        removeMinim(heap);
        if(directoare[curent.direct].size() > curent.index + 1){
            Element nou_heap = Element(directoare[curent.direct][curent.index + 1], curent.direct , curent.index + 1);
            adaugaElement(heap, nou_heap);
        }
    }

    for(auto element:interclasat){
        out<<element<< " ";
    }


    return 0;
}