def A__  (			lowercase:     List[str],		lowercase:     int,		lowercase:     Optional[int]					)				->		Optional[Any]:
       if n == 0:
              return 1

       elif n % 2 == 1:
              return (binary_exponentiation(__A,		n - 1,		__A					) * a) % mod

       else:
              A						:     Optional[int]  =binary_exponentiation(__A,		n / 2,		__A					)
              return (b * b) % mod


# a prime number
_lowercase							:      Dict      							=7_0_1

_lowercase							:      Optional[Any]      							=1_0_0_0_0_0_0_0_0_0
_lowercase							:      List[Any]      							=1_0

# using binary exponentiation function, O(log(p)):
print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p)
print((a / b) % p == (a * b ** (p - 2)) % p)







from typing import List

from .keymap import KEYMAP, get_character



def A__  (			lowercase:     str					)				->		List[str]:

       def decorator(lowercase:     int					):
              A						:     Tuple         =getattr(lowercase,		'handle_key',		[]					)
              handle += [key]
              setattr(lowercase,		'handle_key',		lowercase					)
              return func

       return decorator



def A__  (			*lowercase:     List[str]					)				->		Dict:

       def decorator(lowercase:     Union[str, Any]					):
              A						:     Optional[int]         =getattr(lowercase,		'handle_key',		[]					)
              handle += keys
              setattr(lowercase,		'handle_key',		lowercase					)
              return func

       return decorator



class  SCREAMING_SNAKE_CASE_ (					lowerCAmelCase_			):
  '''simple docstring'''


  def __new__(				cls    :					List[str]      ,	SCREAMING_SNAKE_CASE__    :					Optional[Any]      ,	SCREAMING_SNAKE_CASE__    :					List[Any]      ,	SCREAMING_SNAKE_CASE__    :					List[str]     )    ->				Any:
         A						:     Dict         =super().__new__(cls      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )
         if not hasattr(SCREAMING_SNAKE_CASE__      ,	'key_handler'     ):
                setattr(SCREAMING_SNAKE_CASE__      ,	'key_handler'      ,	{}     )
         setattr(SCREAMING_SNAKE_CASE__      ,	'handle_input'      ,	KeyHandler.handle_input     )

         for value in attrs.values():
                A						:     Optional[Any]         =getattr(SCREAMING_SNAKE_CASE__      ,	'handle_key'      ,	[]     )
                for key in handled_keys:
                       A						:     str         =value
         return new_cls







  @staticmethod
  def 		SCREAMING_SNAKE_CASE_		(				cls    :					str     )    ->				Any:
         A						:     str         =get_character()
         if char != KEYMAP["undefined"]:
                A						:     List[str]         =ord(SCREAMING_SNAKE_CASE__     )
         A						:     List[str]         =cls.key_handler.get(SCREAMING_SNAKE_CASE__     )
         if handler:
                A						:     List[str]         =char
                return handler(cls     )
         else:
                return None







def A__  (			cls:     Optional[int]					)				->		str:
       return KeyHandler(cls.__name__,		cls.__bases__,		cls.__dict__.copy()					)






