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.*;

public class P898F {
    private static class HpReader {
        private BufferedReader in;

        public HpReader(String dir, String inFile, String outFile) {
            initAndRedirectInOut(dir, inFile, outFile);
        }

        private static int ivl(String val) {
            return Integer.parseInt(val);
        }

        private static long lvl(String val) {
            return Long.parseLong(val);
        }

        private void initAndRedirectInOut(String dir, String inFile, String outFile) {
            if (dir != null) {
                try {
                    String containingDirPath = dir.endsWith(File.separator) ? dir : dir + File.separator;
                    if (isDebug && inFile != null) System.setIn(new FileInputStream(new File(containingDirPath + inFile)));
                    if (isDebug && outFile != null) System.setOut(new PrintStream(new File(containingDirPath + outFile)));
                } catch (FileNotFoundException e) {
                    // Do nothing, stdin & stdout are not redirected
                }
            }
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }

        private String nextSingleStr() throws IOException {
            return in.readLine();
        }

        private String[] nextLineStr() throws IOException {
            return nextLineStr(0);
        }

        private String[] nextLineStr(int offset) throws IOException {
            String[] inp = nextSingleStr().split(" ");
            String[] rs = new String[offset + inp.length];
            System.arraycopy(inp, 0, rs, offset, inp.length);
            return rs;
        }

        private int nextSingleInt() throws IOException {
            return ivl(in.readLine());
        }

        private int[] nextLineInt() throws IOException {
            return nextLineInt(0);
        }

        private int[] nextLineInt(int offset) throws IOException {
            String[] inp = nextLineStr();
            int[] rs = new int[offset + inp.length];
            for (int i = 0; i < inp.length; i++) rs[offset + i] = ivl(inp[i]);
            return rs;
        }

        private long nextSingleLong() throws IOException {
            return lvl(in.readLine());
        }

        private long[] nextLineLong() throws IOException {
            return nextLineLong(0);
        }

        private long[] nextLineLong(int offset) throws IOException {
            String[] inp = nextLineStr();
            long[] rs = new long[offset + inp.length];
            for (int i = 0; i < inp.length; i++) rs[offset + i] = lvl(inp[i]);
            return rs;
        }

        private int[][] nextMatInt(int lineCount) throws IOException {
            return nextMatInt(lineCount, 0, 0);
        }

        private int[][] nextMatInt(int lineCount, int rowOffset, int colOffset) throws IOException {
            int[][] rs = new int[rowOffset + lineCount][];
            for (int i = rowOffset; i < rs.length; i++) rs[i] = nextLineInt(colOffset);
            return rs;
        }
    }

    private static class HpHelper {
        private static final String LOCAL_DEBUG_FLAG = "COM_PROG_DEBUG";

        private static boolean isDebug() {
            try {
                return Boolean.parseBoolean(System.getenv(HpHelper.LOCAL_DEBUG_FLAG));
            } catch (Exception e) {
                return false;
            }
        }

        private static String createDelimiter(String delimiter) {
            return delimiter == null ? " " : delimiter;
        }

        private static void println(int[] data, String delimiter) {
            delimiter = createDelimiter(delimiter);
            for (int t : data) out.print(t + delimiter);
            out.println();
        }

        private static void println(long[] data, String delimiter) {
            delimiter = createDelimiter(delimiter);
            for (long t : data) out.print(t + delimiter);
            out.println();
        }

        private static <T> void println(T[] data, String delimiter) {
            delimiter = createDelimiter(delimiter);
            for (T t : data) {
                if (t instanceof int[]) {
                    println((int[]) t, delimiter);
                } else if (t instanceof long[]) {
                    println((long[]) t, delimiter);
                } else if (t instanceof Object[]) {
                    println((Object[]) t, delimiter);
                } else {
                    out.print(t + delimiter);
                }
            }
            out.println();
        }
    }

    private static boolean isDebug = HpHelper.isDebug();
    private static HpReader in = new HpReader("/Users/apple/Work/WorkSpaces/CompetitiveProg/", "in.txt", null);
    private static PrintWriter out;

    private static long[] mods;
    private static long[][] hash, powMod;

    private static void output(String s, int la, int lc) {
        int lb = s.length() - la - lc;
        out.printf("%s+%s=%s", s.substring(0, la), s.substring(la, la + lb), s.substring(la + lb, la + lb + lc));
    }

    private static boolean leadingInvalid(String s, int l, int startIdx) {
        return s.charAt(startIdx) == '0' && l != 1;
    }

    private static boolean tryWith(String s, int la, int lc) {
        int lb = s.length() - la - lc;

        if (la <= 0 || lb <= 0 || lc <= 0) return false;
        if (leadingInvalid(s, la, 0) || leadingInvalid(s, lb, la) || leadingInvalid(s, lc, la + lb)) return false;

        for (int i = 0; i < mods.length; i++) {
            long mod = mods[i];
            long[] hashes = hash[i], powMods = powMod[i];

            long hashA = hashes[la - 1];
            long hashB = (hashes[la + lb - 1] - (hashes[la - 1] * powMods[lb]) % mod + mod) % mod;
            long hashC = (hashes[la + lb + lc - 1] - (hashes[la + lb - 1] * powMods[lc]) % mod + mod) % mod;

            if ((hashA + hashB) % mod != hashC) return false;
        }

        return true;
    }

    public static void main(String[] args) throws IOException {
        String s = in.nextSingleStr();
        int n = s.length(), base = 10;

        mods = new long[]{(long) (1e9 + 7), (long) (1e9 + 11)};
        hash = new long[mods.length][n];
        powMod = new long[mods.length][n];

        for (int i = 0; i < mods.length; i++) {
            for (int j = 0; j < n; j++) {
                hash[i][j] = (j == 0 ? s.charAt(j) - '0' : (hash[i][j - 1] * base + (s.charAt(j) - '0')) % mods[i]);
                powMod[i][j] = (j == 0 ? 1 : (powMod[i][j - 1] * base) % mods[i]);
            }
        }
        for (int lc = 1; lc <= n / 2 + 1; lc++) {
            int l1 = lc, l2 = lc - 1;
            if (tryWith(s, l1, lc)) output(s, l1, lc);
            else if (tryWith(s, l2, lc)) output(s, l2, lc);
            else if (tryWith(s, n - lc - l1, lc)) output(s, n - lc - l1, lc);
            else if (tryWith(s, n - lc - l2, lc)) output(s, n - lc - l2, lc);
        }

        out.flush();
    }
}
