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.math.BigInteger;
import java.util.*;
import java.util.concurrent.TimeUnit;

public class f451 implements Runnable{
	
    public static void main(String[] args) {
    	try{
            new Thread(null, new f451(), "process", 1<<26).start();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
	public void run() {
		FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		//PrintWriter out = new PrintWriter("file.out");
		Task solver = new Task();
		//int t = scan.nextInt();
		int t = 1;
		for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
		out.close();
	}

	static class Task {
		static final int inf = Integer.MAX_VALUE;
		static final int MOD = 1000000009;

		public void solve(int testNumber, FastReader sc, PrintWriter out) {
			String s = sc.nextLine();
			int N = s.length();
			StringHash sh = new StringHash(s);
			
			int maxSize = N/2;
			int minSize = (N+2)/3;
			
			for(int len = minSize; len <= maxSize; len++) {
				// A = len, B = whatever's left
				int A = len, B = N - len - len;
				if(A > 0 && B > 0) {
//					System.out.println(A);
//					System.out.println(sh.hash(0, A) + " " + sh.hash(A, A+B));
					if((sh.hash(0, A-1) + sh.hash(A,  A+B-1)) % MOD == sh.hash(A+B, N-1) && check(A, A + B, s)) {
						out.println(s.substring(0,A) + "+" + s.substring(A,A+B) + "=" + s.substring(A+B));
						return;
					}
				}
				// A = len - 1, B = whatever's left
				
				A = len - 1; B = N - len - A;
				if(A > 0 && B > 0) {
					if((sh.hash(0, A-1) + sh.hash(A,  A+B-1)) % MOD == sh.hash(A+B, N-1) && check(A, A + B, s)) {
						out.println(s.substring(0,A) + "+" + s.substring(A,A+B) + "=" + s.substring(A+B));
						return;
					}
				}
				// B = len, A = whatever's left
				
				B = len; A = N - len - B;
				if(A > 0 && B > 0) {
					if((sh.hash(0, A-1) + sh.hash(A,  A+B-1)) % MOD == sh.hash(A+B, N-1) && check(A, A + B, s)) {
						out.println(s.substring(0,A) + "+" + s.substring(A,A+B) + "=" + s.substring(A+B));
						return;
					}
				}
				// B = len - 1, A = whatever's left
				
				B = len - 1; A = N - len - B;
				if(A > 0 && B > 0) {
					if((sh.hash(0, A-1) + sh.hash(A,  A+B-1)) % MOD == sh.hash(A+B, N-1) && check(A, A + B, s)) {
						out.println(s.substring(0,A) + "+" + s.substring(A,A+B) + "=" + s.substring(A+B));
						return;
					}
				}
			}
		}
		
		public static boolean check(int B, int C, String s) {
			if(s.charAt(0) == '0' && B > 1)
				return false;
			if(s.charAt(B) == '0' && C-B > 1)
				return false;
			if(s.charAt(C) == '0' && s.length() - C > 1)
				return false;
			return true;
//			BigInteger a = new BigInteger(s.substring(0,B));
//			BigInteger b = new BigInteger(s.substring(B,C));
//			BigInteger c = new BigInteger(s.substring(C, s.length()));
//			
//			if(a.add(b).equals(c)) {
//				return true;
//			}
//			return false;
		}
		
		public static class StringHash { // polynomial rolling hash function for a string
			public static final long P = 10; // next-largest prime when compared to size of "alphabet"
			public static final long MOD = 1000000009; // any large prime. the larger it is, the less likely collisions are
			
			public long[] hash;
			public long[] binPow;
			
			public StringHash(String s) { // preprocess in N log N
				long hashVal = 0;
				long pow = P;
				
				hash = new long[s.length()];
				for(int i = 0; i < s.length(); i++) {
					hashVal = ((hashVal*pow)%MOD + (s.charAt(i) - '0')) % MOD;
					//pow *= P;
					//pow %= MOD;
					hash[i] = hashVal;
				}
				
				binPow = new long[s.length()+2];
				binPow[0] = 1;
				for(int i = 1; i < binPow.length; i++) {
					binPow[i] = binPow[i-1] * 10;
					binPow[i] %= MOD;
				}
				//System.out.println(Arrays.toString(hash));
			}
			
			public long binpow(long a, long b, long m) {
				a %= m;
				long res = 1;
				while (b > 0) {
					if ((b & 1) == 1)
						res = res * a % m;
					a = a * a % m;
					b >>= 1;
				}
				return res;
			}
			
			public long hash(int L, int R) { // L, R inclusive. Returns hash value of substring
				long val = hash[R] - (L == 0 ? 0 : hash[L-1]) % MOD * binPow[R-L+1] % MOD;
				if(val < 0)
					val += MOD;
				return (val) % MOD;
			}
		}
	}
	static long binpow(long a, long b, long m) {
		a %= m;
		long res = 1;
		while (b > 0) {
			if ((b & 1) == 1)
				res = res * a % m;
			a = a * a % m;
			b >>= 1;
		}
		return res;
	}
	static void sort(int[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static void sort(long[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static class tup implements Comparable<tup>, Comparator<tup>{
		int a, b;
		tup(int a,int b){
			this.a=a;
			this.b=b;
		}
		public tup() {
		}
		@Override
		public int compareTo(tup o){
			return Integer.compare(b,o.b);
		}
		@Override
		public int compare(tup o1, tup o2) {
			return Integer.compare(o1.b, o2.b);
		}
		
		@Override
	    public int hashCode() {
			return Objects.hash(a, b);
	    }
 
	    @Override
	    public boolean equals(Object obj) {
	    	if (this == obj)
                return true;
	    	if (obj == null)
                return false;
	    	if (getClass() != obj.getClass())
                return false;
	    	tup other = (tup) obj;
	    	return a==other.a && b==other.b;
	    }
	    
	    @Override
	    public String toString() {
	    	return a + " " + b;
	    }
	}
	
	static void shuffle(int[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			int temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static void shuffle(long[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			long temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		public FastReader(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

}