import           Control.Monad
import           Control.Monad.ST
import qualified Data.Array                  as A
import qualified Data.Array.Unboxed          as AU
import qualified Data.ByteString.Char8       as BS
import           Data.Char
import           Data.List
import           Data.Maybe
import           Data.Ord
import           Data.Time
import qualified Data.Vector                 as V
import qualified Data.Vector.Mutable         as VM
import qualified Data.Vector.Unboxed         as VU
import qualified Data.Vector.Unboxed.Mutable as VUM

readIntegers :: IO [Integer]
readIntegers = map (fst . fromJust . BS.readInteger) . BS.words <$> BS.getLine

readIntegerLists :: Int -> IO [[Integer]]
readIntegerLists n =
  replicateM n (map (fst . fromJust . BS.readInteger) . BS.words <$> BS.getLine)

readInts :: IO [Int]
readInts = map (fst . fromJust . BS.readInt) . BS.words <$> BS.getLine

readIntLists :: Int -> IO [[Int]]
readIntLists n =
  replicateM n (map (fst . fromJust . BS.readInt) . BS.words <$> BS.getLine)

readStrings :: IO [String]
readStrings = map BS.unpack . BS.words <$> BS.getLine

readStringLists :: Int -> IO [[String]]
readStringLists n = replicateM n (map BS.unpack . BS.words <$> BS.getLine)

toPair :: [a] -> (a, a)
toPair [x, y] = (x, y)

main :: IO ()
main = do
  numstr <- getLine
  putStrLn $ solve (map (read . (: "")) numstr)

solve :: [Int] -> String
solve nums = g nums opss
  where
    opss :: [[Op]]
    opss = replicateM 3 [Plus, Minus]
    showOps :: [Int] -> [Op] -> String
    showOps nums ops =
      (concat $ concat (zipWith (\a b -> [show a, show b]) (init nums) ops)) ++
      (show $ last nums) ++ "=7"
    g :: [Int] -> [[Op]] -> String
    g nums (ops:opss)
      | f (tail nums) ops (head nums) == 7 = showOps nums ops
      | otherwise = g nums opss
    f :: [Int] -> [Op] -> Int -> Int
    f [] [] acc = acc
    f (x:xs) (op:ops) acc
      | op == Plus = f xs ops (acc + x)
      | op == Minus = f xs ops (acc - x)

data Op
  = Plus
  | Minus
  deriving (Eq, Ord)

instance Show Op where
  show Plus  = "+"
  show Minus = "-"
