
'''simple docstring'''







import sys

sys.set_int_max_str_digits(0)  # type: ignore
def    snake_case_						(							__SCREAMING_SNAKE_CASE   :					int				):



						"""simple docstring"""





						lowercase_      :	Dict						=			[0] * 11
						lowercase_      :	List[str]						=			[0] * 11

						# mark last 9 numbers
						for _ in range(9				):
												lowercase_      :	List[str]						=			1
												lowercase_      :	Union[str, Any]						=			number // 10
						# flag
						lowercase_      :	List[str]						=			True

						# check last 9 numbers for pandigitality

						for x in range(9				):
												if not check_last[x + 1]:
																		lowercase_      :	Any						=			False
						if not f:
												return f

						# mark first 9 numbers
						lowercase_      :	Union[str, Any]						=			int(str(__SCREAMING_SNAKE_CASE				)[:9]				)

						for _ in range(9				):
												lowercase_      :	Dict						=			1
												lowercase_      :	Tuple						=			number // 10

						# check first 9 numbers for pandigitality

						for x in range(9				):
												if not check_front[x + 1]:
																		lowercase_      :	int						=			False
						return f
def    snake_case_						(							__SCREAMING_SNAKE_CASE   :					int				):



						"""simple docstring"""





						lowercase_      :	int						=			[0] * 11

						# mark last 9 numbers
						for _ in range(9				):
												lowercase_      :	Optional[Any]						=			1
												lowercase_      :	List[Any]						=			number // 10
						# flag
						lowercase_      :	List[Any]						=			True

						# check last 9 numbers for pandigitality

						for x in range(9				):
												if not check_last[x + 1]:
																		lowercase_      :	Union[str, Any]						=			False
						return f
def    snake_case_						(							):



						"""simple docstring"""





						lowercase_      :	int						=			1
						lowercase_      :	Tuple						=			1
						lowercase_      :	Any						=			2
						# temporary Fibonacci numbers

						lowercase_      :	List[str]						=			1
						lowercase_      :	Union[str, Any]						=			1
						lowercase_      :	Union[str, Any]						=			2
						# temporary Fibonacci numbers mod 1e9

						# mod m=1e9, done for fast optimisation
						lowercase_      :	Any						=			[0] * 1000000
						lowercase_      :	Any						=			1000000000

						for x in range(1000000				):
												lowercase_      :	Optional[Any]						=			(aa + ba) % m
												lowercase_      :	Union[str, Any]						=			ba % m
												lowercase_      :	Union[str, Any]						=			ca % m
												if checka(__SCREAMING_SNAKE_CASE				):
																		lowercase_      :	Tuple						=			1

						for x in range(1000000				):
												lowercase_      :	Optional[Any]						=			a + b
												lowercase_      :	Optional[int]						=			b
												lowercase_      :	Union[str, Any]						=			c
												# perform check only if in tocheck
												if tocheck[x + 3] and check(__SCREAMING_SNAKE_CASE				):
																		return x + 3  # first 2 already done
						return -1


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





'''simple docstring'''







from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding






class 					lowerCAmelCase__  (    lowerCamelCase_	):
					lowerCAmelCase_	  =	['''image_processor''', '''tokenizer''']
					lowerCAmelCase_	  =	'''EfficientNetImageProcessor'''
					lowerCAmelCase_	  =	('''BertTokenizer''', '''BertTokenizerFast''')






					def __init__(  self							,				__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											super().__init__(__SCREAMING_SNAKE_CASE							,				__SCREAMING_SNAKE_CASE						)






					def __call__(  self							,				__SCREAMING_SNAKE_CASE=None							,				__SCREAMING_SNAKE_CASE=None							,				__SCREAMING_SNAKE_CASE="max_length"							,				__SCREAMING_SNAKE_CASE=64							,				__SCREAMING_SNAKE_CASE=None							,				**__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											if text is None and images is None:
																	raise ValueError('''You have to specify either text or images. Both cannot be none.'''						)

											if text is not None:
																	lowercase_      :	str						=			self.tokenizer(
																	    __SCREAMING_SNAKE_CASE							,				padding=__SCREAMING_SNAKE_CASE							,				max_length=__SCREAMING_SNAKE_CASE							,				return_tensors=__SCREAMING_SNAKE_CASE							,				**__SCREAMING_SNAKE_CASE						)

											if images is not None:
																	lowercase_      :	int						=			self.image_processor(__SCREAMING_SNAKE_CASE							,				return_tensors=__SCREAMING_SNAKE_CASE							,				**__SCREAMING_SNAKE_CASE						)

											if text is not None and images is not None:
																	lowercase_      :	Any						=			image_features.pixel_values
																	return encoding
											elif text is not None:
																	return encoding
											else:
																	return BatchEncoding(data=dict(**__SCREAMING_SNAKE_CASE						)							,				tensor_type=__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self							,				*__SCREAMING_SNAKE_CASE							,				**__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											return self.tokenizer.batch_decode(*__SCREAMING_SNAKE_CASE							,				**__SCREAMING_SNAKE_CASE						)






					def       _snake_case       (  self							,				*__SCREAMING_SNAKE_CASE							,				**__SCREAMING_SNAKE_CASE						):


											"""simple docstring"""





											return self.tokenizer.decode(*__SCREAMING_SNAKE_CASE							,				**__SCREAMING_SNAKE_CASE						)






					@property
					def       _snake_case       (  self						):


											"""simple docstring"""





											lowercase_      :	Dict						=			self.tokenizer.model_input_names
											lowercase_      :	Optional[int]						=			self.image_processor.model_input_names
											return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names						)						)



