





def  lowerCAmelCase__(		lowercase    :      int = 10**6			)	->      int:

  if n <= 0:
    raise ValueError("Please enter an integer greater than 0"			)

  __snake_case				:			List[Any]            =    list(range(n + 1			)			)
  for number in range(2				,       n + 1			):
    if phi[number] == number:
      phi[number] -= 1
      for multiple in range(number * 2				,       n + 1				,       lowercase			):
        __snake_case				:			Optional[int]            =    (phi[multiple] // number) * (number - 1)

  __snake_case				:			List[Any]            =    1
  for number in range(1				,       n + 1			):
    if (answer / phi[answer]) < (number / phi[number]):
      __snake_case				:			List[str]            =    number

  return answer


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








import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import PriorTransformer, UnCLIPPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()




class 			_lowerCamelCase	(      a	,				unittest.TestCase      ):



      """simple docstring"""






      UpperCAmelCase_  : Union[str, Any]				      =UnCLIPPipeline
      UpperCAmelCase_  : Optional[int]				      =TEXT_TO_IMAGE_PARAMS - {
          "negative_prompt",
          "height",
          "width",
          "negative_prompt_embeds",
          "guidance_scale",
          "prompt_embeds",
          "cross_attention_kwargs",
      }
      UpperCAmelCase_  : Optional[Any]				      =TEXT_TO_IMAGE_BATCH_PARAMS
      UpperCAmelCase_  : Any				      =[
          "generator",
          "return_dict",
          "prior_num_inference_steps",
          "decoder_num_inference_steps",
          "super_res_num_inference_steps",
      ]
      UpperCAmelCase_  : str				      =False







      @property
      def   UpperCAmelCase						(	self				)    ->				Optional[int]:






        '''simple docstring'''






        return 32







      @property
      def   UpperCAmelCase						(	self				)    ->				str:






        '''simple docstring'''






        return 32







      @property
      def   UpperCAmelCase						(	self				)    ->				Tuple:






        '''simple docstring'''






        return self.time_input_dim







      @property
      def   UpperCAmelCase						(	self				)    ->				Optional[int]:






        '''simple docstring'''






        return self.time_input_dim * 4







      @property
      def   UpperCAmelCase						(	self				)    ->				Union[str, Any]:






        '''simple docstring'''






        return 100







      @property
      def   UpperCAmelCase						(	self				)    ->				Union[str, Any]:






        '''simple docstring'''






        __snake_case				:			Optional[int]            =    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)
        return tokenizer







      @property
      def   UpperCAmelCase						(	self				)    ->				Optional[int]:






        '''simple docstring'''






        torch.manual_seed(0				)
        __snake_case				:			Optional[int]            =    CLIPTextConfig(
            bos_token_id=0			,  eos_token_id=2			,  hidden_size=self.text_embedder_hidden_size			,  projection_dim=self.text_embedder_hidden_size			,  intermediate_size=37			,  layer_norm_eps=1E-05			,  num_attention_heads=4			,  num_hidden_layers=5			,  pad_token_id=1			,  vocab_size=1000			,  )
        return CLIPTextModelWithProjection(UpperCAmelCase				)







      @property
      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        torch.manual_seed(0				)

        __snake_case				:			List[Any]            =    {
            "num_attention_heads": 2,
            "attention_head_dim": 12,
            "embedding_dim": self.text_embedder_hidden_size,
            "num_layers": 1,
        }

        __snake_case				:			str            =    PriorTransformer(**UpperCAmelCase				)
        return model







      @property
      def   UpperCAmelCase						(	self				)    ->				Any:






        '''simple docstring'''






        torch.manual_seed(0				)

        __snake_case				:			List[str]            =    {
            "clip_embeddings_dim": self.text_embedder_hidden_size,
            "time_embed_dim": self.time_embed_dim,
            "cross_attention_dim": self.cross_attention_dim,
        }

        __snake_case				:			Union[str, Any]            =    UnCLIPTextProjModel(**UpperCAmelCase				)
        return model







      @property
      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        torch.manual_seed(0				)

        __snake_case				:			Tuple            =    {
            "sample_size": 32,
            # RGB in channels
            "in_channels": 3,
            # Out channels is double in channels because predicts mean and variance
            "out_channels": 6,
            "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
            "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
            "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
            "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
            "layers_per_block": 1,
            "cross_attention_dim": self.cross_attention_dim,
            "attention_head_dim": 4,
            "resnet_time_scale_shift": "scale_shift",
            "class_embed_type": "identity",
        }

        __snake_case				:			Optional[int]            =    UNetaDConditionModel(**UpperCAmelCase				)
        return model







      @property
      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        return {
            "sample_size": 64,
            "layers_per_block": 1,
            "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
            "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
            "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
            "in_channels": 6,
            "out_channels": 3,
        }







      @property
      def   UpperCAmelCase						(	self				)    ->				Optional[int]:






        '''simple docstring'''






        torch.manual_seed(0				)

        __snake_case				:			Optional[int]            =    UNetaDModel(**self.dummy_super_res_kwargs				)
        return model







      @property
      def   UpperCAmelCase						(	self				)    ->				Tuple:






        '''simple docstring'''






        torch.manual_seed(1				)

        __snake_case				:			List[str]            =    UNetaDModel(**self.dummy_super_res_kwargs				)
        return model







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






        '''simple docstring'''






        __snake_case				:			List[str]            =    self.dummy_prior
        __snake_case				:			str            =    self.dummy_decoder
        __snake_case				:			Optional[Any]            =    self.dummy_text_proj
        __snake_case				:			List[Any]            =    self.dummy_text_encoder
        __snake_case				:			List[Any]            =    self.dummy_tokenizer
        __snake_case				:			Optional[int]            =    self.dummy_super_res_first
        __snake_case				:			Tuple            =    self.dummy_super_res_last

        __snake_case				:			int            =    UnCLIPScheduler(
            variance_type="fixed_small_log"			,  prediction_type="sample"			,  num_train_timesteps=1000			,  clip_sample_range=5.0			,  )

        __snake_case				:			Union[str, Any]            =    UnCLIPScheduler(
            variance_type="learned_range"			,  prediction_type="epsilon"			,  num_train_timesteps=1000			,  )

        __snake_case				:			Any            =    UnCLIPScheduler(
            variance_type="fixed_small_log"			,  prediction_type="epsilon"			,  num_train_timesteps=1000			,  )

        __snake_case				:			Dict            =    {
            "prior": prior,
            "decoder": decoder,
            "text_proj": text_proj,
            "text_encoder": text_encoder,
            "tokenizer": tokenizer,
            "super_res_first": super_res_first,
            "super_res_last": super_res_last,
            "prior_scheduler": prior_scheduler,
            "decoder_scheduler": decoder_scheduler,
            "super_res_scheduler": super_res_scheduler,
        }

        return components







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase=0				)    ->				int:






        '''simple docstring'''






        if str(UpperCAmelCase				).startswith("mps"				):
          __snake_case				:			int            =    torch.manual_seed(UpperCAmelCase				)
        else:
          __snake_case				:			Optional[int]            =    torch.Generator(device=UpperCAmelCase				).manual_seed(UpperCAmelCase				)
        __snake_case				:			List[str]            =    {
            "prompt": "horse",
            "generator": generator,
            "prior_num_inference_steps": 2,
            "decoder_num_inference_steps": 2,
            "super_res_num_inference_steps": 2,
            "output_type": "numpy",
        }
        return inputs







      def   UpperCAmelCase						(	self				)    ->				Tuple:






        '''simple docstring'''






        __snake_case				:			Dict            =    "cpu"

        __snake_case				:			int            =    self.get_dummy_components()

        __snake_case				:			Optional[int]            =    self.pipeline_class(**UpperCAmelCase				)
        __snake_case				:			Optional[int]            =    pipe.to(UpperCAmelCase				)

        pipe.set_progress_bar_config(disable=UpperCAmelCase				)

        __snake_case				:			Any            =    pipe(**self.get_dummy_inputs(UpperCAmelCase				)				)
        __snake_case				:			List[Any]            =    output.images

        __snake_case				:			int            =    pipe(
            **self.get_dummy_inputs(UpperCAmelCase				)			,  return_dict=UpperCAmelCase			,  )[0]

        __snake_case				:			Tuple            =    image[0, -3:, -3:, -1]
        __snake_case				:			Dict            =    image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)

        __snake_case				:			int            =    np.array(
            [
                0.9_997,
                0.9_988,
                0.0_028,
                0.9_997,
                0.9_984,
                0.9_965,
                0.0_029,
                0.9_986,
                0.0_025,
            ]				)

        assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
        assert np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1E-2







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






        '''simple docstring'''






        __snake_case				:			List[str]            =    torch.device("cpu"				)




        class 			_lowerCamelCase	:



              """simple docstring"""






              UpperCAmelCase_  : str				      =1




        __snake_case				:			Any            =    self.get_dummy_components()

        __snake_case				:			List[Any]            =    self.pipeline_class(**UpperCAmelCase				)
        __snake_case				:			List[Any]            =    pipe.to(UpperCAmelCase				)

        __snake_case				:			Any            =    components["prior"]
        __snake_case				:			List[str]            =    components["decoder"]
        __snake_case				:			List[str]            =    components["super_res_first"]
        __snake_case				:			Union[str, Any]            =    components["tokenizer"]
        __snake_case				:			Optional[Any]            =    components["text_encoder"]

        __snake_case				:			List[str]            =    torch.Generator(device=UpperCAmelCase				).manual_seed(0				)
        __snake_case				:			List[str]            =    prior.dtype
        __snake_case				:			Dict            =    1

        __snake_case				:			str            =    (batch_size, prior.config.embedding_dim)
        __snake_case				:			Any            =    pipe.prepare_latents(
            UpperCAmelCase			,  dtype=UpperCAmelCase			,  device=UpperCAmelCase			,  generator=UpperCAmelCase			,  latents=UpperCAmelCase			,  scheduler=DummyScheduler()				)
        __snake_case				:			List[Any]            =    (batch_size, decoder.config.in_channels, decoder.config.sample_size, decoder.config.sample_size)
        __snake_case				:			List[Any]            =    pipe.prepare_latents(
            UpperCAmelCase			,  dtype=UpperCAmelCase			,  device=UpperCAmelCase			,  generator=UpperCAmelCase			,  latents=UpperCAmelCase			,  scheduler=DummyScheduler()				)

        __snake_case				:			Optional[int]            =    (
            batch_size,
            super_res_first.config.in_channels // 2,
            super_res_first.config.sample_size,
            super_res_first.config.sample_size,
        )
        __snake_case				:			Union[str, Any]            =    pipe.prepare_latents(
            UpperCAmelCase			,  dtype=UpperCAmelCase			,  device=UpperCAmelCase			,  generator=UpperCAmelCase			,  latents=UpperCAmelCase			,  scheduler=DummyScheduler()				)

        pipe.set_progress_bar_config(disable=UpperCAmelCase				)

        __snake_case				:			List[Any]            =    "this is a prompt example"

        __snake_case				:			Dict            =    torch.Generator(device=UpperCAmelCase				).manual_seed(0				)
        __snake_case				:			Optional[Any]            =    pipe(
            [prompt]			,  generator=UpperCAmelCase			,  prior_num_inference_steps=2			,  decoder_num_inference_steps=2			,  super_res_num_inference_steps=2			,  prior_latents=UpperCAmelCase			,  decoder_latents=UpperCAmelCase			,  super_res_latents=UpperCAmelCase			,  output_type="np"			,  )
        __snake_case				:			Tuple            =    output.images

        __snake_case				:			Dict            =    tokenizer(
            UpperCAmelCase			,  padding="max_length"			,  max_length=tokenizer.model_max_length			,  return_tensors="pt"			,  )
        __snake_case				:			Union[str, Any]            =    text_encoder(text_inputs.input_ids				)
        __snake_case				:			Dict            =    text_inputs.attention_mask

        __snake_case				:			int            =    torch.Generator(device=UpperCAmelCase				).manual_seed(0				)
        __snake_case				:			List[Any]            =    pipe(
            generator=UpperCAmelCase			,  prior_num_inference_steps=2			,  decoder_num_inference_steps=2			,  super_res_num_inference_steps=2			,  prior_latents=UpperCAmelCase			,  decoder_latents=UpperCAmelCase			,  super_res_latents=UpperCAmelCase			,  text_model_output=UpperCAmelCase			,  text_attention_mask=UpperCAmelCase			,  output_type="np"			,  )[0]

        # make sure passing text embeddings manually is identical
        assert np.abs(image - image_from_text				).max() < 1E-4







      @skip_mps
      def   UpperCAmelCase						(	self				)    ->				str:






        '''simple docstring'''






        __snake_case				:			Union[str, Any]            =    torch_device == "cpu"

        self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase			,  expected_max_diff=0.01				)







      @skip_mps
      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        __snake_case				:			int            =    torch_device == "cpu"
        __snake_case				:			str            =    True
        __snake_case				:			List[Any]            =    [
            "prior_num_inference_steps",
            "decoder_num_inference_steps",
            "super_res_num_inference_steps",
        ]

        self._test_inference_batch_single_identical(
            test_max_difference=UpperCAmelCase			,  relax_max_difference=UpperCAmelCase			,  additional_params_copy_to_batched_inputs=UpperCAmelCase			,  )







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






        '''simple docstring'''






        __snake_case				:			Dict            =    [
            "prior_num_inference_steps",
            "decoder_num_inference_steps",
            "super_res_num_inference_steps",
        ]

        if torch_device == "mps":
          # TODO: MPS errors with larger batch sizes
          __snake_case				:			List[str]            =    [2, 3]
          self._test_inference_batch_consistent(
              batch_sizes=UpperCAmelCase			,  additional_params_copy_to_batched_inputs=UpperCAmelCase			,  )
        else:
          self._test_inference_batch_consistent(
              additional_params_copy_to_batched_inputs=UpperCAmelCase				)







      @skip_mps
      def   UpperCAmelCase						(	self				)    ->				Tuple:






        '''simple docstring'''






        return super().test_dict_tuple_outputs_equivalent()







      @skip_mps
      def   UpperCAmelCase						(	self				)    ->				Optional[Any]:






        '''simple docstring'''






        return super().test_save_load_local()







      @skip_mps
      def   UpperCAmelCase						(	self				)    ->				Optional[Any]:






        '''simple docstring'''






        return super().test_save_load_optional_components()




@nightly
class 			_lowerCamelCase	(      unittest.TestCase      ):



      """simple docstring"""






      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







      def   UpperCAmelCase						(	self				)    ->				Any:






        '''simple docstring'''






        __snake_case				:			List[str]            =    load_numpy(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/unclip/karlo_v1_alpha_horse_cpu.npy"				)

        __snake_case				:			Optional[int]            =    UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"				)
        pipeline.set_progress_bar_config(disable=UpperCAmelCase				)

        __snake_case				:			Optional[int]            =    torch.manual_seed(0				)
        __snake_case				:			int            =    pipeline(
            "horse"			,  num_images_per_prompt=1			,  generator=UpperCAmelCase			,  output_type="np"			,  )

        __snake_case				:			Any            =    output.images[0]

        assert image.shape == (256, 256, 3)
        assert np.abs(expected_image - image				).max() < 1E-1




@slow
@require_torch_gpu
class 			_lowerCamelCase	(      unittest.TestCase      ):



      """simple docstring"""






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






        '''simple docstring'''






        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







      def   UpperCAmelCase						(	self				)    ->				int:






        '''simple docstring'''






        __snake_case				:			Optional[int]            =    load_numpy(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/unclip/karlo_v1_alpha_horse_fp16.npy"				)

        __snake_case				:			List[Any]            =    UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"			,  torch_dtype=torch.floataa				)
        __snake_case				:			int            =    pipeline.to(UpperCAmelCase				)
        pipeline.set_progress_bar_config(disable=UpperCAmelCase				)

        __snake_case				:			List[str]            =    torch.Generator(device="cpu"				).manual_seed(0				)
        __snake_case				:			Dict            =    pipeline(
            "horse"			,  generator=UpperCAmelCase			,  output_type="np"			,  )

        __snake_case				:			Union[str, Any]            =    output.images[0]

        assert image.shape == (256, 256, 3)

        assert_mean_pixel_difference(UpperCAmelCase			,  UpperCAmelCase				)







      def   UpperCAmelCase						(	self				)    ->				Any:






        '''simple docstring'''






        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()
        torch.cuda.reset_peak_memory_stats()

        __snake_case				:			List[str]            =    UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"			,  torch_dtype=torch.floataa				)
        __snake_case				:			Optional[int]            =    pipe.to(UpperCAmelCase				)
        pipe.set_progress_bar_config(disable=UpperCAmelCase				)
        pipe.enable_attention_slicing()
        pipe.enable_sequential_cpu_offload()

        __snake_case				:			str            =    pipe(
            "horse"			,  num_images_per_prompt=1			,  prior_num_inference_steps=2			,  decoder_num_inference_steps=2			,  super_res_num_inference_steps=2			,  output_type="np"			,  )

        __snake_case				:			Optional[Any]            =    torch.cuda.max_memory_allocated()
        # make sure that less than 7 GB is allocated
        assert mem_bytes < 7 * 10**9

