'''simple docstring'''





import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel


def      a__ (		__UpperCamelCase				):
      # vision encoder
      if "img_encoder.pos_embed" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("img_encoder.pos_embed"     ,      "vision_model.embeddings.position_embeddings"				)
      if "img_encoder.patch_embed.proj" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("img_encoder.patch_embed.proj"     ,      "vision_model.embeddings.patch_embeddings.projection"				)
      if "img_encoder.patch_embed.norm" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("img_encoder.patch_embed.norm"     ,      "vision_model.embeddings.layernorm"				)
      if "img_encoder.layers" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("img_encoder.layers"     ,      "vision_model.encoder.stages"				)
      if "blocks" in name and "res" not in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("blocks"     ,      "layers"				)
      if "attn" in name and "pre_assign" not in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("attn"     ,      "self_attn"				)
      if "proj" in name and "self_attn" in name and "text" not in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("proj"     ,      "out_proj"				)
      if "pre_assign_attn.attn.proj" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("pre_assign_attn.attn.proj"     ,      "pre_assign_attn.attn.out_proj"				)
      if "norm1" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("norm1"     ,      "layer_norm1"				)
      if "norm2" in name and "pre_assign" not in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("norm2"     ,      "layer_norm2"				)
      if "img_encoder.norm" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("img_encoder.norm"     ,      "vision_model.layernorm"				)
      # text encoder
      if "text_encoder.token_embedding" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("text_encoder.token_embedding"     ,      "text_model.embeddings.token_embedding"				)
      if "text_encoder.positional_embedding" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("text_encoder.positional_embedding"     ,      "text_model.embeddings.position_embedding.weight"				)
      if "text_encoder.transformer.resblocks." in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("text_encoder.transformer.resblocks."     ,      "text_model.encoder.layers."				)
      if "ln_1" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("ln_1"     ,      "layer_norm1"				)
      if "ln_2" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("ln_2"     ,      "layer_norm2"				)
      if "c_fc" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("c_fc"     ,      "fc1"				)
      if "c_proj" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("c_proj"     ,      "fc2"				)
      if "text_encoder" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("text_encoder"     ,      "text_model"				)
      if "ln_final" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("ln_final"     ,      "final_layer_norm"				)
      # projection layers
      if "img_projector.linear_hidden." in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("img_projector.linear_hidden."     ,      "visual_projection."				)
      if "img_projector.linear_out." in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("img_projector.linear_out."     ,      "visual_projection.3."				)
      if "text_projector.linear_hidden" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("text_projector.linear_hidden"     ,      "text_projection"				)
      if "text_projector.linear_out" in name:
            SCREAMING_SNAKE_CASE_          =  name.replace("text_projector.linear_out"     ,      "text_projection.3"				)

      return name


def      a__ (		__UpperCamelCase     ,      __UpperCamelCase				):
      for key in orig_state_dict.copy().keys():
            SCREAMING_SNAKE_CASE_          =  orig_state_dict.pop(__UpperCamelCase				)

            if "qkv" in key:
                  # weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment:
                  # we need to split them up into separate matrices/vectors
                  SCREAMING_SNAKE_CASE_          =  key.split("."				)
                  SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  int(key_split[2]				), int(key_split[4]				)
                  SCREAMING_SNAKE_CASE_          =  config.vision_config.hidden_size
                  if "weight" in key:
                        SCREAMING_SNAKE_CASE_          =  val[:dim, :]
                        SCREAMING_SNAKE_CASE_          =  val[dim : dim * 2, :]
                        SCREAMING_SNAKE_CASE_          =  val[-dim:, :]
                  else:
                        SCREAMING_SNAKE_CASE_          =  val[:dim]
                        SCREAMING_SNAKE_CASE_          =  val[dim : dim * 2]
                        SCREAMING_SNAKE_CASE_          =  val[-dim:]
            elif "in_proj" in key:
                  # weights and biases of the key, value and query projections of text encoder's attention layers require special treatment:
                  # we need to split them up into separate matrices/vectors
                  SCREAMING_SNAKE_CASE_          =  key.split("."				)
                  SCREAMING_SNAKE_CASE_          =  int(key_split[3]				)
                  SCREAMING_SNAKE_CASE_          =  config.text_config.hidden_size
                  if "weight" in key:
                        SCREAMING_SNAKE_CASE_          =  val[:dim, :]
                        SCREAMING_SNAKE_CASE_          =  val[
                            dim : dim * 2, :
                        ]
                        SCREAMING_SNAKE_CASE_          =  val[-dim:, :]
                  else:
                        SCREAMING_SNAKE_CASE_          =  val[:dim]
                        SCREAMING_SNAKE_CASE_          =  val[dim : dim * 2]
                        SCREAMING_SNAKE_CASE_          =  val[-dim:]
            else:
                  SCREAMING_SNAKE_CASE_          =  rename_key(__UpperCamelCase				)
                  # squeeze if necessary
                  if (
                      "text_projection.0" in new_name
                      or "text_projection.3" in new_name
                      or "visual_projection.0" in new_name
                      or "visual_projection.3" in new_name
                  ):
                        SCREAMING_SNAKE_CASE_          =  val.squeeze_()
                  else:
                        SCREAMING_SNAKE_CASE_          =  val

      return orig_state_dict


def      a__ (		):
      SCREAMING_SNAKE_CASE_          =  "http://images.cocodataset.org/val2017/000000039769.jpg"
      SCREAMING_SNAKE_CASE_          =  Image.open(requests.get(__UpperCamelCase     ,      stream=__UpperCamelCase				).raw				)
      return im


@torch.no_grad()
def      a__ (		__UpperCamelCase     ,      __UpperCamelCase     ,      __UpperCamelCase="groupvit-gcc-yfcc"     ,      __UpperCamelCase=False				):
      SCREAMING_SNAKE_CASE_          =  GroupViTConfig()
      SCREAMING_SNAKE_CASE_          =  GroupViTModel(__UpperCamelCase				).eval()

      SCREAMING_SNAKE_CASE_          =  torch.load(__UpperCamelCase     ,      map_location="cpu"				)["model"]
      SCREAMING_SNAKE_CASE_          =  convert_state_dict(__UpperCamelCase     ,      __UpperCamelCase				)
      SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  model.load_state_dict(__UpperCamelCase     ,      strict=__UpperCamelCase				)
      assert missing_keys == ["text_model.embeddings.position_ids"]
      assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(__UpperCamelCase				) == 0)

      # verify result
      SCREAMING_SNAKE_CASE_          =  CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32"				)
      SCREAMING_SNAKE_CASE_          =  prepare_img()
      SCREAMING_SNAKE_CASE_          =  processor(text=["a photo of a cat", "a photo of a dog"]     ,      images=__UpperCamelCase     ,      padding=__UpperCamelCase     ,      return_tensors="pt"				)

      with torch.no_grad():
            SCREAMING_SNAKE_CASE_          =  model(**__UpperCamelCase				)

      if model_name == "groupvit-gcc-yfcc":
            SCREAMING_SNAKE_CASE_          =  torch.tensor([[13.3523, 6.3629]]				)
      elif model_name == "groupvit-gcc-redcaps":
            SCREAMING_SNAKE_CASE_          =  torch.tensor([[16.1873, 8.6230]]				)
      else:
            raise ValueError(F'''Model name {model_name} not supported.'''				)
      assert torch.allclose(outputs.logits_per_image     ,      __UpperCamelCase     ,      atol=1E-3				)

      processor.save_pretrained(__UpperCamelCase				)
      model.save_pretrained(__UpperCamelCase				)
      print("Successfully saved processor and model to"     ,      __UpperCamelCase				)

      if push_to_hub:
            print("Pushing to the hub..."				)
            processor.push_to_hub(__UpperCamelCase     ,      organization="nielsr"				)
            model.push_to_hub(__UpperCamelCase     ,      organization="nielsr"				)


if __name__ == "__main__":
      A     :  List[Any]					     =       argparse.ArgumentParser()
      parser.add_argument(
          "--pytorch_dump_folder_path", default=None, type=str, help="Path to dump the processor and PyTorch model."
      )
      parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to GroupViT checkpoint")
      parser.add_argument(
          "--model_name",
          default="groupvit-gccy-fcc",
          type=str,
          help="Name of the model. Expecting either 'groupvit-gcc-yfcc' or 'groupvit-gcc-redcaps'",
      )
      parser.add_argument(
          "--push_to_hub",
          action="store_true",
          help="Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.",
      )
      A     :  Union[str, Any]					     =       parser.parse_args()

      convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)



from __future__ import annotations


def      a__ (		__UpperCamelCase				):
      SCREAMING_SNAKE_CASE_          =  str(__UpperCamelCase				)
      return n == n[::-1]


def      a__ (		__UpperCamelCase = 1_0_0_0_0_0_0				):
      SCREAMING_SNAKE_CASE_          =  0

      for i in range(1     ,      __UpperCamelCase				):
            if is_palindrome(__UpperCamelCase				) and is_palindrome(bin(__UpperCamelCase				).split("b"				)[1]				):
                  total += i
      return total


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


