#include "bits/stdc++.h"
using namespace std;
using ll = long long;

unsigned int bit_ceil(unsigned int n){
    unsigned int x = 1;
    while(x < (unsigned int)(n)) x *= 2;
    return x;
}

int countr_zero(unsigned int n){ return __builtin_ctz(n); }
constexpr int countr_zero_constexpr(unsigned int n){
    int x = 0;
    while(!(n & (1 << x)))x++;
    return x;
}

template<class S, S (*op)(S, S), S (*e)(), class F, S(*mapping)(F, S), F(*composition)(F, F), F(*id)()>
struct lazy_segtree {
    public:
    lazy_segtree(): lazy_segtree(0){}
    explicit lazy_segtree(int n): lazy_segtree(vector<S>(n, e())){}
    explicit lazy_segtree(const vector<S> & v) : _n(int(v.size())){
        size = (int) bit_ceil((unsigned int)(_n));
        log = countr_zero((unsigned int)size);
        d = vector<S>(2 * size, e());
        lz = vector<F>(size, id());
        for(int i = 0; i < _n; i++)d[size + i] = v[i];
        for(int i = size - 1; i >= 1; i--) { update(i); }
    }
    void set(int p, S x){
        p += size;
        for(int i = log; i >= 1; i--) push(p >> i);
        d[p] = x;
        for(int i = 1; i <= log; i++) update(p >> i);
    }

    S get(int p){
        p += size;
        for(int i = log; i >= 1; i--)push(p >> i);
        return d[p];
    }

    S prod(int l, int r){
        if(l == r) return e();
        l += size;
        r += size;
        for(int i = log; i >= 1; i--){
            if(((l >> i) << i) != l)push(l >> i);
            if(((r >> i) << i) != r)push((r - 1) >> i); 
        }
        S sml = e(), smr = e();
        while(l < r){
            if(l & 1) sml = op(sml, d[l++]);
            if(r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml, smr);
    }
    void apply(int l, int r, F f){
        assert(0 <= l && l <= r && r <= _n);
        if(l == r) return;
        l += size;
        r += size;
        for(int i = log; i >= 1; i--){
            if(((l >> i) << i) != l) push(l >> i);
            if(((r >> i) << i) != r) push((r - 1) >> i);
        }
        {
            int l2 = l, r2 = r;
            while(l < r) {
                if(l & 1)all_apply(l++, f);
                if(r & 1)all_apply(--r, f);
                l >>= 1;
                r >>= 1;
            }
            l = l2;
            r = r2;
        }
        for(int i = 1; i <= log; i++){
            if(((l >> i) << i) != l) update(l >> i);
            if(((r >> i) << i) != r) update((r - 1) >> i);
        }
    }
    private:
    int _n, size, log;
    vector<S> d;
    vector<F> lz;
    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
    void all_apply(int k, F f){
        d[k] = mapping(f, d[k]);
        if(k < size) lz[k] = composition(f, lz[k]);
    }
    void push(int k){
        all_apply(2 * k, lz[k]);
        all_apply(2 * k + 1, lz[k]);
        lz[k] = id();
    }
};

using S = array<int, 3>;
S op(S a, S b){
    if(a[0] == a[1] && a[1] == a[2]){
        return b;
    }
    S c;
    for(int i = 0; i < 3; i++){
        int j = (i + 1) % 3;
        if(a[i] == a[j]){
            if(b[i] > b[j])a[i]++;
            else if(b[i] < b[j])a[j]++;
        }
    }  
    return a;
}

S e(){
    return {0, 0, 0};
}

using F = array<int, 3>;

S mapping(F f, S x){
    S ret;
    for(int i = 0; i < 3; i++){
        ret[i] =x[f[i]];
    }
    return ret;
}

F composition(F f, F g){
    F ret;
    for(int i = 0; i < 3; i++){
        ret[i] = g[f[i]];
    }
    return ret;
}
F id(){
    return {0, 1, 2};
}

int main(){
    int M, Q;
    cin >> M >> Q;
    string A,B,C;
    cin >> A >> B >> C;
    vector<vector<pair<char, int>>> V(M);
    vector<S> X(M);
    for(int i = 0; i < M; i++){
        V[i].emplace_back(A[i], 0);
        V[i].emplace_back(B[i], 1);
        V[i].emplace_back(C[i], 2);
        sort(V[i].begin(),V[i].end());
        auto VV= V[i];
        S r;
        if(VV[0].first == VV[2].first)r = {0, 0, 0};
        else if(VV[0].first == VV[1].first){
            r = {2,2,2};
            r[VV[0].second] = 0;
            r[VV[1].second] = 0;
        }else if(VV[1].first == VV[2].first){
            r = {0, 0, 0};
            r[VV[1].second] = 1;
            r[VV[2].second] = 1;
        }else{
            r = {0, 0, 0};
            for(int i = 0; i < 3; i++)r[VV[i].second] = i;
        }
        X[i] = r;
    }
    lazy_segtree<S, op, e, F, mapping, composition, id> seg(X);

    for(int q = 0; q < Q; q++){
        int l, r;
        cin >> l >> r;
        l--;
        auto a = seg.prod(l, r);
        F f;
        vector<int> cnt(3, -1);
        for(int i = 0; i < 3; i ++) {
            cnt[a[i]] ++;
            f[a[i] + cnt[a[i]]] = i;
        }
        seg.apply(l, r, f);
    }
    vector<string> ans(3, A);
    for(int i = 0; i < M; i++){
        auto a = seg.get(i);
        for(int j = 0; j < 3; j++){
            ans[j][i] = V[i][a[j]].first;
        }
    }
    for(int i = 0; i < 3; i++)cout << ans[i] << "\n";
    return 0;
}