





"""simple docstring"""


from typing import List

from .keymap import KEYMAP, get_character





def SCREAMING_SNAKE_CASE_  (			snake_case  :   Tuple						)->						Optional[Any]:

       def decorator(snake_case  :   List[str]						):
              _lowerCamelCase             =   getattr(snake_case		,    'handle_key'		,    []						)
              handle += [key]
              setattr(snake_case		,    'handle_key'		,    snake_case						)
              return func

       return decorator





def SCREAMING_SNAKE_CASE_  (			*snake_case  :   str						)->						Union[str, Any]:

       def decorator(snake_case  :   int						):
              _lowerCamelCase             =   getattr(snake_case		,    'handle_key'		,    []						)
              handle += keys
              setattr(snake_case		,    'handle_key'		,    snake_case						)
              return func

       return decorator







class       __a  (    UpperCamelCase__						):



     def __new__(			cls   ,	a__   ,	a__   ,	a__  ):
            _lowerCamelCase             =   super().__new__(cls   ,	__snake_case   ,	__snake_case   ,	__snake_case  )
            if not hasattr(__snake_case   ,	'key_handler'  ):
                   setattr(__snake_case   ,	'key_handler'   ,	{}  )
            setattr(__snake_case   ,	'handle_input'   ,	KeyHandler.handle_input  )

            for value in attrs.values():
                   _lowerCamelCase             =   getattr(__snake_case   ,	'handle_key'   ,	[]  )
                   for key in handled_keys:
                          _lowerCamelCase             =   value
            return new_cls



     @staticmethod
     def 		snake_case_     (			cls  ):
            _lowerCamelCase             =   get_character()
            if char != KEYMAP["undefined"]:
                   _lowerCamelCase             =   ord(__snake_case  )
            _lowerCamelCase             =   cls.key_handler.get(__snake_case  )
            if handler:
                   _lowerCamelCase             =   char
                   return handler(cls  )
            else:
                   return None





def SCREAMING_SNAKE_CASE_  (			cls  :   List[str]						)->						List[str]:
       return KeyHandler(cls.__name__		,    cls.__bases__		,    cls.__dict__.copy()						)












from __future__ import annotations

from fractions import Fraction




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				return (
				    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
				)




def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						List[str]										=[]
				__magic_name__						:						List[Any]										=11
				__magic_name__						:						Tuple										=int("""1""" + """0""" * digit_len )
				for num in range(lowerCamelCase						,  lowerCamelCase ):
								while den <= 99:
												if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
																if is_digit_cancelling(lowerCamelCase						,  lowerCamelCase ):
																				solutions.append(F"{num}/{den}" )
												den += 1
								num += 1
								__magic_name__						:						List[str]										=10
				return solutions




def 		lowerCAmelCase_ (						lowerCamelCase = 2 ):
				__magic_name__						:						str										=1.0
				for fraction in fraction_list(lowerCamelCase ):
								__magic_name__						:						int										=Fraction(lowerCamelCase )
								result *= frac.denominator / frac.numerator
				return int(lowerCamelCase )


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




