#include <bits/stdc++.h>
char str[1048576];
typedef struct {
  int start;
  int end;
  unsigned hash[3];
  unsigned m[3];
  unsigned table[3][20];
} sectionhash;
int testhash(const unsigned ha[3], const unsigned hb[3], const unsigned hc[3],
             const unsigned m[3]);
inline int testhash(const unsigned ha[3], const unsigned hb[3],
                    const unsigned hc[3], const unsigned m[3]) {
  unsigned sum, ch;
  sum = ha[0] + hb[0];
  ch = hc[0];
  if (sum != ch && sum != ch + m[0]) return 0;
  sum = ha[1] + hb[1];
  ch = hc[1];
  if (sum != ch && sum != ch + m[1]) return 0;
  sum = ha[2] + hb[2];
  ch = hc[2];
  if (sum != ch && sum != ch + m[2]) return 0;
  return 1;
}
int testadd(const char* const s, const char* const p, const char* const q,
            const char* const l);
inline int testadd(const char* const s, const char* const p,
                   const char* const q, const char* const l) {
  if (*p == '0' && q - p > 1) return 0;
  if (*q == '0' && l - q > 1) return 0;
  register char x, y;
  const char *a, *b, *c;
  y = 0;
  a = p, b = q, c = l;
  for (;;) {
    if (--c < q) return !y;
    x = y, y = 0;
    if (a > s) x += *(--a) - '0';
    if (b > p) y = *(--b) - '0';
    x = x + y;
    if (x >= 10)
      x = x - 10, y = 1;
    else
      y = 0;
    if (x != *c - '0') return 0;
  }
}
void output(int p, int q, int lob, int loc) {
  fwrite(&str[0], p, 1, stdout);
  putchar('+');
  fwrite(&str[p], lob, 1, stdout);
  putchar('=');
  fwrite(&str[q], loc, 1, stdout);
}
void init_pow10m(const unsigned int m, unsigned int table[]) {
  unsigned long long pm = 10;
  table[0] = 10;
  for (int i = 1; i < 20; i++) {
    pm = (pm * pm) % m;
    table[i] = pm;
  }
}
unsigned int xpow10m(const unsigned int x, const unsigned int p,
                     const unsigned int m, const unsigned int table[]);
inline unsigned int xpow10m(const unsigned int x, const unsigned int p,
                            const unsigned int m, const unsigned int table[]) {
  unsigned long long ans = x;
  unsigned mbt = 1, i = 0;
  while (p >= mbt) {
    if (p & mbt) ans = (ans * table[i]) % m;
    mbt <<= 1;
    i++;
  }
  return ans;
}
void init_sectionhash(const int start, const int end, sectionhash* const sec) {
  unsigned long long hash[3] = {0};
  sec->start = start;
  sec->end = end;
  sec->m[0] = 1000000001;
  sec->m[1] = 1000000002;
  sec->m[2] = 1000000003;
  init_pow10m(1000000001, sec->table[0]);
  init_pow10m(1000000002, sec->table[1]);
  init_pow10m(1000000003, sec->table[2]);
  unsigned(*table)[20] = sec->table;
  for (int i = end - 1; i >= start; i--) {
    int x = str[i] - '0', p = end - 1 - i;
    hash[0] = (hash[0] + xpow10m(x, p, 1000000001, table[0])) % 1000000001;
    hash[1] = (hash[1] + xpow10m(x, p, 1000000002, table[1])) % 1000000002;
    hash[2] = (hash[2] + xpow10m(x, p, 1000000003, table[2])) % 1000000003;
  }
  sec->hash[0] = hash[0];
  sec->hash[1] = hash[1];
  sec->hash[2] = hash[2];
}
void inc_sectionstart(sectionhash* const sec);
inline void inc_sectionstart(sectionhash* const sec) {
  unsigned hash[3], m[3];
  int start = sec->start, x = str[start] - '0', p = sec->end - start - 1;
  unsigned(*table)[20] = sec->table;
  hash[0] = sec->hash[0];
  hash[1] = sec->hash[1];
  hash[2] = sec->hash[2];
  m[0] = sec->m[0];
  m[1] = sec->m[1];
  m[2] = sec->m[2];
  hash[0] = hash[0] + m[0] - xpow10m(x, p, m[0], table[0]);
  hash[1] = hash[1] + m[1] - xpow10m(x, p, m[1], table[1]);
  hash[2] = hash[2] + m[2] - xpow10m(x, p, m[2], table[2]);
  if (hash[0] >= m[0]) hash[0] -= m[0];
  if (hash[1] >= m[1]) hash[1] -= m[1];
  if (hash[2] >= m[2]) hash[2] -= m[2];
  sec->hash[0] = hash[0];
  sec->hash[1] = hash[1];
  sec->hash[2] = hash[2];
  sec->start = start + 1;
}
void dec_sectionstart(sectionhash* const sec);
inline void dec_sectionstart(sectionhash* const sec) {
  unsigned hash[3], m[3];
  int start = sec->start - 1, x = str[start] - '0', p = sec->end - start - 1;
  unsigned(*table)[20] = sec->table;
  hash[0] = sec->hash[0];
  hash[1] = sec->hash[1];
  hash[2] = sec->hash[2];
  m[0] = sec->m[0];
  m[1] = sec->m[1];
  m[2] = sec->m[2];
  hash[0] = hash[0] + xpow10m(x, p, m[0], table[0]);
  hash[1] = hash[1] + xpow10m(x, p, m[1], table[1]);
  hash[2] = hash[2] + xpow10m(x, p, m[2], table[2]);
  if (hash[0] >= m[0]) hash[0] -= m[0];
  if (hash[1] >= m[1]) hash[1] -= m[1];
  if (hash[2] >= m[2]) hash[2] -= m[2];
  sec->hash[0] = hash[0];
  sec->hash[1] = hash[1];
  sec->hash[2] = hash[2];
  sec->start = start;
}
void inc_sectionend(sectionhash* const sec);
inline void inc_sectionend(sectionhash* const sec) {
  unsigned long long hash[3];
  unsigned m[3];
  int end = sec->end, x = str[end] - '0';
  hash[0] = sec->hash[0];
  hash[1] = sec->hash[1];
  hash[2] = sec->hash[2];
  m[0] = sec->m[0];
  m[1] = sec->m[1];
  m[2] = sec->m[2];
  sec->hash[0] = ((hash[0] << 1) + (hash[0] << 3) + x) % m[0];
  sec->hash[1] = ((hash[1] << 1) + (hash[1] << 3) + x) % m[1];
  sec->hash[2] = ((hash[2] << 1) + (hash[2] << 3) + x) % m[2];
  sec->end = end + 1;
}
unsigned a2hash[524288][4];
int main() {
  int len, p1, p2, q, p;
  len = fread(str, sizeof(char), sizeof(str), stdin);
  while (str[len - 1] < '0') --len;
  sectionhash a1, b1, b2, c;
  q = len - (len >> 1);
  p1 = 1, p2 = q - 1;
  init_sectionhash(q, len, &c);
  init_sectionhash(0, p1, &a1);
  init_sectionhash(p1, q, &b1);
  init_sectionhash(p2, q, &b2);
  sectionhash a2;
  int a2size = len >> 1;
  init_sectionhash(0, 1, &a2);
  for (int i = 1; i <= a2size; i++) {
    a2hash[i][0] = a2.hash[0];
    a2hash[i][1] = a2.hash[1];
    a2hash[i][2] = a2.hash[2];
    inc_sectionend(&a2);
  }
  if (testhash(a1.hash, b1.hash, c.hash, c.m))
    if (testadd(&str[0], &str[p1], &str[q], &str[len])) {
      p = p1;
      goto bingo;
    }
  if (testhash(a2hash[p2], b2.hash, c.hash, c.m))
    if (testadd(&str[0], &str[p2], &str[q], &str[len])) {
      p = p2;
      goto bingo;
    }
  if (len & 1)
    goto equal;
  else
    goto inequal;
  for (;;) {
  equal:
    if (++p1 > p2) break;
    inc_sectionend(&a1);
    inc_sectionstart(&b1);
    if (testhash(a1.hash, b1.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p1], &str[q], &str[len])) {
        p = p1;
        goto bingo;
      }
    if (--p2 <= p1) break;
    dec_sectionstart(&b2);
    if (testhash(a2hash[p2], b2.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p2], &str[q], &str[len])) {
        p = p2;
        goto bingo;
      }
  inequal:
    q++;
    inc_sectionend(&b1);
    inc_sectionend(&b2);
    inc_sectionstart(&c);
    if (testhash(a2hash[p2], b2.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p2], &str[q], &str[len])) {
        p = p2;
        goto bingo;
      }
    if (++p1 >= p2) break;
    inc_sectionend(&a1);
    inc_sectionstart(&b1);
    if (testhash(a1.hash, b1.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p1], &str[q], &str[len])) {
        p = p1;
        goto bingo;
      }
  }
  return 0;
bingo:
  output(p, q, q - p, len - q);
  return 0;
}

### Prompt

Please create a solution in Cpp to the following problem:

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

### Response

```cpp
#include <bits/stdc++.h>
char str[1048576];
typedef struct {
  int start;
  int end;
  unsigned hash[3];
  unsigned m[3];
  unsigned table[3][20];
} sectionhash;
int testhash(const unsigned ha[3], const unsigned hb[3], const unsigned hc[3],
             const unsigned m[3]);
inline int testhash(const unsigned ha[3], const unsigned hb[3],
                    const unsigned hc[3], const unsigned m[3]) {
  unsigned sum, ch;
  sum = ha[0] + hb[0];
  ch = hc[0];
  if (sum != ch && sum != ch + m[0]) return 0;
  sum = ha[1] + hb[1];
  ch = hc[1];
  if (sum != ch && sum != ch + m[1]) return 0;
  sum = ha[2] + hb[2];
  ch = hc[2];
  if (sum != ch && sum != ch + m[2]) return 0;
  return 1;
}
int testadd(const char* const s, const char* const p, const char* const q,
            const char* const l);
inline int testadd(const char* const s, const char* const p,
                   const char* const q, const char* const l) {
  if (*p == '0' && q - p > 1) return 0;
  if (*q == '0' && l - q > 1) return 0;
  register char x, y;
  const char *a, *b, *c;
  y = 0;
  a = p, b = q, c = l;
  for (;;) {
    if (--c < q) return !y;
    x = y, y = 0;
    if (a > s) x += *(--a) - '0';
    if (b > p) y = *(--b) - '0';
    x = x + y;
    if (x >= 10)
      x = x - 10, y = 1;
    else
      y = 0;
    if (x != *c - '0') return 0;
  }
}
void output(int p, int q, int lob, int loc) {
  fwrite(&str[0], p, 1, stdout);
  putchar('+');
  fwrite(&str[p], lob, 1, stdout);
  putchar('=');
  fwrite(&str[q], loc, 1, stdout);
}
void init_pow10m(const unsigned int m, unsigned int table[]) {
  unsigned long long pm = 10;
  table[0] = 10;
  for (int i = 1; i < 20; i++) {
    pm = (pm * pm) % m;
    table[i] = pm;
  }
}
unsigned int xpow10m(const unsigned int x, const unsigned int p,
                     const unsigned int m, const unsigned int table[]);
inline unsigned int xpow10m(const unsigned int x, const unsigned int p,
                            const unsigned int m, const unsigned int table[]) {
  unsigned long long ans = x;
  unsigned mbt = 1, i = 0;
  while (p >= mbt) {
    if (p & mbt) ans = (ans * table[i]) % m;
    mbt <<= 1;
    i++;
  }
  return ans;
}
void init_sectionhash(const int start, const int end, sectionhash* const sec) {
  unsigned long long hash[3] = {0};
  sec->start = start;
  sec->end = end;
  sec->m[0] = 1000000001;
  sec->m[1] = 1000000002;
  sec->m[2] = 1000000003;
  init_pow10m(1000000001, sec->table[0]);
  init_pow10m(1000000002, sec->table[1]);
  init_pow10m(1000000003, sec->table[2]);
  unsigned(*table)[20] = sec->table;
  for (int i = end - 1; i >= start; i--) {
    int x = str[i] - '0', p = end - 1 - i;
    hash[0] = (hash[0] + xpow10m(x, p, 1000000001, table[0])) % 1000000001;
    hash[1] = (hash[1] + xpow10m(x, p, 1000000002, table[1])) % 1000000002;
    hash[2] = (hash[2] + xpow10m(x, p, 1000000003, table[2])) % 1000000003;
  }
  sec->hash[0] = hash[0];
  sec->hash[1] = hash[1];
  sec->hash[2] = hash[2];
}
void inc_sectionstart(sectionhash* const sec);
inline void inc_sectionstart(sectionhash* const sec) {
  unsigned hash[3], m[3];
  int start = sec->start, x = str[start] - '0', p = sec->end - start - 1;
  unsigned(*table)[20] = sec->table;
  hash[0] = sec->hash[0];
  hash[1] = sec->hash[1];
  hash[2] = sec->hash[2];
  m[0] = sec->m[0];
  m[1] = sec->m[1];
  m[2] = sec->m[2];
  hash[0] = hash[0] + m[0] - xpow10m(x, p, m[0], table[0]);
  hash[1] = hash[1] + m[1] - xpow10m(x, p, m[1], table[1]);
  hash[2] = hash[2] + m[2] - xpow10m(x, p, m[2], table[2]);
  if (hash[0] >= m[0]) hash[0] -= m[0];
  if (hash[1] >= m[1]) hash[1] -= m[1];
  if (hash[2] >= m[2]) hash[2] -= m[2];
  sec->hash[0] = hash[0];
  sec->hash[1] = hash[1];
  sec->hash[2] = hash[2];
  sec->start = start + 1;
}
void dec_sectionstart(sectionhash* const sec);
inline void dec_sectionstart(sectionhash* const sec) {
  unsigned hash[3], m[3];
  int start = sec->start - 1, x = str[start] - '0', p = sec->end - start - 1;
  unsigned(*table)[20] = sec->table;
  hash[0] = sec->hash[0];
  hash[1] = sec->hash[1];
  hash[2] = sec->hash[2];
  m[0] = sec->m[0];
  m[1] = sec->m[1];
  m[2] = sec->m[2];
  hash[0] = hash[0] + xpow10m(x, p, m[0], table[0]);
  hash[1] = hash[1] + xpow10m(x, p, m[1], table[1]);
  hash[2] = hash[2] + xpow10m(x, p, m[2], table[2]);
  if (hash[0] >= m[0]) hash[0] -= m[0];
  if (hash[1] >= m[1]) hash[1] -= m[1];
  if (hash[2] >= m[2]) hash[2] -= m[2];
  sec->hash[0] = hash[0];
  sec->hash[1] = hash[1];
  sec->hash[2] = hash[2];
  sec->start = start;
}
void inc_sectionend(sectionhash* const sec);
inline void inc_sectionend(sectionhash* const sec) {
  unsigned long long hash[3];
  unsigned m[3];
  int end = sec->end, x = str[end] - '0';
  hash[0] = sec->hash[0];
  hash[1] = sec->hash[1];
  hash[2] = sec->hash[2];
  m[0] = sec->m[0];
  m[1] = sec->m[1];
  m[2] = sec->m[2];
  sec->hash[0] = ((hash[0] << 1) + (hash[0] << 3) + x) % m[0];
  sec->hash[1] = ((hash[1] << 1) + (hash[1] << 3) + x) % m[1];
  sec->hash[2] = ((hash[2] << 1) + (hash[2] << 3) + x) % m[2];
  sec->end = end + 1;
}
unsigned a2hash[524288][4];
int main() {
  int len, p1, p2, q, p;
  len = fread(str, sizeof(char), sizeof(str), stdin);
  while (str[len - 1] < '0') --len;
  sectionhash a1, b1, b2, c;
  q = len - (len >> 1);
  p1 = 1, p2 = q - 1;
  init_sectionhash(q, len, &c);
  init_sectionhash(0, p1, &a1);
  init_sectionhash(p1, q, &b1);
  init_sectionhash(p2, q, &b2);
  sectionhash a2;
  int a2size = len >> 1;
  init_sectionhash(0, 1, &a2);
  for (int i = 1; i <= a2size; i++) {
    a2hash[i][0] = a2.hash[0];
    a2hash[i][1] = a2.hash[1];
    a2hash[i][2] = a2.hash[2];
    inc_sectionend(&a2);
  }
  if (testhash(a1.hash, b1.hash, c.hash, c.m))
    if (testadd(&str[0], &str[p1], &str[q], &str[len])) {
      p = p1;
      goto bingo;
    }
  if (testhash(a2hash[p2], b2.hash, c.hash, c.m))
    if (testadd(&str[0], &str[p2], &str[q], &str[len])) {
      p = p2;
      goto bingo;
    }
  if (len & 1)
    goto equal;
  else
    goto inequal;
  for (;;) {
  equal:
    if (++p1 > p2) break;
    inc_sectionend(&a1);
    inc_sectionstart(&b1);
    if (testhash(a1.hash, b1.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p1], &str[q], &str[len])) {
        p = p1;
        goto bingo;
      }
    if (--p2 <= p1) break;
    dec_sectionstart(&b2);
    if (testhash(a2hash[p2], b2.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p2], &str[q], &str[len])) {
        p = p2;
        goto bingo;
      }
  inequal:
    q++;
    inc_sectionend(&b1);
    inc_sectionend(&b2);
    inc_sectionstart(&c);
    if (testhash(a2hash[p2], b2.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p2], &str[q], &str[len])) {
        p = p2;
        goto bingo;
      }
    if (++p1 >= p2) break;
    inc_sectionend(&a1);
    inc_sectionstart(&b1);
    if (testhash(a1.hash, b1.hash, c.hash, c.m))
      if (testadd(&str[0], &str[p1], &str[q], &str[len])) {
        p = p1;
        goto bingo;
      }
  }
  return 0;
bingo:
  output(p, q, q - p, len - q);
  return 0;
}

```