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

struct Sloka {
    Sloka() {}
    Sloka(int prvni, int druhy, int poradi)
        : PrvniRym(prvni), DruhyRym(druhy), Poradi(poradi),
        Skupina(-1), Propojeni(-1), Predchozi(-1) {}
    int PrvniRym;        // číslo prvního rýmu sloky
    int DruhyRym;        // číslo druhého rýmu sloky
    short int Poradi;    // pořadí sloky mezi variantami
    short int Skupina;   // skupina, do které sloka patří
    short int Propojeni; // skupina, s níž je sloka spojená; -1 pokud s žádnou
    short int Predchozi; // předchozí sloka (pro rekonstrukci řešení)
};

// porovnání podle prvního rýmu
bool PodlePrvniho(const Sloka &leva, const Sloka &prava)
{
    return leva.PrvniRym < prava.PrvniRym;
}

// porovnání podle druhého rýmu
bool PodleDruheho(const Sloka &leva, const Sloka &prava)
{
    return leva.DruhyRym < prava.DruhyRym;
}

int main()
{
    int N;
    scanf("%d", &N);

    std::vector<std::vector<Sloka>> V(N); // seznam všech variant

    // načtení variant
    int maxS = 0, min = 0;
    for (int i=0; i<N; i++) {
        int S;
        scanf("%d", &S);
        for (int j=0; j<S; j++) {
            int a, b;
            scanf("%d%d", &a, &b);
            V[i].push_back(Sloka(a, b, j));
        }
        // průběžně hledáne číslo sloky s nejmenším počtem variant
        if (V[i].size() < V[min].size()) min = i;
        // a také maximální velikost sloky
        if (S > maxS) maxS = S;
    }

    // otočíme vstup tak, abychom začínali slokou s nejmenším počtem variant
    std::rotate(V.begin(), V.begin() + min, V.end());

    // předzpracování
    for (int i=0; i<N-1; i++) {
        // setřídíme varianty
        std::sort(V[i].begin(), V[i].end(), PodleDruheho);
        std::sort(V[i+1].begin(), V[i+1].end(), PodlePrvniho);

        // nejdříve zařadíme sloky z V[i] do skupin
        int rym = -1, skupina = -1;
        for (int j=0; j<V[i].size(); j++) {
            if (V[i][j].DruhyRym != rym) {
                V[i][j].Skupina = ++skupina;
                rym = V[i][j].DruhyRym;
            } else {
                V[i][j].Skupina = skupina;
            }
        }

        // nyní spojíme sloky z V[i+1] s odpovídajícími skupinami
        int k = 0, l = 0;
        while (k < V[i].size() && l < V[i+1].size()) {
            if (V[i][k].DruhyRym == V[i+1][l].PrvniRym) {
                V[i+1][l].Propojeni = V[i][k].Skupina;
                ++l;
            } else if (V[i][k].DruhyRym < V[i+1][l].PrvniRym) {
                ++k;
            } else {
                ++l;
            }
        }
    }

    std::vector<short int> skupiny(maxS, -1); // výsledky pro jednotlivé skupiny
    std::vector<bool> R(maxS, false);         // množina R

    for (int prvni=0; prvni<V[0].size(); prvni++) {
	std::fill(R.begin(), R.begin() + V[0].size(), false);
        R[prvni] = true; // postupně zkoušíme jednotlivé varianty první sloky

        for (int i=0; i<V.size()-1; i++) {
            std::fill(skupiny.begin(), skupiny.begin()+V[i].size(), -1);

            // spočítáme, které skupiny obsahují aspoň jednu sloku,
            // která je v R, a rovnou si jednu z nich zapamatujeme
            for (int k=0; k<V[i].size(); k++) {
                if (R[k])
                    skupiny[V[i][k].Skupina] = k;
            }

            std::fill(R.begin(), R.begin()+V[i+1].size(), false);

            // do R dáme ty sloky, které jsou spojeny se skupinou,
            // která obsahuje aspoň jednu sloku z minulé verze R
            for (int k=0; k<V[i+1].size(); k++) {
                if (V[i+1][k].Propojeni >= 0 && skupiny[V[i+1][k].Propojeni] >= 0) {
                    V[i+1][k].Predchozi = skupiny[V[i+1][k].Propojeni];
                    R[k] = true;
                }
            }
        }

        // nyní máme R spočítanou a zjistíme, zda lze navázat na první sloku
        for (int i=0; i<V[N-1].size(); i++) {
            if (R[i] && V[N-1][i].DruhyRym == V[0][prvni].PrvniRym) {

                // našli jsme řešení, nyní ho zrekonstruujeme
                std::vector<short int> vysledek(N);
                short int aktualni = i;
                for (int k = N-1; k >= 0; --k) {
		    // kvůli třídění slok se původní pořadí mohlo změnit
                    vysledek[k] = V[k][aktualni].Poradi;
                    aktualni = V[k][aktualni].Predchozi;
                }

                // výslednou posloupnost musíme otočit zpátky tak,
		// aby začínala opět původní první slokou
                std::rotate(vysledek.begin(), vysledek.begin() +
		    ((vysledek.size() - min) % vysledek.size()), vysledek.end());

                for (int k = 0; k < N; k++)
                    printf("%d\n", vysledek[k] + 1);
                return 0; // stačilo najít libovolné řešení, takže můžeme skončit
            }
        }
    }

    printf("NEEXISTUJE\n"); // pokud se program dostal až sem, tak nenalezl řešení
    return 0;
}