A correct expression of the form a+b=c was written; a, b and c are non-negative integers without leading zeros. In this expression, the plus and equally signs were lost. The task is to restore the expression. In other words, one character '+' and one character '=' should be inserted into given sequence of digits so that: 

  * character'+' is placed on the left of character '=', 
  * characters '+' and '=' split the sequence into three non-empty subsequences consisting of digits (let's call the left part a, the middle part — b and the right part — c), 
  * all the three parts a, b and c do not contain leading zeros, 
  * it is true that a+b=c. 



It is guaranteed that in given tests answer always exists.

Input

The first line contains a non-empty string consisting of digits. The length of the string does not exceed 106.

Output

Output the restored expression. If there are several solutions, you can print any of them.

Note that the answer at first should contain two terms (divided with symbol '+'), and then the result of their addition, before which symbol'=' should be. 

Do not separate numbers and operation signs with spaces. Strictly follow the output format given in the examples.

If you remove symbol '+' and symbol '=' from answer string you should get a string, same as string from the input data.

Examples

Input

12345168


Output

123+45=168


Input

099


Output

0+9=9


Input

199100


Output

1+99=100


Input

123123123456456456579579579


Output

123123123+456456456=579579579
#include <bits/stdc++.h>
using namespace std;
long long int ceil_div(long long int a, long long int b) {
  if (a % b == 0)
    return a / b;
  else
    return a / b + 1;
}
class Extended_Euclid {
 private:
  long long int m, n;
  vector<vector<long long int>> mx_multiply(vector<vector<long long int>> mx1,
                                            vector<vector<long long int>> mx2) {
    vector<vector<long long int>> ret(mx1.size(),
                                      vector<long long int>(mx2[0].size(), 0));
    for (int i = 0; i < (int)mx1.size(); i++) {
      for (int j = 0; j < (int)mx1[0].size(); j++) {
        for (int k = 0; k < (int)mx2[0].size(); k++) {
          ret[i][j] += mx1[i][k] * mx2[k][j];
        }
      }
    }
    return ret;
  }
  bool adjust_into_range(
      long long int m, long long int n, long long int *x, long long int *y,
      pair<long long int, long long int> x_range = {LLONG_MIN, LLONG_MAX},
      pair<long long int, long long int> y_range = {LLONG_MIN, LLONG_MAX}) {
    if ((*x) < x_range.first && (*y) < y_range.first) return false;
    if ((*x) > x_range.second && (*y) > y_range.second) return false;
    long long int d;
    if ((*y) > y_range.second) {
      d = ceil_div((*y) - y_range.second, m);
      (*x) += n * d;
      (*y) -= m * d;
      if ((*x) > x_range.second || (*y) < y_range.first) return false;
    }
    if ((*y) < y_range.first) {
      d = ceil_div(y_range.first - (*y), m);
      (*x) -= n * d;
      (*y) += m * d;
      if ((*x) < x_range.first || (*y) > y_range.second) return false;
    }
    if ((*x) < x_range.first) {
      d = ceil_div(x_range.first - (*x), n);
      (*x) += n * d;
      (*y) -= m * d;
      if ((*x) > x_range.second || (*y) < y_range.first) return false;
    }
    if ((*x) > x_range.second) {
      d = ceil_div((*x) - x_range.second, n);
      (*x) -= n * d;
      (*y) += m * d;
      if ((*x) < x_range.first || (*y) > y_range.second) return false;
    }
    return true;
  }

 public:
  long long int x, y, gcd;
  Extended_Euclid(long long int M, long long int N) {
    m = M;
    n = N;
    vector<long long int> r(100), k(100);
    bool swapflag = false, m_negflag = false, n_negflag = false;
    if (m < n) {
      swap(m, n);
      swapflag = true;
    }
    if (m < 0) {
      m *= -1;
      m_negflag = true;
    }
    if (n < 0) {
      n *= -1;
      n_negflag = true;
    }
    r[0] = m;
    r[1] = n;
    int h = 1;
    while (1) {
      k[h - 1] = r[h - 1] / r[h];
      r[h + 1] = r[h - 1] % r[h];
      if (r[h + 1] == 0) break;
      h++;
    }
    gcd = r[h];
    vector<vector<long long int>> mx1 = {{0, 1}, {1, (-1) * k[h - 1]}};
    for (int i = (int)h - 1 - 1; i >= 0; i--) {
      vector<vector<long long int>> mx2 = {{0, 1}, {1, (-1) * k[i]}};
      mx1 = mx_multiply(mx1, mx2);
    }
    x = mx1[0][0];
    y = mx1[0][1];
    if (n_negflag) {
      n *= -1;
      y *= -1;
    }
    if (m_negflag) {
      m *= -1;
      x *= -1;
    }
    if (swapflag) {
      swap(m, n);
      swap(x, y);
    }
  }
  bool solve_equation(long long int r, long long int *x, long long int *y,
                      pair<long long int, long long int> x_range = {LLONG_MIN,
                                                                    LLONG_MAX},
                      pair<long long int, long long int> y_range = {
                          LLONG_MIN, LLONG_MAX}) {
    if (r % gcd != 0)
      return false;
    else {
      bool m_negflag = false, n_negflag = false;
      if (m < 0) {
        m *= -1;
        this->x *= -1;
        x_range = {-x_range.second, -x_range.first};
        m_negflag = true;
      }
      if (n < 0) {
        n *= -1;
        this->y *= -1;
        y_range = {-y_range.second, -y_range.first};
        n_negflag = true;
      }
      long long int ret_x = this->x * (r / gcd);
      long long int ret_y = this->y * (r / gcd);
      bool valid =
          adjust_into_range(m / gcd, n / gcd, &ret_x, &ret_y, x_range, y_range);
      if (n_negflag) {
        n *= -1;
        this->y *= -1;
        ret_y *= -1;
      }
      if (m_negflag) {
        m *= -1;
        this->x *= -1;
        ret_x *= -1;
      }
      if (!valid)
        return false;
      else {
        *x = ret_x;
        *y = ret_y;
        return true;
      }
    }
  }
};
namespace mod_op {
long long int modify(long long int n) {
  long long int ret;
  if (n > 0)
    ret = n - n / (long long int)(1e9 + 7) * (long long int)(1e9 + 7);
  else
    ret = n - (n - (long long int)(1e9 + 7) + 1) / (long long int)(1e9 + 7) *
                  (long long int)(1e9 + 7);
  return ret;
}
long long int mul(long long int x, long long int y) {
  return x * y % (long long int)(1e9 + 7);
}
long long int add(long long int x, long long int y) {
  return (x + y) % (long long int)(1e9 + 7);
}
long long int sub(long long int x, long long int y) { return modify(x - y); }
vector<long long int> factlist(long long int n) {
  if (n < 0)
    return {};
  else {
    vector<long long int> ret((int)n + 1);
    ret[0] = 1;
    for (int i = 1; i <= (int)(int)n; i++) ret[i] = mul(ret[i - 1], i);
    return ret;
  }
}
long long int powm(long long int n, long long int p) {
  if (p == 0)
    return 1;
  else if (p == 1)
    return n;
  else {
    long long int ans = pow(n, p / 2);
    ans = mul(ans, ans);
    if (p % 2 == 1) ans = mul(ans, n);
    return ans;
  }
}
long long int inv(long long int n) {
  Extended_Euclid ee(n, (long long int)(1e9 + 7) * (-1));
  return modify(ee.x);
}
long long int mod_combination(long long int n, long long int r) {
  vector<long long int> facts = factlist(n);
  return mul(facts[n], inv(mul(facts[r], facts[n - r])));
}
long long int divm(long long int x, long long int y) { return mul(x, inv(y)); }
}  // namespace mod_op
using namespace mod_op;
class String_Numeric {
 private:
  char base;
  int decimal, length;

 public:
  vector<long long int> unit_list;
  String_Numeric(char base, int decimal, int length) {
    String_Numeric::base = base;
    String_Numeric::decimal = decimal;
    String_Numeric::length = length;
    unit_list = vector<long long int>(length, 1);
    for (int i = 1; i <= (int)length - 1; i++) {
      unit_list[i] = mul(unit_list[i - 1], decimal);
    }
  }
  string addstr(string a, string b) {
    int n = max(a.size(), b.size());
    string ret;
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
    int carry = 0;
    for (int i = 0; i < (int)n; i++) {
      int sum;
      if (i >= a.size()) {
        sum = (b[i] - base) + carry;
      } else if (i >= b.size()) {
        sum = (a[i] - base) + carry;
      } else {
        sum = (a[i] - base) + (b[i] - base) + carry;
      }
      if (sum >= decimal) {
        sum %= decimal;
        carry = 1;
      } else {
        carry = 0;
      }
      ret += base + sum;
    }
    if (carry) ret += base + 1;
    reverse(ret.begin(), ret.end());
    return ret;
  }
  bool has_leading_zero(string s) {
    if (s.length() > 1 && s[0] == base)
      return true;
    else
      return false;
  }
  long long int modstr(string s) {
    int n = s.length();
    long long int ret = 0;
    for (int i = 0; i < (int)n; i++) {
      ret = add(ret, mul(s[n - i - 1] - base, unit_list[i]));
    }
    return ret;
  }
};
int main() {
  string s;
  cin >> s;
  int n = s.length();
  int decimal = 10;
  char base = '0';
  String_Numeric sn('0', 10, n + 1);
  int l = 1;
  int r = ceil_div(n - l, 2);
  int m = n - l - r;
  long long int hl = sn.modstr(s.substr(0, l));
  long long int hm = sn.modstr(s.substr(l, m));
  long long int hr = sn.modstr(s.substr(l + m, r));
  while (true) {
    if (m < 1 || r < 1 || max(l, m) > r)
      break;
    else {
      if (add(hl, hm) == hr) {
        string s_a = s.substr(0, l);
        string s_b = s.substr(l, m);
        string s_c = s.substr(l + m, r);
        if (!sn.has_leading_zero(s_a) && !sn.has_leading_zero(s_b) &&
            !sn.has_leading_zero(s_b)) {
          if (sn.addstr(s_a, s_b) == s_c) {
            cout << s_a << "+" << s_b << "=" << s_c << endl;
            return 0;
          }
        }
      }
      int next_l = l + 1;
      int next_r = ceil_div(n - next_l, 2);
      int next_m = n - next_l - next_r;
      hl = add(hl * decimal, s[l] - base);
      hm = sub(hm, (s[l] - base) * sn.unit_list[m - 1]);
      if (next_m == m) hm = add(hm * decimal, s[l + m] - base);
      if (next_r < r)
        hr = sub(hr, (s[l + m] - base) * sn.unit_list[r - 1]);
      else if (next_r > r)
        hr = add(hr, (s[l + m - 1] - base) * sn.unit_list[r]);
      l = next_l;
      m = next_m;
      r = next_r;
    }
  }
  l = ceil_div(n, 3);
  r = l;
  m = n - l - r;
  hl = sn.modstr(s.substr(0, l));
  hm = sn.modstr(s.substr(l, m));
  hr = sn.modstr(s.substr(l + m, r));
  while (true) {
    if (m < 1 || r < 1 || max(l, m) > r)
      break;
    else {
      if (add(hl, hm) == hr) {
        string s_a = s.substr(0, l);
        string s_b = s.substr(l, m);
        string s_c = s.substr(l + m, r);
        if (!sn.has_leading_zero(s_a) && !sn.has_leading_zero(s_b) &&
            !sn.has_leading_zero(s_b)) {
          if (sn.addstr(s_a, s_b) == s_c) {
            cout << s_a << "+" << s_b << "=" << s_c << endl;
            return 0;
          }
        }
      }
      int next_m = m - 1;
      int next_r = ceil_div(n - next_m, 2);
      int next_l = n - next_m - next_r;
      if (next_l > l) {
        hl = add(hl * decimal, s[l] - base);
        hm = sub(hm, (s[l] - base) * sn.unit_list[m - 1]);
      } else
        hm = divm(sub(hm, s[l + m - 1] - base), decimal);
      if (next_r < r)
        hr = sub(hr, (s[l + m] - base) * sn.unit_list[r - 1]);
      else if (next_r > r)
        hr = add(hr, (s[l + m - 1] - base) * sn.unit_list[r]);
      l = next_l;
      m = next_m;
      r = next_r;
    }
  }
  return 0;
}
