






"""simple docstring"""
A_     :					List[str]							=     {
    "+": lambda x, y: x + y,
    "-": lambda x, y: x - y,
    "*": lambda x, y: x * y,
    "/": lambda x, y: x / y,
}






def 			lowerCamelCase_    (		_lowerCamelCase							):
 return c.isdigit()






def 			lowerCamelCase_    (		_lowerCamelCase							):
 lowerCamelCase__	:     Dict								=		[]

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

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

 return stack.pop()


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

      A_     :					Dict							=     "/ * 10 2 + 4 1 "
      print(evaluate(test_expression))









"""simple docstring"""
from itertools import combinations, product






def 			lowerCamelCase_    (		_lowerCamelCase     ,  _lowerCamelCase     ,  _lowerCamelCase     ,  _lowerCamelCase							):
 if xa == ya == 0 or xa == ya == 0:
  return False
 lowerCamelCase__	:     Tuple								=		xa * xa + ya * ya
 lowerCamelCase__	:     Union[str, Any]								=		xa * xa + ya * ya
 lowerCamelCase__	:     Optional[Any]								=		(xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
 return (
     a_square + b_square == c_square
     or a_square + c_square == b_square
     or b_square + c_square == a_square
 )






def 			lowerCamelCase_    (		_lowerCamelCase = 50							):
 return sum(
     1
     for pta, pta in combinations(product(range(limit + 1							)     ,  repeat=2							)     ,  2							)
     if is_right(*_lowerCamelCase     ,  *_lowerCamelCase							)							)


if __name__ == "__main__":
      print(f"{solution() = }")

