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;
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;
}