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
/* Author: Ronak Agarwal */
import java.io.* ; import java.util.* ; import java.math.* ;
import static java.lang.Math.min ;
import static java.lang.Math.max ;
import static java.lang.Math.abs ;
import static java.lang.Math.log ;
import static java.lang.Math.pow ;
import static java.lang.Math.sqrt ;
/* Thread is created here to increase the stack size of the java code so that recursive dfs can be performed */
public class Codeshefcode{
	public static void main(String[] args) throws IOException{
		new Thread(null,new Runnable(){	public void run(){ exec_Code() ;} },"Solver",1l<<27).start() ;
	}
	static void exec_Code(){
		try{
			Solver Machine = new Solver() ;
			Machine.Solve() ; Machine.Finish() ;}
		catch(Exception e){ e.printStackTrace() ; print_and_exit() ;}
		catch(Error e){ e.printStackTrace() ; print_and_exit() ; }
	}
	static void print_and_exit(){ System.out.flush() ; System.exit(-1) ;}
}
class Reader{
	BufferedReader reader;
	StringTokenizer tkz;
	Reader(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input)) ;
		tkz = new StringTokenizer("") ;
	}
	String s() throws IOException{
		while (!tkz.hasMoreTokens()) tkz = new StringTokenizer(reader.readLine()) ;
		return tkz.nextToken() ;
	}
	int i() throws IOException{ return Integer.parseInt(s()) ;}
	long l() throws IOException{ return Long.parseLong(s()) ;}
	double d() throws IOException{	return Double.parseDouble(s()) ;}
}
/* All the useful functions,constants,renamings are here*/
class Template{
	/* Constants Section */
	final int INT_MIN = Integer.MIN_VALUE ; final int INT_MAX = Integer.MAX_VALUE ;
	final long LONG_MIN = Long.MIN_VALUE ; final long LONG_MAX = Long.MAX_VALUE ;
	static long MOD = 1000000007 ;
	static Reader ip = new Reader(System.in) ;	
	static PrintWriter op = new PrintWriter(System.out) ;
	/* Methods for writing */
	static void p(Object o){ op.print(o) ; }
	static void pln(Object o){ op.println(o) ;}
	static void Finish(){ op.flush();	op.close(); }
	/* Implementation of operations modulo MOD */
	static long inv(long a){ return powM(a,MOD-2) ; }
	static long m(long a,long b){ return (a*b)%MOD ; }
	static long d(long a,long b){ return (a*inv(b))%MOD ; }
	static long powM(long a,long b){
		if(b<0) return powM(inv(a),-b) ;
		long val=a ; long ans=1 ;
		while(b!=0){
			if((b&1)==1) ans = (ans*val)%MOD ; 
			val = (val*val)%MOD ; 
			b/=2 ;
		}
		return ans ;
	}
	/* Renaming of some generic utility classes */
	final static class mylist extends ArrayList<Integer>{}
	final static class myset extends TreeSet<pair>{}
	final static class mystack extends Stack<Integer>{}
	final static class mymap extends TreeMap<String,Integer>{}
}
/* Implementation of the pair class, useful for every other problem */
class pair implements Comparable<pair>{
	long x ; long y ;
	pair(long _x,long _y){ x=_x ; y=_y ;} 
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
/* Main code starts here */
class Solver extends Template{
	long MOD1 = 1000000009 ;
	char cr[] ;
	int n ;
	pair dig[],hash[],p10[],p10i[] ;
	pair zr = new pair(0,0) ;
	pair add(pair p1,pair p2){
		return new pair((p1.x+p2.x)%MOD,(p1.y+p2.y)%MOD1) ;
	}
	pair sub(pair p1,pair p2){
		return new pair((p1.x-p2.x+MOD)%MOD,(p1.y-p2.y+MOD1)%MOD1) ;
	}
	pair mul(pair p1,pair p2){
		return new pair((p1.x*p2.x)%MOD,(p1.y*p2.y)%MOD1) ;
	}
	pair cal_hash(int i,int j){
		pair p1 = sub(hash[i],hash[j+1]) ;
		pair p2 = p10i[(n-1)-j] ;
		return mul(p1,p2) ;
	}
	void fillpow(){
		long ten = 10 ;
		long ten_xi = inv(10) ;
		long tmp = MOD ; MOD = MOD1 ;
		long ten_yi = inv(10) ;
		MOD = tmp ;
		long p10x=1,p10y=1,p10xi=1,p10yi=1 ;
		for(int i=0 ; i<n ; i++){
			p10[i] = new pair(p10x,p10y) ;
			p10i[i] = new pair(p10xi,p10yi) ;
			p10x = (p10x*ten)%MOD ;
			p10y = (p10y*ten)%MOD1 ;
			p10xi = (p10xi*ten_xi)%MOD ;
			p10yi = (p10yi*ten_yi)%MOD1 ;
		}
	}
	boolean check(int j,int i){
		if(!(j<(i-1) && j>=0)) return false ;
		if(j>=1 && dig[0].compareTo(zr)==0) return false ;
		if((i-(j+1))>=2 && dig[j+1].compareTo(zr)==0) return false ;
		if((n-i)>=2 && dig[i].compareTo(zr)==0) return false ;
		return true ; 
	}
	boolean verify(int j,int i){
		// pln("i="+i+","+"j="+j) ;
		pair v1 = cal_hash(0,j) ;
		pair v2 = cal_hash(j+1,i-1) ;
		pair res = add(v1,v2) ;
		// pln("v1 is "+v1.x+" "+v1.y) ;
		// pln("v2 is "+v2.x+" "+v2.y) ;
		// pln("res is "+res.x+" "+res.y) ;
		return res.compareTo(cal_hash(i,(n-1)))==0 ;
	}
	void print(int j,int i){
		for(int itr=0 ; itr<=j ; itr++) p(cr[itr]) ;
		p("+") ;
		for(int itr=(j+1) ; itr<i ; itr++) p(cr[itr]) ;
		p("=") ;
		for(int itr=i ; itr<n ; itr++) p(cr[itr]) ;
		pln("") ;
	}
	public void Solve() throws IOException{
		cr = ip.s().toCharArray() ;
		n = cr.length ;
		dig = new pair[n] ;
		hash = new pair[n+1] ;
		p10 = new pair[n] ;
		p10i = new pair[n] ;
		fillpow() ;
		// for(int i=0 ; i<n ; i++){
		// 	pln("pow10["+i+"] is "+p10[i].x+" "+p10[i].y) ;
		// }
		for(int i=0 ; i<n ; i++){
			long kk = cr[i]-'0' ;
			dig[i] = new pair(kk,kk) ;
		}
		hash[n] = new pair(0,0) ;
		for(int i=(n-1) ; i>=0 ; i--)
			hash[i] = mul(dig[i],p10[(n-1)-i]) ;
		for(int i=(n-1) ; i>=0 ; i--)
			hash[i] = add(hash[i],hash[i+1]) ;
		// for(int i=(n-1) ; i>=0 ; i--){
		// 	pln("hash["+i+"] is "+hash[i].x+" "+hash[i].y) ;
		// }
		for(int i=2 ; i<n ; i++){
			int dg = (n-i) ;
			if(check(dg,i) && verify(dg,i)){
				print(dg,i) ;
				break ;
			}
			if(check(dg-1,i) && verify(dg-1,i)){
				print(dg-1,i) ;
				break ;
			}
			if(check(dg-2,i) && verify(dg-2,i)){
				print(dg-2,i) ;
				break ;
			}
			if(check((i-1-dg),i) && verify((i-1-dg),i)){
				print((i-1-dg),i) ;
				break ;
			}
			if(check((i-1-dg)+1,i) && verify((i-1-dg)+1,i)){
				print((i-1-dg)+1,i) ;
				break ;
			}
			if(check((i-1-dg)-1,i) && verify((i-1-dg)-1,i)){
				print((i-1-dg)-1,i) ;
				break ;
			}
		}	
	}
}