#include <algorithm>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <new>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;

int main() {
  map<string, string> dict;
  ifstream i("dictionary");
  string eng, cz;
  while (i >> eng >> cz) {
    dict[eng] = cz;
  }
  string in;
  while (cin >> in) {
    #if 0
    auto i = dict.find(in);
    if(i != dict.end()){
      cout << i->second << endl;
    } else {
      cout << in << endl;
    }
    #else
    auto i = dict.lower_bound(in);
    if(i != dict.end() && (i->first.substr(0, in.length()) == in)){
      cout << i->second << endl;
    } else {
      cout << in << endl;
    }
    #endif
  }
  return 0;
}

int main4() {
  ifstream i("input.txt");
  string line;
  std::set<string> s;
  while(std::getline(i, line)) {
    s.emplace(line);
  }
  for (const string& uniqueLine : s) {
    cout << uniqueLine;
    cout << '\n';
  }
  return 0;

}


int main3(){
  ofstream o("table.txt");
  for(int i=0; i<11; i++){
    for(int ii=0; ii<11; ii++){
      o << i*ii << '\t';
    }
    o << std::endl;
  }
  o.close();
  return 0;

}


/* mergesort, merge function */

list<string> merge(list<string> &list1, list<string> &list2) {
  list<string> result;
  /* iterate through the list until there is at least something in both */
  while (!list1.empty() && !list2.empty()) {
    if (list1.front() < list2.front()) {
      result.splice(result.end(), list1, list1.begin());
    } else {
      result.splice(result.end(), list2, list2.begin());
    }
  }

  /* consolidate the results */
  while (!list1.empty()) {
    result.splice(result.end(), list1, list1.begin());
  }

  while (!list2.empty()) {
    result.splice(result.end(), list2, list2.begin());
  }
  return result;
}

/*
 A sketch of the algorithm (iterated mergesort with a queue):
 [2,1,3,4] ::list<int>
 [[2], [1], [3], [4]]  :: list<list<int>>
 [[3],[4],[1,2]]
 [[1,2],[3,4]]
 [[1,2,3,4]]
*/

void mergesort(list<string> &l) {
  list<list<string>> ll; //we could also use an actual queue. :]

  while (!l.empty()) {
    list<string> tmp;
    tmp.emplace_back(std::move(l.front()));
    ll.emplace_back(std::move(tmp));
    l.pop_front();
  }

  while(ll.size() > 1){
    auto temp1 = std::move(ll.front());
    ll.pop_front();
    auto temp2 = std::move(ll.front());
    ll.pop_front();
    ll.emplace_back(merge(temp1, temp2));
  }

  l = std::move(ll.front());
}


/* this mergesorts the words from the input */
int main2() {
  std::list<string> lines;
  string line; //no matter they are called lines
  while(cin >> line) {
    lines.push_back(line);
  }

  mergesort(lines);

  for (const string &s: lines) {
    cout << s << endl;
  }
  return 0;

}

/* string with move semantics */
class String {
  char *s;

  void assign(const char *str) {
    if (!str)
      goto empty;

    size_t length;
    for (length = 0; str[length]; length++)
      ;
    if (!length)
      goto empty;

    s = new char[length + 1];
    for (size_t i = 0; i <= length; i++) {
      s[i] = str[i];
    }
    return;

  empty:
    s = nullptr;
  }

public:
  String() : s(nullptr) {
    std::cerr << "Empty string @" << this << std::endl;
  }

  String(const String &x) {
    assign(x.s);
    std::cerr << "Copy construction @" << this << std::endl;
  }

  String(String &&x) {
    s = x.s;
    x.s = nullptr;
    std::cerr << "Move construction @" << this << std::endl;
  }

  String(const char *str) {
    assign(str);
    std::cerr << "Copy from buffer @" << this << std::endl;
  }

  ~String() {
    clear();
    std::cerr << "Destruction @" << this << std::endl;
  }

  void operator=(const String &second) {
    clear();
    assign(second.c_str());
    std::cerr << "Copy assignment @" << this << std::endl;
  }

  void operator=(String &&second) {
    std::swap(s, second.s);
    std::cerr << "Move assignment @" << this << std::endl;
  }

  void clear() {
    if (empty())
      return;
    delete[] s;
    s = nullptr;
  }

  const char *c_str() const { return s; }

  bool empty() const { return !s; }

  char &operator[](size_t i) { return s[i]; }

  const char &operator[](size_t i) const { return s[i]; }

  size_t length() const {
    if (!s)
      return 0;
    size_t len = 0;
    while (s[len])
      ++len;
    return len;
  }

  void operator+=(const String &second) {
    std::cerr << "Addition += @" << this << std::endl;
    size_t len1 = length();
    size_t len2 = second.length();
    if (!len1 && !len2)
      return;
    char *s2 = new char[len1 + len2 + 1];
    for (size_t i = 0; i < len1; i++)
      s2[i] = s[i];
    for (size_t i = 0; i < len2; i++)
      s2[i + len1] = second.s[i];
    s2[len1 + len2] = 0;
    clear();
    s = s2;
  }

  String operator+(const String &second) const {
    String temp(*this);
    temp += second;
    return temp;
  }

  bool operator==(const String &other) {
    std::cerr << "Comparison == @" << this << std::endl;
    char *p = s, *q = other.s;
    if (!(p && q))
      return p == q;
    for (; *p && *q; p++, q++)
      if (*p != *q)
        return false;
    if (*p != *q)
      return false;
    return true;
  }

  bool operator<(const String &other) {
    std::cerr << "Comparison < @" << this << std::endl;
    char *p = s, *q = other.s;
    if (!(p && q))
      return p < q;
    for (; *p && *q; p++, q++) {
      if (*p == *q)
        continue;
      if (*p > *q)
        return false;
      return true;
    }
    return *p < *q;
  }
};

String reverse(const String &str) {
  String r = String(str.c_str());
  size_t len = r.length();
  for (size_t i = 0; i < len / 2; i++) {
    std::swap(r[i], r[len - i - 1]);
  }
  return r;
}

std::ostream &operator<<(std::ostream &os, const String &s) {
  if (!s.empty())
    os << s.c_str();
  return os;
}

int main5() {
  String a("test");
  String b("aaa");
  std::cerr << " *** Add" << std::endl;
  a += b;
  std::cerr << " *** Reverse" << std::endl;
  b = reverse(a);
  std::cerr << " *** Paste and print" << std::endl;
  std::cout << (reverse(b) + b + "aaa") << std::endl;

  std::cerr << " *** Creating a vector" << std::endl;
  std::vector<String> v;
  v.push_back("test");
  v.push_back("test2");
  v.push_back("asd");
  v.emplace_back("qwe");
  v.emplace_back();
  v.push_back("zxc");

  std::cerr << " *** Vector copy" << std::endl;
  std::vector<String> v2 = v;

  std::cerr << " *** Vector sort" << std::endl;
  std::sort(v2.begin(), v2.end());
  for (auto &i : v2)
    std::cout << "> " << i << std::endl;

  std::cerr << " *** Clear a vector" << std::endl;
  v.clear();

  std::cerr << " *** End" << std::endl;
  return 0;
}