Problem: One day Vasya was solving arithmetical problems. He wrote down an expression a + b = c in his notebook. When the teacher checked Vasya's work it turned out that Vasya had solved the problem incorrectly. Now Vasya tries to find excuses. He says that he simply forgot to write down several digits in numbers a, b and c, but he can't remember what numbers they actually were. Help Vasya, find such numbers x, y and z, with which the following conditions are met: 

  * x + y = z, 
  * from the expression x + y = z several digits can be erased in such a way that the result will be a + b = c, 
  * the expression x + y = z should have the minimal length. 

Input

The first and only input line contains the expression a + b = c (1 ≤ a, b, c ≤ 106, a, b and c don't contain leading zeroes) which is the expression Vasya wrote down.

Output

Print the correct expression x + y = z (x, y and z are non-negative numbers without leading zeroes). The expression a + b = c must be met in x + y = z as a subsequence. The printed solution should have the minimal possible number of characters. If there are several such solutions, you can print any of them.

Examples

Input

2+4=5


Output

21+4=25


Input

1+1=3


Output

1+31=32


Input

1+1=2


Output

1+1=2

Solution (in JAVA):

Solution:
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Codeforces58e {

	static long BIG = 999999999999999999L;
	static int MAX = 1110;
	static long main_a = 0, main_b = 0, main_c = 0;
	static boolean debug = false;

	static long power[] = { 1, 10, 100, 1000, 10_000, 100_000, 1000_000, 10_000_000, 100_000_000, 1000_000_000, 10_000_000_000L, 100_000_000_000L, 1000_000_000_000L, 10_000_000_000_000L,
			100_000_000_000_000L, 1000_000_000_000_000L, 10_000_000_000_000_000L };

	static boolean sub(long big, long small) {
		if (small == 0)
			return true;
		if (big == 0)
			return false;

		if (small % 10 == big % 10)
			return sub(big / 10, small / 10);
		else
			return sub(big / 10, small);
	}

	static boolean compareInts(long a, long x, long b, long y, long c, long z) {
		if (a != x)
			return a < x;
		else if (b != y)
			return b < y;
		else
			return c < z;
	}

	static String simple(long a, long b, long c) {
		String sol = "99999999999999999999999";
		long mina = BIG, minb = BIG, minc = BIG;
		for (long i = a; i < MAX; i++) {
			for (long j = b; j < MAX; j++) {
				if (sub(i, a) && sub(j, b) && sub(i + j, c)) {
					String candidate = "" + i + "+" + j + "=" + (i + j);

					if (candidate.length() < sol.length() || (candidate.length() == sol.length() && compareInts(i, mina, j, minb, i + j, minc))) {
						sol = candidate;
						mina = i;
						minb = j;
						minc = i + j;
					}
				}
			}
		}

		return sol;
	}

	static class Solution {

		public int a;
		public int b;
		public int c;
		public int carry;

		Solution(int ax, int bx, int cx, int carryx) {
			a = ax;
			b = bx;
			c = cx;
			carry = carryx;
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + a;
			result = prime * result + b;
			result = prime * result + c;
			result = prime * result + carry;
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Solution other = (Solution) obj;
			if (a != other.a)
				return false;
			if (b != other.b)
				return false;
			if (c != other.c)
				return false;
			if (carry != other.carry)
				return false;
			return true;
		}
	};

	static class Presentation {
		public long a;
		public long b;
		public long c;
		public int level;

		public int cnta, cntb, cntc;
		public int sum;

		Presentation() {
			a = b = c = level = sum = cnta = cntb = cntc = 0;
		}

		Presentation(long x, long y, long z) {
			a = x;
			b = y;
			c = z;
			level = 0;
			cnta = cntb = cntc = 0;
			sum = 0;
		}

		Presentation merge(Presentation other) {
			Presentation nova = new Presentation();
			nova.level = this.level + 1;
			nova.a = this.a + (other.a) * power[this.level];
			nova.b = this.b + (other.b) * power[this.level];
			nova.c = this.c + (other.c) * power[this.level];
			nova.sum = this.sum + 3;

			// Determine the goods
			boolean goodx = sub(nova.a, main_a);
			boolean goody = sub(nova.b, main_b);
			boolean goodz = sub(nova.c, main_c);

			if (other.a != 0)
				nova.cnta = nova.level;
			else
				nova.cnta = this.cnta + (goodx ? 0 : 1);
			if (other.b != 0)
				nova.cntb = nova.level;
			else
				nova.cntb = this.cntb + (goody ? 0 : 1);
			if (other.c != 0)
				nova.cntc = nova.level;
			else
				nova.cntc = this.cntc + (goodz ? 0 : 1);

			nova.sum = nova.cnta + nova.cntb + nova.cntc;
			return nova;
		}

		boolean compare(Presentation other) {
			// String length
			if (this.sum != other.sum)
				return this.sum < other.sum;

			// Compare each item
			if (this.a != other.a) {
				return this.a < other.a;
			} else if (this.b != other.b)
				return this.b < other.b;
			else
				return this.c < other.c;
		}

		String make() {
			return "" + a + "+" + b + "=" + c;
		}
	};

	static Presentation fill(Map<Solution, Presentation> mini, Solution sol, Presentation first, Presentation plus) {
		Presentation fin = first.merge(plus);

		if (mini.containsKey(sol)) {
			if (fin.compare(mini.get(sol))) {
				mini.put(sol, fin);
			}
		} else {
			mini.put(sol, fin);
		}
		return fin;
	}

	static String real(long a, long b, long c) {
		Deque<Solution> q = new ArrayDeque<Solution>();
		Map<Solution, Presentation> mini = new HashMap<Solution, Presentation>();

		Solution s_first = new Solution(0, 0, 0, 0);
		q.addLast(s_first);
		mini.put(s_first, new Presentation());

		Presentation min_sol = new Presentation(BIG, BIG, BIG);
		min_sol.level = 999;
		min_sol.sum = 999;
		long cnt = 0;
		while (!q.isEmpty()) {
			cnt++;
			Solution next = q.pop();
			Presentation pres = mini.get(next);

			if (debug)
				System.out.println(next.a + " " + next.b + " " + next.c + " " + next.carry + "\t" + pres.make() + " " + pres.sum);

			long ta = a / power[next.a] % 10;
			long tb = b / power[next.b] % 10;
			long tc = c / power[next.c] % 10;
			if (debug)
				System.out.println("* " + ta + " " + tb + " " + tc + "(" + next.carry + ")");

			if (a < power[next.a] && b < power[next.b] && c < power[next.c] && next.carry == 0) {
				if (pres.compare(min_sol)) {
					if (debug) {
						System.out.println(pres.make() + " wins over " + min_sol.make());
						pres.compare(min_sol);
					}
					min_sol = pres;
				}
				if (debug)
					System.out.println("solution " + pres.make() + " || " + pres.make().length() + " vs " + min_sol.make().length());
				if (pres.sum > min_sol.sum + 6)
					break;
				else
					continue;
			}

			// All good
			if (next.carry + ta + tb == tc) {
				Solution sol = new Solution(next.a + 1, next.b + 1, next.c + 1, 0);
				if (!mini.containsKey(sol))
					q.addFirst(sol);
				fill(mini, sol, pres, new Presentation(ta, tb, tc));
			} else if (next.carry + ta + tb == tc + 10) {
				Solution sol = new Solution(next.a + 1, next.b + 1, next.c + 1, 1);
				if (!mini.containsKey(sol))
					q.addFirst(sol);
				fill(mini, sol, pres, new Presentation(ta, tb, tc));
			}

			// Change first
			if (tb + next.carry <= tc) {
				long fill_a = tc - tb - next.carry;
				Solution sol = new Solution(next.a, next.b + 1, next.c + 1, 0);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(fill_a, tb, tc));
			} else {
				long fill_a = 10 + tc - tb - next.carry;
				Solution sol = new Solution(next.a, next.b + 1, next.c + 1, 1);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(fill_a, tb, tc));
			}

			// Change second
			if (ta + next.carry <= tc) {
				long fill_b = tc - ta - next.carry;
				Solution sol = new Solution(next.a + 1, next.b, next.c + 1, 0);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(ta, fill_b, tc));
			} else {
				long fill_b = 10 + tc - ta - next.carry;
				Solution sol = new Solution(next.a + 1, next.b, next.c + 1, 1);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(ta, fill_b, tc));
			}

			// Change third
			if (next.carry + ta + tb <= 9) {
				long fill_c = ta + tb + next.carry;
				Solution sol = new Solution(next.a + 1, next.b + 1, next.c, 0);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(ta, tb, fill_c));
			} else {
				long fill_c = ta + tb + next.carry - 10;
				Solution sol = new Solution(next.a + 1, next.b + 1, next.c, 1);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(ta, tb, fill_c));
			}

			// Change first and second
			if (next.carry <= tc) {
				long fill_x = tc - next.carry;
				Solution sol = new Solution(next.a, next.b, next.c + 1, 0);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(0, fill_x, tc));

				// Force carry
				Solution sol2 = new Solution(next.a, next.b, next.c + 1, 1);
				// cout << "close " << (new Presentation(10+tc-9-next.carry,9,tc)).make() << " " << mini.containsKey(sol) << endl;
				if (!mini.containsKey(sol2))
					q.addLast(sol2);
				fill(mini, sol2, pres, new Presentation(10 + tc - 9 - next.carry, 9, tc));
			} else {
				long fill_x = 10 + tc - next.carry;
				Solution sol = new Solution(next.a, next.b, next.c + 1, 1);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(0, fill_x, tc));
			}

			// Change first and third
			if (next.carry + tb <= 9) {
				long fill_x = next.carry + tb;
				Solution sol = new Solution(next.a, next.b + 1, next.c, 0);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(0, tb, fill_x));

				// Force carry
				Solution sol2 = new Solution(next.a, next.b + 1, next.c, 1);
				if (tb + next.carry > 0) {
					if (!mini.containsKey(sol2))
						q.addLast(sol2);
					fill(mini, sol2, pres, new Presentation(10 - tb - next.carry, tb, 0));
				}
			} else {
				long fill_x = 0;
				Solution sol = new Solution(next.a, next.b + 1, next.c, 1);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(0, tb, 0));
			}

			// Change second and third
			if (next.carry + ta <= 9) {
				long fill_x = next.carry + ta;
				Solution sol = new Solution(next.a + 1, next.b, next.c, 0);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(ta, 0, fill_x));

				// Force carry
				Solution sol2 = new Solution(next.a + 1, next.b, next.c, 1);
				if (ta + next.carry > 0) {
					if (!mini.containsKey(sol2))
						q.addLast(sol2);
					fill(mini, sol2, pres, new Presentation(ta, 10 - ta - next.carry, 0));
				}
			} else {
				long fill_x = 0;
				Solution sol = new Solution(next.a + 1, next.b, next.c, 1);
				if (!mini.containsKey(sol))
					q.addLast(sol);
				fill(mini, sol, pres, new Presentation(ta, 0, 0));
			}

			// delete next;
			// delete pres;
		}
		// cout << "iter" << cnt << endl;
		// cout << mini.size() << endl;
		return min_sol.make();
	}

	static void test() {
		main_a = 1;
		main_b = 10;
		main_c = 2;
		Presentation first = new Presentation();
		Presentation second = first.merge(new Presentation(1, 1, 2));
		Presentation third = second.merge(new Presentation(0, 0, 0));
		Presentation fourth = third.merge(new Presentation(0, 1, 1));
		System.out.println(fourth.sum);
	}

	public static void main(String[] args) {
		// test();
		main_a = 0;
		main_b = 0;
		main_c = 0;
		Scanner sc = new Scanner(System.in);
		String line = sc.nextLine();
		String[] tokens = line.split("\\+|=");

		main_a = Long.parseLong(tokens[0]);
		main_b = Long.parseLong(tokens[1]);
		main_c = Long.parseLong(tokens[2]);
		sc.close();

		// Check
		// for (long i = 1; i < 111; i++) {
		// for (long j = 1; j < 39; j++)
		// for (long k = 1; k < 111; k++) {
		// main_a = i;
		// main_b = j;
		// main_c = k;
		// String r = real(i, j, k);
		// String s = simple(i, j, k);
		// if (r.length() > s.length()) {
		// System.out.println("nums " + i + " " + j + " " + k);
		// System.out.println("real " + real(i, j, k));
		// System.out.println("simple " + s);
		// }
		// }
		// System.out.println(i + "%");
		// }

		// System.out.println("simple => " + simple(main_a, main_b, main_c));
		System.out.println(real(main_a, main_b, main_c));
	}
}