




import inspect
from typing import List, Optional, Union

import torch
from torch import nn
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPImageProcessor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput




class     A					(				nn.Module       ):







							def __init__(    self   :	Any   ,     __UpperCAmelCase   :	List[str]   ,     __UpperCAmelCase   :	Union[str, Any]=1.0				)		->					List[str]:

										"""simple docstring"""



										super().__init__()

										UpperCamelCase_     				= cut_size
										UpperCamelCase_     				= cut_power







							def        lowercase__							(    self   :	str   ,     __UpperCAmelCase   :	Tuple   ,     __UpperCAmelCase   :	List[Any]				)		->					Dict:

										"""simple docstring"""



										UpperCamelCase_				,   UpperCamelCase_     				= pixel_values.shape[2:4]
										UpperCamelCase_     				= min(__UpperCAmelCase   ,     __UpperCAmelCase				)
										UpperCamelCase_     				= min(__UpperCAmelCase   ,     __UpperCAmelCase   ,     self.cut_size				)
										UpperCamelCase_     				= []
										for _ in range(__UpperCAmelCase				):
													UpperCamelCase_     				= int(torch.rand([]				) ** self.cut_power * (max_size - min_size) + min_size				)
													UpperCamelCase_     				= torch.randint(0   ,     sideX - size + 1   ,     ()				)
													UpperCamelCase_     				= torch.randint(0   ,     sideY - size + 1   ,     ()				)
													UpperCamelCase_     				= pixel_values[:, :, offsety : offsety + size, offsetx : offsetx + size]
													cutouts.append(F.adaptive_avg_poolad(__UpperCAmelCase   ,     self.cut_size				)				)
										return torch.cat(__UpperCAmelCase				)







def  a_		(							__snake_case     ,		__snake_case					)	->			Optional[Any]:

			'''simple docstring'''


			UpperCamelCase_     				= F.normalize(__snake_case     ,		dim=-1					)
			UpperCamelCase_     				= F.normalize(__snake_case     ,		dim=-1					)
			return (x - y).norm(dim=-1					).div(2					).arcsin().pow(2					).mul(2					)




def  a_		(							__snake_case     ,		__snake_case					)	->			str:

			'''simple docstring'''


			for param in model.parameters():
						UpperCamelCase_     				= value





class     A					(				lowerCamelCase_       ):







							def __init__(    self   :	Union[str, Any]   ,     __UpperCAmelCase   :	AutoencoderKL   ,     __UpperCAmelCase   :	CLIPTextModel   ,     __UpperCAmelCase   :	CLIPModel   ,     __UpperCAmelCase   :	CLIPTokenizer   ,     __UpperCAmelCase   :	UNetaDConditionModel   ,     __UpperCAmelCase   :	Union[PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler, DPMSolverMultistepScheduler]   ,     __UpperCAmelCase   :	CLIPImageProcessor   ,     )		->					Optional[int]:

										"""simple docstring"""



										super().__init__()
										self.register_modules(
										    vae=__UpperCAmelCase   ,     text_encoder=__UpperCAmelCase   ,     clip_model=__UpperCAmelCase   ,     tokenizer=__UpperCAmelCase   ,     unet=__UpperCAmelCase   ,     scheduler=__UpperCAmelCase   ,     feature_extractor=__UpperCAmelCase   ,     )

										UpperCamelCase_     				= transforms.Normalize(mean=feature_extractor.image_mean   ,     std=feature_extractor.image_std				)
										UpperCamelCase_     				= (
										    feature_extractor.size
										    if isinstance(feature_extractor.size   ,     __UpperCAmelCase				)
										    else feature_extractor.size['shortest_edge']
										)
										UpperCamelCase_     				= MakeCutouts(self.cut_out_size				)

										set_requires_grad(self.text_encoder   ,     __UpperCAmelCase				)
										set_requires_grad(self.clip_model   ,     __UpperCAmelCase				)







							def        lowercase__							(    self   :	Union[str, Any]   ,     __UpperCAmelCase   :	Optional[Union[str, int]] = "auto"				)		->					List[str]:

										"""simple docstring"""



										if slice_size == "auto":
													# half the attention head size is usually a good trade-off between
													# speed and memory
													UpperCamelCase_     				= self.unet.config.attention_head_dim // 2
										self.unet.set_attention_slice(__UpperCAmelCase				)







							def        lowercase__							(    self   :	Optional[int]				)		->					Any:

										"""simple docstring"""



										self.enable_attention_slicing(__UpperCAmelCase				)







							def        lowercase__							(    self   :	Optional[int]				)		->					Optional[Any]:

										"""simple docstring"""



										set_requires_grad(self.vae   ,     __UpperCAmelCase				)







							def        lowercase__							(    self   :	str				)		->					Optional[Any]:

										"""simple docstring"""



										set_requires_grad(self.vae   ,     __UpperCAmelCase				)







							def        lowercase__							(    self   :	int				)		->					str:

										"""simple docstring"""



										set_requires_grad(self.unet   ,     __UpperCAmelCase				)







							def        lowercase__							(    self   :	Tuple				)		->					List[Any]:

										"""simple docstring"""



										set_requires_grad(self.unet   ,     __UpperCAmelCase				)







							@torch.enable_grad()
							def        lowercase__							(    self   :	Any   ,     __UpperCAmelCase   :	str   ,     __UpperCAmelCase   :	str   ,     __UpperCAmelCase   :	str   ,     __UpperCAmelCase   :	int   ,     __UpperCAmelCase   :	Tuple   ,     __UpperCAmelCase   :	Any   ,     __UpperCAmelCase   :	Any   ,     __UpperCAmelCase   :	List[Any]   ,     __UpperCAmelCase   :	Optional[int]=True   ,     )		->					Optional[Any]:

										"""simple docstring"""



										UpperCamelCase_     				= latents.detach().requires_grad_()

										UpperCamelCase_     				= self.scheduler.scale_model_input(__UpperCAmelCase   ,     __UpperCAmelCase				)

										# predict the noise residual
										UpperCamelCase_     				= self.unet(__UpperCAmelCase   ,     __UpperCAmelCase   ,     encoder_hidden_states=__UpperCAmelCase				).sample

										if isinstance(self.scheduler   ,     (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)				):
													UpperCamelCase_     				= self.scheduler.alphas_cumprod[timestep]
													UpperCamelCase_     				= 1 - alpha_prod_t
													# compute predicted original sample from predicted noise also called
													# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
													UpperCamelCase_     				= (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

													UpperCamelCase_     				= torch.sqrt(__UpperCAmelCase				)
													UpperCamelCase_     				= pred_original_sample * (fac) + latents * (1 - fac)
										elif isinstance(self.scheduler   ,     __UpperCAmelCase				):
													UpperCamelCase_     				= self.scheduler.sigmas[index]
													UpperCamelCase_     				= latents - sigma * noise_pred
										else:
													raise ValueError(f'''scheduler type {type(self.scheduler				)} not supported'''				)

										UpperCamelCase_     				= 1 / self.vae.config.scaling_factor * sample
										UpperCamelCase_     				= self.vae.decode(__UpperCAmelCase				).sample
										UpperCamelCase_     				= (image / 2 + 0.5).clamp(0   ,     1				)

										if use_cutouts:
													UpperCamelCase_     				= self.make_cutouts(__UpperCAmelCase   ,     __UpperCAmelCase				)
										else:
													UpperCamelCase_     				= transforms.Resize(self.cut_out_size				)(__UpperCAmelCase				)
										UpperCamelCase_     				= self.normalize(__UpperCAmelCase				).to(latents.dtype				)

										UpperCamelCase_     				= self.clip_model.get_image_features(__UpperCAmelCase				)
										UpperCamelCase_     				= image_embeddings_clip / image_embeddings_clip.norm(p=2   ,     dim=-1   ,     keepdim=__UpperCAmelCase				)

										if use_cutouts:
													UpperCamelCase_     				= spherical_dist_loss(__UpperCAmelCase   ,     __UpperCAmelCase				)
													UpperCamelCase_     				= dists.view([num_cutouts, sample.shape[0], -1]				)
													UpperCamelCase_     				= dists.sum(2				).mean(0				).sum() * clip_guidance_scale
										else:
													UpperCamelCase_     				= spherical_dist_loss(__UpperCAmelCase   ,     __UpperCAmelCase				).mean() * clip_guidance_scale

										UpperCamelCase_     				= -torch.autograd.grad(__UpperCAmelCase   ,     __UpperCAmelCase				)[0]

										if isinstance(self.scheduler   ,     __UpperCAmelCase				):
													UpperCamelCase_     				= latents.detach() + grads * (sigma**2)
													UpperCamelCase_     				= noise_pred_original
										else:
													UpperCamelCase_     				= noise_pred_original - torch.sqrt(__UpperCAmelCase				) * grads
										return noise_pred, latents







							@torch.no_grad()
							def __call__(    self   :	Optional[Any]   ,     __UpperCAmelCase   :	Union[str, List[str]]   ,     __UpperCAmelCase   :	Optional[int] = 512   ,     __UpperCAmelCase   :	Optional[int] = 512   ,     __UpperCAmelCase   :	Optional[int] = 50   ,     __UpperCAmelCase   :	Optional[float] = 7.5   ,     __UpperCAmelCase   :	Optional[int] = 1   ,     __UpperCAmelCase   :	float = 0.0   ,     __UpperCAmelCase   :	Optional[float] = 100   ,     __UpperCAmelCase   :	Optional[Union[str, List[str]]] = None   ,     __UpperCAmelCase   :	Optional[int] = 4   ,     __UpperCAmelCase   :	Optional[bool] = True   ,     __UpperCAmelCase   :	Optional[torch.Generator] = None   ,     __UpperCAmelCase   :	Optional[torch.FloatTensor] = None   ,     __UpperCAmelCase   :	Optional[str] = "pil"   ,     __UpperCAmelCase   :	bool = True   ,     )		->					Optional[Any]:

										"""simple docstring"""



										if isinstance(__UpperCAmelCase   ,     __UpperCAmelCase				):
													UpperCamelCase_     				= 1
										elif isinstance(__UpperCAmelCase   ,     __UpperCAmelCase				):
													UpperCamelCase_     				= len(__UpperCAmelCase				)
										else:
													raise ValueError(f'''`prompt` has to be of type `str` or `list` but is {type(__UpperCAmelCase				)}'''				)

										if height % 8 != 0 or width % 8 != 0:
													raise ValueError(f'''`height` and `width` have to be divisible by 8 but are {height} and {width}.'''				)

										# get prompt text embeddings
										UpperCamelCase_     				= self.tokenizer(
										    __UpperCAmelCase   ,     padding='max_length'   ,     max_length=self.tokenizer.model_max_length   ,     truncation=__UpperCAmelCase   ,     return_tensors='pt'   ,     )
										UpperCamelCase_     				= self.text_encoder(text_input.input_ids.to(self.device				)				)[0]
										# duplicate text embeddings for each generation per prompt
										UpperCamelCase_     				= text_embeddings.repeat_interleave(__UpperCAmelCase   ,     dim=0				)

										if clip_guidance_scale > 0:
													if clip_prompt is not None:
																UpperCamelCase_     				= self.tokenizer(
																    __UpperCAmelCase   ,     padding='max_length'   ,     max_length=self.tokenizer.model_max_length   ,     truncation=__UpperCAmelCase   ,     return_tensors='pt'   ,     ).input_ids.to(self.device				)
													else:
																UpperCamelCase_     				= text_input.input_ids.to(self.device				)
													UpperCamelCase_     				= self.clip_model.get_text_features(__UpperCAmelCase				)
													UpperCamelCase_     				= text_embeddings_clip / text_embeddings_clip.norm(p=2   ,     dim=-1   ,     keepdim=__UpperCAmelCase				)
													# duplicate text embeddings clip for each generation per prompt
													UpperCamelCase_     				= text_embeddings_clip.repeat_interleave(__UpperCAmelCase   ,     dim=0				)

										# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
										# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
										# corresponds to doing no classifier free guidance.
										UpperCamelCase_     				= guidance_scale > 1.0
										# get unconditional embeddings for classifier free guidance
										if do_classifier_free_guidance:
													UpperCamelCase_     				= text_input.input_ids.shape[-1]
													UpperCamelCase_     				= self.tokenizer(['']   ,     padding='max_length'   ,     max_length=__UpperCAmelCase   ,     return_tensors='pt'				)
													UpperCamelCase_     				= self.text_encoder(uncond_input.input_ids.to(self.device				)				)[0]
													# duplicate unconditional embeddings for each generation per prompt
													UpperCamelCase_     				= uncond_embeddings.repeat_interleave(__UpperCAmelCase   ,     dim=0				)

													# For classifier free guidance, we need to do two forward passes.
													# Here we concatenate the unconditional and text embeddings into a single batch
													# to avoid doing two forward passes
													UpperCamelCase_     				= torch.cat([uncond_embeddings, text_embeddings]				)

										# get the initial random noise unless the user supplied it

										# Unlike in other pipelines, latents need to be generated in the target device
										# for 1-to-1 results reproducibility with the CompVis implementation.
										# However this currently doesn't work in `mps`.
										UpperCamelCase_     				= (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
										UpperCamelCase_     				= text_embeddings.dtype
										if latents is None:
													if self.device.type == "mps":
																# randn does not work reproducibly on mps
																UpperCamelCase_     				= torch.randn(__UpperCAmelCase   ,     generator=__UpperCAmelCase   ,     device='cpu'   ,     dtype=__UpperCAmelCase				).to(
																    self.device				)
													else:
																UpperCamelCase_     				= torch.randn(__UpperCAmelCase   ,     generator=__UpperCAmelCase   ,     device=self.device   ,     dtype=__UpperCAmelCase				)
										else:
													if latents.shape != latents_shape:
																raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''				)
													UpperCamelCase_     				= latents.to(self.device				)

										# set timesteps
										UpperCamelCase_     				= 'offset' in set(inspect.signature(self.scheduler.set_timesteps				).parameters.keys()				)
										UpperCamelCase_     				= {}
										if accepts_offset:
													UpperCamelCase_     				= 1

										self.scheduler.set_timesteps(__UpperCAmelCase   ,     **__UpperCAmelCase				)

										# Some schedulers like PNDM have timesteps as arrays
										# It's more optimized to move all timesteps to correct device beforehand
										UpperCamelCase_     				= self.scheduler.timesteps.to(self.device				)

										# scale the initial noise by the standard deviation required by the scheduler
										UpperCamelCase_     				= latents * self.scheduler.init_noise_sigma

										# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
										# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
										# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
										# and should be between [0, 1]
										UpperCamelCase_     				= 'eta' in set(inspect.signature(self.scheduler.step				).parameters.keys()				)
										UpperCamelCase_     				= {}
										if accepts_eta:
													UpperCamelCase_     				= eta

										# check if the scheduler accepts generator
										UpperCamelCase_     				= 'generator' in set(inspect.signature(self.scheduler.step				).parameters.keys()				)
										if accepts_generator:
													UpperCamelCase_     				= generator

										for i, t in enumerate(self.progress_bar(__UpperCAmelCase				)				):
													# expand the latents if we are doing classifier free guidance
													UpperCamelCase_     				= torch.cat([latents] * 2				) if do_classifier_free_guidance else latents
													UpperCamelCase_     				= self.scheduler.scale_model_input(__UpperCAmelCase   ,     __UpperCAmelCase				)

													# predict the noise residual
													UpperCamelCase_     				= self.unet(__UpperCAmelCase   ,     __UpperCAmelCase   ,     encoder_hidden_states=__UpperCAmelCase				).sample

													# perform classifier free guidance
													if do_classifier_free_guidance:
																UpperCamelCase_				,   UpperCamelCase_     				= noise_pred.chunk(2				)
																UpperCamelCase_     				= noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

													# perform clip guidance
													if clip_guidance_scale > 0:
																UpperCamelCase_     				= (
																    text_embeddings.chunk(2				)[1] if do_classifier_free_guidance else text_embeddings
																)
																UpperCamelCase_				,   UpperCamelCase_     				= self.cond_fn(
																    __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     )

													# compute the previous noisy sample x_t -> x_t-1
													UpperCamelCase_     				= self.scheduler.step(__UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     **__UpperCAmelCase				).prev_sample

										# scale and decode the image latents with vae
										UpperCamelCase_     				= 1 / self.vae.config.scaling_factor * latents
										UpperCamelCase_     				= self.vae.decode(__UpperCAmelCase				).sample

										UpperCamelCase_     				= (image / 2 + 0.5).clamp(0   ,     1				)
										UpperCamelCase_     				= image.cpu().permute(0   ,     2   ,     3   ,     1				).numpy()

										if output_type == "pil":
													UpperCamelCase_     				= self.numpy_to_pil(__UpperCAmelCase				)

										if not return_dict:
													return (image, None)

										return StableDiffusionPipelineOutput(images=__UpperCAmelCase   ,     nsfw_content_detected=__UpperCAmelCase				)






from collections import Counter




def  a_		(							__snake_case					)	->			int:

			'''simple docstring'''


			return sum(socks_by_color // 2 for socks_by_color in Counter(__snake_case					).values()					)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				__a			:	List[Any]							     =		[int(x) for x in input("""Enter socks by color :""").rstrip().split()]
				print(f"""sock_merchant({colors}) = {sock_merchant(colors)}""")
