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

using ll = long long;
#define f first
#define s second
template<class T> using V = vector<T>; 
using vi = V<int>;
using vpi = V<pair<int,int>>;
#define sz(x) int((x).size())
#define pb push_back
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define each(a,x) for (auto& a: x)
#define all(x) begin(x), end(x)
template<class T> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; } // set $a = \min(a,b)$

struct MCMF { // 0-based, archi direzionati
    using F = ll; using C = ll; // flow type, cost type
    struct Edge { int to, rev; F flo, cap; C cost; };
    int N; V<C> p, dist; vpi pre; V<V<Edge>> adj;
    void init(int _N) { N = _N;
        p.resize(N),adj.resize(N),dist.resize(N),pre.resize(N);}
    void ae(int u, int v, F cap, C cost) { assert(cap >= 0); 
        adj[u].pb({v,sz(adj[v]),0,cap,cost}); 
        adj[v].pb({u,sz(adj[u])-1,0,0,-cost});
    }
    //send flow through lowest cost path
    bool path(int s, int t) {
        const C inf = numeric_limits<C>::max(); 
        dist.assign(N,inf);
        using T = pair<C,int>;
        priority_queue<T,V<T>,greater<T>> todo;//(or queue<T>)
        todo.push({dist[s] = 0,s}); 
        while (sz(todo)) { // Dijkstra (or SPFA)
            T x = todo.top(); todo.pop(); //(or todo.front())
            if (x.f > dist[x.s]) continue; //(or x.f = dist[x.s])
            //all weights should be non-negative
            each(e,adj[x.s]) {
                if (e.flo < e.cap && ckmin(dist[e.to],
                    x.f+e.cost+p[x.s]-p[e.to])) {
                    pre[e.to]={x.s,e.rev};
                    todo.push({dist[e.to],e.to});
                }
            }
        } // if costs are doubles, add some EPS so you 
        // don't traverse ~0-weight cycle repeatedly
        return dist[t] != inf; // true if augmenting path
    }
    pair<F,C> calc(int s, int t) { assert(s != t);
        //F0R(_,N)F0R(i,N)each(e,adj[i])//utile con grafi densi...
        //  if(e.cap)ckmin(p[e.to],p[i]+e.cost);//e archi negativi
        F totFlow = 0; C totCost = 0;
        while (path(s,t)) { // p -> potentials for Dijkstra
            F0R(i,N)p[i]+=dist[i];//don't matter for unreachable
            F df = numeric_limits<F>::max();
            for (int x = t; x != s; x = pre[x].f) {
                Edge& e = adj[pre[x].f][adj[x][pre[x].s].rev]; 
                ckmin(df,e.cap-e.flo); }
            totFlow += df; totCost += (p[t]-p[s])*df;
            for (int x = t; x != s; x = pre[x].f) {
                Edge& e = adj[x][pre[x].s]; e.flo -= df;
                adj[pre[x].f][e.rev].flo += df;
            }
        } // get max flow you can send along path
        return {totFlow,totCost};
    }
};

const int ALPHA = 26;

void solve(int t){
    int g,l;
    cin>>g>>l;
    
    vector<int> low(ALPHA,0),up(ALPHA,l+1),found(l,-1);
    vector<vector<bool>> ok(l,vector<bool>(ALPHA,true));
    
    for(int i=0;i+1<g;i++){
        string s,t;
        cin>>s>>t;
        
        vector<bool> b(ALPHA,false),y(ALPHA,false);
        for(int j=0;j<l;j++){
            if(t[j]=='G'){
                found[j]=s[j]-'a';
                y[s[j]-'a']=true;
            }else if(t[j]=='B'){
                b[s[j]-'a']=true;
                ok[j][s[j]-'a']=false;
            }else{
                y[s[j]-'a']=true;
                ok[j][s[j]-'a']=false;
            }
        }
        
        for(int j=0;j<ALPHA;j++){
            if(b[j]){
                int cont=0;
                for(int k=0;k<l;k++){
                    if(s[k]-'a'==j && t[k]!='B'){
                        cont++;
                    }
                }
                up[j]=cont;
            }
            if(y[j]){
                int cont=0;
                for(int k=0;k<l;k++){
                    if(s[k]-'a'==j && t[k]!='B'){
                        cont++;
                    }
                }
                low[j]=max(low[j],cont);
            }
        }
    }
    
    MCMF ds;
    ds.init(l+ALPHA+2);
    
    int source = l+ALPHA, sink = l+ALPHA+1;
    for(int i=0;i<ALPHA;i++){
        ds.ae(source,l+i,low[i],0);
        ds.ae(source,l+i,up[i]-low[i],1);
        
        //cout<<low[i]<<" "<<up[i]<<"\n";
        
        for(int j=0;j<l;j++){
            if(found[j]!=-1){
                if(i==found[j]){
                    ds.ae(l+i,j,1,0);
                }
            }else{
                if(ok[j][i]){
                    ds.ae(l+i,j,1,0);
                }
            }
        }
    }
    
    for(int i=0;i<l;i++){
        ds.ae(i,sink,1,0);
    }
    
    auto res = ds.calc(source,sink);
    //cout<<res.first<<" "<<res.second<<"\n";
    
    assert(res.first==l);
    
    vector<char> ans(l);
    for(int i=0;i<l;i++){
        bool ok=false;
        for(auto j : ds.adj[i]){
            //cout<<i<<" "<<j.to<<" "<<j.flo<<"\n";
            if(j.to>=l && j.to<l+ALPHA && j.flo<0){
                ans[i]=char(j.to-l+'a');
                ok=true;
                break;
                //cout<<i<<" "<<j.to<<" ecco\n";
            }
        }
        assert(ok);
    }
    
    for(int i=0;i<l;i++){
        cout<<ans[i];
    }
    cout<<"\n";
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int t=1;
    //cin>>t;
    for(int i=1;i<=t;i++)solve(i);
    
    return 0;
}