import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

class MapEntry<K extends Comparable<K>, E> implements Comparable<K> {

    K key;
    E value;

    public MapEntry(K key, E val) {
        this.key = key;
        this.value = val;
    }

    public int compareTo(K that) {
        @SuppressWarnings("unchecked")
        MapEntry<K, E> other = (MapEntry<K, E>) that;
        return this.key.compareTo(other.key);
    }

    public String toString() {
        return "<" + key + "," + value + ">";
    }
}

class OBHT<K extends Comparable<K>, E> {

    private MapEntry<K, E>[] buckets;
    static final int NONE = -1; // ... distinct from any bucket index.
    @SuppressWarnings({"rawtypes", "unchecked"})
    private static final MapEntry former = new MapEntry(null, null);
    private int occupancy = 0;

    @SuppressWarnings("unchecked")
    public OBHT(int m) {
        buckets = (MapEntry<K, E>[]) new MapEntry[m];
    }

    private int hash(K key) {
        return Math.abs(key.hashCode()) % buckets.length;
    }

    public MapEntry<K, E> getBucket(int i) {
        return buckets[i];
    }

    public int search(K targetKey) {
        int x = hash(targetKey);
        int n = 0;
        for (;;) {
            MapEntry<K, E> oldEntry = buckets[x];
            if (oldEntry == null) {
                return NONE;
            } else if (targetKey.equals(oldEntry.key)) {
                return x;
            } else {
                x = (x+1) % buckets.length;
                n++;
                if (n == buckets.length) {
                    return NONE;
                }
            }
        }
    }

    public void insert(K key, E val) {
        MapEntry<K, E> newEntry = new MapEntry<K, E>(key, val);
        int x = hash(key);
        int n = 0;

        for (;;) {
            MapEntry<K, E> oldEntry = buckets[x];
            if (oldEntry == null) {
                if (++occupancy == buckets.length) {
                    System.out.println("Hash tabelata e polna!!!");
                }
                buckets[x] = newEntry;
                return;
            } else if (oldEntry == former
                    || key.equals(oldEntry.key)) {
                buckets[x] = newEntry;
                return;
            } else {
                x = (x+1) % buckets.length;
                n++;
                if (n == buckets.length) {
                    return;
                }
            }
        }
    }

    @SuppressWarnings("unchecked")
    public void delete(K key) {
        int x = hash(key);
        int n = 0;
        for (;;) {
            MapEntry<K, E> oldEntry = buckets[x];

            if (oldEntry == null) {
                return;
            } else if (key.equals(oldEntry.key)) {
                buckets[x] = former;
                return;
            } else {
                x = (x+1) % buckets.length;
                n++;
                if (n == buckets.length) {
                    return;
                }
            }
        }
    }

    public String toString() {
        String pom = "";
        for (int i = 0; i < buckets.length; i++) {
            pom += i + ":";
            if (buckets[i] == null) {
                pom += "\n";
            } else if (buckets[i] == former) {
                pom += "former\n";
            } else {
                pom += buckets[i] + "\n";
            }
        }
        return pom;
    }
}

class Word implements Comparable<Word> {

    String word;


    public Word(String word) {
        this.word = word;
    }

    @Override
    public boolean equals(Object obj) {
        Word pom = (Word) obj;
        return this.word.equals(pom.word);
    }

    @Override
    public int hashCode() {
        char[] st = word.toCharArray();
        int suma = 0;
        for (int i = 0; i < st.length; i++) {
            suma += st[i];
        }
        return suma;
    }

    @Override
    public String toString() {
        return word;
    }

    @Override
    public int compareTo(Word arg0) {
        return word.compareTo(arg0.word);
    }
}

public class Preveduvac {

    public static void main(String[] args) throws IOException {
        OBHT<Word, String> tabela;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        //---Vie odluchete za goleminata na hesh tabelata----
        tabela = new OBHT<Word, String>(101);
        for (int i = 1; i <= N; i++) {
            String imelozinka = br.readLine();
            String[] pom = imelozinka.split(" ");
            tabela.insert(new Word(pom[1]), pom[0]);
        }
        ArrayList<Word> niza = new ArrayList<>();
        while (true) {
            String s = br.readLine();
            if (s.equals("KRAJ")) {
                break;
            }
            niza.add(new Word(s));
        }
        int y;
        for (int i = 0; i < niza.size(); i++) {
            y = tabela.search(niza.get(i));
            if (y == -1) {
                System.out.println("/");
            } else {
                System.out.println(tabela.getBucket(y).value);
            }
        }

    }
}