code: 
  
  
  
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
  					import torch
  
  if is_vision_available():
  					from PIL import Image
  
  					from transformers import MobileNetVaImageProcessor
  
  class __UpperCamelCase    (							unittest.TestCase		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def __init__(							self							,			lowerCamelCase__							,			lowerCamelCase__=7							,			lowerCamelCase__=3							,			lowerCamelCase__=1_8							,			lowerCamelCase__=3_0							,			lowerCamelCase__=4_0_0							,			lowerCamelCase__=True							,			lowerCamelCase__=None							,			lowerCamelCase__=True							,			lowerCamelCase__=None							,			):
  						UpperCAmelCase__:  Optional[Any]		       =   size if size is not None else {"shortest_edge": 2_0}
  						UpperCAmelCase__:  Tuple		       =   crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
  						UpperCAmelCase__:  Optional[Any]		       =   parent
  						UpperCAmelCase__:  Optional[Any]		       =   batch_size
  						UpperCAmelCase__:  Optional[Any]		       =   num_channels
  						UpperCAmelCase__:  Optional[Any]		       =   image_size
  						UpperCAmelCase__:  Union[str, Any]		       =   min_resolution
  						UpperCAmelCase__:  List[str]		       =   max_resolution
  						UpperCAmelCase__:  Tuple		       =   do_resize
  						UpperCAmelCase__:  Union[str, Any]		       =   size
  						UpperCAmelCase__:  Union[str, Any]		       =   do_center_crop
  						UpperCAmelCase__:  Dict		       =   crop_size
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						return {
  						    "do_resize": self.do_resize,
  						    "size": self.size,
  						    "do_center_crop": self.do_center_crop,
  						    "crop_size": self.crop_size,
  						}
  
  @require_torch
  @require_vision
  class __UpperCamelCase    (							_a				,unittest.TestCase		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					__magic_name__     			=      MobileNetVaImageProcessor if is_vision_available() else None
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Tuple		       =   MobileNetVaImageProcessingTester(self	)
  
  
  
  
  
  					@property
  					def       _UpperCAmelCase						(							self	):
  						return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[str]		       =   self.image_processing_class(**self.image_processor_dict	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"do_resize"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"size"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"do_center_crop"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"center_crop"	)	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[str]		       =   self.image_processing_class.from_dict(self.image_processor_dict	)
  						self.assertEqual(image_processor.size							,			{"shortest_edge": 2_0}	)
  						self.assertEqual(image_processor.crop_size							,			{"height": 1_8, "width": 1_8}	)
  
  						UpperCAmelCase__:  List[str]		       =   self.image_processing_class.from_dict(self.image_processor_dict							,			size=4_2							,			crop_size=8_4	)
  						self.assertEqual(image_processor.size							,			{"shortest_edge": 4_2}	)
  						self.assertEqual(image_processor.crop_size							,			{"height": 8_4, "width": 8_4}	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						pass
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						# Initialize image_processing
  						UpperCAmelCase__:  Tuple		       =   self.image_processing_class(**self.image_processor_dict	)
  						# create random PIL images
  						UpperCAmelCase__:  Union[str, Any]		       =   prepare_image_inputs(self.image_processor_tester							,			equal_resolution=lowerCamelCase__	)
  						for image in image_inputs:
  							self.assertIsInstance(lowerCamelCase__							,			Image.Image	)
  
  						# Test not batched input
  						UpperCAmelCase__:  Optional[int]		       =   image_processing(image_inputs[0]							,			return_tensors="pt"	).pixel_values
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        1,
  						        self.image_processor_tester.num_channels,
  						        self.image_processor_tester.crop_size["height"],
  						        self.image_processor_tester.crop_size["width"],
  						    )							,			)
  
  						# Test batched
  						UpperCAmelCase__:  int		       =   image_processing(lowerCamelCase__							,			return_tensors="pt"	).pixel_values
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        self.image_processor_tester.batch_size,
  						        self.image_processor_tester.num_channels,
  						        self.image_processor_tester.crop_size["height"],
  						        self.image_processor_tester.crop_size["width"],
  						    )							,			)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						# Initialize image_processing
  						UpperCAmelCase__:  Any		       =   self.image_processing_class(**self.image_processor_dict	)
  						# create random numpy tensors
  						UpperCAmelCase__:  Optional[Any]		       =   prepare_image_inputs(self.image_processor_tester							,			equal_resolution=lowerCamelCase__							,			numpify=lowerCamelCase__	)
  						for image in image_inputs:
  							self.assertIsInstance(lowerCamelCase__							,			np.ndarray	)
  
  						# Test not batched input
  						UpperCAmelCase__:  Union[str, Any]		       =   image_processing(image_inputs[0]							,			return_tensors="pt"	).pixel_values
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        1,
  						        self.image_processor_tester.num_channels,
  						        self.image_processor_tester.crop_size["height"],
  						        self.image_processor_tester.crop_size["width"],
  						    )							,			)
  
  						# Test batched
  						UpperCAmelCase__:  Union[str, Any]		       =   image_processing(lowerCamelCase__							,			return_tensors="pt"	).pixel_values
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        self.image_processor_tester.batch_size,
  						        self.image_processor_tester.num_channels,
  						        self.image_processor_tester.crop_size["height"],
  						        self.image_processor_tester.crop_size["width"],
  						    )							,			)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						# Initialize image_processing
  						UpperCAmelCase__:  Optional[int]		       =   self.image_processing_class(**self.image_processor_dict	)
  						# create random PyTorch tensors
  						UpperCAmelCase__:  List[Any]		       =   prepare_image_inputs(self.image_processor_tester							,			equal_resolution=lowerCamelCase__							,			torchify=lowerCamelCase__	)
  						for image in image_inputs:
  							self.assertIsInstance(lowerCamelCase__							,			torch.Tensor	)
  
  						# Test not batched input
  						UpperCAmelCase__:  Any		       =   image_processing(image_inputs[0]							,			return_tensors="pt"	).pixel_values
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        1,
  						        self.image_processor_tester.num_channels,
  						        self.image_processor_tester.crop_size["height"],
  						        self.image_processor_tester.crop_size["width"],
  						    )							,			)
  
  						# Test batched
  						UpperCAmelCase__:  List[Any]		       =   image_processing(lowerCamelCase__							,			return_tensors="pt"	).pixel_values
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        self.image_processor_tester.batch_size,
  						        self.image_processor_tester.num_channels,
  						        self.image_processor_tester.crop_size["height"],
  						        self.image_processor_tester.crop_size["width"],
  						    )							,			)
style_context: 
  
  from __future__ import annotations
  
  from collections import Counter
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Optional[Any]		       =   [True] * n
  	UpperCAmelCase__:  Any		       =   False
  	UpperCAmelCase__:  Tuple		       =   False
  	UpperCAmelCase__:  Optional[Any]		       =   True
  
  	for i in range(3  ,int(n**0.5 + 1			)  ,2			):
  		UpperCAmelCase__:  Any		       =   i * 2
  		while index < n:
  			UpperCAmelCase__:  Optional[int]		       =   False
  			UpperCAmelCase__:  Tuple		       =   index + i
  
  	UpperCAmelCase__:  int		       =   [2]
  
  	for i in range(3  ,SCREAMING_SNAKE_CASE  ,2			):
  		if is_prime[i]:
  			primes.append(SCREAMING_SNAKE_CASE			)
  
  	return primes
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  List[Any]		       =   str(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Tuple		       =   []
  	UpperCAmelCase__:  Optional[int]		       =   ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
  
  	for duplicate in Counter(SCREAMING_SNAKE_CASE			) - Counter(set(SCREAMING_SNAKE_CASE			)			):
  		UpperCAmelCase__:  Optional[Any]		       =   [int(number_str.replace(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)			) for digit in digits]
  		replacements.append(SCREAMING_SNAKE_CASE			)
  
  	return replacements
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE = 8			):
  	UpperCAmelCase__:  Union[str, Any]		       =   set()
  
  	# Filter primes with less than 3 replaceable digits
  	UpperCAmelCase__:  Optional[Any]		       =   {
  	    x for x in set(prime_sieve(1_0_0_0_0_0_0			)			) if len(str(SCREAMING_SNAKE_CASE			)			) - len(set(str(SCREAMING_SNAKE_CASE			)			)			) >= 3
  	}
  
  	for prime in primes:
  		if prime in numbers_checked:
  			continue
  
  		UpperCAmelCase__:  Optional[int]		       =   digit_replacements(SCREAMING_SNAKE_CASE			)
  
  		for family in replacements:
  			numbers_checked.update(SCREAMING_SNAKE_CASE			)
  			UpperCAmelCase__:  Dict		       =   primes.intersection(SCREAMING_SNAKE_CASE			)
  
  			if len(SCREAMING_SNAKE_CASE			) != family_length:
  				continue
  
  			return min(SCREAMING_SNAKE_CASE			)
  
  	return -1
  
  
  if __name__ == "__main__":
  					print(solution())