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
import java.io.*;
import java.util.*;

public class Solution {


    static MyScanner sc;
    private static PrintWriter out;
    static long M2 = 1_000_000_000L + 7;

    private static HashMap<Long, Long>[] mods;

    public static void main(String[] s) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();


        if (stringBuilder.length() == 0) {
            sc = new MyScanner(System.in);
        } else {
            sc = new MyScanner(new BufferedReader(new StringReader(stringBuilder.toString())));
        }

        out = new PrintWriter(new OutputStreamWriter(System.out));

        initData();
        solve();
        out.flush();
    }


    private static void initData() {


    }

    static String k;
    static long[] t0;
    static long[] t1;

    static long[] pow0;
    static long[] pow1;

    private static void solve() throws IOException {

        k = sc.next();
        t0 = new long[k.length() + 1];
        t1 = new long[k.length() + 1];
        pow0 = new long[k.length() + 1];
        pow1 = new long[k.length() + 1];
        pow0[0] = 1;
        pow1[0] = 1;
        for (int i = 0; i < k.length(); i++) {
            t0[i + 1] += 10 * t0[i] + k.charAt(i) - '0';
            t1[i + 1] += 10 * t1[i] + k.charAt(i) - '0';

            pow0[i + 1] += 10 * pow0[i];
            pow1[i + 1] += 10 * pow1[i];

            t0[i + 1] %= 1000000007;
            t1[i + 1] %= 1000000009;

            pow0[i + 1] %= 1000000007;
            pow1[i + 1] %= 1000000009;
        }

        int r1 = k.length() / 2;
        for (int l = 1; l < k.length(); l++) {
            if (check1(l - 1, k.length() - l - l + 1, l)) {
                out.println(pr(l - 1, k.length() - l - l + 1, l));
                return;
            }
            if (check1(l, k.length() - l - l, l)) {
                out.println(pr(l, k.length() - l - l, l));
                return;
            }

            if (check1(k.length() - l - l + 1, l - 1, l)) {
                out.println(pr(k.length() - l - l + 1, l - 1, l));
                return;
            }

            if (check1(k.length() - l - l, l, l)) {
                out.println(pr(k.length() - l - l, l, l));
                return;
            }


        }


    }

    private static String pr(int i, int l, int l1) {
        return k.substring(0, i) + "+" +
                k.substring(i, i + l) + "=" +
                k.substring(i + l);
    }

    private static boolean check1(int i1, int i2, int l) {
        if (i1 <= 0 || i2 <= 0) return false;
        if (i1 > l || i2 > l) return false;
        if (k.charAt(0) == '0' && i1 > 1 || k.charAt(i1) == '0' && i2 > 1 || k.charAt(i1 + i2) == '0' && l > 1) return false;
        long s1 = t0[i1];
        long s2 = t0[i2 + i1] - t0[i1] * (pow0[i2]) % 1000000007;
        long s3 = t0[i1 + i2 + l] - t0[i2 + i1] * pow0[l] % 1000000007;

        long rr = s1 + s2 - s3;
        if (rr % 1000000007 != 0) return false;


        s1 = t1[i1];
        s2 = t1[i2 + i1] - t1[i1] * (pow1[i2]) % 1000000009;
        s3 = t1[i1 + i2 + l] - t1[i2 + i1] * pow1[l] % 1000000009;

        rr = s1 + s2 - s3;
        if (rr % 1000000009 != 0) return false;


        int f0 = i1 - 1;
        int f1 = i1 + i2 - 1;
        int f2 = k.length() - 1;

        int v1 = 0;
        int v2 = 0;
        while (l-- > 0) {
            v1 += k.charAt(f2) - '0';
            if (f0 >= 0) {
                v2 += k.charAt(f0) - '0';
            }
            if (f1 >= i1) {
                v2 += k.charAt(f1) - '0';
            }
            if (v1 % 10 != v2 % 10) {
                return false;
            }
            v1 /= 10;
            v2 /= 10;

            f2--;
            f0--;
            f1--;
        }

        return v1 == v2;

    }

    private static boolean solve(int n, int p, int p1, int i) {
        return false;
    }


    private static boolean isset(long i, int k) {
        return (i & (1 << k)) > 0;
    }

    private static void solveT() throws IOException {
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }


    private static long gcd(long l, long l1) {
        if (l > l1) return gcd(l1, l);
        if (l == 0) return l1;
        return gcd(l1 % l, l);
    }

    private static long pow(long a, long b, long m) {
        if (b == 0) return 1;
        if (b == 1) return a;
        long pp = pow(a, b / 2, m);
        pp *= pp;
        pp %= m;
        return (pp * (b % 2 == 0 ? 1 : a)) % m;
    }


    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        MyScanner(BufferedReader br) {
            this.br = br;
        }

        public MyScanner(InputStream in) {
            this(new BufferedReader(new InputStreamReader(in)));
        }

        void findToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        String next() {
            findToken();
            return st.nextToken();
        }

        Integer[] nab(int n) {
            Integer[] k = new Integer[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        int[] na(int n) {
            int[] k = new int[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        long[] nl(int n) {
            long[] k = new long[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.nextLong();
            }
            return k;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        int fi() {
            String t = next();
            int cur = 0;
            boolean n = t.charAt(0) == '-';
            for (int a = n ? 1 : 0; a < t.length(); a++) {
                cur = cur * 10 + t.charAt(a) - '0';
            }
            return n ? -cur : cur;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }


}