object Main extends App {

  import scala.io.StdIn._
  import scala.math._

  val Array(n, t) = readLine.trim.split(' ').map(_.toInt)
  val func = readLine.trim.toList match {
    case p Poly Nil ⇒ p
    case _ ⇒ ???
  }

  println(
    func(n).map(_ * t).filter(_ <= 1000000000L).getOrElse("TLE")
  )

  def digit(number: Long): Int = {
    number match {
      case _ if number < 10 ⇒ 0
      case _ ⇒ digit(number / 10) + 1
    }
  }
  def exponent(base: Long, exp: Int): Long = {
    exp match {
      case 0 ⇒ 1L
      case 1 ⇒ base
      case _ ⇒ exponent(base, exp / 2).let{it ⇒ it * it * exponent(base, exp % 2)}
    }
  }
  object Poly{
    def unapply(arg: List[Char]): Option[(Long ⇒ Option[Long], List[Char])] = {
      arg match {
        case m Mono '+'::(p Poly t) ⇒ Some({n ⇒
          (m(n), p(n)) match {
            case (Some(a), Some(b)) if a + b > 1000000000 ⇒ None
            case (Some(a), Some(b)) ⇒ Some(a + b)
            case _ ⇒ None
          }
        }, t)
        case m Mono t ⇒ Some(m, t)
        case _ ⇒ None
      }
    }
  }
  object Mono{
    def unapply(arg: List[Char]): Option[(Long ⇒ Option[Long], List[Char])] = {
      arg match {
        case 'n'::'^'::(e Num t) ⇒ Some({ n ⇒
          if (digit(n) * e > 9) None
          else exponent(n, e).let{it ⇒
            if (it > 1000000000) None
            else Some(it)
          }
        }, t)
        case _ ⇒ None
      }
    }
  }
  object Num{
    def unapply(arg: List[Char]): Option[(Int, List[Char])] = {
      arg match {
        case h::t if h.isDigit ⇒ Some(h.asDigit, t)
        case _ ⇒ None
      }
    }
  }
  implicit class Extension[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}
