#include <cstdio>
#include <iostream>
#include <cstring>
#include <fstream>
#include <set>
#include <array>
#include "json.hpp"

using namespace std;
using json = nlohmann::json;

const int MAXWORDN = 400;

enum State {UNKNOWN, WIN, LOSE};

map<string, size_t> wordmap;
vector<string> wordlist;
array<array<set<size_t>, MAXWORDN>, MAXWORDN> adj;
vector<string> idllist;
map<string, size_t> idlmap;
vector<size_t> firstword;
vector<size_t> lastword;
//array<int, MAXWORDN> in;
//array<int, MAXWORDN> out;
array<State, MAXWORDN> state; //0: unknown, 1: win on first hand, 2: lose on first hand
int n;  //num of word

void update_state(){
    state.fill((State)(0));
    while(true){
        bool flag = false;
        for(int i = 0; i < n; i++){
            if(state[i] != UNKNOWN){
                continue;
            }
            State s = LOSE;
            for(int j = 0; j < n; j++){
                if(!adj[i][j].empty()){
                    if(state[j] == LOSE){
                        s = WIN;
                        break;
                    }
                    if(state[j] == UNKNOWN && s == LOSE){
                        s = UNKNOWN;
                    }
                }
            }
            if(state[i] != s){
                state[i] = s;
                flag = true;
            }
        }
        if(!flag){
            break;
        }
    }
}

void count_edge(){
    size_t sum = 0;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            sum += adj[i][j].size();
        }
    }
    cout << sum <<endl;
}

void rmidl(size_t i){
    count_edge();
    size_t f = firstword[i];
    size_t l = lastword[i];
    adj[f][l].erase(i);
    update_state();
    count_edge();
}

size_t decision(string str){
    rmidl(idlmap[str]);
    size_t now = lastword[idlmap[str]];
    if(state[now] == WIN){
        for(int i = 0; i < n; i++){
            if(state[i] == LOSE && !adj[now][i].empty()){
                size_t ans = *adj[now][i].begin();
                rmidl(ans);
                return ans;
            }
        }
    }
    else if(state[now] == UNKNOWN){
        for(int i = 0; i < n; i++){
            if(state[i] == UNKNOWN && !adj[now][i].empty()){
                size_t ans = *adj[now][i].begin();
                rmidl(ans);
                return ans;
            }
        }
    }
    else{
        for(int i = 0; i < n; i++){
            if(!adj[now][i].empty()){
                size_t ans = *adj[now][i].begin();
                rmidl(ans);
                return ans;
            }
        }
    }
    return 0;
}


int main()
{

    std::ifstream fin("idl.json");
    json j;
    fin >> j;

    for(auto& [key, value] : j.items()){
        idllist.push_back(key);
        string first = value["first"];
        string last = value["last"];
        if(wordmap.find(first) == wordmap.end()){
            int idx = wordmap.size();
            wordmap[first] = idx;
            wordlist.push_back(first);
        }
        if(wordmap.find(last) == wordmap.end()){
            int idx = wordmap.size();
            wordmap[last] = idx;
            wordlist.push_back(last);
        }
        size_t idx = idllist.size() - 1;
        size_t f = wordmap[first];
        size_t l = wordmap[last];
        adj[f][l].insert(idx);
        //in[l] ++;
        //out[f] ++;
        firstword.push_back(f);
        lastword.push_back(l);
        idlmap[key] = idx;
        cout << key << " " << first << " " << last << endl;
        cout << idllist[idx] << " " << firstword[idx] << " " << lastword[idx] << endl;
        break;
    }

    n = wordlist.size();

    string str;
    cin >> str;
    while(true){
        str = idllist[decision(str)];
        cout << str << endl;
    }

    return 0;
}