#include <bits/stdc++.h>
using namespace std;
struct tsplay {
  struct node {
    char c;
    node *left, *right, *parent;
    int size;
  };
  struct MemPool {
    node a[3000010];
    int ptr;
    void clear() { ptr = 0; }
    node *allocate() { return &a[ptr++]; }
  };
  MemPool pool;
  node *root;
  node *create(char c, node *p) {
    node *res = pool.allocate();
    res->left = res->right = NULL;
    res->parent = p;
    res->c = c;
    res->size = 1;
    return res;
  }
  void clear() {
    pool.clear();
    root = NULL;
  }
  void update(node *x) {
    x->size = 1;
    if (x->left) x->size += x->left->size;
    if (x->right) x->size += x->right->size;
  }
  void tl(node *x) {
    node *y = x->parent;
    x->parent = y->parent;
    if (y->parent)
      if (y == y->parent->left)
        y->parent->left = x;
      else
        y->parent->right = x;
    y->right = x->left;
    if (x->left) x->left->parent = y;
    x->left = y;
    y->parent = x;
    update(y);
  }
  void tr(node *x) {
    node *y = x->parent;
    x->parent = y->parent;
    if (y->parent)
      if (y == y->parent->left)
        y->parent->left = x;
      else
        y->parent->right = x;
    y->left = x->right;
    if (x->right) x->right->parent = y;
    x->right = y;
    y->parent = x;
    update(y);
  }
  void splay(node *x, node *y) {
    while (x->parent != y)
      if (x->parent->parent == y)
        if (x == x->parent->left)
          tr(x);
        else
          tl(x);
      else if (x->parent == x->parent->parent->left)
        if (x == x->parent->left)
          tr(x->parent), tr(x);
        else
          tl(x), tr(x);
      else if (x == x->parent->right)
        tl(x->parent), tl(x);
      else
        tr(x), tl(x);
    update(x);
    if (!y) root = x;
  }
  node *builder(char *s, int l, int r) {
    if (l > r) return NULL;
    node *res = create(s[(l + r) / 2], NULL);
    res->size = r - l + 1;
    res->left = builder(s, l, (l + r) / 2 - 1);
    if (res->left) res->left->parent = res;
    res->right = builder(s, (l + r) / 2 + 1, r);
    if (res->right) res->right->parent = res;
    return res;
  }
  void build(char *s, int n) { root = builder(s, 1, n); }
  node *getkth(int kth) {
    node *cur = root;
    while (1) {
      int x;
      if (cur->left)
        x = cur->left->size + 1;
      else
        x = 1;
      if (kth == x) return cur;
      if (kth > x)
        kth -= x, cur = cur->right;
      else
        cur = cur->left;
    }
  }
  void insert(int where, node *r) {
    if (where == 0) {
      splay(getkth(1), NULL);
      root->left = r;
      root->left->parent = root;
      update(root);
    } else if (where == root->size) {
      splay(getkth(root->size), NULL);
      root->right = r;
      root->right->parent = root;
      update(root);
    } else {
      node *p = getkth(where), *s = getkth(where + 1);
      splay(p, NULL);
      splay(s, root);
      root->right->left = r;
      root->right->left->parent = root->right;
      update(root->right);
      update(root);
    }
    splay(&pool.a[rand() % pool.ptr], NULL);
  }
  node *cuttree(int l, int r) {
    if (l == 1 && r == root->size) return root;
    if (l == 1) {
      splay(getkth(r + 1), NULL);
      return root->left;
    }
    if (r == root->size) {
      splay(getkth(l - 1), NULL);
      return root->right;
    }
    node *p = getkth(l - 1), *s = getkth(r + 1);
    splay(p, NULL);
    splay(s, p);
    return root->right->left;
  }
  void dumper(node *cur, char *s) {
    if (!cur) return;
    int x;
    if (cur->left)
      x = cur->left->size;
    else
      x = 0;
    s[x] = cur->c;
    dumper(cur->left, s);
    dumper(cur->right, s + x + 1);
  }
  void dump(char *s) {
    dumper(root, s);
    s[root->size] = 0;
  }
};
char buf[3000010], ss[3000010], st[3000010];
int ld[5010], rd[5010];
tsplay final;
void solve(int m, int n) {
  if (n == 0) {
    final.build(buf, m);
    return;
  }
  int l = rd[n] + 1;
  int r = l + rd[n] - ld[n];
  int len;
  if (r <= m)
    len = r - l + 1;
  else if (l > m)
    len = 0;
  else
    len = m - l + 1;
  solve(m - len, n - 1);
  if (len == 0) return;
  int rr;
  if (ld[n] + len * 2 > rd[n])
    rr = rd[n];
  else
    rr = ld[n] + len * 2;
  final.dumper(final.cuttree(ld[n], rr), ss + 1);
  int p1 = ld[n] + 1;
  if (p1 > rd[n]) p1 = rd[n];
  int p2 = 0;
  for (int i = (1); i <= (len); i++) {
    p2++;
    st[p2] = ss[p1 - ld[n] + 1];
    p1 += 2;
    if (p1 > rd[n]) p1 = ld[n];
  }
  final.insert(rd[n], final.builder(st, 1, len));
}
char s[3000010];
void lemon() {
  scanf("%s", buf + 1);
  int m;
  scanf("%d", &m);
  int n;
  scanf("%d", &n);
  for (int i = (1); i <= (n); i++) scanf("%d%d", &ld[i], &rd[i]);
  final.clear();
  solve(m, n);
  final.dump(s);
  printf("%s\n", s);
}
int main() {
  ios::sync_with_stdio(true);
  lemon();
  return 0;
}
