






import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()




class 							_lowerCAmelCase(			UpperCAmelCase_				,      unittest.TestCase   ):





       """simple docstring"""







       a							:						Union[str, Any]										=KandinskyVaaControlnetImgaImgPipeline
       a							:						List[Any]										=['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
       a							:						List[str]										=['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
       a							:						Union[str, Any]										=[
           '''generator''',
           '''height''',
           '''width''',
           '''strength''',
           '''guidance_scale''',
           '''num_inference_steps''',
           '''return_dict''',
           '''guidance_scale''',
           '''num_images_per_prompt''',
           '''output_type''',
           '''return_dict''',
       ]
       a							:						List[Any]										=False





       @property
       def      _a       (   self				):
         return 3_2





       @property
       def      _a       (   self				):
         return 3_2





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





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





       @property
       def      _a       (   self				):
         return 1_0_0





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

         UpperCamelCase_:   Dict        =							{
             'in_channels': 8,
             # Out channels is double in channels because predicts mean and variance
             'out_channels': 8,
             'addition_embed_type': 'image_hint',
             '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,
             'encoder_hid_dim': self.text_embedder_hidden_size,
             'encoder_hid_dim_type': 'image_proj',
             'cross_attention_dim': self.cross_attention_dim,
             'attention_head_dim': 4,
             'resnet_time_scale_shift': 'scale_shift',
             'class_embed_type': None,
         }

         UpperCamelCase_:   str        =							UNetaDConditionModel(**_lowerCamelCase				)
         return model





       @property
       def      _a       (   self				):
         return {
             "block_out_channels": [3_2, 3_2, 6_4, 6_4],
             "down_block_types": [
                 "DownEncoderBlock2D",
                 "DownEncoderBlock2D",
                 "DownEncoderBlock2D",
                 "AttnDownEncoderBlock2D",
             ],
             "in_channels": 3,
             "latent_channels": 4,
             "layers_per_block": 1,
             "norm_num_groups": 8,
             "norm_type": "spatial",
             "num_vq_embeddings": 1_2,
             "out_channels": 3,
             "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
             "vq_embed_dim": 4,
         }





       @property
       def      _a       (   self				):
         torch.manual_seed(0				)
         UpperCamelCase_:   Tuple        =							VQModel(**self.dummy_movq_kwargs				)
         return model





       def      _a       (   self				):
         UpperCamelCase_:   Union[str, Any]        =							self.dummy_unet
         UpperCamelCase_:   List[Any]        =							self.dummy_movq

         UpperCamelCase_:   Optional[int]        =							{
             'num_train_timesteps': 1_0_0_0,
             'beta_schedule': 'linear',
             'beta_start': 0.0_0_0_8_5,
             'beta_end': 0.0_1_2,
             'clip_sample': False,
             'set_alpha_to_one': False,
             'steps_offset': 0,
             'prediction_type': 'epsilon',
             'thresholding': False,
         }

         UpperCamelCase_:   Tuple        =							DDIMScheduler(**_lowerCamelCase				)

         UpperCamelCase_:   Tuple        =							{
             'unet': unet,
             'scheduler': scheduler,
             'movq': movq,
         }

         return components





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase=0				):
         UpperCamelCase_:   Any        =							floats_tensor((1, self.text_embedder_hidden_size)    ,     rng=random.Random(_lowerCamelCase				)				).to(_lowerCamelCase				)
         UpperCamelCase_:   Any        =							floats_tensor((1, self.text_embedder_hidden_size)    ,     rng=random.Random(seed + 1				)				).to(
             _lowerCamelCase				)
         # create init_image
         UpperCamelCase_:   Any        =							floats_tensor((1, 3, 6_4, 6_4)    ,     rng=random.Random(_lowerCamelCase				)				).to(_lowerCamelCase				)
         UpperCamelCase_:   Tuple        =							image.cpu().permute(0    ,     2    ,     3    ,     1				)[0]
         UpperCamelCase_:   Optional[Any]        =							Image.fromarray(np.uinta(_lowerCamelCase				)				).convert('RGB'				).resize((2_5_6, 2_5_6)				)
         # create hint
         UpperCamelCase_:   Tuple        =							floats_tensor((1, 3, 6_4, 6_4)    ,     rng=random.Random(_lowerCamelCase				)				).to(_lowerCamelCase				)

         if str(_lowerCamelCase				).startswith('mps'				):
           UpperCamelCase_:   Tuple        =							torch.manual_seed(_lowerCamelCase				)
         else:
           UpperCamelCase_:   int        =							torch.Generator(device=_lowerCamelCase				).manual_seed(_lowerCamelCase				)
         UpperCamelCase_:   str        =							{
             'image': init_image,
             'image_embeds': image_embeds,
             'negative_image_embeds': negative_image_embeds,
             'hint': hint,
             'generator': generator,
             'height': 6_4,
             'width': 6_4,
             'num_inference_steps': 1_0,
             'guidance_scale': 7.0,
             'strength': 0.2,
             'output_type': 'np',
         }
         return inputs





       def      _a       (   self				):
         UpperCamelCase_:   Union[str, Any]        =							'cpu'

         UpperCamelCase_:   str        =							self.get_dummy_components()

         UpperCamelCase_:   str        =							self.pipeline_class(**_lowerCamelCase				)
         UpperCamelCase_:   Dict        =							pipe.to(_lowerCamelCase				)

         pipe.set_progress_bar_config(disable=_lowerCamelCase				)

         UpperCamelCase_:   Union[str, Any]        =							pipe(**self.get_dummy_inputs(_lowerCamelCase				)				)
         UpperCamelCase_:   Union[str, Any]        =							output.images

         UpperCamelCase_:   str        =							pipe(
             **self.get_dummy_inputs(_lowerCamelCase				)    ,     return_dict=_lowerCamelCase    ,     )[0]

         UpperCamelCase_:   Tuple        =							image[0, -3:, -3:, -1]
         UpperCamelCase_:   Optional[int]        =							image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 6_4, 6_4, 3)

         UpperCamelCase_:   int        =							np.array(
             [0.5_4_9_8_5_0_3_4, 0.5_5_5_0_9_3_6_5, 0.5_2_5_6_1_5_0_4, 0.5_5_7_0_4_9_4, 0.5_5_9_3_8_1_8, 0.5_2_6_3_9_7_9, 0.5_0_2_8_5_6_4_3, 0.5_0_6_9_8_4_6, 0.5_1_1_9_6_7_3_6]				)
         assert (
             np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
         ), f''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
         assert (
             np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1e-2
         ), f''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''







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





       """simple docstring"""







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





       def      _a       (   self				):
         UpperCamelCase_:   Optional[Any]        =							load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy'				)

         UpperCamelCase_:   List[str]        =							load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png'				)
         UpperCamelCase_:   List[str]        =							init_image.resize((5_1_2, 5_1_2)				)

         UpperCamelCase_:   str        =							load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/kandinskyv22/hint_image_cat.png'				)
         UpperCamelCase_:   Optional[Any]        =							torch.from_numpy(np.array(_lowerCamelCase				)				).float() / 2_5_5.0
         UpperCamelCase_:   Optional[int]        =							hint.permute(2    ,     0    ,     1				).unsqueeze(0				)

         UpperCamelCase_:   Union[str, Any]        =							'A robot, 4k photo'

         UpperCamelCase_:   int        =							KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
             'kandinsky-community/kandinsky-2-2-prior'    ,     torch_dtype=torch.floataa				)
         pipe_prior.to(_lowerCamelCase				)

         UpperCamelCase_:   Union[str, Any]        =							KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
             'kandinsky-community/kandinsky-2-2-controlnet-depth'    ,     torch_dtype=torch.floataa				)
         UpperCamelCase_:   str        =							pipeline.to(_lowerCamelCase				)

         pipeline.set_progress_bar_config(disable=_lowerCamelCase				)

         UpperCamelCase_:   Optional[Any]        =							torch.Generator(device='cpu'				).manual_seed(0				)

         UpperCamelCase_ ,UpperCamelCase_:   Optional[Any]        =							pipe_prior(
             _lowerCamelCase    ,     image=_lowerCamelCase    ,     strength=0.8_5    ,     generator=_lowerCamelCase    ,     negative_prompt=''    ,     ).to_tuple()

         UpperCamelCase_:   Tuple        =							pipeline(
             image=_lowerCamelCase    ,     image_embeds=_lowerCamelCase    ,     negative_image_embeds=_lowerCamelCase    ,     hint=_lowerCamelCase    ,     generator=_lowerCamelCase    ,     num_inference_steps=1_0_0    ,     height=5_1_2    ,     width=5_1_2    ,     strength=0.5    ,     output_type='np'    ,     )

         UpperCamelCase_:   Tuple        =							output.images[0]

         assert image.shape == (5_1_2, 5_1_2, 3)

         assert_mean_pixel_difference(_lowerCamelCase    ,     _lowerCamelCase				)



def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase = 100				)    ->				int:
  snake_case__						= set()

  snake_case__						= 0

  snake_case__						= n + 1  # maximum limit

  for a in range(2							,   __lowerCAmelCase				):
    for b in range(2							,   __lowerCAmelCase				):
      snake_case__						= a**b  # calculates the current power
      collect_powers.add(__lowerCAmelCase				)  # adds the result to the set
  return len(__lowerCAmelCase				)


if __name__ == "__main__":
   print("""Number of terms """, solution(int(str(input()).strip())))

