




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     snake_case  (	unittest.TestCase							):


   '''simple docstring'''







   def 	UpperCAmelCase       (					self     :	int			)					->str:
     '''simple docstring'''







     UpperCAmelCase__    						=   tempfile.mkdtemp()

     # fmt: off
     UpperCAmelCase__    						=   ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest"""]
     # fmt: on
     UpperCAmelCase__    						=   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]			)			)

     UpperCAmelCase__    						=   {
         """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,
     }

     UpperCAmelCase__    						=   os.path.join(self.tmpdirname						,    lowerCamelCase_			)
     with open(self.image_processor_file						,    """w"""						,    encoding="""utf-8"""			) as fp:
       json.dump(lowerCamelCase_						,    lowerCamelCase_			)




   def 	UpperCAmelCase       (					self     :	Optional[Any]						,    **lowerCamelCase_     :	List[str]			)					->List[Any]:
     '''simple docstring'''







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




   def 	UpperCAmelCase       (					self     :	Tuple						,    **lowerCamelCase_     :	int			)					->Optional[Any]:
     '''simple docstring'''







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




   def 	UpperCAmelCase       (					self     :	Union[str, Any]						,    **lowerCamelCase_     :	Dict			)					->Any:
     '''simple docstring'''







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




   def 	UpperCAmelCase       (					self     :	int			)					->Tuple:
     '''simple docstring'''







     shutil.rmtree(self.tmpdirname			)




   def 	UpperCAmelCase       (					self     :	str			)					->Tuple:
     '''simple docstring'''







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

     UpperCAmelCase__    						=   [Image.fromarray(np.moveaxis(lowerCamelCase_						,    0						,    -1			)			) for x in image_inputs]

     return image_inputs




   def 	UpperCAmelCase       (					self     :	Tuple			)					->Union[str, Any]:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_tokenizer()
     UpperCAmelCase__    						=   self.get_rust_tokenizer()
     UpperCAmelCase__    						=   self.get_image_processor()

     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=lowerCamelCase_						,    image_processor=lowerCamelCase_			)
     processor_slow.save_pretrained(self.tmpdirname			)
     UpperCAmelCase__    						=   FlavaProcessor.from_pretrained(self.tmpdirname						,    use_fast=lowerCamelCase_			)

     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=lowerCamelCase_						,    image_processor=lowerCamelCase_			)
     processor_fast.save_pretrained(self.tmpdirname			)
     UpperCAmelCase__    						=   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						,    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 	UpperCAmelCase       (					self     :	Optional[Any]			)					->List[Any]:
     '''simple docstring'''







     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=self.get_tokenizer()						,    image_processor=self.get_image_processor()			)
     processor.save_pretrained(self.tmpdirname			)

     UpperCAmelCase__    						=   self.get_tokenizer(bos_token="""(BOS)"""						,    eos_token="""(EOS)"""			)
     UpperCAmelCase__    						=   self.get_image_processor(do_normalize=lowerCamelCase_						,    padding_value=1.0			)

     UpperCAmelCase__    						=   FlavaProcessor.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 	UpperCAmelCase       (					self     :	int			)					->int:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_image_processor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=lowerCamelCase_						,    image_processor=lowerCamelCase_			)

     UpperCAmelCase__    						=   self.prepare_image_inputs()

     UpperCAmelCase__    						=   image_processor(lowerCamelCase_						,    return_tensors="""np"""			)
     UpperCAmelCase__    						=   processor(images=lowerCamelCase_						,    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			)
     UpperCAmelCase__    						=   image_processor(
         lowerCamelCase_						,    return_image_mask=lowerCamelCase_						,    return_codebook_pixels=lowerCamelCase_						,    return_tensors="""np"""			)
     random.seed(1234			)
     UpperCAmelCase__    						=   processor(
         images=lowerCamelCase_						,    return_image_mask=lowerCamelCase_						,    return_codebook_pixels=lowerCamelCase_						,    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 	UpperCAmelCase       (					self     :	Optional[int]			)					->Any:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_image_processor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=lowerCamelCase_						,    image_processor=lowerCamelCase_			)

     UpperCAmelCase__    						=   """lower newer"""

     UpperCAmelCase__    						=   processor(text=lowerCamelCase_			)

     UpperCAmelCase__    						=   tokenizer(lowerCamelCase_			)

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




   def 	UpperCAmelCase       (					self     :	List[Any]			)					->List[str]:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_image_processor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=lowerCamelCase_						,    image_processor=lowerCamelCase_			)

     UpperCAmelCase__    						=   """lower newer"""
     UpperCAmelCase__    						=   self.prepare_image_inputs()

     UpperCAmelCase__    						=   processor(text=lowerCamelCase_						,    images=lowerCamelCase_			)

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

     # add extra args
     UpperCAmelCase__    						=   processor(text=lowerCamelCase_						,    images=lowerCamelCase_						,    return_codebook_pixels=lowerCamelCase_						,    return_image_mask=lowerCamelCase_			)

     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(lowerCamelCase_			):
       processor()




   def 	UpperCAmelCase       (					self     :	str			)					->Optional[int]:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_image_processor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=lowerCamelCase_						,    image_processor=lowerCamelCase_			)

     UpperCAmelCase__    						=   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     UpperCAmelCase__    						=   processor.batch_decode(lowerCamelCase_			)
     UpperCAmelCase__    						=   tokenizer.batch_decode(lowerCamelCase_			)

     self.assertListEqual(lowerCamelCase_						,    lowerCamelCase_			)







   def 	UpperCAmelCase       (					self     :	Optional[int]			)					->Any:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_image_processor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   FlavaProcessor(tokenizer=lowerCamelCase_						,    image_processor=lowerCamelCase_			)

     UpperCAmelCase__    						=   """lower newer"""
     UpperCAmelCase__    						=   self.prepare_image_inputs()

     UpperCAmelCase__    						=   processor(text=lowerCamelCase_						,    images=lowerCamelCase_			)

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










from __future__ import annotations

from collections import Counter


def 						lowercase		(     _lowerCAmelCase      ):
  UpperCAmelCase__    						=   [True] * n
  UpperCAmelCase__    						=   False
  UpperCAmelCase__    						=   False
  UpperCAmelCase__    						=   True

  for i in range(3   ,     int(n**0.5 + 1      )   ,     2      ):
    UpperCAmelCase__    						=   i * 2
    while index < n:
      UpperCAmelCase__    						=   False
      UpperCAmelCase__    						=   index + i

  UpperCAmelCase__    						=   [2]

  for i in range(3   ,     _lowerCAmelCase   ,     2      ):
    if is_prime[i]:
      primes.append(_lowerCAmelCase      )

  return primes


def 						lowercase		(     _lowerCAmelCase      ):
  UpperCAmelCase__    						=   str(_lowerCAmelCase      )
  UpperCAmelCase__    						=   []
  UpperCAmelCase__    						=   ["""0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9"""]

  for duplicate in Counter(_lowerCAmelCase      ) - Counter(set(_lowerCAmelCase      )      ):
    UpperCAmelCase__    						=   [int(number_str.replace(_lowerCAmelCase   ,     _lowerCAmelCase      )      ) for digit in digits]
    replacements.append(_lowerCAmelCase      )

  return replacements


def 						lowercase		(     _lowerCAmelCase = 8      ):
  UpperCAmelCase__    						=   set()

  # Filter primes with less than 3 replaceable digits
  UpperCAmelCase__    						=   {
      x for x in set(prime_sieve(100_0000      )      ) if len(str(_lowerCAmelCase      )      ) - len(set(str(_lowerCAmelCase      )      )      ) >= 3
  }

  for prime in primes:
    if prime in numbers_checked:
      continue

    UpperCAmelCase__    						=   digit_replacements(_lowerCAmelCase      )

    for family in replacements:
      numbers_checked.update(_lowerCAmelCase      )
      UpperCAmelCase__    						=   primes.intersection(_lowerCAmelCase      )

      if len(_lowerCAmelCase      ) != family_length:
        continue

      return min(_lowerCAmelCase      )

  return -1


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




