



from typing import Dict

from .base import GenericTensor, Pipeline




class 							lowerCAmelCase__  (	UpperCamelCase						):







					def  _lowercase			(       self      :     int			,		_A      :     Tuple=None			,		_A      :     Union[str, Any]=None			,		_A      :     int=None			,		**_A      :     Optional[int]):
											if tokenize_kwargs is None:
																	A__	:							Tuple						    = {}

											if truncation is not None:
																	if "truncation" in tokenize_kwargs:
																							raise ValueError(
																							    "truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)")
																	A__	:							Union[str, Any]						    = truncation

											A__	:							List[str]						    = tokenize_kwargs

											A__	:							List[str]						    = {}
											if return_tensors is not None:
																	A__	:							int						    = return_tensors

											return preprocess_params, {}, postprocess_params







					def  _lowercase			(       self      :     Any			,		_A      :     int			,		**_A      :     str):
											A__	:							Optional[Any]						    = self.framework
											A__	:							List[str]						    = self.tokenizer(_A			,		return_tensors=_A			,		**_A)
											return model_inputs







					def  _lowercase			(       self      :     Optional[int]			,		_A      :     Optional[int]):
											A__	:							Dict						    = self.model(**_A)
											return model_outputs







					def  _lowercase			(       self      :     Optional[int]			,		_A      :     Optional[Any]			,		_A      :     List[Any]=False):
											# [0] is the first available tensor, logits or last_hidden_state.
											if return_tensors:
																	return model_outputs[0]
											if self.framework == "pt":
																	return model_outputs[0].tolist()
											elif self.framework == "tf":
																	return model_outputs[0].numpy().tolist()







					def __call__(       self      :     int			,		*_A      :     str			,		**_A      :     Optional[int]):
											return super().__call__(*_A			,		**_A)




def 	snake_case__       (					)		->		Union[str, Any]:







						"""simple docstring"""

						A__	:							Tuple						    = []
						A__	:							Optional[int]						    = 1

						while len(__lowercase       ) < 1E6:
												constant.append(str(__lowercase       )       )
												i += 1

						A__	:							Any						    = "".join(__lowercase       )

						return (
						    int(constant[0]       )
						    * int(constant[9]       )
						    * int(constant[9_9]       )
						    * int(constant[9_9_9]       )
						    * int(constant[9_9_9_9]       )
						    * int(constant[9_9_9_9_9]       )
						    * int(constant[9_9_9_9_9_9]       )
						)


if __name__ == "__main__":
		print(solution())