import scala.annotation.tailrec
object Main extends App {

  import scala.io.StdIn._

  solve
  def solve: Unit = {
    val expression = readLine
    if (expression == null) return
    Expression.calculate(expression) match {
      case Some(c) ⇒ println(c)
      case None ⇒ println("overflow")
    }
    solve
  }

  case class Real(value: Int) {
    def +(that: Real): Real = Real(value + that.value)
    def -(that: Real): Real = Real(value - that.value)
    def *(that: Real): Real = Real(value * that.value)
    def *(that: Image): Image = Image(value * that.value)
    override def toString: String = if (value == 0) "" else s"$value"
  }
  case class Image(value: Int) {
    def +(that: Image): Image = Image(value + that.value)
    def -(that: Image): Image = Image(value - that.value)
    def *(that: Image): Real = Real(-value * that.value)
    def *(that: Real): Image = Image(value * that.value)
    override def toString: String = if (value == 0) "" else if (value > 0) s"${value}i" else s"${value}i"
  }
  case class ComplexType(real: Real = Real(0), image: Image = Image(0)) {
    def +(that: ComplexType): ComplexType = ComplexType(real + that.real, image + that.image)
    def -(that: ComplexType): ComplexType = ComplexType(real - that.real, image - that.image)
    def *(that: ComplexType): ComplexType = ComplexType(real * that.real + image * that.image, real * that.image + image * that.real)
    def isOverflow: Boolean = math.abs(real.value) > 10000 || math.abs(image.value) > 10000
    def overflowChecked: Option[ComplexType] = if (isOverflow) None else Some(this)
    override def toString(): String = {
      if (real.value == 0 && image.value != 0){
        image.toString
      }else if (real.value == 0){
        "0"
      }else if (image.value == 0){
        real.toString
      }else if (image.value > 0){
        s"$real+$image"
      }else {
        s"$real$image"
      }
    }
  }
  object Expression{
    def calculate(expression: String): Option[ComplexType] = {
      expression.toList match {
        case f Expression Nil ⇒ f
        case _ ⇒ ???
      }
    }
    def unapply(arg: List[Char]): Option[(Option[ComplexType], List[Char])] = {
      arg match {
        case left Term rest ⇒ Some(parseAll(rest, left))
        case _ ⇒ None
      }
    }
    @tailrec
    private def parseAll(arg: List[Char], left: Option[ComplexType]): (Option[ComplexType], List[Char]) = {
      arg match {
        case '+'::(right Term t) ⇒ parseAll(t, left.flatMap(l ⇒ right.map(r ⇒ l + r)).filterNot(_.isOverflow))
        case '-'::(right Term t) ⇒ parseAll(t, left.flatMap(l ⇒ right.map(r ⇒ l - r)).filterNot(_.isOverflow))
        case _ ⇒ (left, arg)
      }
    }
  }

  object Term {
    def unapply(arg: List[Char]): Option[(Option[ComplexType], List[Char])] = {
      arg match {
        case f Factor rest ⇒ Some(parseAll(rest, f))
        case _ ⇒ None
      }
    }
    @tailrec
    private def parseAll(arg: List[Char], left: Option[ComplexType]): (Option[ComplexType], List[Char]) = {
      arg match {
        case '*'::(right Factor t) ⇒ parseAll(t, left.flatMap(l ⇒ right.map(r ⇒ l * r)).filterNot(_.isOverflow))
        case _ ⇒ (left, arg)
      }
    }
  }
  object Factor {
    def unapply(arg: List[Char]): Option[(Option[ComplexType], List[Char])] = {
      arg match {
        case '('::(f Expression ')'::t) ⇒ Some(f, t)
        case r Number t ⇒ Some(r.flatMap(real ⇒ ComplexType(real = real).overflowChecked), t)
        case i Image t ⇒ Some(ComplexType(image = i).overflowChecked, t)
      }
    }
  }
  object Image{
    def unapply(arg: List[Char]): Option[(Image, List[Char])] = {
      arg match {
        case 'i'::t ⇒ Some(Image(1), t)
        case _ ⇒ None
      }
    }
  }
  object Number{
    def unapply(arg: List[Char]): Option[(Option[Real], List[Char])] = {
      arg.span(_.isDigit) match {
        case (Nil, _) ⇒ None
        case (number, t) ⇒ Some(number.foldLeft(Some(0):Option[Int]){(o, r) ⇒ o.map(l ⇒ l * 10 + r.asDigit).filterNot(i ⇒ math.abs(i) > 10000)}.map(i ⇒ Real(i)), t)
      }
    }
  }
  implicit class Extension[T](val value :T) extends AnyVal {
    @inline
    def let[A](@inline func: T ⇒ A): A = func(value)
    @inline
    def also(@inline func: T ⇒ Unit): T = {func(value); value}
  }
}
