
from ..utils import DummyObject, requires_backends




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   List[str]			,  **snake_case							:   Optional[Any]						)   -> Optional[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Any			,  *snake_case							:   Any			,  **snake_case							:   Tuple						)   -> Dict:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[int]			,  *snake_case							:   Dict			,  **snake_case							:   Any						)   -> List[str]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   str			,  *snake_case							:   Optional[int]			,  **snake_case							:   Union[str, Any]						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   List[Any]			,  **snake_case							:   str						)   -> List[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[int]			,  *snake_case							:   Dict			,  **snake_case							:   Union[str, Any]						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   Optional[int]			,  **snake_case							:   List[str]						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Union[str, Any]			,  *snake_case							:   Optional[Any]			,  **snake_case							:   Dict						)   -> Dict:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   Optional[int]			,  **snake_case							:   List[str]						)   -> int:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Dict			,  *snake_case							:   Any			,  **snake_case							:   List[str]						)   -> Union[str, Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[Any]			,  *snake_case							:   Any			,  **snake_case							:   str						)   -> int:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[int]			,  *snake_case							:   Any			,  **snake_case							:   Optional[int]						)   -> Optional[int]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   List[Any]			,  **snake_case							:   Tuple						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[Any]			,  *snake_case							:   Any			,  **snake_case							:   Tuple						)   -> Optional[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   Union[str, Any]			,  **snake_case							:   Tuple						)   -> int:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Dict			,  *snake_case							:   int			,  **snake_case							:   Union[str, Any]						)   -> Optional[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   Optional[Any]			,  **snake_case							:   Optional[Any]						)   -> List[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   str			,  **snake_case							:   int						)   -> Any:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Any			,  *snake_case							:   Any			,  **snake_case							:   Dict						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Tuple			,  *snake_case							:   Union[str, Any]			,  **snake_case							:   Optional[Any]						)   -> Any:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   int			,  **snake_case							:   Optional[Any]						)   -> List[str]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Dict			,  *snake_case							:   Any			,  **snake_case							:   List[Any]						)   -> Dict:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   List[str]			,  **snake_case							:   Any						)   -> Any:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Tuple			,  *snake_case							:   Tuple			,  **snake_case							:   Optional[Any]						)   -> List[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   List[Any]			,  **snake_case							:   List[Any]						)   -> Union[str, Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   int			,  **snake_case							:   Optional[Any]						)   -> Any:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   str			,  *snake_case							:   int			,  **snake_case							:   List[Any]						)   -> Union[str, Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   str			,  **snake_case							:   List[str]						)   -> List[str]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   int			,  *snake_case							:   List[str]			,  **snake_case							:   Tuple						)   -> Optional[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   Optional[Any]			,  **snake_case							:   Optional[Any]						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Dict			,  *snake_case							:   Dict			,  **snake_case							:   str						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[int]			,  *snake_case							:   Optional[Any]			,  **snake_case							:   Optional[int]						)   -> Optional[int]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[Any]			,  *snake_case							:   str			,  **snake_case							:   List[Any]						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Dict			,  *snake_case							:   str			,  **snake_case							:   Any						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Dict			,  *snake_case							:   str			,  **snake_case							:   Optional[int]						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Any			,  *snake_case							:   int			,  **snake_case							:   List[str]						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Tuple			,  *snake_case							:   str			,  **snake_case							:   int						)   -> Any:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   int			,  *snake_case							:   int			,  **snake_case							:   str						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Tuple			,  *snake_case							:   str			,  **snake_case							:   List[str]						)   -> int:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[Any]			,  *snake_case							:   Union[str, Any]			,  **snake_case							:   List[str]						)   -> Dict:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[Any]			,  *snake_case							:   Dict			,  **snake_case							:   Dict						)   -> Any:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Union[str, Any]			,  *snake_case							:   str			,  **snake_case							:   int						)   -> Optional[int]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   int			,  *snake_case							:   Any			,  **snake_case							:   Any						)   -> List[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   Any			,  **snake_case							:   Optional[Any]						)   -> int:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[Any]			,  *snake_case							:   Dict			,  **snake_case							:   Optional[Any]						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[int]			,  *snake_case							:   int			,  **snake_case							:   Tuple						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Any			,  *snake_case							:   List[str]			,  **snake_case							:   Union[str, Any]						)   -> List[Any]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   int			,  *snake_case							:   List[Any]			,  **snake_case							:   Union[str, Any]						)   -> Dict:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Union[str, Any]			,  *snake_case							:   Union[str, Any]			,  **snake_case							:   Tuple						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Any			,  *snake_case							:   Optional[int]			,  **snake_case							:   Tuple						)   -> List[str]:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   Optional[int]			,  **snake_case							:   Optional[int]						)   -> Dict:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[int]			,  *snake_case							:   str			,  **snake_case							:   Optional[int]						)   -> Tuple:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   str			,  *snake_case							:   int			,  **snake_case							:   Optional[int]						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   str			,  *snake_case							:   Union[str, Any]			,  **snake_case							:   Any						)   -> Dict:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Tuple			,  *snake_case							:   Optional[Any]			,  **snake_case							:   Dict						)   -> int:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Optional[Any]			,  *snake_case							:   Optional[Any]			,  **snake_case							:   Union[str, Any]						)   -> int:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   Any			,  *snake_case							:   Optional[Any]			,  **snake_case							:   Union[str, Any]						)   -> str:
							requires_backends(self			,  ["tokenizers"]						)




class      __lowercase	(	metaclass=__snake_case					):
	_A   			=      ["tokenizers"]






	def __init__(self							:   List[str]			,  *snake_case							:   List[str]			,  **snake_case							:   Optional[int]						)   -> Union[str, Any]:
							requires_backends(self			,  ["tokenizers"]						)






def 		UpperCamelCase    (					_UpperCAmelCase     :      int     )      -> bool:






						'''simple docstring'''

						if not isinstance(_UpperCAmelCase   , _UpperCAmelCase     ):
												_lowercase					:  Optional[int]    			=      f"""Input value of [number={number}] must be an integer"""
												raise TypeError(_UpperCAmelCase     )
						if number < 0 or number % 2 == 1:
												return False
						_lowercase					:  List[str]    			=      int(number**0.5     )
						return number == number_sqrt * (number_sqrt + 1)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




