




from ..utils import DummyObject, requires_backends







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Tuple							=     ["""tokenizers"""]

     def __init__(   self			:							List[Any]    ,					*A			:							Optional[int]    ,					**A			:							Union[str, Any]     )      ->      Optional[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Dict    ,					*A			:							Union[str, Any]    ,					**A			:							Any     )      ->      Tuple:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							List[str]    ,					**A			:							Any     )      ->      Union[str, Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Any							=     ["""tokenizers"""]

     def __init__(   self			:							List[str]    ,					*A			:							List[str]    ,					**A			:							Dict     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			int							=     ["""tokenizers"""]

     def __init__(   self			:							List[Any]    ,					*A			:							Optional[int]    ,					**A			:							str     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			str							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							Tuple    ,					**A			:							Any     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							Dict    ,					*A			:							List[Any]    ,					**A			:							Dict     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Dict							=     ["""tokenizers"""]

     def __init__(   self			:							List[Any]    ,					*A			:							List[str]    ,					**A			:							Union[str, Any]     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							Optional[Any]    ,					**A			:							int     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							Union[str, Any]    ,					**A			:							Optional[int]     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Any							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[int]    ,					*A			:							List[str]    ,					**A			:							int     )      ->      Optional[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							List[str]    ,					*A			:							List[str]    ,					**A			:							List[Any]     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			int							=     ["""tokenizers"""]

     def __init__(   self			:							Dict    ,					*A			:							Union[str, Any]    ,					**A			:							List[Any]     )      ->      List[str]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			str							=     ["""tokenizers"""]

     def __init__(   self			:							Tuple    ,					*A			:							str    ,					**A			:							Optional[int]     )      ->      List[str]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Any							=     ["""tokenizers"""]

     def __init__(   self			:							Tuple    ,					*A			:							Tuple    ,					**A			:							List[str]     )      ->      Tuple:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Any							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							List[str]    ,					**A			:							Dict     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							List[Any]    ,					*A			:							List[str]    ,					**A			:							Any     )      ->      Dict:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							str    ,					*A			:							str    ,					**A			:							Tuple     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[Any]    ,					*A			:							str    ,					**A			:							Optional[int]     )      ->      List[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Dict							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[Any]    ,					*A			:							int    ,					**A			:							Optional[Any]     )      ->      Optional[int]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Dict							=     ["""tokenizers"""]

     def __init__(   self			:							List[Any]    ,					*A			:							List[Any]    ,					**A			:							Any     )      ->      List[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			str							=     ["""tokenizers"""]

     def __init__(   self			:							str    ,					*A			:							List[Any]    ,					**A			:							Any     )      ->      Tuple:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							List[Any]    ,					*A			:							Tuple    ,					**A			:							Tuple     )      ->      Dict:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							Tuple    ,					*A			:							int    ,					**A			:							str     )      ->      List[str]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Tuple							=     ["""tokenizers"""]

     def __init__(   self			:							str    ,					*A			:							int    ,					**A			:							Union[str, Any]     )      ->      Union[str, Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			str							=     ["""tokenizers"""]

     def __init__(   self			:							Tuple    ,					*A			:							Tuple    ,					**A			:							str     )      ->      Dict:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			int							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[int]    ,					*A			:							Union[str, Any]    ,					**A			:							Tuple     )      ->      Optional[int]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							Tuple    ,					**A			:							Optional[Any]     )      ->      Optional[int]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							List[str]    ,					**A			:							Union[str, Any]     )      ->      Union[str, Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							str    ,					**A			:							Optional[int]     )      ->      int:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			str							=     ["""tokenizers"""]

     def __init__(   self			:							Dict    ,					*A			:							Optional[Any]    ,					**A			:							int     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Dict							=     ["""tokenizers"""]

     def __init__(   self			:							List[str]    ,					*A			:							str    ,					**A			:							Optional[int]     )      ->      Union[str, Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							Tuple    ,					*A			:							Optional[Any]    ,					**A			:							Optional[int]     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Union[str, Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							List[Any]    ,					**A			:							int     )      ->      int:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Any							=     ["""tokenizers"""]

     def __init__(   self			:							List[str]    ,					*A			:							List[str]    ,					**A			:							int     )      ->      Optional[int]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Tuple							=     ["""tokenizers"""]

     def __init__(   self			:							Tuple    ,					*A			:							Optional[int]    ,					**A			:							Dict     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[int]    ,					*A			:							Optional[int]    ,					**A			:							List[Any]     )      ->      Optional[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Tuple							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							Optional[Any]    ,					**A			:							Tuple     )      ->      Union[str, Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							Dict    ,					*A			:							List[Any]    ,					**A			:							Optional[int]     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							List[Any]    ,					*A			:							str    ,					**A			:							List[Any]     )      ->      Dict:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[int]    ,					*A			:							Any    ,					**A			:							List[Any]     )      ->      int:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Any							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							List[Any]    ,					**A			:							int     )      ->      int:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[Any]    ,					*A			:							List[Any]    ,					**A			:							str     )      ->      Dict:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							Dict    ,					*A			:							str    ,					**A			:							Union[str, Any]     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Dict							=     ["""tokenizers"""]

     def __init__(   self			:							int    ,					*A			:							List[str]    ,					**A			:							Dict     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							int    ,					*A			:							Tuple    ,					**A			:							List[Any]     )      ->      Any:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Union[str, Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							Tuple    ,					**A			:							Optional[int]     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Union[str, Any]							=     ["""tokenizers"""]

     def __init__(   self			:							str    ,					*A			:							Any    ,					**A			:							Dict     )      ->      List[str]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Union[str, Any]							=     ["""tokenizers"""]

     def __init__(   self			:							int    ,					*A			:							int    ,					**A			:							Optional[Any]     )      ->      Optional[int]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Dict							=     ["""tokenizers"""]

     def __init__(   self			:							str    ,					*A			:							Tuple    ,					**A			:							Optional[int]     )      ->      int:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Any							=     ["""tokenizers"""]

     def __init__(   self			:							Optional[Any]    ,					*A			:							Dict    ,					**A			:							str     )      ->      Optional[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							Dict    ,					*A			:							List[str]    ,					**A			:							Union[str, Any]     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							Tuple    ,					**A			:							str     )      ->      str:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			int							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							Dict    ,					**A			:							List[str]     )      ->      Optional[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							List[str]    ,					**A			:							str     )      ->      Union[str, Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			List[str]							=     ["""tokenizers"""]

     def __init__(   self			:							Any    ,					*A			:							List[str]    ,					**A			:							List[str]     )      ->      List[Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			int							=     ["""tokenizers"""]

     def __init__(   self			:							str    ,					*A			:							str    ,					**A			:							str     )      ->      Union[str, Any]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )







class 		__UpperCAmelCase(		metaclass=lowercase__			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[Any]							=     ["""tokenizers"""]

     def __init__(   self			:							Union[str, Any]    ,					*A			:							List[str]    ,					**A			:							Optional[int]     )      ->      Optional[int]:






         """simple docstring"""
         requires_backends(self    ,					["""tokenizers"""]     )












from __future__ import annotations

import sys
def 							__lowerCAmelCase			(UpperCAmelCase_		):
    if n < 0:
        raise ValueError("""Negative arguments are not supported"""		)
    return _fib(UpperCAmelCase_		)[0]
def 							__lowerCAmelCase			(UpperCAmelCase_		):
    if n == 0:  # (F(0), F(1))
        return (0, 1)

    # F(2n) = F(n)[2F(n+1) − F(n)]
    # F(2n+1) = F(n+1)^2+F(n)^2
    a__			,		a__  			=							_fib(n // 2		)
    a__  			=							a * (b * 2 - a)
    a__  			=							a * a + b * b
    return (d, c + d) if n % 2 else (c, d)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE_    :       Dict       =							int(sys.argv[1])
 print(F"fibonacci({n}) is {fibonacci(n)}")






