#include <bits/stdc++.h>
using namespace std;
char s[3000005], now[3000005];
int k, n, len, f[5005], pre[3000005];
char out[3000005], in[3000005];
struct wyh {
  int l, r;
} e[5005];
namespace SBT {
const int INF = 1000000000;
struct node {
  int val;
  int sz;
  node *l, *r;
  node(int v, int s = 1);
};
node _null_nd(INF, 0);
node* null_nd = &_null_nd;
node::node(int v, int s) {
  val = v;
  sz = s;
  l = &_null_nd;
  r = &_null_nd;
}
inline void calc_size(node* nd) { nd->sz = nd->l->sz + nd->r->sz + 1; }
node* right_rotate(node* nd) {
  node* k = nd->l;
  nd->l = k->r;
  k->r = nd;
  k->sz = nd->sz;
  calc_size(nd);
  return k;
}
node* left_rotate(node* nd) {
  node* k = nd->r;
  nd->r = k->l;
  k->l = nd;
  k->sz = nd->sz;
  calc_size(nd);
  return k;
}
node* maintain(node* nd, bool f) {
  if (nd == null_nd) return nd;
  if (!f) {
    if (nd->l->l->sz > nd->r->sz) {
      nd = right_rotate(nd);
    } else if (nd->l->r->sz > nd->r->sz) {
      nd->l = left_rotate(nd->l);
      nd = right_rotate(nd);
    } else
      return nd;
  } else {
    if (nd->r->r->sz > nd->l->sz) {
      nd = left_rotate(nd);
    } else if (nd->r->l->sz > nd->l->sz) {
      nd->r = right_rotate(nd->r);
      nd = right_rotate(nd);
    } else
      return nd;
  }
  nd->l = maintain(nd->l, false);
  nd->r = maintain(nd->r, true);
  nd = maintain(nd, false);
  nd = maintain(nd, true);
}
node* insert(node* nd, int v) {
  if (nd == null_nd) {
    return new node(v);
  } else {
    nd->sz++;
    if (v < nd->val) {
      nd->l = insert(nd->l, v);
    } else {
      nd->r = insert(nd->r, v);
    }
    return maintain(nd, v >= nd->val);
  }
}
int deleted;
node* del(node* nd, int v) {
  nd->sz--;
  if (v == nd->val || (v < nd->val && nd->l == null_nd) ||
      (v > nd->val && nd->r == null_nd)) {
    deleted = nd->val;
    if (nd->l == null_nd) {
      node* k = nd->r;
      nd = k;
    } else if (nd->r == null_nd) {
      node* k = nd->l;
      nd = k;
    } else {
      nd->l = del(nd->l, INF);
      nd->val = deleted;
    }
  } else {
    if (v < nd->val) {
      nd->l = del(nd->l, v);
    } else {
      nd->r = del(nd->r, v);
    }
  }
  return nd;
}
node* find(node* nd, int v) {
  if (nd == null_nd) return null_nd;
  if (nd->val == v)
    return nd;
  else if (v < nd->val)
    return find(nd->l, v);
  else
    return find(nd->r, v);
}
node* rank(node* nd, int k) {
  if (k == nd->l->sz + 1)
    return nd;
  else if (k <= nd->l->sz)
    return rank(nd->l, k);
  else
    return rank(nd->r, k - nd->l->sz - 1);
}
}  // namespace SBT
inline char run(int np) {
  if (out[np]) return out[np];
  return out[np] = run(pre[np]);
}
inline void traverse(SBT::node* nd, int r) {
  if (nd->l != SBT::null_nd) traverse(nd->l, r);
  out[nd->val] = in[nd->l->sz + r];
  if (nd->r != SBT::null_nd) traverse(nd->r, nd->l->sz + 1 + r);
}
inline SBT::node* build(int x, int y) {
  int m = (x + y) / 2;
  SBT::node* nd = new SBT::node(m);
  nd->sz = y - x + 1;
  if (x < m) nd->l = build(x, m - 1);
  if (y > m) nd->r = build(m + 1, y);
  return nd;
}
void work() {
  scanf("%s%d%d", in, &k, &n);
  for (int i = 1; i <= n; ++i) scanf("%d%d", &e[i].l, &e[i].r);
  SBT::node* root = build(1, k);
  for (int i = n - 1; i >= 0; --i) {
    int sz = root->sz, l = e[i + 1].l, r = e[i + 1].r, len = r - l + 1, r1;
    if (r >= sz) continue;
    r1 = min(r + len, sz);
    int id = 0;
    for (int j = 1; j <= r1 - r; ++j) {
      SBT::node* n_ = SBT::rank(root, r + 1);
      id += 2;
      if (id > len) id = 1;
      SBT::node* n1_ = SBT::rank(root, l + id - 1);
      pre[n_->val] = n1_->val;
      root = SBT::del(root, n_->val);
    }
  }
  traverse(root, 0);
  for (int i = 1; i <= k; ++i) printf("%c", run(i));
  printf("\n");
}
int main() {
  work();
  return 0;
}
