




import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling

def  UpperCAmelCase_							(				__UpperCAmelCase						:     str							) ->			int:
      SCREAMING_SNAKE_CASE_     						=      [2, 2, 6, 2] if 'tiny' in model_name else [2, 2, 18, 2]
      SCREAMING_SNAKE_CASE_     						=      True if 'large' in model_name or 'huge' in model_name else False
      SCREAMING_SNAKE_CASE_     						=      True if 'large' in model_name or 'huge' in model_name else False
      SCREAMING_SNAKE_CASE_     						=      True if 'large' in model_name or 'huge' in model_name else False

      if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
            if "fl3" in model_name:
                  SCREAMING_SNAKE_CASE_     						=      [3, 3, 3, 3]
                  SCREAMING_SNAKE_CASE_     						=      [5, 5, 5, 5]
            elif "fl4" in model_name:
                  SCREAMING_SNAKE_CASE_     						=      [4, 4, 4, 4]
                  SCREAMING_SNAKE_CASE_     						=      [3, 3, 3, 3]

      if "tiny" in model_name or "small" in model_name or "base" in model_name:
            SCREAMING_SNAKE_CASE_     						=      [3, 3, 3, 3]
            if "lrf" in model_name:
                  SCREAMING_SNAKE_CASE_     						=      [3, 3, 3, 3]
            else:
                  SCREAMING_SNAKE_CASE_     						=      [2, 2, 2, 2]

      if "tiny" in model_name:
            SCREAMING_SNAKE_CASE_     						=      96
      elif "small" in model_name:
            SCREAMING_SNAKE_CASE_     						=      96
      elif "base" in model_name:
            SCREAMING_SNAKE_CASE_     						=      1_28
      elif "large" in model_name:
            SCREAMING_SNAKE_CASE_     						=      1_92
      elif "xlarge" in model_name:
            SCREAMING_SNAKE_CASE_     						=      2_56
      elif "huge" in model_name:
            SCREAMING_SNAKE_CASE_     						=      3_52

      # set label information
      SCREAMING_SNAKE_CASE_     						=      'huggingface/label-files'
      if "large" in model_name or "huge" in model_name:
            SCREAMING_SNAKE_CASE_     						=      'imagenet-22k-id2label.json'
      else:
            SCREAMING_SNAKE_CASE_     						=      'imagenet-1k-id2label.json'

      SCREAMING_SNAKE_CASE_     						=      json.load(open(hf_hub_download(__UpperCAmelCase      ,      __UpperCAmelCase      ,      repo_type='dataset'							)      ,      'r'							)							)
      SCREAMING_SNAKE_CASE_     						=      {int(__UpperCAmelCase							): v for k, v in idalabel.items()}
      SCREAMING_SNAKE_CASE_     						=      {v: k for k, v in idalabel.items()}

      SCREAMING_SNAKE_CASE_     						=      FocalNetConfig(
          embed_dim=__UpperCAmelCase      ,      depths=__UpperCAmelCase      ,      focal_levels=__UpperCAmelCase      ,      focal_windows=__UpperCAmelCase      ,      use_conv_embed=__UpperCAmelCase      ,      idalabel=__UpperCAmelCase      ,      labelaid=__UpperCAmelCase      ,      use_post_layernorm=__UpperCAmelCase      ,      use_layerscale=__UpperCAmelCase      ,      )

      return config

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			Optional[Any]:
      if "patch_embed.proj" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('patch_embed.proj'      ,      'embeddings.patch_embeddings.projection'							)
      if "patch_embed.norm" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('patch_embed.norm'      ,      'embeddings.norm'							)
      if "layers" in name:
            SCREAMING_SNAKE_CASE_     						=      'encoder.' + name
      if "encoder.layers" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('encoder.layers'      ,      'encoder.stages'							)
      if "downsample.proj" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('downsample.proj'      ,      'downsample.projection'							)
      if "blocks" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('blocks'      ,      'layers'							)
      if "modulation.f.weight" in name or "modulation.f.bias" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('modulation.f'      ,      'modulation.projection_in'							)
      if "modulation.h.weight" in name or "modulation.h.bias" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('modulation.h'      ,      'modulation.projection_context'							)
      if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('modulation.proj'      ,      'modulation.projection_out'							)

      if name == "norm.weight":
            SCREAMING_SNAKE_CASE_     						=      'layernorm.weight'
      if name == "norm.bias":
            SCREAMING_SNAKE_CASE_     						=      'layernorm.bias'

      if "head" in name:
            SCREAMING_SNAKE_CASE_     						=      name.replace('head'      ,      'classifier'							)
      else:
            SCREAMING_SNAKE_CASE_     						=      'focalnet.' + name

      return name

def  UpperCAmelCase_							(				__UpperCAmelCase						:     Any      ,      __UpperCAmelCase						:     Union[str, Any]      ,      __UpperCAmelCase						:     Dict=False							) ->			Optional[Any]:
      # fmt: off
      SCREAMING_SNAKE_CASE_     						=      {
          'focalnet-tiny': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth',
          'focalnet-tiny-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth',
          'focalnet-small': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth',
          'focalnet-small-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth',
          'focalnet-base': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth',
          'focalnet-base-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth',
          'focalnet-large-lrf-fl3': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth',
          'focalnet-large-lrf-fl4': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth',
          'focalnet-xlarge-lrf-fl3': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth',
          'focalnet-xlarge-lrf-fl4': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth',
      }
      # fmt: on

      SCREAMING_SNAKE_CASE_     						=      model_name_to_url[model_name]
      print('Checkpoint URL: '      ,      __UpperCAmelCase							)
      SCREAMING_SNAKE_CASE_     						=      torch.hub.load_state_dict_from_url(__UpperCAmelCase      ,      map_location='cpu'							)['model']

      # rename keys
      for key in state_dict.copy().keys():
            SCREAMING_SNAKE_CASE_     						=      state_dict.pop(__UpperCAmelCase							)
            SCREAMING_SNAKE_CASE_     						=      val

      SCREAMING_SNAKE_CASE_     						=      get_focalnet_config(__UpperCAmelCase							)
      SCREAMING_SNAKE_CASE_     						=      FocalNetForImageClassification(__UpperCAmelCase							)
      model.eval()

      # load state dict
      model.load_state_dict(__UpperCAmelCase							)

      # verify conversion
      SCREAMING_SNAKE_CASE_     						=      'http://images.cocodataset.org/val2017/000000039769.jpg'

      SCREAMING_SNAKE_CASE_     						=      BitImageProcessor(
          do_resize=__UpperCAmelCase      ,      size={'shortest_edge': 2_56}      ,      resample=PILImageResampling.BILINEAR      ,      do_center_crop=__UpperCAmelCase      ,      crop_size=2_24      ,      do_normalize=__UpperCAmelCase      ,      image_mean=__UpperCAmelCase      ,      image_std=__UpperCAmelCase      ,      )
      SCREAMING_SNAKE_CASE_     						=      Image.open(requests.get(__UpperCAmelCase      ,      stream=__UpperCAmelCase							).raw							)
      SCREAMING_SNAKE_CASE_     						=      processor(images=__UpperCAmelCase      ,      return_tensors='pt'							)

      SCREAMING_SNAKE_CASE_     						=      transforms.Compose(
          [
              transforms.Resize(2_56							),
              transforms.CenterCrop(2_24							),
              transforms.ToTensor(),
              transforms.Normalize(mean=[0.4_8_5, 0.4_5_6, 0.4_0_6]      ,      std=[0.2_2_9, 0.2_2_4, 0.2_2_5]							),
          ]							)

      SCREAMING_SNAKE_CASE_     						=      image_transforms(__UpperCAmelCase							).unsqueeze(0							)

      # verify pixel_values
      assert torch.allclose(inputs.pixel_values      ,      __UpperCAmelCase      ,      atol=1E-4							)

      SCREAMING_SNAKE_CASE_     						=      model(**__UpperCAmelCase							)

      SCREAMING_SNAKE_CASE_     						=      outputs.logits.argmax(-1							).item()
      print('Predicted class:'      ,      model.config.idalabel[predicted_class_idx]							)

      print('First values of logits:'      ,      outputs.logits[0, :3]							)

      if model_name == "focalnet-tiny":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]							)
      elif model_name == "focalnet-tiny-lrf":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([1.1_6_6_9, 0.0_1_2_5, -0.1_6_9_5]							)
      elif model_name == "focalnet-small":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([0.4_9_1_7, -0.0_4_3_0, 0.1_3_4_1]							)
      elif model_name == "focalnet-small-lrf":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([-0.2_5_8_8, -0.5_3_4_2, -0.2_3_3_1]							)
      elif model_name == "focalnet-base":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([-0.1_6_5_5, -0.4_0_9_0, -0.1_7_3_0]							)
      elif model_name == "focalnet-base-lrf":
            SCREAMING_SNAKE_CASE_     						=      torch.tensor([0.5_3_0_6, -0.0_4_8_3, -0.3_9_2_8]							)
      assert torch.allclose(outputs.logits[0, :3]      ,      __UpperCAmelCase      ,      atol=1E-4							)
      print('Looks ok!'							)

      if pytorch_dump_folder_path is not None:
            print(f"Saving model and processor of {model_name} to {pytorch_dump_folder_path}"							)
            model.save_pretrained(__UpperCAmelCase							)
            processor.save_pretrained(__UpperCAmelCase							)

      if push_to_hub:
            print(f"Pushing model and processor of {model_name} to the hub..."							)
            model.push_to_hub(f"{model_name}"							)
            processor.push_to_hub(f"{model_name}"							)


if __name__ == "__main__":
   lowerCamelCase__			:       Optional[Any]         =							argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--model_name',
       default='focalnet-tiny',
       type=str,
       help='Name of the FocalNet model you\'d like to convert.',
   )
   parser.add_argument(
       '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
   )
   parser.add_argument(
       '--push_to_hub',
       action='store_true',
       help='Whether to push the model and processor to the hub.',
   )

   lowerCamelCase__			:       Union[str, Any]         =							parser.parse_args()
   convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





def  UpperCAmelCase_							(				) ->			int:
      return 1

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else two_pence(x - 2							) + one_pence()

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else five_pence(x - 5							) + two_pence(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else ten_pence(x - 10							) + five_pence(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else twenty_pence(x - 20							) + ten_pence(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else fifty_pence(x - 50							) + twenty_pence(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else one_pound(x - 1_00							) + fifty_pence(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int							) ->			int:
      return 0 if x < 0 else two_pound(x - 2_00							) + one_pound(__UpperCAmelCase							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int = 2_00							) ->			int:
      return two_pound(__UpperCAmelCase							)


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