





"""simple docstring"""




from __future__ import annotations

from enum import Enum




class 					_a		( _lowerCAmelCase							):
				UpperCamelCase								=       24
				UpperCamelCase								=       21
				UpperCamelCase								=       18
				UpperCamelCase								=       15
				UpperCamelCase								=       12
				UpperCamelCase								=       9
				UpperCamelCase								=       6
				UpperCamelCase								=       3
				UpperCamelCase								=       2
				UpperCamelCase								=       1
				UpperCamelCase								=       -1
				UpperCamelCase								=       -2
				UpperCamelCase								=       -3
				UpperCamelCase								=       -6
				UpperCamelCase								=       -9
				UpperCamelCase								=       -12
				UpperCamelCase								=       -15
				UpperCamelCase								=       -18
				UpperCamelCase								=       -21
				UpperCamelCase								=       -24




class 					_a		( _lowerCAmelCase							):
				UpperCamelCase								=       8
				UpperCamelCase								=       7
				UpperCamelCase								=       6
				UpperCamelCase								=       5
				UpperCamelCase								=       4
				UpperCamelCase								=       3
				UpperCamelCase								=       2
				UpperCamelCase								=       1





def 			a_							(				_lowercase			,		_lowercase			,		_lowercase			,		):
						if isinstance(_lowercase			,		_lowercase  ):
												_UpperCamelCase     :   List[str]      =       SIUnit[known_prefix.lower()]
						if isinstance(_lowercase			,		_lowercase  ):
												_UpperCamelCase     :   Optional[Any]      =       SIUnit[unknown_prefix.lower()]
						_UpperCamelCase     :   float      =       known_amount * (
						    10 ** (known_prefix.value - unknown_prefix.value)
						)
						return unknown_amount





def 			a_							(				_lowercase			,		_lowercase			,		_lowercase			,		):
						if isinstance(_lowercase			,		_lowercase  ):
												_UpperCamelCase     :   Optional[int]      =       BinaryUnit[known_prefix.lower()]
						if isinstance(_lowercase			,		_lowercase  ):
												_UpperCamelCase     :   Tuple      =       BinaryUnit[unknown_prefix.lower()]
						_UpperCamelCase     :   float      =       known_amount * (
						    2 ** ((known_prefix.value - unknown_prefix.value) * 10)
						)
						return unknown_amount


if __name__ == "__main__":
						import doctest

						doctest.testmod()







_A		:					Optional[int]          =							{
    '''+''': lambda x, y: x + y,
    '''-''': lambda x, y: x - y,
    '''*''': lambda x, y: x * y,
    '''/''': lambda x, y: x / y,
}



def      __lowerCAmelCase    (				snake_case						:     Union[str, Any]			)							->				str:
   return c.isdigit()



def      __lowerCAmelCase    (				snake_case						:     Optional[Any]			)							->				str:
   __lowerCamelCase:					List[str]	 =						[]

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

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

   return stack.pop()


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

   _A		:					str          =							'''/ * 10 2 + 4 1 '''
   print(evaluate(test_expression))


