



'''simple docstring'''



import json
import os
import random
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 FlavaImageProcessor, FlavaProcessor
				from transformers.models.flava.image_processing_flava import (
				    FLAVA_CODEBOOK_MEAN,
				    FLAVA_CODEBOOK_STD,
				    FLAVA_IMAGE_MEAN,
				    FLAVA_IMAGE_STD,
				)






@require_vision
class 			_SCREAMING_SNAKE_CASE				(unittest.TestCase      ):



			def 				lowerCAmelCase (     self		:						List[str]			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   int      =    tempfile.mkdtemp()

							# fmt: off
							snake_case__      :   Union[str, Any]      =    ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''']
							# fmt: on
							snake_case__      :   Dict      =    os.path.join(self.tmpdirname    ,			VOCAB_FILES_NAMES['''vocab_file''']			)

							with open(self.vocab_file    ,			'''w'''    ,			encoding='''utf-8'''			) as fp:
											fp.write(''''''.join([x + '''\n''' for x in vocab_tokens]			)			)

							snake_case__      :   Union[str, Any]      =    {
							    '''image_mean''': FLAVA_IMAGE_MEAN,
							    '''image_std''': FLAVA_IMAGE_STD,
							    '''do_normalize''': True,
							    '''do_resize''': True,
							    '''size''': 224,
							    '''do_center_crop''': True,
							    '''crop_size''': 224,
							    '''input_size_patches''': 14,
							    '''total_mask_patches''': 75,
							    '''mask_group_max_patches''': None,
							    '''mask_group_min_patches''': 16,
							    '''mask_group_min_aspect_ratio''': 0.3,
							    '''mask_group_max_aspect_ratio''': None,
							    '''codebook_do_resize''': True,
							    '''codebook_size''': 112,
							    '''codebook_do_center_crop''': True,
							    '''codebook_crop_size''': 112,
							    '''codebook_do_map_pixels''': True,
							    '''codebook_do_normalize''': True,
							    '''codebook_image_mean''': FLAVA_CODEBOOK_MEAN,
							    '''codebook_image_std''': FLAVA_CODEBOOK_STD,
							}

							snake_case__      :   int      =    os.path.join(self.tmpdirname    ,			__UpperCamelCase			)
							with open(self.image_processor_file    ,			'''w'''    ,			encoding='''utf-8'''			) as fp:
											json.dump(__UpperCamelCase    ,			__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						List[str]    ,			**__UpperCamelCase		:						str			)      ->      Any:
							"""simple docstring"""





							return BertTokenizer.from_pretrained(self.tmpdirname    ,			**__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						Tuple    ,			**__UpperCamelCase		:						Union[str, Any]			)      ->      Optional[Any]:
							"""simple docstring"""





							return BertTokenizerFast.from_pretrained(self.tmpdirname    ,			**__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						Optional[Any]    ,			**__UpperCamelCase		:						Union[str, Any]			)      ->      Optional[int]:
							"""simple docstring"""





							return FlavaImageProcessor.from_pretrained(self.tmpdirname    ,			**__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						int			)      ->      List[str]:
							"""simple docstring"""





							shutil.rmtree(self.tmpdirname			)



			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      List[Any]:
							"""simple docstring"""





							snake_case__      :   str      =    [np.random.randint(255    ,			size=(3, 30, 400)    ,			dtype=np.uinta			)]

							snake_case__      :   List[str]      =    [Image.fromarray(np.moveaxis(__UpperCamelCase    ,			0    ,			-1			)			) for x in image_inputs]

							return image_inputs



			def 				lowerCAmelCase (     self		:						str			)      ->      Dict:
							"""simple docstring"""





							snake_case__      :   List[str]      =    self.get_tokenizer()
							snake_case__      :   Dict      =    self.get_rust_tokenizer()
							snake_case__      :   Union[str, Any]      =    self.get_image_processor()

							snake_case__      :   int      =    FlavaProcessor(tokenizer=__UpperCamelCase    ,			image_processor=__UpperCamelCase			)
							processor_slow.save_pretrained(self.tmpdirname			)
							snake_case__      :   Optional[Any]      =    FlavaProcessor.from_pretrained(self.tmpdirname    ,			use_fast=__UpperCamelCase			)

							snake_case__      :   Tuple      =    FlavaProcessor(tokenizer=__UpperCamelCase    ,			image_processor=__UpperCamelCase			)
							processor_fast.save_pretrained(self.tmpdirname			)
							snake_case__      :   Dict      =    FlavaProcessor.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    ,			__UpperCamelCase			)
							self.assertIsInstance(processor_fast.tokenizer    ,			__UpperCamelCase			)

							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    ,			__UpperCamelCase			)
							self.assertIsInstance(processor_fast.image_processor    ,			__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Optional[Any]:
							"""simple docstring"""





							snake_case__      :   Optional[Any]      =    FlavaProcessor(tokenizer=self.get_tokenizer()    ,			image_processor=self.get_image_processor()			)
							processor.save_pretrained(self.tmpdirname			)

							snake_case__      :   Tuple      =    self.get_tokenizer(bos_token='''(BOS)'''    ,			eos_token='''(EOS)'''			)
							snake_case__      :   List[str]      =    self.get_image_processor(do_normalize=__UpperCamelCase    ,			padding_value=1.0			)

							snake_case__      :   int      =    FlavaProcessor.from_pretrained(
							    self.tmpdirname    ,			bos_token='''(BOS)'''    ,			eos_token='''(EOS)'''    ,			do_normalize=__UpperCamelCase    ,			padding_value=1.0			)

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

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



			def 				lowerCAmelCase (     self		:						Any			)      ->      Tuple:
							"""simple docstring"""





							snake_case__      :   Any      =    self.get_image_processor()
							snake_case__      :   Any      =    self.get_tokenizer()

							snake_case__      :   List[str]      =    FlavaProcessor(tokenizer=__UpperCamelCase    ,			image_processor=__UpperCamelCase			)

							snake_case__      :   Tuple      =    self.prepare_image_inputs()

							snake_case__      :   Union[str, Any]      =    image_processor(__UpperCamelCase    ,			return_tensors='''np'''			)
							snake_case__      :   str      =    processor(images=__UpperCamelCase    ,			return_tensors='''np'''			)

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

							# With rest of the args
							random.seed(1234			)
							snake_case__      :   Union[str, Any]      =    image_processor(
							    __UpperCamelCase    ,			return_image_mask=__UpperCamelCase    ,			return_codebook_pixels=__UpperCamelCase    ,			return_tensors='''np'''			)
							random.seed(1234			)
							snake_case__      :   Union[str, Any]      =    processor(
							    images=__UpperCamelCase    ,			return_image_mask=__UpperCamelCase    ,			return_codebook_pixels=__UpperCamelCase    ,			return_tensors='''np'''			)

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



			def 				lowerCAmelCase (     self		:						int			)      ->      Tuple:
							"""simple docstring"""





							snake_case__      :   Optional[Any]      =    self.get_image_processor()
							snake_case__      :   Optional[Any]      =    self.get_tokenizer()

							snake_case__      :   Tuple      =    FlavaProcessor(tokenizer=__UpperCamelCase    ,			image_processor=__UpperCamelCase			)

							snake_case__      :   Optional[int]      =    '''lower newer'''

							snake_case__      :   List[Any]      =    processor(text=__UpperCamelCase			)

							snake_case__      :   Dict      =    tokenizer(__UpperCamelCase			)

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



			def 				lowerCAmelCase (     self		:						Any			)      ->      Union[str, Any]:
							"""simple docstring"""





							snake_case__      :   Tuple      =    self.get_image_processor()
							snake_case__      :   List[str]      =    self.get_tokenizer()

							snake_case__      :   List[Any]      =    FlavaProcessor(tokenizer=__UpperCamelCase    ,			image_processor=__UpperCamelCase			)

							snake_case__      :   Optional[Any]      =    '''lower newer'''
							snake_case__      :   List[Any]      =    self.prepare_image_inputs()

							snake_case__      :   Dict      =    processor(text=__UpperCamelCase    ,			images=__UpperCamelCase			)

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

							# add extra args
							snake_case__      :   Union[str, Any]      =    processor(text=__UpperCamelCase    ,			images=__UpperCamelCase    ,			return_codebook_pixels=__UpperCamelCase    ,			return_image_mask=__UpperCamelCase			)

							self.assertListEqual(
							    list(inputs.keys()			)    ,			[
							        '''input_ids''',
							        '''token_type_ids''',
							        '''attention_mask''',
							        '''pixel_values''',
							        '''codebook_pixel_values''',
							        '''bool_masked_pos''',
							    ]    ,			)

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



			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      Dict:
							"""simple docstring"""





							snake_case__      :   str      =    self.get_image_processor()
							snake_case__      :   List[str]      =    self.get_tokenizer()

							snake_case__      :   List[Any]      =    FlavaProcessor(tokenizer=__UpperCamelCase    ,			image_processor=__UpperCamelCase			)

							snake_case__      :   Tuple      =    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							snake_case__      :   Any      =    processor.batch_decode(__UpperCamelCase			)
							snake_case__      :   Optional[Any]      =    tokenizer.batch_decode(__UpperCamelCase			)

							self.assertListEqual(__UpperCamelCase    ,			__UpperCamelCase			)







			def 				lowerCAmelCase (     self		:						Any			)      ->      Tuple:
							"""simple docstring"""





							snake_case__      :   Tuple      =    self.get_image_processor()
							snake_case__      :   Tuple      =    self.get_tokenizer()

							snake_case__      :   Any      =    FlavaProcessor(tokenizer=__UpperCamelCase    ,			image_processor=__UpperCamelCase			)

							snake_case__      :   Dict      =    '''lower newer'''
							snake_case__      :   Any      =    self.prepare_image_inputs()

							snake_case__      :   Any      =    processor(text=__UpperCamelCase    ,			images=__UpperCamelCase			)

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








import math
def 							UpperCAmelCase_   (				__snake_case		)	->     int:







 """simple docstring"""


 return sum(int(__snake_case		) for digit in str(__snake_case		)		)
def 							UpperCAmelCase_   (				__snake_case = 30		)	->     int:







 """simple docstring"""


 _lowercase				 =[]
 for digit in range(2	,		100		):
  for power in range(2	,		100		):
   _lowercase				 =int(math.pow(__snake_case	,		__snake_case		)		)
   if digit == digit_sum(__snake_case		):
    digit_to_powers.append(__snake_case		)

 digit_to_powers.sort()
 return digit_to_powers[n - 1]


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

