



'''simple docstring'''






from ..utils import DummyObject, requires_backends

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Dict		,      *__snake_case      :					int		,      **__snake_case      :					List[Any]		)      ->		List[str]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					List[Any]		,      *__snake_case      :					int		,      **__snake_case      :					Dict		)      ->		Optional[Any]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Optional[Any]		,      *__snake_case      :					Dict		,      **__snake_case      :					Optional[int]		)      ->		int:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Dict		,      *__snake_case      :					List[Any]		,      **__snake_case      :					int		)      ->		Dict:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Dict		,      *__snake_case      :					int		,      **__snake_case      :					Optional[int]		)      ->		Any:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Dict		,      *__snake_case      :					int		,      **__snake_case      :					List[Any]		)      ->		List[str]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					int		,      *__snake_case      :					List[Any]		,      **__snake_case      :					Optional[Any]		)      ->		List[Any]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					List[Any]		,      *__snake_case      :					Tuple		,      **__snake_case      :					int		)      ->		int:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Optional[Any]		,      *__snake_case      :					Tuple		,      **__snake_case      :					Optional[Any]		)      ->		Dict:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					int		,      *__snake_case      :					Optional[int]		,      **__snake_case      :					int		)      ->		int:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					List[Any]		,      *__snake_case      :					Tuple		,      **__snake_case      :					List[str]		)      ->		Dict:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					str		,      *__snake_case      :					Dict		,      **__snake_case      :					List[Any]		)      ->		str:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Tuple		,      *__snake_case      :					str		,      **__snake_case      :					List[str]		)      ->		List[str]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Tuple		,      *__snake_case      :					Any		,      **__snake_case      :					List[str]		)      ->		Union[str, Any]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					List[str]		,      *__snake_case      :					Dict		,      **__snake_case      :					str		)      ->		str:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					int		,      *__snake_case      :					Union[str, Any]		,      **__snake_case      :					Dict		)      ->		Union[str, Any]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Union[str, Any]		,      *__snake_case      :					List[str]		,      **__snake_case      :					int		)      ->		Tuple:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Dict		,      *__snake_case      :					Optional[int]		,      **__snake_case      :					Optional[int]		)      ->		List[Any]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					str		,      *__snake_case      :					Tuple		,      **__snake_case      :					Any		)      ->		Optional[Any]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Optional[int]		,      *__snake_case      :					Any		,      **__snake_case      :					Dict		)      ->		Any:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Tuple		,      *__snake_case      :					Any		,      **__snake_case      :					Any		)      ->		int:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Tuple		,      *__snake_case      :					Optional[int]		,      **__snake_case      :					str		)      ->		Any:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					List[str]		,      *__snake_case      :					List[str]		,      **__snake_case      :					str		)      ->		Any:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







	def __init__(						self      :					Dict		,      *__snake_case      :					Tuple		,      **__snake_case      :					Dict		)      ->		List[Any]:
								requires_backends(self		,      ['''tokenizers''']		)

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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

class     SCREAMING_SNAKE_CASE(							metaclass=A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	["""tokenizers"""]







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










'''simple docstring'''






from __future__ import annotations


def 			snake_case_					( _lowerCAmelCase  :						list[int]       ,				_lowerCAmelCase  :						int  )				->       list[int]:
							UpperCAmelCase			:	dict[int, int]										=		{}
							for index, val in enumerate(_lowerCAmelCase  ):
														UpperCAmelCase			:	Tuple										=		target - val
														if compl in chk_map:
																					return [chk_map[compl], index]
														UpperCAmelCase			:	Any										=		index
							return []


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						print(F"{two_sum([2, 7, 11, 15], 9) = }")





