#include <bits/stdc++.h>
 
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
 
mt19937 rng((int) chrono::steady_clock::now().time_since_epoch().count());
    
const int MOD = 1e9 + 7;
const int MAXN = 5e5 + 5;
const ll INF = 2e18;

const int maxn = 100010;

ll p = 29;
ll mod = 1000000007;

struct Node
{
    ll hash;

    int l, r, sz;
    int idLeft, idRight;
};

ll pw[maxn];

Node v[6*maxn];

vector<int> roots;

void merge(int node)
{
    int L = v[node].idLeft;
    int R = v[node].idRight;

    v[node].sz = v[L].sz + v[R].sz;
    v[node].l = v[L].l; v[node].r = v[R].r;

    v[node].hash = v[L].hash + v[R].hash*pw[ v[L].sz ];
    v[node].hash %= mod;
}

bool cmpNodes(int A, int B)
{
    if( v[A].l == v[A].r )
        return v[A].hash < v[B].hash;

    if( v[ v[A].idLeft ].hash == v[ v[B].idLeft ].hash )
        return cmpNodes( v[A].idRight , v[B].idRight );

    return cmpNodes( v[A].idLeft , v[B].idLeft );
}

bool cmp(vector<int>& A, vector<int>& B)
{
    for(int i = 0 ; i < (int)A.size() ; i++)
    {
        if( v[ A[i] ].hash == v[ B[i] ].hash )
            continue;

        return cmpNodes( A[i] , B[i] );
    }

    return false;
}

int build(int l, int r, int& cur, string& s)
{
    int myNode = ++cur;

    if( l == r )
    {
        v[myNode].sz = 1;

        v[myNode].hash = s[l] - 'a';
        v[myNode].l = v[myNode].r = l;

        return myNode;
    }

    int m = ( l + r )/2;

    v[myNode].idLeft = build( l , m , cur , s );
    v[myNode].idRight = build( m + 1 , r , cur , s );

    merge( myNode );

    return myNode;
}

void buildSEGs(string& A, string& B, string& C)
{
    int cur = 0;
    int n = (int)A.size();

    roots.push_back( build( 0 , n - 1 , cur , A ) );
    roots.push_back( build( 0 , n - 1 , cur , B ) );
    roots.push_back( build( 0 , n - 1 , cur , C ) );
}

void getNodes(int root, int l, int r, vector<int>& nodes)
{
    if( r < v[root].l || v[root].r < l )
        return;

    if( l <= v[root].l && v[root].r <= r )
    {
        nodes.push_back( root );
        return;
    }

    getNodes( v[root].idLeft , l , r , nodes );
    getNodes( v[root].idRight , l , r , nodes );
}

int replaceNodes(int node, int oldNode, int newNode)
{
    if( node == oldNode )
        return newNode;

    if( v[oldNode].r <= v[ v[node].idLeft ].r )
        v[node].idLeft = replaceNodes( v[node].idLeft , oldNode , newNode );
    else
        v[node].idRight = replaceNodes( v[node].idRight , oldNode , newNode );

    merge( node );
    return node;
}

void update(int l, int r)
{
    vector<int> A, B, C;

    getNodes( roots[0] , l , r , A );
    getNodes( roots[1] , l , r , B );
    getNodes( roots[2] , l , r , C );

    vector<int> oldA = A, oldB = B, oldC = C;

    if( !cmp( A , B ) )
        swap( A , B );

    if( !cmp( A , C ) )
        swap( A , C );

    if( !cmp( B , C ) )
        swap( B , C );

    for(int i = 0 ; i < (int)A.size() ; i++)    
        roots[0] = replaceNodes( roots[0] , oldA[i] , A[i] );

    for(int i = 0 ; i < (int)B.size() ; i++)    
        roots[1] = replaceNodes( roots[1] , oldB[i] , B[i] );

    for(int i = 0 ; i < (int)C.size() ; i++)    
        roots[2] = replaceNodes( roots[2] , oldC[i] , C[i] );
}

void printSEG(int root)
{
    if( v[root].l == v[root].r )
    {
        char c = 'a' + v[root].hash;
        cout << c;

        return;
    }

    printSEG( v[root].idLeft );
    printSEG( v[root].idRight );
}

int main() 
{
    int n, q;
    cin >> n >> q;

    string A, B, C;
    cin >> A >> B >> C;

    pw[0] = 1;

    for(int i = 1 ; i < maxn ; i++)
        pw[i] = (pw[i - 1]*p)%mod;

    buildSEGs( A , B , C );

    while( q-- )
    {
        int l, r;
        cin >> l >> r;
        l--; r--;

        update( l , r );
    }

    for(int i = 0 ; i < 3 ; i++, cout << endl)
        printSEG( roots[i] );
    
    return 0;
}