

import math
from itertools import permutations





def    _snake_case		(snake_case_				:    int     )       ->		bool:

  if 1 < number < 4:
    # 2 and 3 are primes
    return True
  elif number < 2 or number % 2 == 0 or number % 3 == 0:
    # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
    return False

  # All primes number are in format of 6k +/- 1
  for i in range(5						,					int(math.sqrt(snake_case_     ) + 1     )						,					6     ):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True





def    _snake_case		(snake_case_				:    int						,					snake_case_				:    list     )       ->		bool:
  __UpperCAmelCase, __UpperCAmelCase  :     Any		=    0, len(snake_case_     ) - 1
  while left <= right:
    __UpperCAmelCase  :     List[str]		=    (left + right) // 2
    if prime_list[middle] == target:
      return True
    elif prime_list[middle] < target:
      __UpperCAmelCase  :     Tuple		=    middle + 1
    else:
      __UpperCAmelCase  :     Tuple		=    middle - 1

  return False





def    _snake_case		()       ->		str:
  __UpperCAmelCase  :     List[Any]		=    [n for n in range(1001						,					1_0000						,					2     ) if is_prime(snake_case_     )]
  __UpperCAmelCase  :     Tuple		=    []

  for number in prime_list:
    __UpperCAmelCase  :     List[str]		=    []

    for prime_member in permutations(list(str(snake_case_     )     )     ):
      __UpperCAmelCase  :     Dict		=    int(''.join(snake_case_     )     )

      if prime % 2 == 0:
        continue

      if search(snake_case_						,					snake_case_     ):
        tmp_numbers.append(snake_case_     )

    tmp_numbers.sort()
    if len(snake_case_     ) >= 3:
      candidates.append(snake_case_     )

  __UpperCAmelCase  :     Optional[int]		=    []
  for candidate in candidates:
    __UpperCAmelCase  :     int		=    len(snake_case_     )
    __UpperCAmelCase  :     List[Any]		=    False

    for i in range(snake_case_     ):
      for j in range(i + 1						,					snake_case_     ):
        for k in range(j + 1						,					snake_case_     ):
          if (
              abs(candidate[i] - candidate[j]     )
              == abs(candidate[j] - candidate[k]     )
              and len({candidate[i], candidate[j], candidate[k]}     ) == 3
          ):
            passed.append(
                sorted([candidate[i], candidate[j], candidate[k]]     )     )
            __UpperCAmelCase  :     Any		=    True

          if found:
            break
        if found:
          break
      if found:
        break

  __UpperCAmelCase  :     Dict		=    set()
  for seq in passed:
    answer.add(''.join([str(snake_case_     ) for i in seq]     )     )

  return max(int(snake_case_     ) for x in answer     )


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








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     lowerCamelCase_   ( nn.Module):




 def __init__( self     ,     _UpperCAmelCase     ,     _UpperCAmelCase=1.0       ):
   super().__init__()

   __UpperCAmelCase  :     List[str]		=    cut_size
   __UpperCAmelCase  :     Dict		=    cut_power




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





def    _snake_case		(snake_case_				:    Optional[int]						,					snake_case_				:    Optional[int]     )       ->		Dict:
  __UpperCAmelCase  :     Any		=    F.normalize(snake_case_						,					dim=-1     )
  __UpperCAmelCase  :     Any		=    F.normalize(snake_case_						,					dim=-1     )
  return (x - y).norm(dim=-1     ).div(2     ).arcsin().pow(2     ).mul(2     )





def    _snake_case		(snake_case_				:    Optional[int]						,					snake_case_				:    Optional[Any]     )       ->		Tuple:
  for param in model.parameters():
    __UpperCAmelCase  :     int		=    value







class     lowerCamelCase_   ( _lowerCAmelCase):




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

   __UpperCAmelCase  :     int		=    transforms.Normalize(mean=feature_extractor.image_mean     ,     std=feature_extractor.image_std       )
   __UpperCAmelCase  :     Dict		=    (
       feature_extractor.size
       if isinstance(feature_extractor.size     ,     _UpperCAmelCase       )
       else feature_extractor.size['shortest_edge']
   )
   __UpperCAmelCase  :     Optional[Any]		=    MakeCutouts(self.cut_out_size       )

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




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




 def 						a					( self       ):
   self.enable_attention_slicing(_UpperCAmelCase       )




 def 						a					( self       ):
   set_requires_grad(self.vae     ,     _UpperCAmelCase       )




 def 						a					( self       ):
   set_requires_grad(self.vae     ,     _UpperCAmelCase       )




 def 						a					( self       ):
   set_requires_grad(self.unet     ,     _UpperCAmelCase       )




 def 						a					( self       ):
   set_requires_grad(self.unet     ,     _UpperCAmelCase       )




 @torch.enable_grad()
 def 						a					( self     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase=True     ,     ):
   __UpperCAmelCase  :     List[str]		=    latents.detach().requires_grad_()

   __UpperCAmelCase  :     Any		=    self.scheduler.scale_model_input(_UpperCAmelCase     ,     _UpperCAmelCase       )

   # predict the noise residual
   __UpperCAmelCase  :     Tuple		=    self.unet(_UpperCAmelCase     ,     _UpperCAmelCase     ,     encoder_hidden_states=_UpperCAmelCase       ).sample

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

     __UpperCAmelCase  :     Optional[int]		=    torch.sqrt(_UpperCAmelCase       )
     __UpperCAmelCase  :     Optional[int]		=    pred_original_sample * (fac) + latents * (1 - fac)
   elif isinstance(self.scheduler     ,     _UpperCAmelCase       ):
     __UpperCAmelCase  :     List[str]		=    self.scheduler.sigmas[index]
     __UpperCAmelCase  :     int		=    latents - sigma * noise_pred
   else:
     raise ValueError(F"scheduler type {type(self.scheduler       )} not supported"       )

   __UpperCAmelCase  :     int		=    1 / self.vae.config.scaling_factor * sample
   __UpperCAmelCase  :     Union[str, Any]		=    self.vae.decode(_UpperCAmelCase       ).sample
   __UpperCAmelCase  :     Any		=    (image / 2 + 0.5).clamp(0     ,     1       )

   if use_cutouts:
     __UpperCAmelCase  :     str		=    self.make_cutouts(_UpperCAmelCase     ,     _UpperCAmelCase       )
   else:
     __UpperCAmelCase  :     List[str]		=    transforms.Resize(self.cut_out_size       )(_UpperCAmelCase       )
   __UpperCAmelCase  :     Any		=    self.normalize(_UpperCAmelCase       ).to(latents.dtype       )

   __UpperCAmelCase  :     Union[str, Any]		=    self.clip_model.get_image_features(_UpperCAmelCase       )
   __UpperCAmelCase  :     str		=    image_embeddings_clip / image_embeddings_clip.norm(p=2     ,     dim=-1     ,     keepdim=_UpperCAmelCase       )

   if use_cutouts:
     __UpperCAmelCase  :     Optional[Any]		=    spherical_dist_loss(_UpperCAmelCase     ,     _UpperCAmelCase       )
     __UpperCAmelCase  :     Dict		=    dists.view([num_cutouts, sample.shape[0], -1]       )
     __UpperCAmelCase  :     Any		=    dists.sum(2       ).mean(0       ).sum() * clip_guidance_scale
   else:
     __UpperCAmelCase  :     Union[str, Any]		=    spherical_dist_loss(_UpperCAmelCase     ,     _UpperCAmelCase       ).mean() * clip_guidance_scale

   __UpperCAmelCase  :     Dict		=    -torch.autograd.grad(_UpperCAmelCase     ,     _UpperCAmelCase       )[0]

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




 @torch.no_grad()
 def __call__( self     ,     _UpperCAmelCase     ,     _UpperCAmelCase = 512     ,     _UpperCAmelCase = 512     ,     _UpperCAmelCase = 50     ,     _UpperCAmelCase = 7.5     ,     _UpperCAmelCase = 1     ,     _UpperCAmelCase = 0.0     ,     _UpperCAmelCase = 100     ,     _UpperCAmelCase = None     ,     _UpperCAmelCase = 4     ,     _UpperCAmelCase = True     ,     _UpperCAmelCase = None     ,     _UpperCAmelCase = None     ,     _UpperCAmelCase = "pil"     ,     _UpperCAmelCase = True     ,     ):
   if isinstance(_UpperCAmelCase     ,     _UpperCAmelCase       ):
     __UpperCAmelCase  :     str		=    1
   elif isinstance(_UpperCAmelCase     ,     _UpperCAmelCase       ):
     __UpperCAmelCase  :     List[str]		=    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  :     Any		=    self.tokenizer(
       _UpperCAmelCase     ,     padding='max_length'     ,     max_length=self.tokenizer.model_max_length     ,     truncation=_UpperCAmelCase     ,     return_tensors='pt'     ,     )
   __UpperCAmelCase  :     str		=    self.text_encoder(text_input.input_ids.to(self.device       )       )[0]
   # duplicate text embeddings for each generation per prompt
   __UpperCAmelCase  :     Optional[int]		=    text_embeddings.repeat_interleave(_UpperCAmelCase     ,     dim=0       )

   if clip_guidance_scale > 0:
     if clip_prompt is not None:
       __UpperCAmelCase  :     Dict		=    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  :     Optional[Any]		=    text_input.input_ids.to(self.device       )
     __UpperCAmelCase  :     Optional[Any]		=    self.clip_model.get_text_features(_UpperCAmelCase       )
     __UpperCAmelCase  :     Any		=    text_embeddings_clip / text_embeddings_clip.norm(p=2     ,     dim=-1     ,     keepdim=_UpperCAmelCase       )
     # duplicate text embeddings clip for each generation per prompt
     __UpperCAmelCase  :     int		=    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  :     List[str]		=    guidance_scale > 1.0
   # get unconditional embeddings for classifier free guidance
   if do_classifier_free_guidance:
     __UpperCAmelCase  :     Union[str, Any]		=    text_input.input_ids.shape[-1]
     __UpperCAmelCase  :     Tuple		=    self.tokenizer(['']     ,     padding='max_length'     ,     max_length=_UpperCAmelCase     ,     return_tensors='pt'       )
     __UpperCAmelCase  :     Dict		=    self.text_encoder(uncond_input.input_ids.to(self.device       )       )[0]
     # duplicate unconditional embeddings for each generation per prompt
     __UpperCAmelCase  :     List[str]		=    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  :     Dict		=    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  :     List[Any]		=    (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
   __UpperCAmelCase  :     Dict		=    text_embeddings.dtype
   if latents is None:
     if self.device.type == "mps":
       # randn does not work reproducibly on mps
       __UpperCAmelCase  :     Tuple		=    torch.randn(_UpperCAmelCase     ,     generator=_UpperCAmelCase     ,     device='cpu'     ,     dtype=_UpperCAmelCase       ).to(
           self.device       )
     else:
       __UpperCAmelCase  :     Tuple		=    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  :     str		=    latents.to(self.device       )

   # set timesteps
   __UpperCAmelCase  :     Union[str, Any]		=    'offset' in set(inspect.signature(self.scheduler.set_timesteps       ).parameters.keys()       )
   __UpperCAmelCase  :     Union[str, Any]		=    {}
   if accepts_offset:
     __UpperCAmelCase  :     Union[str, Any]		=    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  :     int		=    self.scheduler.timesteps.to(self.device       )

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

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

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

     # predict the noise residual
     __UpperCAmelCase  :     Optional[int]		=    self.unet(_UpperCAmelCase     ,     _UpperCAmelCase     ,     encoder_hidden_states=_UpperCAmelCase       ).sample

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

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

     # compute the previous noisy sample x_t -> x_t-1
     __UpperCAmelCase  :     Optional[Any]		=    self.scheduler.step(_UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     **_UpperCAmelCase       ).prev_sample

   # scale and decode the image latents with vae
   __UpperCAmelCase  :     Optional[Any]		=    1 / self.vae.config.scaling_factor * latents
   __UpperCAmelCase  :     List[str]		=    self.vae.decode(_UpperCAmelCase       ).sample

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

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

   if not return_dict:
     return (image, None)

   return StableDiffusionPipelineOutput(images=_UpperCAmelCase     ,     nsfw_content_detected=_UpperCAmelCase       )





