






'''simple docstring'''





from typing import Dict

from .base import GenericTensor, Pipeline


class    _lowerCAmelCase			(		lowercase_      ):



				"""simple docstring"""



				def 					__magic_name__							(      self    :    List[Any]			,		UpperCamelCase__    :    str=None			,		UpperCamelCase__    :    List[Any]=None			,		UpperCamelCase__    :    List[Any]=None			,		**UpperCamelCase__    :    int):






											'''simple docstring'''







											if tokenize_kwargs is None:
																		snake_case__	  =       {}

											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)""")
																		snake_case__	  =       truncation

											snake_case__	  =       tokenize_kwargs

											snake_case__	  =       {}
											if return_tensors is not None:
																		snake_case__	  =       return_tensors

											return preprocess_params, {}, postprocess_params



				def 					__magic_name__							(      self    :    List[str]			,		UpperCamelCase__    :    Dict			,		**UpperCamelCase__    :    int):






											'''simple docstring'''







											snake_case__	  =       self.framework
											snake_case__	  =       self.tokenizer(UpperCamelCase__			,		return_tensors=UpperCamelCase__			,		**UpperCamelCase__)
											return model_inputs



				def 					__magic_name__							(      self    :    List[str]			,		UpperCamelCase__    :    List[Any]):






											'''simple docstring'''







											snake_case__	  =       self.model(**UpperCamelCase__)
											return model_outputs



				def 					__magic_name__							(      self    :    Dict			,		UpperCamelCase__    :    Optional[int]			,		UpperCamelCase__    :    Union[str, Any]=False):






											'''simple docstring'''







											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			,		*UpperCamelCase__    :    Optional[Any]			,		**UpperCamelCase__    :    str):






											'''simple docstring'''







											return super().__call__(*UpperCamelCase__			,		**UpperCamelCase__)








def _UpperCAmelCase   (	a						:	int = 400_0000 ):
							snake_case__	  =       [0, 1]
							snake_case__	  =       0
							while fib[i] <= n:
														fib.append(fib[i] + fib[i + 1] )
														if fib[i + 2] > n:
																					break
														i += 1
							snake_case__	  =       0
							for j in range(len(a ) - 1 ):
														if fib[j] % 2 == 0:
																					total += fib[j]

							return total


if __name__ == "__main__":
	print(F'''{solution() = }''')
