//高精度整数
const int BASE = 1000000000;
const int BASEDIGITS = 9;
struct bint {
  vector<int> s; char sign;
  bint(): s(), sign(1) {}
  bint(const ll &v): s(), sign(v < 0 ? -1 : 1) {
    for (ll t = v < 0 ? -v : v; t; t /= BASE) { s.push_back(t % BASE); }
  }
  bint(const string &v): s(), sign(1) {
    int beg = 0;
    for (; beg < (int)v.size() && (v[beg] == '-' || v[beg] == '+'); beg++) {
      if (v[beg] == '-') { sign = -1; }
    }
    for (int i = (int)v.size() - 1, x, j; i >= beg; i -= BASEDIGITS) {
      for (x = 0, j = max(beg, i - BASEDIGITS + 1); j <= i; x = x * 10 + v[j++] - '0');
      s.push_back(x);
    }
    trim();
  }
  bint &operator=(const bint &v) { sign = v.sign; s = v.s; return *this; }
  bint &operator+=(const bint &v) {
    if (sign == v.sign) {
      for (int i = 0, is = 0, len = max(s.size(), v.s.size()); i < len || is; i++) {
        if (i == (int)s.size()) { s.push_back(0); }
        s[i] += is + (i < (int)v.s.size() ? v.s[i] : 0);
        if ((is = s[i] >= BASE)) { s[i] -= BASE; }
      }
      return *this;
    } else { return *this -= -v; }
  }
  bint &operator-=(const bint &v) {
    if (sign == v.sign) {
      if (cmp(v, 0) != -1) {
        for (int i = 0, is = 0; i < (int)v.s.size() || is; i++) {
          s[i] -= is + (i < (int)v.s.size() ? v.s[i] : 0);
          if ((is = s[i] < 0)) { s[i] += BASE; }
        }
        trim(); return *this;
      } else { return *this = -(bint(v) -= *this); }
    } else { return *this += -v; }
  }
  bint &operator*=(const bint &v) {
    vector<ll> num(s.size() + v.s.size());
    for (int i = 0; i < (int)s.size(); i++) {
      for (int j = 0; j < (int)v.s.size(); j++) {
        num[i + j] += (ll)s[i] * v.s[j];
        if (num[i + j] >= BASE) { num[i + j + 1] += num[i + j] / BASE; num[i + j] %= BASE; }
      }
    }
    sign *= v.sign; s.resize(num.size());
    for (int i = 0; i < (int)num.size(); i++) { s[i] = num[i]; }
    trim(); return *this;
  }
  bint &operator/=(const bint &v) { return *this = divmod(*this, v).first; }
  bint &operator%=(const bint &v) { return *this = divmod(*this, v).second; }
  bint operator-()const { bint ret(*this); ret.sign = -sign; return ret; }
  bint operator+(const bint &v)const { return bint(*this) += v; }
  bint operator-(const bint &v)const { return bint(*this) -= v; }
  bint operator*(const bint &v)const { return bint(*this) *= v; }
  bint operator/(const bint &v)const { return divmod(*this, v).first; }
  bint operator%(const bint &v)const { return divmod(*this, v).second; }
  bint operator^(const ll &v)const {
    bint ret(1), t(*this);
    for (ll b = v; b; b >>= 1) { if (b & 1) { ret *= t; } t *= t; }
    return ret;
  }
  //乘除法辅助函数
  friend pair<bint, bint> divmod(const bint &a, const bint &b) {
    int norm = BASE / (b.s.back() + 1);
    bint x = a.abs().mul(norm), y = b.abs().mul(norm), q, r; q.s.resize(x.s.size());
    for (int i = (int)x.s.size() - 1; i >= 0; i--) {
      r = r.mul(BASE); r += x.s[i];
      int s1 = r.s.size() <= y.s.size() ? 0 : r.s[y.s.size()];
      int s2 = r.s.size() + 1 <= y.s.size() ? 0 : r.s[y.s.size() - 1];
      int d = ((ll)BASE * s1 + s2) / y.s.back();
      r -= y.mul(d);
      while (r.cmp(0, 1) == -1) { r += y; --d; }
      q.s[i] = d;
    }
    q.sign = a.sign * b.sign; q.trim(); r.sign = a.sign; r.trim();
    return make_pair(q, r.div(norm));
  }
  bint mul(int v)const {
    bint ret(*this);
    if (v < 0) { ret.sign = -ret.sign; v = -v; }
    for (int i = 0, is = 0; i < (int)ret.s.size() || is; i++) {
      if (i == (int)s.size()) { ret.s.push_back(0); }
      ll a = ret.s[i] * (ll)v + is; is = a / BASE; ret.s[i] = a % BASE;
    }
    ret.trim(); return ret;
  }
  bint div(int v)const {
    bint ret(*this);
    if (v < 0) { ret.sign = -ret.sign; v = -v; }
    for (int i = (int)ret.s.size() - 1, rem = 0; i >= 0; i--) {
      ll a = ret.s[i] + rem * (ll)BASE; ret.s[i] = a / v; rem = a % v;
    }
    ret.trim(); return ret;
  }
  int mod(int v)const {
    if (v < 0) { v = -v; }
    int m = 0;
    for (int i = (int)s.size() - 1; i >= 0; i--) { m = (s[i] + m * (ll)BASE) % v; }
    return m * sign;
  }
  bool operator<(const bint &v)const { return cmp(v) < 0; }
  bool operator>(const bint &v)const { return cmp(v) > 0; }
  bool operator<=(const bint &v)const { return cmp(v) <= 0; }
  bool operator>=(const bint &v)const { return cmp(v) >= 0; }
  bool operator==(const bint &v)const { return cmp(v) == 0; }
  bool operator!=(const bint &v)const { return cmp(v) != 0; }
  int cmp(const bint &v, bool is = 1)const {
    if (is) { if (sign > v.sign) { return 1; } if (sign < v.sign) { return -1; } }
    int d = sign > 0 || !is ? 1 : -1;
    if (s.size() > v.s.size()) { return d; }
    if (s.size() < v.s.size()) { return -d; }
    for (int i = (int)s.size() - 1; i >= 0; i--) {
      if (s[i] > v.s[i]) { return d; } if (s[i] < v.s[i]) { return -d; }
    }
    return 0;
  }
  bint abs()const { bint ret(*this); ret.sign *= ret.sign; return ret; }
  void trim() {
    while (!s.empty() && !s.back()) { s.pop_back(); }
    if (s.empty()) { sign = 1; }
  }
  void print()const {
    if (sign == -1) { putchar('-'); }
    printf("%d", s.empty() ? 0 : s.back());
    for (int i = (int)s.size() - 2; i >= 0; i--) { printf("%09d", s[i]); }
  }
  friend istream &operator>>(istream &in, bint &v) { string s; in >> s; v = s; return in; }
  friend ostream &operator<<(ostream &out, const bint &v) {
    if (v.sign == -1) { out << '-'; }
    out << setfill('0') << (v.s.empty() ? 0 : v.s.back());
    for (int i = (int)v.s.size() - 2; i >= 0; i--) { out << setw(BASEDIGITS) << v.s[i]; }
    return out << setfill(' ');
  }
  string toString()const {
    if (s.empty()) { return "0"; }
    string ret, x;
    if (sign == -1) { ret += '-'; }
    for (int o = s[s.size() - 1]; o; o /= 10) { x += o % 10 + '0'; }
    for (int i = (int)x.size() - 1; i >= 0; i--) { ret += x[i]; }
    for (int i = (int)s.size() - 2; i >= 0; i--) {
      x.clear();
      for (int j = 0, p = s[i]; j < BASEDIGITS; j++, p /= 10) { x += p % 10 + '0'; }
      for (int j = BASEDIGITS - 1; j >= 0; j--) { ret += x[j]; }
    }
    return ret;
  }
  operator bool()const { return s.size() && !(s.size() == 1 && !s[0]); }
  //高精度开方
  bint sqrt()const {
    bint ret, t(*this); ret.s.resize((t.s.size() + 1) >> 1);
    for (int i = (int)ret.s.size() - 1; i >= 0; i--) {
      int l = 0, r = BASE - 1, mid = ret.s[i] = (l + r + 1) >> 1;
      while (l < r) {
        if (comp(ret, mid, i - 1, t)) { r = mid - 1; }
        else { l = mid; }
        mid = ret.s[i] = (l + r + 1) >> 1;
      }
      sub(t, ret, mid, i - 1); ret.s[i] += mid;
    }
    for (int i = 0; i < (int)ret.s.size(); i++) { ret.s[i] >>= 1; }
    ret.trim(); return ret;
  }
  void sub(bint &a, const bint &b, const int &k, const int &d)const {
    for (int i = d + 1, l = b.s.size() + d; i <= l; i++) {
      ll tmp = a.s[i] - (ll)b.s[i - d - 1] * k;
      if (tmp < 0) { a.s[i + 1] += (tmp - BASE + 1) / BASE; a.s[i] = tmp - (tmp - BASE + 1) / BASE * BASE; }
      else { a.s[i] = tmp; }
    }
    for (int i = b.s.size() + d + 1; i < (int)a.s.size() && a.s[i] < 0; i++) {
      a.s[i + 1] += (a.s[i] - BASE + 1) / BASE; a.s[i] -= (a.s[i] - BASE + 1) / BASE * BASE;
    }
    a.trim();
  }
  bool comp(const bint &a, const int &c, const int &d, const bint &b)const {
    int l = -(BASE << 1); ll t = 0;
    if (b.s.size() < a.s.size() + d && c) { return true; }
    for (int i = (int)b.s.size() - 1; i > d; i--) {
      t = t * BASE + (ll)(i - d - 1 < (int)a.s.size() ? a.s[i - d - 1] : 0) * c - b.s[i];
      if (t > 0) { return true; }
      if (t < l) { return false; }
    }
    for (int i = d - 1; i >= 0; i--) {
      t = t * BASE - b.s[i];
      if (t > 0) { return true; }
      if (t < l) { return false; }
    }
    return t > 0;
  }
};