

# import numpy as np

# import numpypy as np

import sys

input = sys.stdin.readline



def eprint(*args, **kwargs):

    print(*args, file=sys.stderr, **kwargs)

    return



import math

import string

import fractions

from fractions import Fraction

from fractions import gcd



def lcm(n,m):

    return int(n*m/gcd(n,m))



import re

import array

import copy

import functools

import operator



import collections

import itertools

import bisect

import heapq





from heapq import heappush

from heapq import heappop

from heapq import heappushpop

from heapq import heapify

from heapq import heapreplace



from queue import PriorityQueue as pq



def reduce(p, q):

    common = fractions.gcd(p, q)

    return (p//common , q//common )

# from itertools import accumulate

# from collections import deque



import random





def main():

    # l = list(map(int, input().split()))

    ll=input().strip()

    l=[0 for i in range(4)]

    for i in range(len(l)):

        l[i]=int(ll[i])

    NUM_CASE=3



    for case in range(2**NUM_CASE):

        # eprint("case : " + str(case))

        sum=l[0]

        

        stack=[]

        S=""

        for index in range(NUM_CASE):

            if (case>>index) & 1 == 1:

                # eprint("l[%d] : %d" % (index+1,l[index+1]) )

                sum+=l[index+1]

                stack.append("+")

            else:

                # eprint("l[%d] : %d" % (index+1,l[index+1]) )

                sum-=l[index+1]

                stack.append("-")

        # eprint("sum : " + str(sum))

        if sum==7:

            for i in range(4):

                S+=str(l[i])

                if i!=3:

                    S+=str(stack[i])

            S+="=7"

            print(S)

            return

    return



if __name__ == '__main__':

    main()



# import numpy as np

# import numpypy as np

import sys

input = sys.stdin.readline



def eprint(*args, **kwargs):

    print(*args, file=sys.stderr, **kwargs)

    return



# import math

# import string

# import fractions

# from fractions import Fraction

# from fractions import gcd



# def lcm(n,m):

#     return int(n*m/gcd(n,m))



# import re

# import array

# import copy

# import functools

# import operator



# import collections

# import itertools

# import bisect

# import heapq





# from heapq import heappush

# from heapq import heappop

# from heapq import heappushpop

# from heapq import heapify

# from heapq import heapreplace



# from queue import PriorityQueue as pq



# def reduce(p, q):

#     common = fractions.gcd(p, q)

#     return (p//common , q//common )

# # from itertools import accumulate

# # from collections import deque



# from operator import mul

# from functools import reduce



# def combinations_count(n, r):

#     r = min(r, n - r)

#     numer = reduce(mul, range(n, n - r, -1), 1)

#     denom = reduce(mul, range(1, r + 1), 1)

#     return numer // denom



# import random





def main():

    # a,b,c,d = map(int, input().strip().split())

    l_abcd = list(map(int,input().strip()))

    eprint("l_abcd ",end=": ")

    eprint(l_abcd)

    for case in range(2 ** 3):     # 場合ループ # nは人とかモノとかの個数

        l_op_bin = list(map(int,(format(case,'b').zfill(3))))

        # eprint("l_op_bin ",end=": ")

        # eprint(l_op_bin)

        

        #flag=0

        sum_x=l_abcd[0]

        l_op=[]

        for index_location in range(3):      # 人とかモノとかループ

            if l_op_bin[index_location]==1:                   # その桁がyesだと仮定している場合

               sum_x += l_abcd[1+index_location]

               l_op.append("+")

            else:                                 # その桁がnoだと仮定している場合

               sum_x -= l_abcd[1+index_location]

               l_op.append("-")

        if sum_x==7:

            print(l_abcd[0], end="")

            print(l_op[0],end="")

            print(l_abcd[1], end="")    

            print(l_op[1],end="")

            print(l_abcd[2], end="")    

            print(l_op[2],end="")

            print(l_abcd[3], end="=7\n")

            return

if __name__ == '__main__':

    main()

# import numpy as np
# import numpypy as np
import sys

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


import math
import string
import fractions
from fractions import Fraction
from fractions import gcd


def lcm(n, m):
    return int(n * m / gcd(n, m))


import re
import array
import copy
import functools
import operator
import collections
import itertools
import bisect
import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq


def reduce(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


# from itertools import accumulate
# from collections import deque
import random


def main():
    # l = list(map(int, input().split()))
    ll = input().strip()
    l = [0 for i in range(4)]
    for i in range(len(l)):
        l[i] = int(ll[i])
    NUM_CASE = 3
    for case in range(2**NUM_CASE):
        # eprint("case : " + str(case))
        sum = l[0]
        stack = []
        S = ""
        for index in range(NUM_CASE):
            if (case >> index) & 1 == 1:
                # eprint("l[%d] : %d" % (index+1,l[index+1]) )
                sum += l[index + 1]
                stack.append("+")
            else:
                # eprint("l[%d] : %d" % (index+1,l[index+1]) )
                sum -= l[index + 1]
                stack.append("-")
        # eprint("sum : " + str(sum))
        if sum == 7:
            for i in range(4):
                S += str(l[i])
                if i != 3:
                    S += str(stack[i])
            S += "=7"
            print(S)
            return
    return


if __name__ == "__main__":
    main()

# import numpy as np
# import numpypy as np
import sys

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


# import math
# import string
# import fractions
# from fractions import Fraction
# from fractions import gcd
# def lcm(n,m):
#     return int(n*m/gcd(n,m))
# import re
# import array
# import copy
# import functools
# import operator
# import collections
# import itertools
# import bisect
# import heapq
# from heapq import heappush
# from heapq import heappop
# from heapq import heappushpop
# from heapq import heapify
# from heapq import heapreplace
# from queue import PriorityQueue as pq
# def reduce(p, q):
#     common = fractions.gcd(p, q)
#     return (p//common , q//common )
# # from itertools import accumulate
# # from collections import deque
# from operator import mul
# from functools import reduce
# def combinations_count(n, r):
#     r = min(r, n - r)
#     numer = reduce(mul, range(n, n - r, -1), 1)
#     denom = reduce(mul, range(1, r + 1), 1)
#     return numer // denom
# import random
def main():
    # a,b,c,d = map(int, input().strip().split())
    l_abcd = list(map(int, input().strip()))
    eprint("l_abcd ", end=": ")
    eprint(l_abcd)
    for case in range(2**3):  # 場合ループ # nは人とかモノとかの個数
        l_op_bin = list(map(int, (format(case, "b").zfill(3))))
        # eprint("l_op_bin ",end=": ")
        # eprint(l_op_bin)
        # flag=0
        sum_x = l_abcd[0]
        l_op = []
        for index_location in range(3):  # 人とかモノとかループ
            if l_op_bin[index_location] == 1:  # その桁がyesだと仮定している場合
                sum_x += l_abcd[1 + index_location]
                l_op.append("+")
            else:  # その桁がnoだと仮定している場合
                sum_x -= l_abcd[1 + index_location]
                l_op.append("-")
        if sum_x == 7:
            print(l_abcd[0], end="")
            print(l_op[0], end="")
            print(l_abcd[1], end="")
            print(l_op[1], end="")
            print(l_abcd[2], end="")
            print(l_op[2], end="")
            print(l_abcd[3], end="=7\n")
            return


if __name__ == "__main__":
    main()

-import math -import string -import fractions -from fractions import Fraction -from fractions import gcd - - -def lcm(n, m): -    return int(n * m / gcd(n, m)) - - -import re -import array -import copy -import functools -import operator -import collections -import itertools -import bisect -import heapq -from heapq import heappush -from heapq import heappop -from heapq import heappushpop -from heapq import heapify -from heapq import heapreplace -from queue import PriorityQueue as pq - - -def reduce(p, q): -    common = fractions.gcd(p, q) -    return (p // common, q // common) - - -# from itertools import accumulate -# from collections import deque -import random - - +# import math +# import string +# import fractions +# from fractions import Fraction +# from fractions import gcd +# def lcm(n,m): +#     return int(n*m/gcd(n,m)) +# import re +# import array +# import copy +# import functools +# import operator +# import collections +# import itertools +# import bisect +# import heapq +# from heapq import heappush +# from heapq import heappop +# from heapq import heappushpop +# from heapq import heapify +# from heapq import heapreplace +# from queue import PriorityQueue as pq +# def reduce(p, q): +#     common = fractions.gcd(p, q) +#     return (p//common , q//common ) +# # from itertools import accumulate +# # from collections import deque +# from operator import mul +# from functools import reduce +# def combinations_count(n, r): +#     r = min(r, n - r) +#     numer = reduce(mul, range(n, n - r, -1), 1) +#     denom = reduce(mul, range(1, r + 1), 1) +#     return numer // denom +# import random -    # l = list(map(int, input().split())) -    ll = input().strip() -    l = [0 for i in range(4)] -    for i in range(len(l)): -        l[i] = int(ll[i]) -    NUM_CASE = 3 -    for case in range(2**NUM_CASE): -        # eprint("case : " + str(case)) -        sum = l[0] -        stack = [] -        S = "" -        for index in range(NUM_CASE): -            if (case >> index) & 1 == 1: -                # eprint("l[%d] : %d" % (index+1,l[index+1]) ) -                sum += l[index + 1] -                stack.append("+") -            else: -                # eprint("l[%d] : %d" % (index+1,l[index+1]) ) -                sum -= l[index + 1] -                stack.append("-") -        # eprint("sum : " + str(sum)) -        if sum == 7: -            for i in range(4): -                S += str(l[i]) -                if i != 3: -                    S += str(stack[i]) -            S += "=7" -            print(S) +    # a,b,c,d = map(int, input().strip().split()) +    l_abcd = list(map(int, input().strip())) +    eprint("l_abcd ", end=": ") +    eprint(l_abcd) +    for case in range(2**3):  # 場合ループ # nは人とかモノとかの個数 +        l_op_bin = list(map(int, (format(case, "b").zfill(3)))) +        # eprint("l_op_bin ",end=": ") +        # eprint(l_op_bin) +        # flag=0 +        sum_x = l_abcd[0] +        l_op = [] +        for index_location in range(3):  # 人とかモノとかループ +            if l_op_bin[index_location] == 1:  # その桁がyesだと仮定している場合 +                sum_x += l_abcd[1 + index_location] +                l_op.append("+") +            else:  # その桁がnoだと仮定している場合 +                sum_x -= l_abcd[1 + index_location] +                l_op.append("-") +        if sum_x == 7: +            print(l_abcd[0], end="") +            print(l_op[0], end="") +            print(l_abcd[1], end="") +            print(l_op[1], end="") +            print(l_abcd[2], end="") +            print(l_op[2], end="") +            print(l_abcd[3], end="=7\n") -    return