



from ..utils import DummyObject, requires_backends







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Union[str, Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			int)				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Union[str, Any])				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			str)				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			List[str])				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Any          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Optional[int])				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			int)				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Any          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Optional[int]				,		**lowerCAmelCase							:			Union[str, Any])				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Optional[int])				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			Dict)				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			int)				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[int]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Any)				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Optional[int])				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[str]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			Optional[Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			Optional[int])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			int)				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			Optional[Any])				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Tuple          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			Optional[int]				,		**lowerCAmelCase							:			int)				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			Union[str, Any])				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Any          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Any)				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Tuple)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[int]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			List[Any])				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Any)				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])



def       lowercase       (   *SCREAMING_SNAKE_CASE__       :	List[Any]				,       **SCREAMING_SNAKE_CASE__       :	Optional[int]				)  ->     List[Any]:
 requires_backends(SCREAMING_SNAKE_CASE__				,       ["""torch"""]				)



def       lowercase       (   *SCREAMING_SNAKE_CASE__       :	Optional[int]				,       **SCREAMING_SNAKE_CASE__       :	Dict				)  ->     int:
 requires_backends(SCREAMING_SNAKE_CASE__				,       ["""torch"""]				)



def       lowercase       (   *SCREAMING_SNAKE_CASE__       :	Union[str, Any]				,       **SCREAMING_SNAKE_CASE__       :	Tuple				)  ->     List[str]:
 requires_backends(SCREAMING_SNAKE_CASE__				,       ["""torch"""]				)



def       lowercase       (   *SCREAMING_SNAKE_CASE__       :	Dict				,       **SCREAMING_SNAKE_CASE__       :	Any				)  ->     List[str]:
 requires_backends(SCREAMING_SNAKE_CASE__				,       ["""torch"""]				)



def       lowercase       (   *SCREAMING_SNAKE_CASE__       :	List[str]				,       **SCREAMING_SNAKE_CASE__       :	Optional[Any]				)  ->     Optional[int]:
 requires_backends(SCREAMING_SNAKE_CASE__				,       ["""torch"""]				)



def       lowercase       (   *SCREAMING_SNAKE_CASE__       :	Tuple				,       **SCREAMING_SNAKE_CASE__       :	Optional[Any]				)  ->     Any:
 requires_backends(SCREAMING_SNAKE_CASE__				,       ["""torch"""]				)



def       lowercase       (   *SCREAMING_SNAKE_CASE__       :	Union[str, Any]				,       **SCREAMING_SNAKE_CASE__       :	str				)  ->     List[Any]:
 requires_backends(SCREAMING_SNAKE_CASE__				,       ["""torch"""]				)







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: str          =		["""torch"""]

   def __init__(					self							:			str				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Tuple)				->				Tuple:

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			Optional[Any])				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			Tuple)				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: str          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Union[str, Any])				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			str)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[str]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Tuple)				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			str)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: str          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			str)				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Dict)				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			List[str])				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			int)				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Any          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			str)				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Tuple)				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: int          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[int]				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			Optional[int])				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			int)				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[int]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			List[str])				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			List[Any])				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: int          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			Dict)				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Optional[int])				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Union[str, Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			Dict)				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Any)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[int]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Optional[Any])				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			List[Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Tuple          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Tuple)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			List[Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[str]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			int)				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Dict)				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[Any]          =		["""torch"""]

   def __init__(					self							:			int				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			int)				->				Any:

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Tuple)				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Union[str, Any])				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[str]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Dict)				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Optional[int]				,		**lowerCAmelCase							:			Dict)				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Union[str, Any])				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[int]				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			str)				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Dict)				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Any)				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Any          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Dict)				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			List[Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Dict)				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Optional[int])				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Dict          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Union[str, Any])				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Tuple)				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Optional[int]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[int]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Union[str, Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			List[str])				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			List[Any])				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Optional[Any])				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Optional[Any])				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			Optional[int])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[str]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			Optional[int])				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Any)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Dict          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Union[str, Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Any)				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Tuple          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			str)				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Optional[Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: int          =		["""torch"""]

   def __init__(					self							:			str				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			int)				->				Tuple:

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Tuple)				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			Optional[int]				,		**lowerCAmelCase							:			Union[str, Any])				->				Dict:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Union[str, Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			List[str])				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Union[str, Any])				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Any          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Union[str, Any])				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			Optional[Any])				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Tuple          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Optional[int]				,		**lowerCAmelCase							:			Union[str, Any])				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[Any]				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Tuple)				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: str          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			Optional[int])				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Dict)				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Tuple          =		["""torch"""]

   def __init__(					self							:			Dict				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Tuple)				->				int:

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Union[str, Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			str)				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Union[str, Any]          =		["""torch"""]

   def __init__(					self							:			Any				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			int)				->				str:

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Any				,		*lowerCAmelCase							:			Optional[Any]				,		**lowerCAmelCase							:			Tuple)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			Dict				,		**lowerCAmelCase							:			Union[str, Any])				->				Optional[int]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: str          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Tuple)				->				Union[str, Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Union[str, Any])				->				List[str]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: List[Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			Any				,		**lowerCAmelCase							:			Union[str, Any])				->				str:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[Any]				,		*lowerCAmelCase							:			str				,		**lowerCAmelCase							:			Any)				->				List[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Union[str, Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Optional[int]				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Optional[Any])				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Any)				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Tuple          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			Union[str, Any]				,		**lowerCAmelCase							:			Tuple)				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			int				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			Optional[Any])				->				Optional[Any]:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Any          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			str				,		*lowerCAmelCase							:			List[Any]				,		**lowerCAmelCase							:			List[Any])				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			Dict				,		*lowerCAmelCase							:			List[str]				,		**lowerCAmelCase							:			Tuple)				->				Tuple:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])







class 		snake_case						(	metaclass=SCREAMING_SNAKE_CASE_  ):



   '''simple docstring'''






   snake_case_					: Union[str, Any]          =		["""torch"""]

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

    """simple docstring"""







    requires_backends(self				,		["""torch"""])

   @classmethod
   def      UpperCamelCase_  (					cls							:			Union[str, Any]				,		*lowerCAmelCase							:			int				,		**lowerCAmelCase							:			Optional[Any])				->				Any:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])


   @classmethod
   def      UpperCamelCase_  (					cls							:			List[str]				,		*lowerCAmelCase							:			Tuple				,		**lowerCAmelCase							:			Union[str, Any])				->				int:

    """simple docstring"""







    requires_backends(cls				,		["""torch"""])





from __future__ import annotations

from math import pi

# Define the Reduced Planck Constant ℏ (H bar), speed of light C, value of
# Pi and the function
a__    =	1.0_54_57_18_17E-34  # unit of ℏ : J * s

a__    =	3E8  # unit of c : m * s^-1



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	float				,       SCREAMING_SNAKE_CASE__       :	float				,       SCREAMING_SNAKE_CASE__       :	float				)  ->     dict[str, float]:

 if (force, area, distance).count(0				) != 1:
  raise ValueError("""One and only one argument must be 0"""				)
 if force < 0:
  raise ValueError("""Magnitude of force can not be negative"""				)
 if distance < 0:
  raise ValueError("""Distance can not be negative"""				)
 if area < 0:
  raise ValueError("""Area can not be negative"""				)
 if force == 0:
  _snake_case    :  Union[str, Any]					=					(REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (
      240 * (distance) ** 4
  )
  return {"force": force}
 elif area == 0:
  _snake_case    :  Optional[Any]					=					(240 * force * (distance) ** 4) / (
      REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2
  )
  return {"area": area}
 elif distance == 0:
  _snake_case    :  str					=					(
      (REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (240 * force)
  ) ** (1 / 4)
  return {"distance": distance}
 raise ValueError("""One and only one argument must be 0"""				)


# Run doctest
if __name__ == "__main__":
  import doctest

  doctest.testmod()
