

"""simple docstring"""






import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()
class        _lowercase					(     __UpperCAmelCase   , unittest.TestCase     ):
     _lowerCamelCase     =       UnCLIPImageVariationPipeline
     _lowerCamelCase     =       IMAGE_VARIATION_PARAMS - {'''height''', '''width''', '''guidance_scale'''}
     _lowerCamelCase     =       IMAGE_VARIATION_BATCH_PARAMS

     _lowerCamelCase     =       [
         '''generator''',
         '''return_dict''',
         '''decoder_num_inference_steps''',
         '''super_res_num_inference_steps''',
     ]
     _lowerCamelCase     =       False







     @property
     def 	lowerCAmelCase__    (      self       ):
      return 32







     @property
     def 	lowerCAmelCase__    (      self       ):
      return 32







     @property
     def 	lowerCAmelCase__    (      self       ):
      return self.time_input_dim







     @property
     def 	lowerCAmelCase__    (      self       ):
      return self.time_input_dim * 4







     @property
     def 	lowerCAmelCase__    (      self       ):
      return 100







     @property
     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )
      return tokenizer







     @property
     def 	lowerCAmelCase__    (      self       ):
      torch.manual_seed(0       )
      __magic_name__     =      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-0_5 ,						num_attention_heads=4 ,						num_hidden_layers=5 ,						pad_token_id=1 ,						vocab_size=1000 ,						)
      return CLIPTextModelWithProjection(UpperCamelCase_       )







     @property
     def 	lowerCAmelCase__    (      self       ):
      torch.manual_seed(0       )
      __magic_name__     =      CLIPVisionConfig(
          hidden_size=self.text_embedder_hidden_size ,						projection_dim=self.text_embedder_hidden_size ,						num_hidden_layers=5 ,						num_attention_heads=4 ,						image_size=32 ,						intermediate_size=37 ,						patch_size=1 ,						)
      return CLIPVisionModelWithProjection(UpperCamelCase_       )







     @property
     def 	lowerCAmelCase__    (      self       ):
      torch.manual_seed(0       )

      __magic_name__     =      {
          '''clip_embeddings_dim''': self.text_embedder_hidden_size,
          '''time_embed_dim''': self.time_embed_dim,
          '''cross_attention_dim''': self.cross_attention_dim,
      }

      __magic_name__     =      UnCLIPTextProjModel(**UpperCamelCase_       )
      return model







     @property
     def 	lowerCAmelCase__    (      self       ):
      torch.manual_seed(0       )

      __magic_name__     =      {
          '''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''',
      }

      __magic_name__     =      UNetaDConditionModel(**UpperCamelCase_       )
      return model







     @property
     def 	lowerCAmelCase__    (      self       ):
      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 	lowerCAmelCase__    (      self       ):
      torch.manual_seed(0       )

      __magic_name__     =      UNetaDModel(**self.dummy_super_res_kwargs       )
      return model







     @property
     def 	lowerCAmelCase__    (      self       ):
      # seeded differently to get different unet than `self.dummy_super_res_first`
      torch.manual_seed(1       )

      __magic_name__     =      UNetaDModel(**self.dummy_super_res_kwargs       )
      return model







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      self.dummy_decoder
      __magic_name__     =      self.dummy_text_proj
      __magic_name__     =      self.dummy_text_encoder
      __magic_name__     =      self.dummy_tokenizer
      __magic_name__     =      self.dummy_super_res_first
      __magic_name__     =      self.dummy_super_res_last

      __magic_name__     =      UnCLIPScheduler(
          variance_type='''learned_range''' ,						prediction_type='''epsilon''' ,						num_train_timesteps=1000 ,						)

      __magic_name__     =      UnCLIPScheduler(
          variance_type='''fixed_small_log''' ,						prediction_type='''epsilon''' ,						num_train_timesteps=1000 ,						)

      __magic_name__     =      CLIPImageProcessor(crop_size=32 ,						size=32       )

      __magic_name__     =      self.dummy_image_encoder

      return {
          "decoder": decoder,
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
          "text_proj": text_proj,
          "feature_extractor": feature_extractor,
          "image_encoder": image_encoder,
          "super_res_first": super_res_first,
          "super_res_last": super_res_last,
          "decoder_scheduler": decoder_scheduler,
          "super_res_scheduler": super_res_scheduler,
      }







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_=0 ,						UpperCamelCase_=True       ):
      __magic_name__     =      floats_tensor((1, 3, 32, 32) ,						rng=random.Random(UpperCamelCase_       )       ).to(UpperCamelCase_       )
      if str(UpperCamelCase_       ).startswith('''mps'''       ):
       __magic_name__     =      torch.manual_seed(UpperCamelCase_       )
      else:
       __magic_name__     =      torch.Generator(device=UpperCamelCase_       ).manual_seed(UpperCamelCase_       )

      if pil_image:
       __magic_name__     =      input_image * 0.5 + 0.5
       __magic_name__     =      input_image.clamp(0 ,						1       )
       __magic_name__     =      input_image.cpu().permute(0 ,						2 ,						3 ,						1       ).float().numpy()
       __magic_name__     =      DiffusionPipeline.numpy_to_pil(UpperCamelCase_       )[0]

      return {
          "image": input_image,
          "generator": generator,
          "decoder_num_inference_steps": 2,
          "super_res_num_inference_steps": 2,
          "output_type": "np",
      }







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      '''cpu'''

      __magic_name__     =      self.get_dummy_components()

      __magic_name__     =      self.pipeline_class(**UpperCamelCase_       )
      __magic_name__     =      pipe.to(UpperCamelCase_       )

      pipe.set_progress_bar_config(disable=UpperCamelCase_       )

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )

      __magic_name__     =      pipe(**UpperCamelCase_       )
      __magic_name__     =      output.images

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )

      __magic_name__     =      pipe(
          **UpperCamelCase_ ,						return_dict=UpperCamelCase_ ,						)[0]

      __magic_name__     =      image[0, -3:, -3:, -1]
      __magic_name__     =      image_from_tuple[0, -3:, -3:, -1]

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

      __magic_name__     =      np.array(
          [
              0.9_9_9_7,
              0.0_0_0_2,
              0.9_9_9_7,
              0.9_9_9_7,
              0.9_9_6_9,
              0.0_0_2_3,
              0.9_9_9_7,
              0.9_9_6_9,
              0.9_9_7_0,
          ]       )

      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 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      '''cpu'''

      __magic_name__     =      self.get_dummy_components()

      __magic_name__     =      self.pipeline_class(**UpperCamelCase_       )
      __magic_name__     =      pipe.to(UpperCamelCase_       )

      pipe.set_progress_bar_config(disable=UpperCamelCase_       )

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )

      __magic_name__     =      pipe(**UpperCamelCase_       )
      __magic_name__     =      output.images

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )

      __magic_name__     =      pipe(
          **UpperCamelCase_ ,						return_dict=UpperCamelCase_ ,						)[0]

      __magic_name__     =      image[0, -3:, -3:, -1]
      __magic_name__     =      image_from_tuple[0, -3:, -3:, -1]

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

      __magic_name__     =      np.array([0.9_9_9_7, 0.0_0_0_3, 0.9_9_9_7, 0.9_9_9_7, 0.9_9_7_0, 0.0_0_2_4, 0.9_9_9_7, 0.9_9_7_1, 0.9_9_7_1]       )

      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 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      '''cpu'''

      __magic_name__     =      self.get_dummy_components()

      __magic_name__     =      self.pipeline_class(**UpperCamelCase_       )
      __magic_name__     =      pipe.to(UpperCamelCase_       )

      pipe.set_progress_bar_config(disable=UpperCamelCase_       )

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )
      __magic_name__     =      [
          pipeline_inputs['''image'''],
          pipeline_inputs['''image'''],
      ]

      __magic_name__     =      pipe(**UpperCamelCase_       )
      __magic_name__     =      output.images

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )
      __magic_name__     =      [
          tuple_pipeline_inputs['''image'''],
          tuple_pipeline_inputs['''image'''],
      ]

      __magic_name__     =      pipe(
          **UpperCamelCase_ ,						return_dict=UpperCamelCase_ ,						)[0]

      __magic_name__     =      image[0, -3:, -3:, -1]
      __magic_name__     =      image_from_tuple[0, -3:, -3:, -1]

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

      __magic_name__     =      np.array(
          [
              0.9_9_9_7,
              0.9_9_8_9,
              0.0_0_0_8,
              0.0_0_2_1,
              0.9_9_6_0,
              0.0_0_1_8,
              0.0_0_1_4,
              0.0_0_0_2,
              0.9_9_3_3,
          ]       )

      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 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      torch.device('''cpu'''       )
      class        _lowercase					:
           _lowerCamelCase     =       1


      __magic_name__     =      self.get_dummy_components()

      __magic_name__     =      self.pipeline_class(**UpperCamelCase_       )
      __magic_name__     =      pipe.to(UpperCamelCase_       )

      pipe.set_progress_bar_config(disable=UpperCamelCase_       )

      __magic_name__     =      torch.Generator(device=UpperCamelCase_       ).manual_seed(0       )
      __magic_name__     =      pipe.decoder.dtype
      __magic_name__     =      1

      __magic_name__     =      (
          batch_size,
          pipe.decoder.config.in_channels,
          pipe.decoder.config.sample_size,
          pipe.decoder.config.sample_size,
      )
      __magic_name__     =      pipe.prepare_latents(
          UpperCamelCase_ ,						dtype=UpperCamelCase_ ,						device=UpperCamelCase_ ,						generator=UpperCamelCase_ ,						latents=UpperCamelCase_ ,						scheduler=DummyScheduler()       )

      __magic_name__     =      (
          batch_size,
          pipe.super_res_first.config.in_channels // 2,
          pipe.super_res_first.config.sample_size,
          pipe.super_res_first.config.sample_size,
      )
      __magic_name__     =      pipe.prepare_latents(
          UpperCamelCase_ ,						dtype=UpperCamelCase_ ,						device=UpperCamelCase_ ,						generator=UpperCamelCase_ ,						latents=UpperCamelCase_ ,						scheduler=DummyScheduler()       )

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )

      __magic_name__     =      pipe(
          **UpperCamelCase_ ,						decoder_latents=UpperCamelCase_ ,						super_res_latents=UpperCamelCase_       ).images

      __magic_name__     =      self.get_dummy_inputs(UpperCamelCase_ ,						pil_image=UpperCamelCase_       )
      # Don't pass image, instead pass embedding
      __magic_name__     =      pipeline_inputs.pop('''image'''       )
      __magic_name__     =      pipe.image_encoder(UpperCamelCase_       ).image_embeds

      __magic_name__     =      pipe(
          **UpperCamelCase_ ,						decoder_latents=UpperCamelCase_ ,						super_res_latents=UpperCamelCase_ ,						image_embeddings=UpperCamelCase_ ,						).images

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







     @skip_mps
     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      torch_device == '''cpu'''

      # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
      __magic_name__     =      1E-2

      self._test_attention_slicing_forward_pass(
          test_max_difference=UpperCamelCase_ ,						expected_max_diff=UpperCamelCase_       )







     @skip_mps
     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      torch_device == '''cpu'''
      __magic_name__     =      True
      __magic_name__     =      [
          '''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 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      [
          '''decoder_num_inference_steps''',
          '''super_res_num_inference_steps''',
      ]

      if torch_device == "mps":
       # TODO: MPS errors with larger batch sizes
       __magic_name__     =      [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 	lowerCAmelCase__    (      self       ):
      return super().test_dict_tuple_outputs_equivalent()







     @skip_mps
     def 	lowerCAmelCase__    (      self       ):
      return super().test_save_load_local()







     @skip_mps
     def 	lowerCAmelCase__    (      self       ):
      return super().test_save_load_optional_components()


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







     def 	lowerCAmelCase__    (      self       ):
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      load_image(
          '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'''       )
      __magic_name__     =      load_numpy(
          '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
          '''/unclip/karlo_v1_alpha_cat_variation_fp16.npy'''       )

      __magic_name__     =      UnCLIPImageVariationPipeline.from_pretrained(
          '''kakaobrain/karlo-v1-alpha-image-variations''' ,						torch_dtype=torch.floataa       )
      __magic_name__     =      pipeline.to(UpperCamelCase_       )
      pipeline.set_progress_bar_config(disable=UpperCamelCase_       )

      __magic_name__     =      torch.Generator(device='''cpu'''       ).manual_seed(0       )
      __magic_name__     =      pipeline(
          UpperCamelCase_ ,						generator=UpperCamelCase_ ,						output_type='''np''' ,						)

      __magic_name__     =      output.images[0]

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

      assert_mean_pixel_difference(UpperCamelCase_ ,						UpperCamelCase_ ,						15       )




"""simple docstring"""






def 	lowercase      (   ) ->      int:
 return 1





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else two_pence(x - 2						) + one_pence()





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else five_pence(x - 5						) + two_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else ten_pence(x - 10						) + five_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else twenty_pence(x - 20						) + ten_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else fifty_pence(x - 50						) + twenty_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else one_pound(x - 100						) + fifty_pence(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return 0 if x < 0 else two_pound(x - 200						) + one_pound(__UpperCamelCase						)





def 	lowercase      (   __UpperCamelCase = 200						) ->      int:
 return two_pound(__UpperCamelCase						)


if __name__ == "__main__":
 print(solution(int(input().strip())))

