






from ..utils import DummyObject, requires_backends
class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			int		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			int					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			List[str]		,      **__lowercase					:			Dict					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			List[Any]		,      **__lowercase					:			Optional[Any]					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			Union[str, Any]		,      *__lowercase					:			List[str]		,      **__lowercase					:			List[str]					)							->      Optional[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			int		,      **__lowercase					:			str					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			str		,      **__lowercase					:			Any					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Tuple							       =	['torch']
      def __init__(      self					:			Tuple		,      *__lowercase					:			Tuple		,      **__lowercase					:			Dict					)							->      Any:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[int]		,      *__lowercase					:			int		,      **__lowercase					:			Dict					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			str		,      **__lowercase					:			List[Any]					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Tuple							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			Dict		,      **__lowercase					:			List[str]					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			List[Any]		,      **__lowercase					:			List[Any]					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			str					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			int		,      *__lowercase					:			List[str]		,      **__lowercase					:			Union[str, Any]					)							->      Optional[int]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			List[str]		,      **__lowercase					:			List[str]					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			str		,      **__lowercase					:			Optional[Any]					)							->      Tuple:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			Optional[Any]		,      *__lowercase					:			List[Any]		,      **__lowercase					:			List[Any]					)							->      int:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Tuple					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Dict					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Tuple							       =	['torch']
      def __init__(      self					:			List[Any]		,      *__lowercase					:			Tuple		,      **__lowercase					:			Any					)							->      Any:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Any					)							->      Optional[int]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			str		,      **__lowercase					:			Union[str, Any]					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Dict					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			List[Any]					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Tuple					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : int							       =	['torch']
      def __init__(      self					:			Tuple		,      *__lowercase					:			int		,      **__lowercase					:			Tuple					)							->      Optional[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Tuple					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Optional[int]					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : int							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			Dict		,      **__lowercase					:			Any					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			Tuple		,      **__lowercase					:			int					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Optional[int]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : int							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			Dict		,      **__lowercase					:			Optional[int]					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			str		,      **__lowercase					:			int					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			List[str]		,      **__lowercase					:			int					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)






def 				lowerCamelCase__      (    *__lowerCamelCase			:     str  ,		**__lowerCamelCase			:     Dict		):
  requires_backends(__lowerCamelCase  ,		["""torch"""]		)






def 				lowerCamelCase__      (    *__lowerCamelCase			:     Optional[int]  ,		**__lowerCamelCase			:     List[str]		):
  requires_backends(__lowerCamelCase  ,		["""torch"""]		)






def 				lowerCamelCase__      (    *__lowerCamelCase			:     List[Any]  ,		**__lowerCamelCase			:     Optional[int]		):
  requires_backends(__lowerCamelCase  ,		["""torch"""]		)






def 				lowerCamelCase__      (    *__lowerCamelCase			:     Union[str, Any]  ,		**__lowerCamelCase			:     Tuple		):
  requires_backends(__lowerCamelCase  ,		["""torch"""]		)






def 				lowerCamelCase__      (    *__lowerCamelCase			:     List[Any]  ,		**__lowerCamelCase			:     Tuple		):
  requires_backends(__lowerCamelCase  ,		["""torch"""]		)






def 				lowerCamelCase__      (    *__lowerCamelCase			:     Any  ,		**__lowerCamelCase			:     List[Any]		):
  requires_backends(__lowerCamelCase  ,		["""torch"""]		)






def 				lowerCamelCase__      (    *__lowerCamelCase			:     Union[str, Any]  ,		**__lowerCamelCase			:     Tuple		):
  requires_backends(__lowerCamelCase  ,		["""torch"""]		)
class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[str]							       =	['torch']
      def __init__(      self					:			int		,      *__lowercase					:			List[str]		,      **__lowercase					:			Dict					)							->      Dict:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			List[Any]		,      **__lowercase					:			Union[str, Any]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			int					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			List[Any]		,      **__lowercase					:			Union[str, Any]					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			Dict		,      **__lowercase					:			Union[str, Any]					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Tuple		,      **__lowercase					:			Tuple					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : str							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			int		,      **__lowercase					:			int					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			Dict		,      **__lowercase					:			Dict					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[int]		,      *__lowercase					:			Tuple		,      **__lowercase					:			Optional[int]					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Optional[Any]							       =	['torch']
      def __init__(      self					:			int		,      *__lowercase					:			Any		,      **__lowercase					:			Dict					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Tuple					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			str		,      **__lowercase					:			Union[str, Any]					)							->      Optional[int]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			Dict		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Union[str, Any]					)							->      Dict:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			Tuple		,      **__lowercase					:			Any					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			List[Any]		,      **__lowercase					:			List[str]					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			List[str]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Tuple					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			int					)							->      Tuple:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Tuple		,      *__lowercase					:			int		,      **__lowercase					:			Union[str, Any]					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Union[str, Any]							       =	['torch']
      def __init__(      self					:			Tuple		,      *__lowercase					:			List[str]		,      **__lowercase					:			Optional[int]					)							->      List[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Tuple		,      *__lowercase					:			int		,      **__lowercase					:			int					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			Any		,      **__lowercase					:			Dict					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[str]							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			Dict		,      **__lowercase					:			Dict					)							->      Dict:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Optional[Any]					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			int		,      **__lowercase					:			Optional[int]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Tuple							       =	['torch']
      def __init__(      self					:			List[str]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Optional[Any]					)							->      Dict:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Tuple		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Union[str, Any]					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Any					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			int		,      *__lowercase					:			Dict		,      **__lowercase					:			Any					)							->      int:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Dict		,      **__lowercase					:			str					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			List[str]		,      **__lowercase					:			int					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : int							       =	['torch']
      def __init__(      self					:			Tuple		,      *__lowercase					:			str		,      **__lowercase					:			Optional[Any]					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[int]		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			List[Any]					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			List[str]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Tuple							       =	['torch']
      def __init__(      self					:			List[str]		,      *__lowercase					:			str		,      **__lowercase					:			int					)							->      Dict:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			List[str]		,      **__lowercase					:			Optional[Any]					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			List[str]		,      **__lowercase					:			List[str]					)							->      Tuple:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			Union[str, Any]		,      *__lowercase					:			List[Any]		,      **__lowercase					:			Any					)							->      Tuple:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Optional[int]					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			List[Any]		,      **__lowercase					:			Any					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			str		,      **__lowercase					:			str					)							->      int:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			List[str]		,      **__lowercase					:			str					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			List[str]		,      **__lowercase					:			int					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			str		,      **__lowercase					:			Optional[Any]					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			str		,      **__lowercase					:			Dict					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			str					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Union[str, Any]							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			int		,      **__lowercase					:			Tuple					)							->      Optional[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			Tuple		,      **__lowercase					:			Optional[int]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			Dict					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[str]							       =	['torch']
      def __init__(      self					:			Optional[Any]		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			List[Any]					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			List[Any]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			Tuple		,      **__lowercase					:			List[Any]					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Union[str, Any]							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			List[Any]		,      **__lowercase					:			str					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Tuple					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Tuple					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Optional[Any]							       =	['torch']
      def __init__(      self					:			Optional[Any]		,      *__lowercase					:			int		,      **__lowercase					:			Union[str, Any]					)							->      Tuple:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			str					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			Dict		,      **__lowercase					:			List[Any]					)							->      Optional[int]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : int							       =	['torch']
      def __init__(      self					:			List[str]		,      *__lowercase					:			int		,      **__lowercase					:			Optional[Any]					)							->      List[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[int]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Optional[Any]					)							->      Optional[int]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			List[str]		,      **__lowercase					:			List[Any]					)							->      Tuple:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Any					)							->      List[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Any					)							->      Tuple:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Any					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Optional[int]							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			str		,      **__lowercase					:			Tuple					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			Any		,      **__lowercase					:			List[str]					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			List[str]		,      **__lowercase					:			int					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			List[Any]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Optional[Any]					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Dict		,      **__lowercase					:			Any					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			str		,      **__lowercase					:			Dict					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Any							       =	['torch']
      def __init__(      self					:			Tuple		,      *__lowercase					:			Any		,      **__lowercase					:			Optional[Any]					)							->      Dict:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			List[str]					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[Any]		,      *__lowercase					:			int		,      **__lowercase					:			Tuple					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[str]							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			str		,      **__lowercase					:			Union[str, Any]					)							->      Optional[int]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Any					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			List[str]		,      **__lowercase					:			Dict					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			Dict		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			int					)							->      int:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			List[Any]		,      **__lowercase					:			List[Any]					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			Any		,      **__lowercase					:			Any					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[str]							       =	['torch']
      def __init__(      self					:			Optional[int]		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Optional[int]					)							->      Optional[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			Tuple		,      **__lowercase					:			Dict					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			str		,      **__lowercase					:			Optional[Any]					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[str]							       =	['torch']
      def __init__(      self					:			Tuple		,      *__lowercase					:			List[str]		,      **__lowercase					:			Optional[int]					)							->      int:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			Dict		,      **__lowercase					:			Tuple					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			List[str]		,      **__lowercase					:			Union[str, Any]					)							->      str:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : str							       =	['torch']
      def __init__(      self					:			int		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Optional[Any]					)							->      Tuple:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			str		,      **__lowercase					:			Union[str, Any]					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			Tuple					)							->      Tuple:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Optional[int]							       =	['torch']
      def __init__(      self					:			Dict		,      *__lowercase					:			Tuple		,      **__lowercase					:			Union[str, Any]					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			Dict		,      **__lowercase					:			int					)							->      List[Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			List[Any]		,      **__lowercase					:			Dict					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Tuple							       =	['torch']
      def __init__(      self					:			Tuple		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			int					)							->      Optional[int]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[int]		,      *__lowercase					:			Any		,      **__lowercase					:			Optional[Any]					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[Any]		,      *__lowercase					:			str		,      **__lowercase					:			str					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Any							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			Tuple		,      **__lowercase					:			Dict					)							->      Tuple:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Tuple		,      *__lowercase					:			Dict		,      **__lowercase					:			Optional[Any]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Optional[int]		,      *__lowercase					:			int		,      **__lowercase					:			Optional[Any]					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			Any		,      *__lowercase					:			Tuple		,      **__lowercase					:			List[Any]					)							->      Optional[Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			Optional[int]		,      **__lowercase					:			str					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Dict		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			List[str]					)							->      Optional[int]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			List[str]		,      *__lowercase					:			Tuple		,      **__lowercase					:			Union[str, Any]					)							->      Dict:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Union[str, Any]		,      *__lowercase					:			Any		,      **__lowercase					:			Union[str, Any]					)							->      Optional[int]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			Union[str, Any]					)							->      int:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : int							       =	['torch']
      def __init__(      self					:			Dict		,      *__lowercase					:			Dict		,      **__lowercase					:			List[Any]					)							->      Optional[int]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			Tuple		,      **__lowercase					:			Any					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Any		,      *__lowercase					:			Union[str, Any]		,      **__lowercase					:			Union[str, Any]					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : str							       =	['torch']
      def __init__(      self					:			int		,      *__lowercase					:			Dict		,      **__lowercase					:			List[Any]					)							->      List[str]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			str		,      *__lowercase					:			Dict		,      **__lowercase					:			str					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			str		,      **__lowercase					:			Any					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Dict							       =	['torch']
      def __init__(      self					:			Dict		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			int					)							->      Tuple:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			Tuple		,      **__lowercase					:			int					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			List[str]		,      *__lowercase					:			Tuple		,      **__lowercase					:			str					)							->      Optional[Any]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : List[Any]							       =	['torch']
      def __init__(      self					:			str		,      *__lowercase					:			str		,      **__lowercase					:			Dict					)							->      Optional[int]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Tuple		,      *__lowercase					:			Tuple		,      **__lowercase					:			Optional[Any]					)							->      Any:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			Tuple		,      *__lowercase					:			List[str]		,      **__lowercase					:			Optional[int]					)							->      List[str]:
        requires_backends(cls		,      ["""torch"""]					)


class     a    ( metaclass=lowercase__   ):



      """simple docstring"""


      a  : Any							       =	['torch']
      def __init__(      self					:			List[Any]		,      *__lowercase					:			str		,      **__lowercase					:			Union[str, Any]					)							->      Union[str, Any]:
        requires_backends(self		,      ["""torch"""]					)
      @classmethod
      def 	UpperCAmelCase      (      cls					:			Tuple		,      *__lowercase					:			Optional[Any]		,      **__lowercase					:			Any					)							->      Union[str, Any]:
        requires_backends(cls		,      ["""torch"""]					)




      @classmethod
      def 	UpperCAmelCase      (      cls					:			int		,      *__lowercase					:			str		,      **__lowercase					:			Dict					)							->      Dict:
        requires_backends(cls		,      ["""torch"""]					)










from math import log

from scipy.constants import Boltzmann, physical_constants

a		:       Any			     = 300  # TEMPERATURE (unit = K)






def 				lowerCamelCase__      (    __lowerCamelCase			:     float  ,		__lowerCamelCase			:     float  ,		__lowerCamelCase			:     float  ,		):

  if donor_conc <= 0:
    raise ValueError("""Donor concentration should be positive"""		)
  elif acceptor_conc <= 0:
    raise ValueError("""Acceptor concentration should be positive"""		)
  elif intrinsic_conc <= 0:
    raise ValueError("""Intrinsic concentration should be positive"""		)
  elif donor_conc <= intrinsic_conc:
    raise ValueError(
        """Donor concentration should be greater than intrinsic concentration"""		)
  elif acceptor_conc <= intrinsic_conc:
    raise ValueError(
        """Acceptor concentration should be greater than intrinsic concentration"""		)
  else:
    return (
        Boltzmann
        * T
        * log((donor_conc * acceptor_conc) / intrinsic_conc**2		)
        / physical_constants["electron volt"][0]
    )


if __name__ == "__main__":
       import doctest

       doctest.testmod()


