




from ..utils import DummyObject, requires_backends






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    Tuple					,					**snake_case__					:    Optional[int]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    Any					,					*snake_case__					:    Union[str, Any]					,					**snake_case__					:    List[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    Optional[Any]					,					*snake_case__					:    List[str]					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    Union[str, Any]					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    Tuple   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    Dict					,					*snake_case__					:    str					,					**snake_case__					:    List[str]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Tuple				  =  ["tokenizers"]







			def __init__( self					:    int					,					*snake_case__					:    int					,					**snake_case__					:    str   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    List[Any]					,					*snake_case__					:    Dict					,					**snake_case__					:    Union[str, Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    Any					,					*snake_case__					:    Optional[int]					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    Any					,					*snake_case__					:    List[Any]					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[str]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    int					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    Union[str, Any]					,					*snake_case__					:    Any					,					**snake_case__					:    Tuple   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[Any]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    int					,					**snake_case__					:    Optional[int]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[Any]				  =  ["tokenizers"]







			def __init__( self					:    Optional[int]					,					*snake_case__					:    str					,					**snake_case__					:    List[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    str					,					*snake_case__					:    List[str]					,					**snake_case__					:    Union[str, Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[Any]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    Any   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    List[Any]					,					*snake_case__					:    Tuple					,					**snake_case__					:    int   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    Union[str, Any]					,					**snake_case__					:    int   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Tuple				  =  ["tokenizers"]







			def __init__( self					:    Dict					,					*snake_case__					:    Union[str, Any]					,					**snake_case__					:    str   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    Optional[Any]					,					*snake_case__					:    Any					,					**snake_case__					:    str   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				str				  =  ["tokenizers"]







			def __init__( self					:    Dict					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    List[str]					,					**snake_case__					:    List[str]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    Tuple   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[Any]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    str					,					**snake_case__					:    Optional[int]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    str					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    List[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    Optional[int]					,					**snake_case__					:    str   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Dict				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    str					,					**snake_case__					:    Any   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				int				  =  ["tokenizers"]







			def __init__( self					:    str					,					*snake_case__					:    Tuple					,					**snake_case__					:    str   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Tuple				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    Tuple					,					**snake_case__					:    int   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    Optional[Any]					,					*snake_case__					:    List[str]					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[Any]				  =  ["tokenizers"]







			def __init__( self					:    Union[str, Any]					,					*snake_case__					:    int					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[Any]				  =  ["tokenizers"]







			def __init__( self					:    Union[str, Any]					,					*snake_case__					:    Any					,					**snake_case__					:    int   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Dict				  =  ["tokenizers"]







			def __init__( self					:    Any					,					*snake_case__					:    Union[str, Any]					,					**snake_case__					:    Union[str, Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				str				  =  ["tokenizers"]







			def __init__( self					:    Optional[int]					,					*snake_case__					:    List[Any]					,					**snake_case__					:    Tuple   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[Any]				  =  ["tokenizers"]







			def __init__( self					:    Any					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    Union[str, Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    Union[str, Any]					,					*snake_case__					:    List[str]					,					**snake_case__					:    List[str]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[str]				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    Dict					,					**snake_case__					:    Optional[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Dict				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    Dict					,					**snake_case__					:    Any   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				int				  =  ["tokenizers"]







			def __init__( self					:    Dict					,					*snake_case__					:    Tuple					,					**snake_case__					:    Any   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    int					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    Tuple   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Tuple				  =  ["tokenizers"]







			def __init__( self					:    int					,					*snake_case__					:    Optional[int]					,					**snake_case__					:    Tuple   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Tuple				  =  ["tokenizers"]







			def __init__( self					:    Dict					,					*snake_case__					:    Union[str, Any]					,					**snake_case__					:    Any   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				int				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    List[str]					,					**snake_case__					:    Optional[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[str]				  =  ["tokenizers"]







			def __init__( self					:    Optional[int]					,					*snake_case__					:    Optional[int]					,					**snake_case__					:    Union[str, Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[str]				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    str					,					**snake_case__					:    Any   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    Any					,					*snake_case__					:    Tuple					,					**snake_case__					:    str   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				int				  =  ["tokenizers"]







			def __init__( self					:    str					,					*snake_case__					:    int					,					**snake_case__					:    List[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Optional[int]				  =  ["tokenizers"]







			def __init__( self					:    int					,					*snake_case__					:    Dict					,					**snake_case__					:    Optional[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Tuple				  =  ["tokenizers"]







			def __init__( self					:    List[Any]					,					*snake_case__					:    Dict					,					**snake_case__					:    Tuple   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Dict				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    str					,					**snake_case__					:    Any   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    Any					,					**snake_case__					:    Union[str, Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Union[str, Any]				  =  ["tokenizers"]







			def __init__( self					:    List[str]					,					*snake_case__					:    str					,					**snake_case__					:    Union[str, Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				int				  =  ["tokenizers"]







			def __init__( self					:    Tuple					,					*snake_case__					:    Optional[Any]					,					**snake_case__					:    List[str]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Any				  =  ["tokenizers"]







			def __init__( self					:    Any					,					*snake_case__					:    Optional[int]					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				Tuple				  =  ["tokenizers"]







			def __init__( self					:    str					,					*snake_case__					:    Any					,					**snake_case__					:    List[Any]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				int				  =  ["tokenizers"]







			def __init__( self					:    List[Any]					,					*snake_case__					:    List[Any]					,					**snake_case__					:    str   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				int				  =  ["tokenizers"]







			def __init__( self					:    Optional[int]					,					*snake_case__					:    Dict					,					**snake_case__					:    Optional[int]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				str				  =  ["tokenizers"]







			def __init__( self					:    Optional[int]					,					*snake_case__					:    Optional[int]					,					**snake_case__					:    List[str]   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )






class 					__lowerCAmelCase				( metaclass=UpperCAmelCase__				):
			snake_case_   :				List[Any]				  =  ["tokenizers"]







			def __init__( self					:    Union[str, Any]					,					*snake_case__					:    List[str]					,					**snake_case__					:    Dict   ):




									"""simple docstring"""


									requires_backends(self					,					["tokenizers"]   )










from math import exp


def 							__SCREAMING_SNAKE_CASE						(    snake_case_		):

						'''simple docstring'''


						return 8 * x - 2 * exp(-x		)


def 							__SCREAMING_SNAKE_CASE						(    snake_case_			,					snake_case_			,					snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase									=  lower_bound
						_UpperCAmelCase									=  upper_bound
						for _ in range(0			,					snake_case_		):
												_UpperCAmelCase							,				_UpperCAmelCase									=  xa, xa - (f(snake_case_		) * (xa - xa)) / (f(snake_case_		) - f(snake_case_		))
						return xa


if __name__ == "__main__":
				print(f"""Example: {secant_method(1, 3, 2)}""")




