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
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class x898F
   {
      static long MOD = 1000000021L;
      static long BASE = 10L;
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         String input = infile.readLine();
         N = input.length();
         int[] arr = new int[N];
         for(int i=0; i < N; i++)
            arr[i] = Integer.parseInt(input.charAt(i)+"");
         pow = new long[N+5];
         pow[0] = 1L;
         for(int i=1; i <= N; i++)
            pow[i] = (pow[i-1]*BASE)%MOD;
         invpow = new long[N+5];
         for(int i=0; i <= N; i++)
            invpow[i] = power(pow[i], MOD-2, MOD);
         hash = new long[N];
         hash[N-1] = arr[N-1];
         for(int i=N-2; i >= 0; i--)
         {
            hash[i] = (pow[N-1-i]*arr[i])%MOD;
            hash[i] += hash[i+1];
            if(hash[i] >= MOD)   hash[i] -= MOD;
         }
         StringBuilder sb = new StringBuilder();
         for(int end=N-1; end >= 0; end--)
         {
            if(arr[end] == 0 && end != N-1)
               continue;
            int first = N-end;
            if(2*first < N)
            {
               int second = N-2*first;
               if(hashed(first, second))
               {
                  String res1 = input.substring(0, first);
                  String res2 = input.substring(first, end);
                  if(res1.length() >= 2 && res1.charAt(0) == '0' || res2.length() >= 2 && res2.charAt(0) == '0');
                  else
                  {
                     sb.append(res1);  sb.append("+");
                     sb.append(res2); sb.append("=");
                     sb.append(input.substring(end));
                     System.out.println(sb);
                     return;
                  }
               }
               if(hashed(second, first))
               {
                  String res1 = input.substring(0, second);
                  String res2 = input.substring(second, end);
                  if(res1.length() >= 2 && res1.charAt(0) == '0' || res2.length() >= 2 && res2.charAt(0) == '0');
                  else
                  {
                     sb.append(res1);  sb.append("+");
                     sb.append(res2); sb.append("=");
                     sb.append(input.substring(end));
                     System.out.println(sb);
                     return;
                  }
               }
            }
            first--;
            if(2*first+1 < N && first > 0)
            {
               int second = N-2*first-1;
               if(hashed(first, second))
               {
                  String res1 = input.substring(0, first);
                  String res2 = input.substring(first, end);
                  if(res1.length() >= 2 && res1.charAt(0) == '0' || res2.length() >= 2 && res2.charAt(0) == '0');
                  else
                  {
                     sb.append(res1);  sb.append("+");
                     sb.append(res2); sb.append("=");
                     sb.append(input.substring(end));
                     System.out.println(sb);
                     return;
                  }
               }
               if(hashed(second, first))
               {
                  String res1 = input.substring(0, second);
                  String res2 = input.substring(second, end);
                  if(res1.length() >= 2 && res1.charAt(0) == '0' || res2.length() >= 2 && res2.charAt(0) == '0');
                  else
                  {
                     sb.append(res1);  sb.append("+");
                     sb.append(res2); sb.append("=");
                     sb.append(input.substring(end));
                     System.out.println(sb);
                     return;
                  }
               }
            }
         }
      }
      static int N;
      static long[] hash;
      static long[] pow;
      static long[] invpow;
      public static boolean hashed(int a, int b)
      {
         int c = N-a-b;
         long sum = hash[N-c];
         //first segment
         long temp = hash[0]-hash[a]+MOD;
         temp = (temp*invpow[N-a])%MOD;
         long check = temp;
         //second segment
         temp = hash[a]-hash[a+b]+MOD;
         temp = (temp*invpow[c])%MOD;
         check += temp;
         if(check >= MOD)
            check -= MOD;
         return check == sum;
      }
      public static long power(long x, long y, long p) 
      { 
          long res = 1L;      
          x = x % p;  
          while(y > 0) 
          { 
              if((y & 1)==1) 
                  res = (res * x) % p; 
              y = y >> 1;  
              x = (x * x) % p;  
          } 
          return res; 
      } 
   }