#include <stdio.h>
#include <string.h>

#define ALPHABET_SIZE ('z'-'a'+1)   // Velikost abecedy
#define MAX_WORD_LEN 10001          // Maximální velikost dotazu nebo slova v seznamu

struct WORD
{
   char *word;    // Vlastní slovo
   int lex_id;    // Jeho lexikografické pořadí
};

struct TRIE_NODE
{
   TRIE_NODE() 
   { 
      for (int i=0; i<ALPHABET_SIZE; i++)
         sons[i] = NULL;
      word = NULL;
   }

   TRIE_NODE *sons[ALPHABET_SIZE];  // Synové uzlu
   WORD *word;     // Obsahuje pointer na slovo, které v daném uzlu končí, nebo NULL
   WORD *min_word; // Minimální slovo v postromu uzlu
};

// Přidání slova do trie
void trie_add(TRIE_NODE *root, WORD *word)
{
   char *word_iter = word->word;
   while (*word_iter)
   {
      int son_id = *word_iter-'a';
      if (root->sons[son_id] == NULL)
         root->sons[son_id] = new TRIE_NODE;
      root = root->sons[son_id];
      word_iter++;
   }
   root->word = word;
}

// Lexikografické očíslování slov přidaných do trie
void trie_sort(TRIE_NODE *root, int &id)
{
   if (root->word)
      root->word->lex_id = id++;
   for (int i=0; i<ALPHABET_SIZE; i++)
      if (root->sons[i])
         trie_sort(root->sons[i], id);
}

// Pro každý uzel najdeme nejmenší slovo v jeho podstromu
void trie_construct_min_words(TRIE_NODE *root)
{
   WORD *min_word = NULL;
   for (int i=0; i<ALPHABET_SIZE; i++)
      if (root->sons[i])
      {
         trie_construct_min_words(root->sons[i]);
         if (min_word==NULL || min_word->lex_id>root->sons[i]->min_word->lex_id)
            min_word = root->sons[i]->min_word;
      } 
   if (min_word==NULL || (root->word!=NULL && min_word->lex_id>root->word->lex_id))
      min_word = root->word;
      
   root->min_word = min_word;  
}

// Otočení slova
void reverse_word(char *word)
{
   char *start = word;
   char *end = word + strlen(word) - 1;
   while (start < end)
   {
      char tmp = *end;
      *end = *start;
      *start = tmp; 
      start++; end--;
   }
}

// Nalezení minimálního slova s nejdelším společným úsekem k danému slovu
void trie_find_min(TRIE_NODE *root, char *to_search)
{
   while (root->sons[*to_search-'a'])
      root = root->sons[*to_search++ -'a'];
   
   char to_print[MAX_WORD_LEN];
   strcpy(to_print, root->min_word->word);
   reverse_word(to_print);
   printf("%s\n", to_print);
}

int main()
{
   int dict_size, query_count;
   scanf("%d %d", &dict_size, &query_count);
   WORD *dictionary = new WORD[dict_size];
   
   TRIE_NODE *sorting_trie = new TRIE_NODE;
   char input[MAX_WORD_LEN];
   for (int i=0; i<dict_size; i++)
   {
      scanf("%s", input);
      dictionary[i].word = new char[strlen(input)+1];
      strcpy(dictionary[i].word, input);
      trie_add(sorting_trie, &dictionary[i]);
   }
   int lex_id = 0;
   trie_sort(sorting_trie, lex_id);
   
   TRIE_NODE *searching_trie = new TRIE_NODE;
   for (int i=0; i<dict_size; i++)
   {
      reverse_word(dictionary[i].word);      
      trie_add(searching_trie, &dictionary[i]);
   }
   trie_construct_min_words(searching_trie);
   
   char fake_nelze[] = "EZLEN";
   WORD fake_root_min_word;
   fake_root_min_word.word = fake_nelze;
   searching_trie->min_word = &fake_root_min_word;
   
   for (int i=0; i<query_count;i++)
   {
      scanf("%s", input);
      reverse_word(input);
      trie_find_min(searching_trie, input);
   }

   return 0;
}