#include <bits/stdc++.h>

#define endl '\n'
#define DEBUG_VAR(x) { cerr << "* "#x" = " << x << endl; }

using namespace std;
using LL = long long;


const int N = 1024;
constexpr int inf = 1E6;

int m, n;
char str[N];
bool isSure[N];

bool can[N][26];
int sureLimit[26]; // Y+G 确切
int unsure[26]; // Y+G 下界

template<class cap_t>
struct MaxFlowGraph
{
	vector<cap_t> cap;
	vector<int> one;
	vector<int> ver, nxt;
	int idx;

	int n;

	int S, T;
	vector<int> d, cur;

	static constexpr cap_t INF = numeric_limits<cap_t>::max();

	void reset(int n)
	{
		cap.clear(); ver.clear(); nxt.clear();
		idx = 0;
		this->n = n;
		one.clear(); one.resize(n); fill(one.begin(), one.end(), -1);
		d.clear(); d.resize(n);
	}

	MaxFlowGraph(int n) { this->reset(n); }

	void addEdge(int a, int b, cap_t c)
	{
		nxt.push_back(one[a]); ver.push_back(b); cap.push_back(c); one[a] = idx++;
		nxt.push_back(one[b]); ver.push_back(a); cap.push_back(0); one[b] = idx++;
	}

	bool bfs()
	{
		queue<int> q;
		fill(d.begin(), d.end(), -1);
		cur = one;

		q.push(S); d[S] = 1;
		while(q.size()) {
			int x = q.front(); q.pop();
			for(int i = one[x]; ~i; i = nxt[i]) {
				int y = ver[i];
				if(cap[i] > 0 && d[y] == -1) {
					d[y] = d[x]+1;
					q.push(y);
					if(y == T) return true;
				}
			}
		}
		return false;
	}
	
	cap_t dinic(int x, cap_t limit)
	{
		if(x == T) return limit;
		cap_t flow = 0;
		for(int i = cur[x]; ~i && flow < limit; i = nxt[i]) {
			int y = ver[cur[x] = i];
			if(cap[i] > 0 && d[y] == d[x]+1) {
				cap_t k = dinic(y, min(cap[i], limit-flow));
				if(!k) d[y] = -1;
				cap[i] -= k; cap[i^1] += k;
				flow += k;
			}
		}
		return flow;
	}

	cap_t maxFlow(int S, int T)
	{
		this->S = S, this->T = T;
		cap_t res = 0;
		while(bfs()) 
			res += dinic(S, INF);
		return res;
	}

	void bringOutAns(int n)
	{
		for (int i = 1; i <= n; ++i)
		{
			if (isSure[i]) continue;
			for (int j = one[i]; ~j; j = nxt[j])
				if (int k = ver[j]; k != T)
					if (cap[j])
						str[i] = 'a' + k - n - 1;
		}
	}
};


set<int> pos[26];

int main()
{
	// freopen("1.in", "r", stdin);
	cin >> m >> n;

	static char a[N], s[N];

	memset(sureLimit, -1, sizeof sureLimit);
	memset(unsure, 0, sizeof unsure);
	memset(can, true, sizeof can);

	while(--m) {
		scanf(" %s %s", a+1, s+1);

		int cnt[26];
		memset(cnt, 0, sizeof cnt);
		bool hasBlack[26];
		memset(hasBlack, false, sizeof hasBlack);

		for(int i = 1; i <= n; i++) {
			int c = a[i]-'a';
			if(s[i] == 'G') {
				str[i] = a[i];
				isSure[i] = true;
				cnt[c]++;
				pos[c].insert(i);
			} else {
				can[i][c] = false;
				if(s[i] == 'Y') {
					cnt[c]++;
				} else {
					hasBlack[c] = true;
				} 
			}
		}

		for(int i = 0; i < 26; i++) {
			if(hasBlack[i]) {
				sureLimit[i] = cnt[i];
			} else {
				unsure[i] = max(unsure[i], cnt[i]);
			}
		}
	}

	MaxFlowGraph<int> g(n+31);

	int S = n+27, T = n+28;
	int S_ = n + 29, T_ = n + 30;

	g.addEdge(T, S, inf);
	// g.addEdge(S_, S, inf), g.addEdge(T, T_, inf);
	for(int i = 0; i < 26; i++) {
		int id = n+i+1;
		if(sureLimit[i] != -1) {
			g.addEdge(S_, id, sureLimit[i]-(int)pos[i].size());
			g.addEdge(S, T_, sureLimit[i]-(int)pos[i].size());
			// sum += sureLimit[i];
		} else {
			g.addEdge(S_, id, unsure[i]-(int)pos[i].size());
			g.addEdge(S, T_, unsure[i]-(int)pos[i].size());
			g.addEdge(S, id, inf);
			// sum += unsure[i];
		}
	}

	for(int i = 1; i <= n; i++) {
		if(isSure[i]) continue;
		g.addEdge(S_, T, 1);
		g.addEdge(i, T_, 1);
	}

	for(int i = 1; i <= n; i++) {
		if(isSure[i]) {
			g.addEdge(n+(str[i]-'a')+1, i, 1);
			continue;
		}
		for(int j = 0; j < 26; j++) {
			if(!can[i][j]) continue;
			int id = n+j+1;
			g.addEdge(id, i, 1);
		}
	}

	g.maxFlow(S_, T_);
	// if(res < sum) {
	// 	assert(0);
	// }

	g.bringOutAns(n);
	

	printf("%s\n", str+1);
	return 0;
}