

import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
						from PIL import Image

						from transformers import AlignProcessor, EfficientNetImageProcessor



@require_vision
class   __lowercase				( unittest.TestCase	):




			"""simple docstring"""







			def        _SCREAMING_SNAKE_CASE			( self  :     Union[str, Any]):
									SCREAMING_SNAKE_CASE_: int  		=       tempfile.mkdtemp()

									SCREAMING_SNAKE_CASE_: Dict  		=       [
									    "[UNK]",
									    "[CLS]",
									    "[SEP]",
									    "[PAD]",
									    "[MASK]",
									    "want",
									    "##want",
									    "##ed",
									    "wa",
									    "un",
									    "runn",
									    "##ing",
									    ",",
									    "low",
									    "lowest",
									]
									SCREAMING_SNAKE_CASE_: str  		=       os.path.join(self.tmpdirname   ,						VOCAB_FILES_NAMES["vocab_file"])
									with open(self.vocab_file   ,						"w"   ,						encoding="utf-8") as vocab_writer:
															vocab_writer.write("".join([x + "\n" for x in vocab_tokens]))

									SCREAMING_SNAKE_CASE_: Any  		=       {
									    "do_resize": True,
									    "size": 20,
									    "do_center_crop": True,
									    "crop_size": 18,
									    "do_normalize": True,
									    "image_mean": [0.4814_5466, 0.457_8275, 0.4082_1073],
									    "image_std": [0.2686_2954, 0.2613_0258, 0.2757_7711],
									}
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       os.path.join(self.tmpdirname   ,						lowerCAmelCase__)
									with open(self.image_processor_file   ,						"w"   ,						encoding="utf-8") as fp:
															json.dump(lowerCAmelCase__   ,						lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     List[Any]   ,						**lowerCAmelCase__  :     Optional[int]):
									return BertTokenizer.from_pretrained(self.tmpdirname   ,						**lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]   ,						**lowerCAmelCase__  :     str):
									return BertTokenizerFast.from_pretrained(self.tmpdirname   ,						**lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     List[str]   ,						**lowerCAmelCase__  :     Tuple):
									return EfficientNetImageProcessor.from_pretrained(self.tmpdirname   ,						**lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     List[str]):
									shutil.rmtree(self.tmpdirname)



			def        _SCREAMING_SNAKE_CASE			( self  :     List[Any]):
									SCREAMING_SNAKE_CASE_: int  		=       [np.random.randint(255   ,						size=(3, 30, 400)   ,						dtype=np.uinta)]
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       [Image.fromarray(np.moveaxis(lowerCAmelCase__   ,						0   ,						-1)) for x in image_inputs]
									return image_inputs



			def        _SCREAMING_SNAKE_CASE			( self  :     str):
									SCREAMING_SNAKE_CASE_: Tuple  		=       self.get_tokenizer()
									SCREAMING_SNAKE_CASE_: List[Any]  		=       self.get_rust_tokenizer()
									SCREAMING_SNAKE_CASE_: List[Any]  		=       self.get_image_processor()

									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       AlignProcessor(tokenizer=lowerCAmelCase__   ,						image_processor=lowerCAmelCase__)
									processor_slow.save_pretrained(self.tmpdirname)
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       AlignProcessor.from_pretrained(self.tmpdirname   ,						use_fast=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: List[Any]  		=       AlignProcessor(tokenizer=lowerCAmelCase__   ,						image_processor=lowerCAmelCase__)
									processor_fast.save_pretrained(self.tmpdirname)
									SCREAMING_SNAKE_CASE_: Tuple  		=       AlignProcessor.from_pretrained(self.tmpdirname)

									self.assertEqual(processor_slow.tokenizer.get_vocab()   ,						tokenizer_slow.get_vocab())
									self.assertEqual(processor_fast.tokenizer.get_vocab()   ,						tokenizer_fast.get_vocab())
									self.assertEqual(tokenizer_slow.get_vocab()   ,						tokenizer_fast.get_vocab())
									self.assertIsInstance(processor_slow.tokenizer   ,						lowerCAmelCase__)
									self.assertIsInstance(processor_fast.tokenizer   ,						lowerCAmelCase__)

									self.assertEqual(processor_slow.image_processor.to_json_string()   ,						image_processor.to_json_string())
									self.assertEqual(processor_fast.image_processor.to_json_string()   ,						image_processor.to_json_string())
									self.assertIsInstance(processor_slow.image_processor   ,						lowerCAmelCase__)
									self.assertIsInstance(processor_fast.image_processor   ,						lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     Tuple):
									SCREAMING_SNAKE_CASE_: List[Any]  		=       AlignProcessor(tokenizer=self.get_tokenizer()   ,						image_processor=self.get_image_processor())
									processor.save_pretrained(self.tmpdirname)

									SCREAMING_SNAKE_CASE_: Dict  		=       self.get_tokenizer(bos_token="(BOS)"   ,						eos_token="(EOS)")
									SCREAMING_SNAKE_CASE_: List[str]  		=       self.get_image_processor(do_normalize=lowerCAmelCase__   ,						padding_value=1.0)

									SCREAMING_SNAKE_CASE_: Dict  		=       AlignProcessor.from_pretrained(
									    self.tmpdirname   ,						bos_token="(BOS)"   ,						eos_token="(EOS)"   ,						do_normalize=lowerCAmelCase__   ,						padding_value=1.0)

									self.assertEqual(processor.tokenizer.get_vocab()   ,						tokenizer_add_kwargs.get_vocab())
									self.assertIsInstance(processor.tokenizer   ,						lowerCAmelCase__)

									self.assertEqual(processor.image_processor.to_json_string()   ,						image_processor_add_kwargs.to_json_string())
									self.assertIsInstance(processor.image_processor   ,						lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     List[str]):
									SCREAMING_SNAKE_CASE_: List[Any]  		=       self.get_image_processor()
									SCREAMING_SNAKE_CASE_: Any  		=       self.get_tokenizer()

									SCREAMING_SNAKE_CASE_: List[str]  		=       AlignProcessor(tokenizer=lowerCAmelCase__   ,						image_processor=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: Any  		=       self.prepare_image_inputs()

									SCREAMING_SNAKE_CASE_: List[Any]  		=       image_processor(lowerCAmelCase__   ,						return_tensors="np")
									SCREAMING_SNAKE_CASE_: int  		=       processor(images=lowerCAmelCase__   ,						return_tensors="np")

									for key in input_image_proc.keys():
															self.assertAlmostEqual(input_image_proc[key].sum()   ,						input_processor[key].sum()   ,						delta=1E-2)



			def        _SCREAMING_SNAKE_CASE			( self  :     Any):
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       self.get_image_processor()
									SCREAMING_SNAKE_CASE_: List[str]  		=       self.get_tokenizer()

									SCREAMING_SNAKE_CASE_: Any  		=       AlignProcessor(tokenizer=lowerCAmelCase__   ,						image_processor=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: str  		=       "lower newer"

									SCREAMING_SNAKE_CASE_: Tuple  		=       processor(text=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: Dict  		=       tokenizer(lowerCAmelCase__   ,						padding="max_length"   ,						max_length=64)

									for key in encoded_tok.keys():
															self.assertListEqual(encoded_tok[key]   ,						encoded_processor[key])



			def        _SCREAMING_SNAKE_CASE			( self  :     List[str]):
									SCREAMING_SNAKE_CASE_: List[str]  		=       self.get_image_processor()
									SCREAMING_SNAKE_CASE_: str  		=       self.get_tokenizer()

									SCREAMING_SNAKE_CASE_: Dict  		=       AlignProcessor(tokenizer=lowerCAmelCase__   ,						image_processor=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: List[str]  		=       "lower newer"
									SCREAMING_SNAKE_CASE_: Tuple  		=       self.prepare_image_inputs()

									SCREAMING_SNAKE_CASE_: Optional[int]  		=       processor(text=lowerCAmelCase__   ,						images=lowerCAmelCase__)

									self.assertListEqual(list(inputs.keys())   ,						["input_ids", "token_type_ids", "attention_mask", "pixel_values"])

									# test if it raises when no input is passed
									with pytest.raises(lowerCAmelCase__):
															processor()



			def        _SCREAMING_SNAKE_CASE			( self  :     Tuple):
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       self.get_image_processor()
									SCREAMING_SNAKE_CASE_: int  		=       self.get_tokenizer()

									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       AlignProcessor(tokenizer=lowerCAmelCase__   ,						image_processor=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: Optional[int]  		=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       processor.batch_decode(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: List[str]  		=       tokenizer.batch_decode(lowerCAmelCase__)

									self.assertListEqual(lowerCAmelCase__   ,						lowerCAmelCase__)




			def        _SCREAMING_SNAKE_CASE			( self  :     List[Any]):
									SCREAMING_SNAKE_CASE_: Dict  		=       self.get_image_processor()
									SCREAMING_SNAKE_CASE_: Tuple  		=       self.get_tokenizer()

									SCREAMING_SNAKE_CASE_: Any  		=       AlignProcessor(tokenizer=lowerCAmelCase__   ,						image_processor=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: Tuple  		=       "lower newer"
									SCREAMING_SNAKE_CASE_: str  		=       self.prepare_image_inputs()

									SCREAMING_SNAKE_CASE_: int  		=       processor(text=lowerCAmelCase__   ,						images=lowerCAmelCase__)

									self.assertListEqual(list(inputs.keys())   ,						processor.model_input_names)









import math
import sys







def 			A_      (    _UpperCAmelCase    ):
						if number != int(_UpperCAmelCase    ):
												raise ValueError("the value of input must be a natural number"    )
						if number < 0:
												raise ValueError("the value of input must not be a negative number"    )
						if number == 0:
												return 1
						SCREAMING_SNAKE_CASE_: List[str]  		=       [-1] * (number + 1)
						SCREAMING_SNAKE_CASE_: str  		=       0
						for i in range(1				,	number + 1    ):
												SCREAMING_SNAKE_CASE_: str  		=       sys.maxsize
												SCREAMING_SNAKE_CASE_: List[Any]  		=       int(math.sqrt(_UpperCAmelCase    )    )
												for j in range(1				,	root + 1    ):
																		SCREAMING_SNAKE_CASE_: List[str]  		=       1 + answers[i - (j**2)]
																		SCREAMING_SNAKE_CASE_: Optional[Any]  		=       min(_UpperCAmelCase				,	_UpperCAmelCase    )
												SCREAMING_SNAKE_CASE_: Dict  		=       answer
						return answers[number]


if __name__ == "__main__":
						import doctest

						doctest.testmod()






