


from ..utils import DummyObject, requires_backends


class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Tuple		,						**_lowercase      :					Optional[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					str		,						**_lowercase      :					List[str] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					Dict		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					int		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					Any		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					List[Any]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					List[str] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Tuple		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Any		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Dict		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Tuple		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






  def __init__(					self      :					Any		,						*_lowercase      :					Dict		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					str		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






  def __init__(					self      :					Any		,						*_lowercase      :					int		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					Any		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Optional[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )





def __UpperCAmelCase       (		*__A ,						**__A			)						->					Tuple:



       '''simple docstring'''





       requires_backends(_lowerCAmelCase ,						["torch"]			)





def __UpperCAmelCase       (		*__A ,						**__A			)						->					Tuple:



       '''simple docstring'''





       requires_backends(_lowerCAmelCase ,						["torch"]			)





def __UpperCAmelCase       (		*__A ,						**__A			)						->					Union[str, Any]:



       '''simple docstring'''





       requires_backends(_lowerCAmelCase ,						["torch"]			)





def __UpperCAmelCase       (		*__A ,						**__A			)						->					Union[str, Any]:



       '''simple docstring'''





       requires_backends(_lowerCAmelCase ,						["torch"]			)





def __UpperCAmelCase       (		*__A ,						**__A			)						->					Any:



       '''simple docstring'''





       requires_backends(_lowerCAmelCase ,						["torch"]			)





def __UpperCAmelCase       (		*__A ,						**__A			)						->					List[str]:



       '''simple docstring'''





       requires_backends(_lowerCAmelCase ,						["torch"]			)





def __UpperCAmelCase       (		*__A ,						**__A			)						->					Optional[int]:



       '''simple docstring'''





       requires_backends(_lowerCAmelCase ,						["torch"]			)


class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






  def __init__(					self      :					Dict		,						*_lowercase      :					Dict		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					str		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					List[str]		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					Dict		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					int		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					int		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Any		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Dict		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Any		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					Any		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






  def __init__(					self      :					Tuple		,						*_lowercase      :					Dict		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					str		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					List[Any]		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Tuple		,						*_lowercase      :					Tuple		,						**_lowercase      :					str ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					Any		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					List[str]		,						**_lowercase      :					str ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					Any		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Tuple		,						**_lowercase      :					Optional[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					Dict		,						**_lowercase      :					List[str] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Dict		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					str		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					Any		,						**_lowercase      :					Optional[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Tuple		,						*_lowercase      :					List[Any]		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					Dict		,						**_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					str		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					Dict		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Any		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					List[str]		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					List[Any]		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






  def __init__(					self      :					int		,						*_lowercase      :					str		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					List[Any]		,						**_lowercase      :					str ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Any		,						**_lowercase      :					Optional[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					List[str]		,						**_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					List[Any]		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					List[str]		,						**_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Any		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					Tuple		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					int		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					int		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					Dict		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					int		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					List[str] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					Tuple		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






  def __init__(					self      :					str		,						*_lowercase      :					str		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[Any]		,						*_lowercase      :					List[Any]		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Dict		,						**_lowercase      :					str ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					List[Any]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					Dict		,						**_lowercase      :					Optional[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					str		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Any		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					List[Any]		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					List[str]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					Dict		,						**_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					Any		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Tuple		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					int		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					str		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Dict		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Union[str, Any]		,						*_lowercase      :					Tuple		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[Any]		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					int ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					int		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					Union[str, Any]		,						**_lowercase      :					Any ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Tuple		,						*_lowercase      :					Any		,						**_lowercase      :					List[str] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					int		,						**_lowercase      :					Tuple ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Optional[int]		,						*_lowercase      :					str		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					str		,						*_lowercase      :					List[Any]		,						**_lowercase      :					Union[str, Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )




class     lowercase__  (					metaclass=__snake_case		):
  A__=  ['torch']






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




         """simple docstring"""







         requires_backends(self		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					Dict		,						*_lowercase      :					Optional[int]		,						**_lowercase      :					List[Any] ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )






  @classmethod
  def 			_UpperCAmelCase  (					cls      :					List[str]		,						*_lowercase      :					Optional[Any]		,						**_lowercase      :					Dict ):




         """simple docstring"""







         requires_backends(cls		,						["torch"] )









from math import atan, cos, radians, sin, tan

from .haversine_distance import haversine_distance

A      = 6378137.0
A      = 6356752.314245
A      = 637_8137





def __UpperCAmelCase       (		__A ,						__A ,						__A ,						__A			)						->					float:



       '''simple docstring'''





       UpperCAmelCase__										=     (AXIS_A - AXIS_B) / AXIS_A
       # Parametric latitudes
       # https://en.wikipedia.org/wiki/Latitude#Parametric_(or_reduced)_latitude
       UpperCAmelCase__										=     atan((1 - flattening) * tan(radians(__A			)			)			)
       UpperCAmelCase__										=     atan((1 - flattening) * tan(radians(__A			)			)			)

       # Compute central angle between two points
       # using haversine theta. sigma =  haversine_distance / equatorial radius
       UpperCAmelCase__										=     haversine_distance(__A ,						__A ,						__A ,						__A			) / EQUATORIAL_RADIUS

       # Intermediate P and Q values
       UpperCAmelCase__										=     (b_lata + b_lata) / 2
       UpperCAmelCase__										=     (b_lata - b_lata) / 2

       # Intermediate X value
       # X = (sigma - sin(sigma)) * sin^2Pcos^2Q / cos^2(sigma/2)
       UpperCAmelCase__										=     (sin(__A			) ** 2) * (cos(__A			) ** 2)
       UpperCAmelCase__										=     cos(sigma / 2			) ** 2
       UpperCAmelCase__										=     (sigma - sin(__A			)) * (x_numerator / x_demonimator)

       # Intermediate Y value
       # Y = (sigma + sin(sigma)) * cos^2Psin^2Q / sin^2(sigma/2)
       UpperCAmelCase__										=     (cos(__A			) ** 2) * (sin(__A			) ** 2)
       UpperCAmelCase__										=     sin(sigma / 2			) ** 2
       UpperCAmelCase__										=     (sigma + sin(__A			)) * (y_numerator / y_denominator)

       return EQUATORIAL_RADIUS * (sigma - ((flattening / 2) * (x_value + y_value)))


if __name__ == "__main__":
    import doctest

    doctest.testmod()





