#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <iterator>

using namespace std;

struct node{
    map<char, int> next;
    int cnt=0;
};

struct tr{
    vector<node> go;
    tr(){
        go.resize(1);
    }
    void add_str(string &s){
        int q=0;
        for(char ch: s){
            if(!go[q].next.count(ch)){
                go[q].next[ch]=go.size();
                q=go.size();
                go.resize(go.size()+1);
            }
            else{
                go[q].next[ch];
            }
        }
        ++go[q].cnt;
    }
};


bool dfs(vector<string> &grid, vector<vector<int>> &used, int i, int j, vector<node> &go, int q){
    if(used[i][j]){
        return false;
    }
    used[i][j]=1;
    if(go[q].cnt){
        --go[q].cnt;
        return true;
    }

    int n=used.size(), m=used[0].size();

    if(i<n-1 && go[q].next.count(grid[i+1][j])){
        bool res=dfs(grid, used, i+1, j, go, go[q].next[grid[i+1][j]]);
        if(res){
            return true;
        }
    }

    if(i>0 && go[q].next.count(grid[i-1][j])){
        bool res=dfs(grid, used, i-1, j, go, go[q].next[grid[i-1][j]]);
        if(res){
            return true;
        }
    }

    if(j<m-1 && go[q].next.count(grid[i][j+1])){
        bool res=dfs(grid, used, i, j+1, go, go[q].next[grid[i][j+1]]);
        if(res){
            return true;
        }
    }

    if(j>0 && go[q].next.count(grid[i][j-1])){
        bool res=dfs(grid, used, i, j-1, go, go[q].next[grid[i][j-1]]);
        if(res){
            return true;
        }
    }


    used[i][j]=0;
    return false;
}

int main()
{
    int n, m, p; cin>>n>>m>>p;

    vector<string> grid(n);
    vector<vector<int>> used(n, vector<int> (m, 0));
    tr trie;

    for(int i=0; i<n; ++i)
        cin>>grid[i];

    for(int i=0; i<p; ++i){
        string s; cin>>s;
        trie.add_str(s);
    }

    for(int i=0; i<n; ++i)
        for(int j=0; j<m; ++j)
            if(trie.go[0].next.count(grid[i][j]))
                dfs(grid, used, i, j, trie.go, trie.go[0].next[grid[i][j]]);

    vector<char> ans;
    for(int i=0; i<n; ++i)
        for(int j=0; j<m; ++j)
            if(!used[i][j])
                ans.push_back(grid[i][j]);

    sort(ans.begin(), ans.end());

    copy(ans.begin(), ans.end(), ostreambuf_iterator<char>(cout));


    return 0;
}