



"""simple docstring"""






import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

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




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_	)						->				Tuple:
  if isinstance(lowerCAmelCase_  ,						torch.Tensor	):
    return image
  elif isinstance(lowerCAmelCase_  ,						PIL.Image.Image	):
    _snake_case   	=      [image]

  if isinstance(image[0]  ,						PIL.Image.Image	):
    _snake_case   	=      [np.array(i.resize((w, h)  ,						resample=PIL_INTERPOLATION['''lanczos''']	)	)[None, :] for i in image]
    _snake_case   	=      np.concatenate(lowerCAmelCase_  ,						axis=0	)
    _snake_case   	=      np.array(lowerCAmelCase_	).astype(np.floataa	) / 255.0
    _snake_case   	=      image.transpose(0  ,						3  ,						1  ,						2	)
    _snake_case   	=      2.0 * image - 1.0
    _snake_case   	=      torch.from_numpy(lowerCAmelCase_	)
  elif isinstance(image[0]  ,						torch.Tensor	):
    _snake_case   	=      torch.cat(lowerCAmelCase_  ,						dim=0	)
  return image




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_=0.9995	)						->				str:
  if not isinstance(lowerCAmelCase_  ,						np.ndarray	):
    _snake_case   	=      True
    _snake_case   	=      va.device
    _snake_case   	=      va.cpu().numpy()
    _snake_case   	=      va.cpu().numpy()

  _snake_case   	=      np.sum(va * va / (np.linalg.norm(lowerCAmelCase_	) * np.linalg.norm(lowerCAmelCase_	))	)
  if np.abs(lowerCAmelCase_	) > DOT_THRESHOLD:
    _snake_case   	=      (1 - t) * va + t * va
  else:
    _snake_case   	=      np.arccos(lowerCAmelCase_	)
    _snake_case   	=      np.sin(lowerCAmelCase_	)
    _snake_case   	=      theta_a * t
    _snake_case   	=      np.sin(lowerCAmelCase_	)
    _snake_case   	=      np.sin(theta_a - theta_t	) / sin_theta_a
    _snake_case   	=      sin_theta_t / sin_theta_a
    _snake_case   	=      sa * va + sa * va

  if inputs_are_torch:
    _snake_case   	=      torch.from_numpy(lowerCAmelCase_	).to(lowerCAmelCase_	)

  return va




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_	)						->				List[str]:
  _snake_case   	=      F.normalize(lowerCAmelCase_  ,						dim=-1	)
  _snake_case   	=      F.normalize(lowerCAmelCase_  ,						dim=-1	)
  return (x - y).norm(dim=-1	).div(2	).arcsin().pow(2	).mul(2	)




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_	)						->				int:
  for param in model.parameters():
    _snake_case   	=      value







class     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE  ):



   def __init__(       self    :	Any							,       __lowerCamelCase    :	AutoencoderKL							,       __lowerCamelCase    :	CLIPTextModel							,       __lowerCamelCase    :	CLIPModel							,       __lowerCamelCase    :	CLIPTokenizer							,       __lowerCamelCase    :	UNetaDConditionModel							,       __lowerCamelCase    :	Union[PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler, DPMSolverMultistepScheduler]							,       __lowerCamelCase    :	CLIPFeatureExtractor							,       __lowerCamelCase    :	Union[str, Any]=None							,       __lowerCamelCase    :	List[str]=None							,       __lowerCamelCase    :	Tuple=None							,       ):



     """simple docstring"""
     super().__init__()
     self.register_modules(
         vae=__lowerCamelCase							,       text_encoder=__lowerCamelCase							,       clip_model=__lowerCamelCase							,       tokenizer=__lowerCamelCase							,       unet=__lowerCamelCase							,       scheduler=__lowerCamelCase							,       feature_extractor=__lowerCamelCase							,       coca_model=__lowerCamelCase							,       coca_tokenizer=__lowerCamelCase							,       coca_transform=__lowerCamelCase							,       )
     _snake_case   	=      (
         feature_extractor.size
         if isinstance(feature_extractor.size							,       __lowerCamelCase				)
         else feature_extractor.size['''shortest_edge''']
     )
     _snake_case   	=      transforms.Normalize(mean=feature_extractor.image_mean							,       std=feature_extractor.image_std				)
     set_requires_grad(self.text_encoder							,       __lowerCamelCase				)
     set_requires_grad(self.clip_model							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	List[str]							,       __lowerCamelCase    :	Optional[Union[str, int]] = "auto"				):



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



   def    __UpperCAmelCase    (       self    :	List[Any]				):



     """simple docstring"""
     self.enable_attention_slicing(__lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Optional[Any]				):



     """simple docstring"""
     set_requires_grad(self.vae							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     set_requires_grad(self.vae							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Union[str, Any]				):



     """simple docstring"""
     set_requires_grad(self.unet							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	int				):



     """simple docstring"""
     set_requires_grad(self.unet							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Optional[int]							,       __lowerCamelCase    :	Any							,       __lowerCamelCase    :	Union[str, Any]							,       __lowerCamelCase    :	Optional[int]				):



     """simple docstring"""
     # get the original timestep using init_timestep
     _snake_case   	=      min(int(num_inference_steps * strength				)							,       __lowerCamelCase				)

     _snake_case   	=      max(num_inference_steps - init_timestep							,       0				)
     _snake_case   	=      self.scheduler.timesteps[t_start:]

     return timesteps, num_inference_steps - t_start



   def    __UpperCAmelCase    (       self    :	List[Any]							,       __lowerCamelCase    :	Tuple							,       __lowerCamelCase    :	Any							,       __lowerCamelCase    :	Union[str, Any]							,       __lowerCamelCase    :	List[str]							,       __lowerCamelCase    :	List[str]							,       __lowerCamelCase    :	Optional[Any]=None				):



     """simple docstring"""
     if not isinstance(__lowerCamelCase							,       torch.Tensor				):
       raise ValueError(f"""`image` has to be of type `torch.Tensor` but is {type(__lowerCamelCase				)}"""				)

     _snake_case   	=      image.to(device=__lowerCamelCase							,       dtype=__lowerCamelCase				)

     if isinstance(__lowerCamelCase							,       __lowerCamelCase				):
       _snake_case   	=      [
           self.vae.encode(image[i : i + 1]				).latent_dist.sample(generator[i]				) for i in range(__lowerCamelCase				)
       ]
       _snake_case   	=      torch.cat(__lowerCamelCase							,       dim=0				)
     else:
       _snake_case   	=      self.vae.encode(__lowerCamelCase				).latent_dist.sample(__lowerCamelCase				)

     # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
     _snake_case   	=      0.1_8_2_1_5 * init_latents
     _snake_case   	=      init_latents.repeat_interleave(__lowerCamelCase							,       dim=0				)

     _snake_case   	=      randn_tensor(init_latents.shape							,       generator=__lowerCamelCase							,       device=__lowerCamelCase							,       dtype=__lowerCamelCase				)

     # get latents
     _snake_case   	=      self.scheduler.add_noise(__lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)
     _snake_case   	=      init_latents

     return latents



   def    __UpperCAmelCase    (       self    :	str							,       __lowerCamelCase    :	List[str]				):



     """simple docstring"""
     _snake_case   	=      self.coca_transform(__lowerCamelCase				).unsqueeze(0				)
     with torch.no_grad(), torch.cuda.amp.autocast():
       _snake_case   	=      self.coca_model.generate(transformed_image.to(device=self.device							,       dtype=self.coca_model.dtype				)				)
     _snake_case   	=      self.coca_tokenizer.decode(generated[0].cpu().numpy()				)
     return generated.split('''<end_of_text>'''				)[0].replace('''<start_of_text>'''							,       ''''''				).rstrip(''' .,'''				)



   def    __UpperCAmelCase    (       self    :	List[str]							,       __lowerCamelCase    :	List[str]							,       __lowerCamelCase    :	List[str]				):



     """simple docstring"""
     _snake_case   	=      self.feature_extractor.preprocess(__lowerCamelCase				)
     _snake_case   	=      torch.from_numpy(clip_image_input['''pixel_values'''][0]				).unsqueeze(0				).to(self.device				).half()
     _snake_case   	=      self.clip_model.get_image_features(__lowerCamelCase				)
     _snake_case   	=      image_embeddings_clip / image_embeddings_clip.norm(p=2							,       dim=-1							,       keepdim=__lowerCamelCase				)
     _snake_case   	=      image_embeddings_clip.repeat_interleave(__lowerCamelCase							,       dim=0				)
     return image_embeddings_clip



   @torch.enable_grad()
   def    __UpperCAmelCase    (       self    :	int							,       __lowerCamelCase    :	Union[str, Any]							,       __lowerCamelCase    :	Optional[Any]							,       __lowerCamelCase    :	List[Any]							,       __lowerCamelCase    :	List[str]							,       __lowerCamelCase    :	List[str]							,       __lowerCamelCase    :	str							,       __lowerCamelCase    :	Optional[Any]							,       ):



     """simple docstring"""
     _snake_case   	=      latents.detach().requires_grad_()

     _snake_case   	=      self.scheduler.scale_model_input(__lowerCamelCase							,       __lowerCamelCase				)

     # predict the noise residual
     _snake_case   	=      self.unet(__lowerCamelCase							,       __lowerCamelCase							,       encoder_hidden_states=__lowerCamelCase				).sample

     if isinstance(self.scheduler							,       (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)				):
       _snake_case   	=      self.scheduler.alphas_cumprod[timestep]
       _snake_case   	=      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
       _snake_case   	=      (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

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

     # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
     _snake_case   	=      1 / 0.1_8_2_1_5 * sample
     _snake_case   	=      self.vae.decode(__lowerCamelCase				).sample
     _snake_case   	=      (image / 2 + 0.5).clamp(0							,       1				)

     _snake_case   	=      transforms.Resize(self.feature_extractor_size				)(__lowerCamelCase				)
     _snake_case   	=      self.normalize(__lowerCamelCase				).to(latents.dtype				)

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

     _snake_case   	=      spherical_dist_loss(__lowerCamelCase							,       __lowerCamelCase				).mean() * clip_guidance_scale

     _snake_case   	=      -torch.autograd.grad(__lowerCamelCase							,       __lowerCamelCase				)[0]

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





   @torch.no_grad()
   def __call__(       self    :	List[str]							,       __lowerCamelCase    :	Union[torch.FloatTensor, PIL.Image.Image]							,       __lowerCamelCase    :	Union[torch.FloatTensor, PIL.Image.Image]							,       __lowerCamelCase    :	Optional[str] = None							,       __lowerCamelCase    :	Optional[str] = None							,       __lowerCamelCase    :	Optional[int] = 5_1_2							,       __lowerCamelCase    :	Optional[int] = 5_1_2							,       __lowerCamelCase    :	float = 0.6							,       __lowerCamelCase    :	Optional[int] = 5_0							,       __lowerCamelCase    :	Optional[float] = 7.5							,       __lowerCamelCase    :	Optional[int] = 1							,       __lowerCamelCase    :	float = 0.0							,       __lowerCamelCase    :	Optional[float] = 1_0_0							,       __lowerCamelCase    :	Optional[torch.Generator] = None							,       __lowerCamelCase    :	Optional[str] = "pil"							,       __lowerCamelCase    :	bool = True							,       __lowerCamelCase    :	float = 0.8							,       __lowerCamelCase    :	float = 0.1							,       __lowerCamelCase    :	float = 0.1							,       ):



     """simple docstring"""
     if isinstance(__lowerCamelCase							,       __lowerCamelCase				) and len(__lowerCamelCase				) != batch_size:
       raise ValueError(f"""You have passed {batch_size} batch_size, but only {len(__lowerCamelCase				)} generators."""				)

     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}."""				)

     if isinstance(__lowerCamelCase							,       torch.Generator				) and batch_size > 1:
       _snake_case   	=      [generator] + [None] * (batch_size - 1)

     _snake_case   	=      [
         ('''model''', self.coca_model is None),
         ('''tokenizer''', self.coca_tokenizer is None),
         ('''transform''', self.coca_transform is None),
     ]
     _snake_case   	=      [x[0] for x in coca_is_none if x[1]]
     _snake_case   	=      ''', '''.join(__lowerCamelCase				)
     # generate prompts with coca model if prompt is None
     if content_prompt is None:
       if len(__lowerCamelCase				):
         raise ValueError(
             f"""Content prompt is None and CoCa [{coca_is_none_str}] is None."""
             f"""Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."""				)
       _snake_case   	=      self.get_image_description(__lowerCamelCase				)
     if style_prompt is None:
       if len(__lowerCamelCase				):
         raise ValueError(
             f"""Style prompt is None and CoCa [{coca_is_none_str}] is None."""
             f""" Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."""				)
       _snake_case   	=      self.get_image_description(__lowerCamelCase				)

     # get prompt text embeddings for content and style
     _snake_case   	=      self.tokenizer(
         __lowerCamelCase							,       padding='''max_length'''							,       max_length=self.tokenizer.model_max_length							,       truncation=__lowerCamelCase							,       return_tensors='''pt'''							,       )
     _snake_case   	=      self.text_encoder(content_text_input.input_ids.to(self.device				)				)[0]

     _snake_case   	=      self.tokenizer(
         __lowerCamelCase							,       padding='''max_length'''							,       max_length=self.tokenizer.model_max_length							,       truncation=__lowerCamelCase							,       return_tensors='''pt'''							,       )
     _snake_case   	=      self.text_encoder(style_text_input.input_ids.to(self.device				)				)[0]

     _snake_case   	=      slerp(__lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)

     # duplicate text embeddings for each generation per prompt
     _snake_case   	=      text_embeddings.repeat_interleave(__lowerCamelCase							,       dim=0				)

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

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

     _snake_case	,     _snake_case   	=      self.get_timesteps(__lowerCamelCase							,       __lowerCamelCase							,       self.device				)
     _snake_case   	=      timesteps[:1].repeat(__lowerCamelCase				)

     # Preprocess image
     _snake_case   	=      preprocess(__lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)
     _snake_case   	=      self.prepare_latents(
         __lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase							,       text_embeddings.dtype							,       self.device							,       __lowerCamelCase				)

     _snake_case   	=      preprocess(__lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)
     _snake_case   	=      self.prepare_latents(
         __lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase							,       text_embeddings.dtype							,       self.device							,       __lowerCamelCase				)

     _snake_case   	=      slerp(__lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)

     if clip_guidance_scale > 0:
       _snake_case   	=      self.get_clip_image_embeddings(__lowerCamelCase							,       __lowerCamelCase				)
       _snake_case   	=      self.get_clip_image_embeddings(__lowerCamelCase							,       __lowerCamelCase				)
       _snake_case   	=      slerp(
           __lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)

     # 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.
     _snake_case   	=      guidance_scale > 1.0
     # get unconditional embeddings for classifier free guidance
     if do_classifier_free_guidance:
       _snake_case   	=      content_text_input.input_ids.shape[-1]
       _snake_case   	=      self.tokenizer(['''''']							,       padding='''max_length'''							,       max_length=__lowerCamelCase							,       return_tensors='''pt'''				)
       _snake_case   	=      self.text_encoder(uncond_input.input_ids.to(self.device				)				)[0]
       # duplicate unconditional embeddings for each generation per prompt
       _snake_case   	=      uncond_embeddings.repeat_interleave(__lowerCamelCase							,       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
       _snake_case   	=      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`.
     _snake_case   	=      (batch_size, self.unet.config.in_channels, height // 8, width // 8)
     _snake_case   	=      text_embeddings.dtype
     if latents is None:
       if self.device.type == "mps":
         # randn does not work reproducibly on mps
         _snake_case   	=      torch.randn(__lowerCamelCase							,       generator=__lowerCamelCase							,       device='''cpu'''							,       dtype=__lowerCamelCase				).to(
             self.device				)
       else:
         _snake_case   	=      torch.randn(__lowerCamelCase							,       generator=__lowerCamelCase							,       device=self.device							,       dtype=__lowerCamelCase				)
     else:
       if latents.shape != latents_shape:
         raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""				)
       _snake_case   	=      latents.to(self.device				)

     # scale the initial noise by the standard deviation required by the scheduler
     _snake_case   	=      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]
     _snake_case   	=      '''eta''' in set(inspect.signature(self.scheduler.step				).parameters.keys()				)
     _snake_case   	=      {}
     if accepts_eta:
       _snake_case   	=      eta

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

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

         # predict the noise residual
         _snake_case   	=      self.unet(__lowerCamelCase							,       __lowerCamelCase							,       encoder_hidden_states=__lowerCamelCase				).sample

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

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

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

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
     _snake_case   	=      1 / 0.1_8_2_1_5 * latents
     _snake_case   	=      self.vae.decode(__lowerCamelCase				).sample

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

     if output_type == "pil":
       _snake_case   	=      self.numpy_to_pil(__lowerCamelCase				)

     if not return_dict:
       return (image, None)

     return StableDiffusionPipelineOutput(images=__lowerCamelCase							,       nsfw_content_detected=__lowerCamelCase				)






def 	lowerCamelCase					(	UpperCamelCase     :				int							)   ->    bool:
		_lowerCamelCase				   =  (1 + 24 * n) ** 0.5
		return ((1 + root) / 6) % 1 == 0


def 	lowerCamelCase					(	UpperCamelCase     :				int = 50_00							)   ->    int:
		_lowerCamelCase				   =  [(i * (3 * i - 1)) // 2 for i in range(1			,       UpperCamelCase							)]
		for i, pentagonal_i in enumerate(UpperCamelCase							):
				for j in range(UpperCamelCase			,       len(UpperCamelCase							)							):
						_lowerCamelCase				   =  pentagonal_nums[j]
						_lowerCamelCase				   =  pentagonal_i + pentagonal_j
						_lowerCamelCase				   =  pentagonal_j - pentagonal_i
						if is_pentagonal(UpperCamelCase							) and is_pentagonal(UpperCamelCase							):
								return b

		return -1


if __name__ == "__main__":
				print(F'''{solution() = }''')