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

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define subnb true
#define Lnb true
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
const int N = 505, INF = (int)1e9;

struct edge {
    int to, cap, rev;
    edge(int _to, int _cap, int _rev) {
        to = _to, cap = _cap, rev = _rev;
    }
};

struct Dinic {
    vector<vector<edge>> G;
    vi level, iter;

    Dinic(int n) : G(n), level(n), iter(n) {}

    void add_edge(int from, int to, int cap) {
        G[from].push_back(edge(to, cap, sz(G[to])));
        G[to].push_back(edge(from, 0, sz(G[from]) - 1));
    }

    void bfs(int s) {
        fill(all(level), -1);
        queue<int> que;
        level[s] = 0;
        que.push(s);
        while(!que.empty()) {
            int v = que.front(); que.pop();
            for (auto &e : G[v]) {
                if(e.cap > 0 && level[e.to] < 0) {
                    level[e.to] = level[v] + 1;
                    que.push(e.to);
                }
            }
        }
    }

    int dfs(int v, int t, int f) {
        if(v == t) return f;
        for (int &i = iter[v]; i < sz(G[v]); i++) {
            edge &e = G[v][i];
            if(e.cap > 0 && level[v] < level[e.to]) {
                int d = dfs(e.to, t, min(e.cap, f));
                if(d > 0) {
                    e.cap -= d;
                    G[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }

    int max_flow(int s, int t) {
        int flow = 0;
        for(;;) {
            bfs(s);
            if(level[t] < 0) return flow;
            fill(all(iter), 0);
            int f;
            while((f = dfs(s, t, INF)) > 0) {
                flow += f;
            }
        }
    }
};


int k, n;
string str[N], col[N];
int res[N];
int in[26], want[26];
int block[N][26];
int lower[N], upper[N];
int cnt[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);


    cin >> k >> n;
    k--;
    rep(i, 0, k) {
        cin >> str[i] >> col[i];
    }
    fill(res, res + n, -1);
    rep(i, 0, k) {
        rep(j, 0, n) {

        }
    }
    Dinic flow(n + 26 + 3);
    int s = n + 26, t = s + 1, smid = t + 1;

    fill(upper, upper + 26, INF);

    rep(l, 0, 26) {
        rep(i, 0, k) {
            int b = 0, g = 0, y = 0;
            rep(j, 0, n) {
                if(str[i][j] - 'a' != l) continue;
                if(col[i][j] == 'B') b++;
                else if(col[i][j] == 'G') g++;
                else y++;
            }
            lower[l] = max(lower[l], g + y);
            if(b) {
                upper[l] = min(upper[l], g + y);
            }
        }
    }
    int sum = 0;
    rep(l, 0, 26) {
//        cout << char(l + 'a') << " " << lower[l] << ", " << upper[l] << endl;
        assert(lower[l] <= upper[l]);
        sum += lower[l];
    }
    assert(sum <= n);
    rep(l, 0, 26) {
        flow.add_edge(s, n + l, lower[l]);
        if(upper[l] == INF) flow.add_edge(smid, n + l, INF);
    }
    flow.add_edge(s, smid, n - sum);

    rep(i, 0, k) {
        set<int> cs;
        rep(j, 0, n) {
            if(col[i][j] == 'G') {
                res[j] = str[i][j] - 'a';
            } else if(col[i][j] == 'B' || col[i][j] == 'Y') {
                block[j][str[i][j] - 'a'] = 1;
            }
        }
    }
    rep(i, 0, n) {
        flow.add_edge(i, t, 1);
        if(res[i] != -1) {
            flow.add_edge(n + res[i], i, 1);
        } else {
            rep(j, 0, 26) {
                if(!block[i][j]) flow.add_edge(n + j, i, 1);
            }
        }
    }
    int f = flow.max_flow(s, t);


//    cout << f << endl;
    rep(i, 0, n) {
        for (auto e : flow.G[i]) {
            if(e.cap == 1 && e.to != t) {
                res[i] = e.to - n;
            }
        }
    }
    rep(i, 0, n) cout << (char)(res[i] + 'a');
    cout << '\n';

}