

lowerCamelCase_					  =   {
    '''+''': lambda x, y: x + y,
    '''-''': lambda x, y: x - y,
    '''*''': lambda x, y: x * y,
    '''/''': lambda x, y: x / y,
}



def   UpperCamelCase(   lowercase_				)      ->							Dict:





  '''simple docstring'''





  return c.isdigit()



def   UpperCamelCase(   lowercase_				)      ->							Union[str, Any]:





  '''simple docstring'''





  snake_case_					= []

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

    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](lowercase_     ,   lowercase_				)				)

  return stack.pop()


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

    lowerCamelCase_					  =   '''/ * 10 2 + 4 1 '''
    print(evaluate(test_expression))


def   UpperCamelCase(   lowercase_     ,   lowercase_				)      ->							Union[str, Any]:





  '''simple docstring'''





  if len(str(lowercase_				)				) == 1 or len(str(lowercase_				)				) == 1:
    return a * b

  snake_case_					= max(len(str(lowercase_				)				)     ,   len(str(lowercase_				)				)				)
  snake_case_					= ma // 2

  snake_case_		,							snake_case_					= divmod(lowercase_     ,   10**ma				)
  snake_case_		,							snake_case_					= divmod(lowercase_     ,   10**ma				)

  snake_case_					= karatsuba(lowercase_     ,   lowercase_				)
  snake_case_					= karatsuba((aa + aa)     ,   (ba + ba)				)
  snake_case_					= karatsuba(lowercase_     ,   lowercase_				)

  return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)



def   UpperCamelCase(   )      ->							Dict:





  '''simple docstring'''





  print(karatsuba(15463     ,   23489				)				)


if __name__ == "__main__":
    main()