


def 							__lowerCamelCase		(					UpperCAmelCase_		:						Tuple					,    UpperCAmelCase_		:						Dict					,    UpperCAmelCase_		:						Union[str, Any]		):




      """simple docstring"""





      if n == 0:
            return 1

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

      else:
            a		:List[Any]									=			binary_exponentiation(UpperCAmelCase_					,    n / 2					,    UpperCAmelCase_		)
            return (b * b) % mod


# a prime number
snake_case							:       Tuple										=	7_01

snake_case							:       int										=	10_00_00_00_00
snake_case							:       Union[str, Any]										=	10

# 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 __future__ import annotations

from typing import Any







class 						_snake_case    ( _snake_case				):
 pass







class 						_snake_case    :




 def __init__(						self   ,    _lowerCamelCase       ):
       a		:Any									=			data
       a		:Node | None									=			None




 def __iter__(						self       ):
       a		:Dict									=			self
       a		:Optional[int]									=			[]
       while node:
             if node in visited:
                   raise ContainsLoopError
             visited.append(_lowerCamelCase       )
             yield node.data
             a		:str									=			node.next_node




 @property
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       try:
             list(self       )
             return False
       except ContainsLoopError:
             return True


if __name__ == "__main__":
     snake_case							:       int										=	Node(1)
     snake_case							:       int										=	Node(2)
     snake_case							:       Optional[int]										=	Node(3)
     snake_case							:       List[str]										=	Node(4)
     print(root_node.has_loop)  # False
     snake_case							:       Optional[Any]										=	root_node.next_node
     print(root_node.has_loop)  # True

     snake_case							:       Dict										=	Node(5)
     snake_case							:       List[Any]										=	Node(6)
     snake_case							:       Optional[int]										=	Node(5)
     snake_case							:       Union[str, Any]										=	Node(6)
     print(root_node.has_loop)  # False

     snake_case							:       Tuple										=	Node(1)
     print(root_node.has_loop)  # False





