Problem: Professor Bajtocy is conducting experiments on alien DNA. He has discovered that it is subject to repetitive mutations — each mutation happens in the same way: some continuous subsequence of the alien DNA becomes active, copies itself, the copy gets mangled and inserts itself right after the original subsequence. The mangled copy of the activated continuous subsequence is formed by first joining all the elements at the even positions in that subsequence, and then joining all the elements at the odd ones at the end. That is, if the activated subsequence consists of 11 elements and represented as s1s2... s11, its mangled copy is s2s4s6s8s10s1s3s5s7s9s11.

For example, if the original sequence was "ACTGG" and the mutation happened on the segment [2, 4] (that is the activated subsequence is "CTG"), the mutated DNA is: "ACTGTCGG". The mangled copy of the activated subsequence is marked with bold font.

Professor Bajtocy has written down the original DNA sequence and the mutations that sequentially happened to it, and he now asks you to recover the first k elements of the DNA sequence after all the mutations.

Input

The first line of input contains the original DNA sequence, consisting only of letters "A", "C", "T" and "G" and not exceeding 3·106 in length. 

The second line contains a single integer k (1 ≤ k ≤ 3·106).

The third line contains a single integer n (0 ≤ n ≤ 5000) — the number of mutations. The next n lines describe the mutations in chronological order — each mutation is described by two numbers li and ri (1 ≤ li ≤ ri ≤ 109), meaning that the continuous subsequence [li, ri] has become active and cloned itself, joining itself with the mangled copy. 

It is guaranteed that the input data is correct, that is, no mutation acts on non-existing elements of the DNA sequence, and the resulting DNA sequence has at least k elements.

Assume that the DNA elements are indexed starting from 1 and that the notation [l, r] meaning the continuous subsequence of DNA sequence that consists of r - l + 1 elements starting at the l-th DNA sequence element and ending at the r-th DNA sequence element.

Output

Output a single line, containing the first k letters of the mutated DNA sequence.

Examples

Input

GAGA
4
0


Output

GAGA


Input

ACGTACGT
16
2
1 2
2 8


Output

ACCAGTACCGACATCG

Note

In the second example, after the first mutation the sequence is "ACCAGTACGT". After the second mutation it's "ACCAGTACCGACATCGT".

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
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
const int MAXN = 3000100;
char in[MAXN];
int pre[3000100];
int ll[5010], rr[5010];
char out[MAXN];
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;
}
int main() {
  int k, q, i, j;
  scanf("%s%d%d", in, &k, &q);
  SBT::node* root = build(1, k);
  for (i = 0; i < q; i++) {
    scanf("%d%d", &ll[i], &rr[i]);
  }
  for (i = q - 1; i >= 0; i--) {
    int n = root->sz;
    int l = ll[i], r = rr[i];
    if (r >= n) continue;
    int len = r - l + 1;
    int r2 = r + len;
    if (r2 > n) r2 = n;
    int id = 0;
    for (j = 1; j <= r2 - r; j++) {
      SBT::node* nd = SBT::rank(root, r + 1);
      id += 2;
      if (id > len) id = 1;
      SBT::node* pn = SBT::rank(root, l + id - 1);
      pre[nd->val] = pn->val;
      root = SBT::del(root, nd->val);
    }
  }
  traverse(root, 0);
  for (i = 1; i <= k; i++) putchar(run(i));
  puts("");
}