package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

type State struct {
	i, j, k, c, ax, ay, az int
}

type Node struct {
	prev       State
	dx, dy, dz int
}

var dist [10][10][10][2][2][2][2]int
var parent [10][10][10][2][2][2][2]Node

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	if !scanner.Scan() {
		return
	}
	line := strings.ReplaceAll(scanner.Text(), " ", "")
	parts := strings.Split(line, "=")
	if len(parts) != 2 {
		return
	}
	cStr := parts[1]
	left := strings.Split(parts[0], "+")
	if len(left) != 2 {
		return
	}
	aStr := left[0]
	bStr := left[1]

	lenA := len(aStr)
	lenB := len(bStr)
	lenC := len(cStr)

	a_rev := reverse(aStr)
	b_rev := reverse(bStr)
	c_rev := reverse(cStr)

	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			for k := 0; k < 10; k++ {
				for c := 0; c < 2; c++ {
					for ax := 0; ax < 2; ax++ {
						for ay := 0; ay < 2; ay++ {
							for az := 0; az < 2; az++ {
								dist[i][j][k][c][ax][ay][az] = 1e9
							}
						}
					}
				}
			}
		}
	}

	var queues [256][]State
	dist[0][0][0][0][1][1][1] = 0
	queues[0] = append(queues[0], State{0, 0, 0, 0, 1, 1, 1})

	for d := 0; d < 256; d++ {
		for len(queues[d]) > 0 {
			u := queues[d][0]
			queues[d] = queues[d][1:]

			if dist[u.i][u.j][u.k][u.c][u.ax][u.ay][u.az] < d {
				continue
			}

			if u.ax == 0 && u.ay == 0 && u.az == 0 && u.c == 0 && u.i == lenA && u.j == lenB && u.k == lenC {
				var x_ans, y_ans, z_ans []int
				curr := u
				start := State{0, 0, 0, 0, 1, 1, 1}
				for curr != start {
					p := parent[curr.i][curr.j][curr.k][curr.c][curr.ax][curr.ay][curr.az]
					prev := p.prev
					if prev.ax == 1 {
						x_ans = append(x_ans, p.dx)
					}
					if prev.ay == 1 {
						y_ans = append(y_ans, p.dy)
					}
					if prev.az == 1 {
						z_ans = append(z_ans, p.dz)
					}
					curr = prev
				}

				for _, v := range x_ans {
					fmt.Print(v)
				}
				fmt.Print("+")
				for _, v := range y_ans {
					fmt.Print(v)
				}
				fmt.Print("=")
				for _, v := range z_ans {
					fmt.Print(v)
				}
				fmt.Println()
				return
			}

			if u.ax == 0 && u.ay == 0 && u.az == 0 {
				continue
			}

			cost := u.ax + u.ay + u.az

			for dx := 0; dx <= 9; dx++ {
				if u.ax == 0 && dx != 0 {
					continue
				}
				next_i := u.i
				if u.ax == 1 && u.i < lenA && dx == int(a_rev[u.i]-'0') {
					next_i++
				}

				var n_ax_list []int
				if u.ax == 0 {
					n_ax_list = []int{0}
				} else {
					n_ax_list = []int{1}
					if dx > 0 {
						n_ax_list = append(n_ax_list, 0)
					}
				}

				for dy := 0; dy <= 9; dy++ {
					if u.ay == 0 && dy != 0 {
						continue
					}
					next_j := u.j
					if u.ay == 1 && u.j < lenB && dy == int(b_rev[u.j]-'0') {
						next_j++
					}

					var n_ay_list []int
					if u.ay == 0 {
						n_ay_list = []int{0}
					} else {
						n_ay_list = []int{1}
						if dy > 0 {
							n_ay_list = append(n_ay_list, 0)
						}
					}

					dz := (dx + dy + u.c) % 10
					next_c := (dx + dy + u.c) / 10

					if u.az == 0 && dz != 0 {
						continue
					}
					next_k := u.k
					if u.az == 1 && u.k < lenC && dz == int(c_rev[u.k]-'0') {
						next_k++
					}

					var n_az_list []int
					if u.az == 0 {
						n_az_list = []int{0}
					} else {
						n_az_list = []int{1}
						if dz > 0 {
							n_az_list = append(n_az_list, 0)
						}
					}

					for _, n_ax := range n_ax_list {
						for _, n_ay := range n_ay_list {
							for _, n_az := range n_az_list {
								if n_ax == 0 && n_ay == 0 && n_az == 0 && next_c > 0 {
									continue
								}

								v := State{next_i, next_j, next_k, next_c, n_ax, n_ay, n_az}
								if dist[v.i][v.j][v.k][v.c][v.ax][v.ay][v.az] > d+cost {
									dist[v.i][v.j][v.k][v.c][v.ax][v.ay][v.az] = d + cost
									parent[v.i][v.j][v.k][v.c][v.ax][v.ay][v.az] = Node{u, dx, dy, dz}
									queues[d+cost] = append(queues[d+cost], v)
								}
							}
						}
					}
				}
			}
		}
	}
}

func reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}