import scala.annotation.tailrec
import scala.io.StdIn.{readInt, readLine}

object Main extends App {
  import Implicits.ListOps

  val Zero = BigInt(0)
  val VMax = BigInt(1_000_000_000_000_000_000L)

  val n  = readInt()
  val xs = readLine().split(' ').view.map { BigInt(_) }.toList

  val (s, isOver) =
    if (xs.contains(Zero)) (Zero, false)
    else {
      val (s, ys) = xs.reduceWhile { _ * _ } { _ <= VMax }
      (s, ys.nonEmpty)
    }

  println(if (isOver) -1 else s)
}

/**
  * 拡張メソッド群
  */
object Implicits {

  /**
    * List用拡張メソッド
    * @param self 自身を表すList
    * @tparam A 要素の型
    */
  implicit class ListOps[A](self: List[A]) {

    /**
      * 条件を満たし続ける限りListの要素を集約する
      * 条件を満たさなくなった時点で処理を打切る
      * @param z 初期値
      * @param op 集約演算用の関数
      * @param p 処理を続けるかどうかを判定する述語関数
      * @return 条件を満たさなくなった時点のそれまでの計算結果と残りのリストListの組
      */
    def foldWhile[B](z: B)(op: (B, A) => B)(p: B => Boolean): (B, List[A]) = {

      @tailrec
      def loop(accum: B, zs: List[A]): (B, List[A]) = zs match {
        case Nil => (accum, Nil)
        case x :: xs =>
          val s = op(accum, x)
          if (p(s)) loop(s, xs) else (accum, zs)
      }

      loop(z, self)
    }

    /**
      * foldWhileの初期値を自身の先頭要素にした関数
      */
    def reduceWhile(op: (A, A) => A)(p: A => Boolean): (A, List[A]) = self match {
      case Nil     => throw new UnsupportedOperationException("empty list")
      case x :: xs => xs.foldWhile(x)(op)(p)
    }
  }
}
