#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 5;

int n, q;

struct Node {
  Node *left = nullptr, *right = nullptr;
  int seg_id, node_id;
  char content;
};

struct SegmentTree {
  Node* root = nullptr;
  int id, cnt_nodes;
  string s;

  void build(Node* cur, int l, int r) {
    cur->seg_id = id;
    cur->node_id = ++cnt_nodes;
    if (l == r) {
      cur->content = s[l];
      return;
    }
    int mid = (l + r) / 2;
    cur->left = new Node();
    cur->right = new Node();
    build(cur->left, l, mid);
    build(cur->right, mid + 1, r);
  }

  void build() {
    s = "#" + s;
    cnt_nodes = 0;
    root = new Node();
    build(root, 1, n);
  }

  void build_output(Node* cur, int l, int r, string& res) {
    if (l == r) {
      res += cur->content;
      return;
    }
    int mid = (l + r) / 2;
    build_output(cur->left, l, mid, res);
    build_output(cur->right, mid + 1, r, res);
  }

  string output() {
    string res;
    build_output(root, 1, n, res);
    return res;
  }

  void split_nodes(Node* cur, int l, int r, int u, int v, vector<Node*>& nodes) {
    if (v < l || r < u) {
      return;
    }
    if (u <= l && r <= v) {
      nodes.push_back(cur);
      return;
    }
    int mid = (l + r) / 2;
    split_nodes(cur->left, l, mid, u, v, nodes);
    split_nodes(cur->right, mid + 1, r, u, v, nodes);
  }

  void split_nodes(int u, int v, vector<Node*>& nodes) {
    split_nodes(root, 1, n, u, v, nodes);
  }

  Node* merge_nodes(Node* cur, int l, int r, int u, int v, vector<Node*>& nodes) {
    if (v < l || r < u) {
      return cur;
    }
    if (u <= l && r <= v) {
      auto res = nodes.back();
      nodes.pop_back();
      return res;
    }
    int mid = (l + r) / 2;
    cur->left = merge_nodes(cur->left, l, mid, u, v, nodes);
    cur->right = merge_nodes(cur->right, mid + 1, r, u, v, nodes);
    return cur;
  }

  void merge_nodes(int u, int v, vector<Node*>& nodes) {
    root = merge_nodes(root, 1, n, u, v, nodes);
  }
} segtree[3];

bool is_equal[3][3][N << 2];

bool build_equal(Node* cur1, Node* cur2, int l, int r) {
  int node_id = cur1->node_id;
  assert(node_id == cur2->node_id);
  int st_id1 = cur1->seg_id;
  int st_id2 = cur2->seg_id;
  if (l == r) {
    bool match = segtree[st_id1].s[l] == segtree[st_id2].s[l];
    is_equal[st_id1][st_id2][node_id] = match;
    is_equal[st_id2][st_id1][node_id] = match;
    return match;
  }
  int mid = (l + r) / 2;
  bool match = build_equal(cur1->left, cur2->left, l, mid);
  match     &= build_equal(cur1->right, cur2->right, mid + 1, r);
  is_equal[st_id1][st_id2][node_id] = match;
  is_equal[st_id2][st_id1][node_id] = match;
  return match;
}

void build_equal(int st_id1, int st_id2) {
  build_equal(segtree[st_id1].root, segtree[st_id2].root, 1, n);
}

bool rebuild_equal(Node* cur1, Node* cur2, int l, int r, int u, int v) {
  int node_id = cur1->node_id;
  assert(node_id == cur2->node_id);
  int st_id1 = cur1->seg_id;
  int st_id2 = cur2->seg_id;
  if (v < l || r < u) {
    return is_equal[st_id1][st_id2][node_id];
  }
  if (u <= l && r <= v) {
    return is_equal[st_id1][st_id2][node_id];
  }
  int mid = (l + r) / 2;
  bool match = rebuild_equal(cur1->left, cur2->left, l, mid, u, v);
  match     &= rebuild_equal(cur1->right, cur2->right, mid + 1, r, u, v);
  is_equal[st_id1][st_id2][node_id] = match;
  is_equal[st_id2][st_id1][node_id] = match;
  return match;
}

void rebuild_equal(int st_id1, int st_id2, int u, int v) {
  rebuild_equal(segtree[st_id1].root, segtree[st_id2].root, 1, n, u, v);
}

int compare_node(Node* cur1, Node* cur2) {
  int node_id = cur1->node_id;
  assert(node_id == cur2->node_id);
  int st_id1 = cur1->seg_id;
  int st_id2 = cur2->seg_id;
  if (is_equal[st_id1][st_id2][node_id]) {
    return 0;
  }
  if (cur1->left == nullptr) {
    // l == r
    if (cur1->content < cur2->content) {
      return -1;
    } else if (cur1->content > cur2->content) {
      return 1;
    } else {
      return 0;
    }
  }
  int tmp = compare_node(cur1->left, cur2->left);
  if (tmp) return tmp;
  return compare_node(cur1->right, cur2->right);
}

void process_query(int u, int v) {
  vector<vector<Node*>> segs(3);
  for (int i = 0; i < 3; ++i) {
    segtree[i].split_nodes(u, v, segs[i]);
  }

  sort(segs.begin(), segs.end(), [&](const vector<Node*>& s1, const vector<Node*>& s2) {
    assert(s1.size() == s2.size());
    int k = s1.size();
    for (int i = 0; i < k; ++i) {
      auto cur1 = s1[i], cur2 = s2[i];
      int node_id = cur1->node_id;
      assert(node_id == cur2->node_id);
      int st_id1 = cur1->seg_id;
      int st_id2 = cur2->seg_id;
      if (!is_equal[st_id1][st_id2][node_id]) {
        return compare_node(cur1, cur2) == -1;
      }
    }
    return false;
  });

  for (int i = 0; i < 3; ++i) {
    reverse(segs[i].begin(), segs[i].end());
    segtree[i].merge_nodes(u, v, segs[i]);
  }

  rebuild_equal(0, 1, u, v);
  rebuild_equal(0, 2, u, v);
  rebuild_equal(1, 2, u, v);

//  for (int i = 0; i < 3; ++i) {
//    cout << segtree[i].output() << '\n';
//  }
//  cout << "-----------------\n";
}

int main() {
  if (fopen("input_e.txt", "r")) {
    freopen("input_e.txt", "r", stdin);
  }
  ios::sync_with_stdio(false);
  cin.tie(0);

  cin >> n >> q;
  for (int i = 0; i < 3; ++i) {
    cin >> segtree[i].s;
    segtree[i].id = i;
    segtree[i].build();
  }
  build_equal(0, 1);
  build_equal(0, 2);
  build_equal(1, 2);

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

  for (int i = 0; i < 3; ++i) {
    cout << segtree[i].output() << '\n';
  }

  return 0;
}