





from __future__ import annotations

import math



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     bool:


      '''simple docstring'''


      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5				,		int(math.sqrt(_SCREAMING_SNAKE_CASE			) + 1			)				,		6			):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     list[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		str(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		[n]
      for i in range(1				,		len(_SCREAMING_SNAKE_CASE			)			):
            list_nums.append(int(str_num[i:]			)			)
            list_nums.append(int(str_num[:-i]			)			)
      return list_nums



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     bool:


      '''simple docstring'''


      if len(str(_SCREAMING_SNAKE_CASE			)			) > 3:
            if not is_prime(int(str(_SCREAMING_SNAKE_CASE			)[-3:]			)			) or not is_prime(int(str(_SCREAMING_SNAKE_CASE			)[:3]			)			):
                  return False
      return True



def      __lowercase     (   _SCREAMING_SNAKE_CASE = 11			)				->     list[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		13
      while len(_SCREAMING_SNAKE_CASE			) != count:
            if validate(_SCREAMING_SNAKE_CASE			):
                  SCREAMING_SNAKE_CASE	=		list_truncated_nums(_SCREAMING_SNAKE_CASE			)
                  if all(is_prime(_SCREAMING_SNAKE_CASE			) for i in list_nums			):
                        list_truncated_primes.append(_SCREAMING_SNAKE_CASE			)
            num += 2
      return list_truncated_primes



def      __lowercase     (   )				->     int:


      '''simple docstring'''


      return sum(compute_truncated_primes(11			)			)


if __name__ == "__main__":
      print(F'''{sum(compute_truncated_primes(1_1)) = }''')









import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

class 	UpperCamelCase__				(   lowerCAmelCase_							,   lowerCAmelCase_							,   unittest.TestCase     ):



     '''simple docstring'''

     __snake_case					:			str				=    VQModel
     __snake_case					:			Optional[Any]				=    "sample"






     @property
     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple		,lowerCamelCase__		:					Optional[Any]=(32, 32) )  ->	Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		4
           SCREAMING_SNAKE_CASE	=		3

           SCREAMING_SNAKE_CASE	=		floats_tensor((batch_size, num_channels) + sizes ).to(lowerCamelCase__ )

           return {"sample": image}






     @property
     def        SCREAMING_SNAKE_CASE__						(							self		:					Optional[Any] )  ->	List[str]:




           '''simple docstring'''


           return (3, 32, 32)






     @property
     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple )  ->	List[str]:




           '''simple docstring'''


           return (3, 32, 32)






     def        SCREAMING_SNAKE_CASE__						(							self		:					Optional[int] )  ->	Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		{
               """block_out_channels""": [32, 64],
               """in_channels""": 3,
               """out_channels""": 3,
               """down_block_types""": ["""DownEncoderBlock2D""", """DownEncoderBlock2D"""],
               """up_block_types""": ["""UpDecoderBlock2D""", """UpDecoderBlock2D"""],
               """latent_channels""": 3,
           }
           SCREAMING_SNAKE_CASE	=		self.dummy_input
           return init_dict, inputs_dict






     def        SCREAMING_SNAKE_CASE__						(							self		:					int )  ->	str:




           '''simple docstring'''


           pass






     def        SCREAMING_SNAKE_CASE__						(							self		:					Union[str, Any] )  ->	List[str]:




           '''simple docstring'''


           pass






     def        SCREAMING_SNAKE_CASE__						(							self		:					List[str] )  ->	Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE	=		VQModel.from_pretrained("""fusing/vqgan-dummy"""		,output_loading_info=lowerCamelCase__ )
           self.assertIsNotNone(lowerCamelCase__ )
           self.assertEqual(len(loading_info["""missing_keys"""] )		,0 )

           model.to(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		model(**self.dummy_input )

           assert image is not None, "Make sure output is not None"






     def        SCREAMING_SNAKE_CASE__						(							self		:					str )  ->	List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		VQModel.from_pretrained("""fusing/vqgan-dummy""" )
           model.to(lowerCamelCase__ ).eval()

           torch.manual_seed(0 )
           if torch.cuda.is_available():
                 torch.cuda.manual_seed_all(0 )

           SCREAMING_SNAKE_CASE	=		torch.randn(1		,model.config.in_channels		,model.config.sample_size		,model.config.sample_size )
           SCREAMING_SNAKE_CASE	=		image.to(lowerCamelCase__ )
           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model(lowerCamelCase__ ).sample

           SCREAMING_SNAKE_CASE	=		output[0, -1, -3:, -3:].flatten().cpu()
           # fmt: off
           SCREAMING_SNAKE_CASE	=		torch.tensor([-0.0153, -0.4044, -0.1880, -0.5161, -0.2418, -0.4072, -0.1612, -0.0633, -0.0143] )
           # fmt: on
           self.assertTrue(torch.allclose(lowerCamelCase__		,lowerCamelCase__		,atol=1e-3 ) )


