

UpperCamelCase__		   =    {
    """+""": lambda x, y: x + y,
    """-""": lambda x, y: x - y,
    """*""": lambda x, y: x * y,
    """/""": lambda x, y: x / y,
}







def 	lowerCamelCase__			(   __A						:Tuple		):


       """simple docstring"""




       return c.isdigit()







def 	lowerCamelCase__			(   __A						:List[str]		):


       """simple docstring"""




       __snake_case					  =       []

       # iterate over the string in reverse order
       for c in expression.split()[::-1]:
              # push operand to stack
              if is_operand(__A		):
                     stack.append(int(__A		)		)

              else:
                     # pop values from stack can calculate the result
                     # push the result onto the stack again
                     __snake_case					  =       stack.pop()
                     __snake_case					  =       stack.pop()
                     stack.append(calc[c](__A  ,__A		)		)

       return stack.pop()


# Driver code
if __name__ == "__main__":
  UpperCamelCase__		   =    """+ 9 * 2 6"""
  print(evaluate(test_expression))

  UpperCamelCase__		   =    """/ * 10 2 + 4 1 """
  print(evaluate(test_expression))




import math







def 	lowerCamelCase__			(   __A						:int		):


       """simple docstring"""




       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5  ,int(math.sqrt(__A		) + 1		)  ,6		):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True







def 	lowerCamelCase__			(   __A						:int = 1_0_0_0  ,__A						:int = 1_0_0_0		):


       """simple docstring"""




       __snake_case					  =       [0, 0, 0]  # length, a, b
       for a in range((a_limit * -1) + 1  ,__A		):
              for b in range(2  ,__A		):
                     if is_prime(__A		):
                            __snake_case					  =       0
                            __snake_case					  =       0
                            while is_prime((n**2) + (a * n) + b		):
                                   count += 1
                                   n += 1
                            if count > longest[0]:
                                   __snake_case					  =       [count, a, b]
       __snake_case					  =       longest[1] * longest[2]
       return ans


if __name__ == "__main__":
    print(solution(1000, 1000))

