/*
 *  Take 5 (via mjd@cs.auckland.ac.nz)
 */
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <assert.h>

// #define DEBUG

using namespace std;

const static int MAXDIM=10;
static int grid[MAXDIM][MAXDIM];

typedef vector<char> vchar;

bool isAssigned(string sKey, vchar map) 
{ 
#ifdef DEBUG
cerr << "isAssigned(" << sKey << ")\n";
#endif
   int n=sKey.size(); 
   for (int i=0; i<n; i++)
   { 
     int index = sKey[i]-'A';
     if (map[index]==' ') return false;
   }       
#ifdef DEBUG
cerr << "is true\n";
#endif
   return true;
}

bool isMatch(string sKey, string dictWord, vchar map)
{
#ifdef DEBUG
cerr << "isMatch(" << sKey << "," << dictWord << ")\n";
#endif
   int n=sKey.size(); 
   assert(dictWord.size()==n);

   for (int i=0; i<n; i++)
   {
     int index = sKey[i]-'A';
     if (map[index]==' ') 
     {
       for (int j=0; j<26; j++) if (map[j]==dictWord[i]) return false;
       for (int j=i+1; j<n; j++)
	 if (sKey[j] == sKey[i] && dictWord[i] != dictWord[j]) return false;
     }
     else if (map[index] != dictWord[i]) return false;
   }
   return true;
}

int setMatch(string sKey, string dictWord, int num, vchar &map)
{
#ifdef DEBUG
cerr << "setMatch(" << sKey << "," << dictWord << ")\n";
#endif
   int cnt=0;  
   int n=sKey.size(); 

   for (int i=0; i<n; i++)
   {
     int index = sKey[i]-'A';
     if (map[index]==' ') 
     {
       map[index]=dictWord[i];
#ifdef DEBUG
cerr << "new map[" << index << "]=" << dictWord[i] << endl;
#endif
       cnt++;
     }
   }
   return cnt;
}

string assignedWord(string nextW, vchar map)
{
  int n=nextW.size();
  char c[11]; // [n+1];
  for (int i=0; i<n; i++) c[i]=map[nextW[i]-'A']; 
  c[n]=0;
  return string(c);
}

class Take5
{
public:

  vector<string> dict[11], words;
  int r, c; // row and column dimensions

  Take5(int n=0) {} 

  void getPuzzleWords();
  void printAnswer(vchar map);

   friend ostream& operator<<(ostream&, const Take5&);
   friend istream& operator>>(istream&, Take5&);
};

void Take5::getPuzzleWords()
{
  char cw[MAXDIM+1]; 

  // horizontal words
  for (int i=0; i<r; i++)
  {
    int startcol = 0; 
trynext:
    while (startcol<c && grid[i][startcol] == 0) startcol++;
    if (startcol>=c-1) continue;

    int stopcol = startcol+1;
    while (stopcol<c && grid[i][stopcol] != 0) stopcol++;
    if (--stopcol == startcol) { startcol++; goto trynext; }

    for (int k=startcol; k<=stopcol; k++) 
      cw[k-startcol]= (char) (grid[i][k]-1+'A');
    cw[stopcol-startcol+1]=0; string sw(cw);
    words.push_back(sw);

    if (stopcol < c-1) { startcol=stopcol+1; goto trynext; }
  }

  // vertical words
  for (int j=0; j<r; j++)
  {
    int startrow = 0; 
trynextV:
    while (startrow<r && grid[startrow][j] == 0) startrow++;
    if (startrow>=r-1) continue;

    int stoprow = startrow+1;
    while ( stoprow<r && grid[stoprow][j] != 0) stoprow++;
    if (--stoprow == startrow) { startrow++; goto trynextV; }

    for (int k=startrow; k<=stoprow; k++) 
      cw[k-startrow]= (char) (grid[k][j]-1+'A');
    cw[stoprow-startrow+1]=0; string sw(cw);
    words.push_back(sw);

    if (stoprow < r-1) { startrow=stoprow+1; goto trynextV; }
  }
  return;
}

void Take5::printAnswer(vchar map)
{
  for (int i=0; i<r; i++)  
  {
    for (int j=0; j<c; j++) 
    { 
      int idx = grid[i][j];
      if (idx==0) cout << ' ';
      else if (map[idx-1]==' ') cout << (char) (idx-1+'A');
      else cout << map[idx-1];
    }
    cout << endl;
  }
  cout << endl;
}

ostream& operator<<(ostream& o, const Take5& G)
{
  for (int s=2; s<=10; s++)    
  {      
    int n = G.dict[s].size(); 
//    o << "dict words[" << s << "] = " << n << "\n";
    for (int i=0; i<n; i++) o << G.dict[s][i] << endl;
  }   
  o << G.r << ' ' << G.c << endl;
  for (int i=0; i<G.r; i++)  
  {
    for (int j=0; j<G.c; j++) o << grid[i][j];
    o << endl;
  }
  int n = G.words.size(); 
  o << "match words = " << n << "\n";
  for (int i=0; i<n; i++) o << G.words[i] << endl;
  return o;
}

istream& operator>>(istream& in, Take5& G) 
{
  for (int i=0; i<11; i++) G.dict[i].resize(0);
  G.words.resize(0);
  int n;
  in >> n;
  if (n==0) exit(1);

  string w;
  for (int i=0; i<n; i++) 
  {
    in >> w;
    G.dict[w.size()].push_back(w);
  }

  int c;
  in >> G.r >> G.c;  
  for (int i=0; i<G.r; i++)  
  {
    for (int j=0; j<G.c; j++) { in >> c; grid[i][j] = c; }
  }
  return in;
}

Take5 me;

bool solvePuzzle(int numW, int numC, vchar map)
{
#ifdef DEBUG
cerr << "numW=" << numW << " numC=" << numC << endl;
me.printAnswer(map);
#endif

  int totW = me.words.size();
  
  if (numW == totW) { me.printAnswer(map); return true; }
  
  vchar Nmap(26);
  string nextW = me.words[numW];
  int lenW = nextW.size();

  if (isAssigned(nextW, map) && 
     (find(me.dict[lenW].begin(), me.dict[lenW].end(),
        assignedWord(nextW, map)) != me.dict[lenW].end() ))
  {
#ifdef DEBUG
cerr << "found assignedWord = " << assignedWord(nextW, map) << endl;
#endif
     return solvePuzzle(numW+1, numC, map);
  }
  else   
  {     
    for (int i=0; i<me.dict[nextW.size()].size(); i++)
    {
       if (isMatch(nextW, me.dict[lenW][i], map))
       {
	  Nmap = map;
	  int newC = setMatch(nextW, me.dict[lenW][i], numC, Nmap);
          if (solvePuzzle(numW+1, numC+newC, Nmap)) return true;
       }
    }	 
    return false;
  }
}

int main()
{
  while (true)
  {
    cin >> me;
    me.getPuzzleWords();
//    cout << me;

    vchar map(26);
    for (int i=0; i<26; i++) { map[i]=' '; } 
    assert( solvePuzzle(0, 0, map) );
  }
}