





'''simple docstring'''







from ..utils import DummyObject, requires_backends
class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					Tuple					,				**__a     :					Dict					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Any					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					List[str]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Optional[Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					List[Any]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Any					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Dict					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Optional[int]					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Any					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					List[Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					List[str]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Dict					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Union[str, Any]					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					str					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Optional[int]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Dict					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Optional[int]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Tuple					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					int					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Tuple					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Dict					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					List[Any]					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					List[str]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Any					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Tuple					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					Any					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					List[str]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Tuple					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					str					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					List[Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					str					,				*__a     :					str					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Optional[int]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Union[str, Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)






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






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






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






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






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






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






def  _lowerCamelCase				( *lowercase						:      List[Any]    ,							**lowercase						:      List[str]						)	->	List[str]:
				requires_backends(lowercase    ,							["torch"]						)
class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					str					,				*__a     :					int					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					List[Any]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Optional[Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Dict					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Any					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					int					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					Any					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Tuple					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					List[str]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Optional[Any]					,				**__a     :					Union[str, Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					Optional[int]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Union[str, Any]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Optional[int]					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Any					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					int					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					List[Any]					,				**__a     :					Union[str, Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					List[Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					str					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					int					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					List[Any]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Tuple					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					Tuple					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					List[Any]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					int					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					int					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Optional[int]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					List[str]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					Any					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Any					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Optional[int]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Union[str, Any]					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Optional[Any]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					int					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					Tuple					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Dict					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					str					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Optional[Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Dict					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					Tuple					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					Tuple					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					int					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Optional[Any]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					str					,				**__a     :					Any					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Any					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Tuple					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					List[Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					int					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Any					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					List[Any]					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Optional[int]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					int					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Tuple					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Any					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Any					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					Optional[Any]					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Dict					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Any					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					Union[str, Any]					,				**__a     :					Any					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					int					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					str					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Tuple					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Union[str, Any]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					List[Any]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Dict					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Any					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					List[str]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					int					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Optional[int]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Optional[Any]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					List[str]					,				**__a     :					Any					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					List[str]					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Tuple					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Any					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					str					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Tuple					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					List[str]					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					int					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Any					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Dict					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Dict					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					List[str]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					int					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Optional[int]					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					List[Any]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					List[Any]					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					List[str]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Optional[int]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					List[Any]					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Optional[Any]					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Optional[int]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					str					,				*__a     :					Tuple					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Tuple					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					List[str]					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					List[Any]					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Optional[Any]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Union[str, Any]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					List[Any]					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					List[Any]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					List[str]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					Union[str, Any]					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Union[str, Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Tuple					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Union[str, Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Union[str, Any]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Optional[int]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					int					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					str					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Optional[int]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					str					,				**__a     :					Union[str, Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					str					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Tuple					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					str					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					str					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					str					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=lowerCamelCase_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Tuple					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Union[str, Any]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Optional[Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


import requests

_A   =     "https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey="






def    lowerCamelCase__				(				__lowerCAmelCase  :  str				):




			"""simple docstring"""


			lowerCAmelCase_						=	requests.get(_NEWS_API + bbc_news_api_key				).json()
			# each article in the list is a dict
			for i, article in enumerate(bbc_news_page["articles"]    ,							1				):
						print(F"""{i}.) {article['title']}"""				)


if __name__ == "__main__":
			fetch_bbc_news(bbc_news_api_key="<Your BBC News API key goes here>")



