#include <bits/stdc++.h>
using namespace std;

#define MAY_BE_HERE     0
#define MUST_BE_HERE    1
#define CANNOT_BE_HERE  2

char guess[600], reply[600];
int f[26][600];
int cnt_min[26], cnt_max[26];
char ans[600];











template <typename Cap = int64_t>
class Dinic{
public:
	struct E{
		int to, rev;
		Cap cap;
	};
	int n, st, ed;
	vector<vector<E>> G;
	vector<int> lv, idx;
	vector<pair<int, int>> egs;
	bool BFS(){
		lv.assign(n, -1);
		queue<int> bfs;
		bfs.push(st); lv[st] = 0;
		while (not bfs.empty()){
			int u = bfs.front(); bfs.pop();
			for (auto e: G[u]) {
				if (e.cap <= 0 or lv[e.to]!=-1) continue;
				bfs.push(e.to); lv[e.to] = lv[u] + 1;
			}
		}
		return lv[ed] != -1;
	}
	Cap DFS(int u, Cap f){
		if (u == ed) return f;
		Cap ret = 0;
		for(int &i = idx[u]; i < int(G[u].size()); ++i) {
			auto &e = G[u][i];
			if (e.cap <= 0 or lv[e.to]!=lv[u]+1) continue;
			Cap nf = DFS(e.to, min(f, e.cap));
			ret += nf; e.cap -= nf; f -= nf;
			G[e.to][e.rev].cap += nf;
			if (f == 0) return ret;
		}
		if (ret == 0) lv[u] = -1;
		return ret;
	}
public:
	void init(int n_) { G.assign(n = n_, vector<E>()); egs.clear(); }
	void add_edge(int u, int v, Cap c){
		G[u].push_back({v, int(G[v].size()), c});
		G[v].push_back({u, int(G[u].size())-1, 0});
		egs.emplace_back(v, int(G[v].size()) - 1);
	}
	Cap max_flow(int st_, int ed_){
		st = st_, ed = ed_; Cap ret = 0;
		while (BFS()) {
			idx.assign(n, 0);
			Cap f = DFS(st, numeric_limits<Cap>::max());
			ret += f;
			if (f == 0) break;
		}
		return ret;
	}
	Cap flow_at(int eid) const {
		return G[egs[eid].first][egs[eid].second].cap;
	}
};
Dinic<long long> dinic;


























// S = 0
// 10..35, 40
// 100..100+len-1
// T = 1000
void add_edge(int u, int v, int cap) {
    dinic.add_edge(u, v, cap);
}

vector<int> graph[2000];
void my_add_edge(int u, int v) {
    graph[u].push_back(v);
    graph[v].push_back(u);
}



int zzk(int x) {
    if (x > 0 && x < 100) return x;
    for (int o: graph[x]) {
        return zzk(o);
    }
    return 0;
}


void solve()
{
    int g, len;
    for (int i=0; i<26; i++) cnt_min[i] = 0, cnt_max[i] = 600;
    scanf("%d%d", &g, &len);
    for (int tt=1; tt<g; tt++) {
        scanf("%s%s", guess, reply);
        vector<int> cnt(26), max_flag(26);
        for (int i=0; i<len; i++) {
            int ch = guess[i] - 'a';
            if (reply[i] == 'G') {
                f[ch][i] = MUST_BE_HERE;
                for (int j=0; j<26; j++) if (j != ch) f[j][i] = CANNOT_BE_HERE;
                ans[i] = ch+'a';
                cnt[ch]++;
            }
            else if (reply[i] == 'Y') {
                f[ch][i] = CANNOT_BE_HERE;
                cnt[ch]++;
            }
            else {
                f[ch][i] = CANNOT_BE_HERE;
                max_flag[ch] = 1;
            }
        }
        for (int i=0; i<26; i++) {
            cnt_min[i] = max(cnt_min[i], cnt[i]);
            if (max_flag[i]) cnt_max[i] = cnt[i];
        }
    }

    dinic.init(1005);

    map<int, int> free_to_use;
    int need_free = len;
    for (int i=0; i<26; i++) {
        int rest_min = cnt_min[i];
        int flag_max = (cnt_min[i] == cnt_max[i]);

        for (int j=0; j<len; j++) if (f[i][j] == MUST_BE_HERE) rest_min--, need_free--;

        if (rest_min > 0) {
            add_edge(0, 10+i, rest_min);
            need_free -= rest_min;
            for (int j=0; j<len; j++) if (f[i][j] == MAY_BE_HERE)
                add_edge(10+i, 100+j, 1);
        }

        if (!flag_max) {
            for (int j=0; j<len; j++) if (f[i][j] == MAY_BE_HERE)
                free_to_use[j] = i;
        }
    }
    if (need_free > 0) {
        add_edge(0, 40, need_free);
        for (auto [i, _]: free_to_use)
            add_edge(40, 100+i, 1);
    }
    for (int i=0; i<len; i++) {
        add_edge(100+i, 1000, 1);
    }

    int mxflow = dinic.max_flow(0, 1000);



    /*
    for (int u=0; u<=1000; u++) if (graph[u].size()) {
        printf("[%d]\n", u);
        for (auto [v, w]: graph[u])
            printf("\t[%4d] %d\n", v, w);
    }
    printf("%d\n", mxflow);
    */
    
    int en = dinic.egs.size();
    for (int eid=0; eid<en; eid++) if (dinic.flow_at(eid) > 0) {
        auto [v, id] = dinic.egs[eid];
        int u = dinic.G[v][id].to;
        my_add_edge(u, v);
        //printf("%d %d\n", u, v);
    }


    for (int i=0; i<len; i++) if (!ans[i]) {
        int ch = zzk(100+i);
        if (ch == 40) ans[i] = free_to_use[i] + 'a';
        else ans[i] = ch-10+'a';
    }
    ans[len] = '\0';

    printf("%s\n", ans);

}




int main()
{
    solve();
    return 0;
}