#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <stack>
#include <set>
#include <stdlib.h>
#include <algorithm>
#include <stack>

using namespace std;

void Reverse_Sort(vector<pair<int, int>>& arr, int l, int r) {
    int i = l, j = r;
    int obj = arr[(l + r) / 2].second;

    while (i <= j) {
        while (arr[i].second > obj)
            i++;
        while (arr[j].second < obj)
            j--;
        if (i <= j) {
            swap(arr[i], arr[j]);
            i++;
            j--;
        }
    };

    if (l < j)
        Reverse_Sort(arr, l, j);

    if (i < r)
        Reverse_Sort(arr, i, r);
}

void Sort(vector<int>& arr, int l, int r) {
    int i = l, j = r;
    int obj = arr[(l + r) / 2];

    while (i <= j) {
        while (arr[i] < obj)
            i++;
        while (arr[j] > obj)
            j--;
        if (i <= j) {
            swap(arr[i], arr[j]);
            i++;
            j--;
        }
    };

    if (l < j)
        Sort(arr, l, j);

    if (i < r)
        Sort(arr, i, r);
}


int a = 1;






void dfs(vector<vector<bool>>& relations,int i,vector<pair<int, int>>& post, vector<bool>& used ){
    for (int j = 0; j < relations[i].size(); ++j) {
        if (relations[i][j]) {
            if (!used[j]) {
                used[j] = true;
                ++a;
                dfs(relations, j, post, used);
            }
        }
    }
    post[i].first=i+1;
    post[i].second=++a;
}

bool mymet(vector<vector<bool>>& relations, int pos_in_post, int k,vector<bool>& used, vector<vector<int>>& goal ){

    if(used[pos_in_post]) {

        goal[k].push_back(pos_in_post);
        used[pos_in_post] = false;

        for (int j = 0; j < relations[0].size(); ++j)
            if (relations[j][pos_in_post])
                if (used[j]) {
                    mymet(relations, j, k, used, goal);
                    return true;
                }
    }
    return false;
}



vector<vector<std::string>> getList(vector<string>& names, vector<vector<bool>>& relations)
{
    int n = relations[0].size();
    vector<pair<int, int>> post(n);

    vector<bool> used(n);

    vector<vector<int>> goal();

    used[0] = true;
    dfs(relations, 0, post, used);
    Reverse_Sort(post, 0, post.size()-1);
    int k=0;
    for (auto &i : post)
        if(!mymet(relations, i.first-1, k, used, goal()))
            ++k;
    for (auto &i : goal)
        Sort(i, 0, i.size()-1);
    vector<vector<string>> relust(goal.size());
    for(int i=0; i<goal.size(); ++i) {
        for (int j = 0; j < goal[i].size(); ++j)
            relust[i].push_back(names[goal[i][j]]);
    }

    return relust;
}







int main()
{

    vector<string> names = vector<string>();
    vector<vector<bool>> relations;
    int startIndex;

    ifstream fin;
    fin.open("input.txt");
    if (fin.is_open())
    {
        string str = "";
        getline(fin, str);

        while (str != "#")
        {
            names.emplace_back(str.substr(str.find(' ') + 1));
            getline(fin, str);
        }

        relations = vector<vector<bool>>(names.size());

        for (int i = 0; i < names.size(); i++)
        {
            relations[i] = vector<bool>(names.size());
            for (int j = 0; j < names.size(); j++)
                relations[i][j] = false;
        }

        getline(fin, str);

        while (fin)
        {
            int a = stoi(str.substr(0, str.find(' '))) - 1;
            int b = stoi(str.substr(str.find(' '))) - 1;
            relations[a][b] = true;
            getline(fin, str);
        }

        fin.close();
    }

    vector<vector<string>> res = getList(names, relations);

    fstream fout;
    fout.open("output.txt", ios::out);
    for (int i = 0; i < res.size(); i++)
    {
        for (int j = 0; j < res[i].size(); j++)
            fout << res[i][j] << "\n";
        fout << "\n";
    }
    fout.close();

    return 0;
}