#include <bits/stdc++.h>

#define f first
#define s second
#define pb push_back
#define mp make_pair

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;

const int N = 300500, inf = 1e9, mod = 998244353;
const ll INF = 1e18;

int sum(int a, int b) {
    a += b;
    if (a >= mod)
        a -= mod;
    return a;
}

int sub(int a, int b) {
    a -= b;
    if (a < 0)
        a += mod;
    return a;
}

int mult(int a, int b) {
    return 1ll * a * b % mod;
}

int bp(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1)
            res = mult(res, a);
        a = mult(a, a);
        b >>= 1;
    }
    return res;
}

int inv(int x) {
    return bp(x, mod - 2);
}
const int infinity = 1e9;
struct DinitzFlow{
    struct Edge {
        int src, dst, cap, flow;
        Edge() {
        }
        Edge(int src, int dst, int cap, int flow)
                : src(src), dst(dst), cap(cap), flow(flow) {
        }
    };
    int n, s, t;
    vector<Edge> edges;
    vector< vector<int> > g;
    vector<int> layer;
    vector<int> ptr;
    inline bool bfs() {
        layer.assign(n, -1);
        queue<int> q;
        layer[s] = 0;
        q.push(s);
        while (!q.empty() && layer[t] < 0) {
            int v = q.front(); q.pop();
            for (int eid: g[v]) {
                int to = edges[eid].dst;
                if (edges[eid].cap > edges[eid].flow) {
                    if (layer[to] < 0) {
                        layer[to] = layer[v] + 1;
                        q.push(to);
                    }
                }
            }
        }
        return layer[t] >= 0;
    }
    int dfs(int v, int flow = infinity) {
        if (v == t) {
            return flow;
        }
        if (flow == 0) {
            return 0;
        }
        for (; ptr[v] < (int)g[v].size(); ptr[v]++) {
            int eid = g[v][ptr[v]];
            int to = edges[eid].dst;
            if (layer[to] == layer[v] + 1) {
                int can = edges[eid].cap - edges[eid].flow;
                int pushed = dfs(to, min(flow, can));
                if (pushed > 0) {
                    edges[eid].flow += pushed;
                    edges[eid^1].flow -= pushed;
                    return pushed;
                }
            }
        }
        return 0;
    }
    inline void changeSrcDst(int ns, int nt) {
        s = ns; t = nt;
        for (Edge &e : edges) {
            e.flow = 0;
        }
    }
    inline vector<char> getCut() {
        // side[i] = 1 if the vertex is in component of s after the cut
        // side[i] = 0 otherwise (even if the vertex is not in component of t)
        vector<char> side(n, 0);
        function<void(int)> dfs = [&](int v) {
            if (side[v]) {
                return;
            }
            side[v] = 1;
            for (int eid : g[v]) {
                if (edges[eid].cap == edges[eid].flow) {
                    continue;
                }
                dfs(edges[eid].dst);
            }
        };
        dfs(s);
        return side;
    }
    inline int flow() {
        int ans = 0;
        while (bfs()) {
            ptr.assign(n, 0);
            int pushed = dfs(s);
            while (pushed != 0) {
                ans += pushed;
                pushed = dfs(s);
            }
        }
        return ans;
    }
    inline void addEdge(int src, int dst, int cap) {
        g[src].push_back(edges.size());
        edges.emplace_back(src, dst, cap, 0);
        g[dst].push_back(edges.size());
        edges.emplace_back(dst, src, 0, 0);
    }
    DinitzFlow(int n, int s, int t)
            : n(n), s(s), t(t), g(n), layer(n), ptr(n) {
    }
};

void solve() {
    int q, n;
    cin >> q >> n;
    q--;
    vector<vector<int>> ok(n,vector<int>(26,1));
    vector<int> L(26), R(26,n);
    for (int i=0;i<q;i++)
    {
        string s, t;
        cin >> s >> t;
        vector<int> C(26);
        for (int j=0;j<n;j++)
        {
            if (t[j]=='G' or t[j]=='Y') C[s[j]-'a']++;
            if (t[j]=='G')
            {
                for (int w=0;w<26;w++)
                {
                    if (w!=s[j]-'a') ok[j][w] = 0;
                }
            }
            else ok[j][s[j]-'a'] = 0;
        }
        for (int j=0;j<26;j++) L[j] = max(L[j],C[j]);
        for (int j=0;j<n;j++)
        {
            if (t[j]=='B') R[s[j]-'a'] = C[s[j]-'a'];
        }
    }
    int A = 26;
    int istok = n+A;
    int stok = istok+1;
    int loh = stok+1;
    int NN = loh+1;
    DinitzFlow ds(NN, istok, stok);
    for (int i=0;i<A;i++)
    {
        for (int j=0;j<n;j++)
        {
            if (ok[j][i]) ds.addEdge(i,A+j,1);
        }
    }
    for (int i=0;i<n;i++)
    {
        ds.addEdge(A+i,stok,1);
    }
    int LL = n;
    for (int i=0;i<A;i++)
    {
        ds.addEdge(istok,i,L[i]);
        LL -= L[i];
    }
    ds.addEdge(istok,loh,LL);
    for (int i=0;i<A;i++)
    {
        ds.addEdge(loh,i,R[i]-L[i]);
    }
    int res = ds.flow();
    assert(res==n);
    vector<int> ans(n);
    for (int i=0;i<ds.edges.size();i+=2)
    {
        auto x = ds.edges[i];
        if (x.dst>=A and x.dst<A+n and x.flow==1)
        {
            ans[x.dst-A] = x.src;
        }
    }
    for (int i=0;i<n;i++) cout << (char)(ans[i]+'a');
}

int main() {
//#ifdef DEBUG
//    freopen("input.txt", "r", stdin);
//#endif
    ios_base::sync_with_stdio(false);
    int t = 1;
//    cin >> t;
    for (int i = 1; i <= t; i++) {
//        cout << "Case #" << i << endl;
        solve();
    }
}