





import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						Optional[int]:


   '''simple docstring'''







   __A ,						__A ,						__A				 =       pt_attn_layer.in_proj_weight.chunk(3    ,	dim=0     )
   __A ,						__A ,						__A				 =       pt_attn_layer.in_proj_bias.chunk(3    ,	dim=0     )

   __A				 =       pt_attn_layer.out_proj.weight
   __A				 =       pt_attn_layer.out_proj.bias

   __A				 =       q_proj
   __A				 =       q_proj_bias

   __A				 =       k_proj
   __A				 =       k_proj_bias

   __A				 =       v_proj
   __A				 =       v_proj_bias

   __A				 =       out_proj_weights
   __A				 =       out_proj_bias
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						List[str]:


   '''simple docstring'''







   copy_linear(hf_mlp.fca    ,	pt_mlp.c_fc     )
   copy_linear(hf_mlp.fca    ,	pt_mlp.c_proj     )
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						Dict:


   '''simple docstring'''







   __A				 =       pt_linear.weight
   __A				 =       pt_linear.bias
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						List[str]:


   '''simple docstring'''







   copy_linear(hf_layer.layer_norma    ,	pt_layer.ln_a     )
   copy_linear(hf_layer.layer_norma    ,	pt_layer.ln_a     )

   # copy MLP
   copy_mlp(hf_layer.mlp    ,	pt_layer.mlp     )

   # copy attn
   copy_attn_layer(hf_layer.self_attn    ,	pt_layer.attn     )
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						int:


   '''simple docstring'''







   for hf_layer, pt_layer in zip(snake_case    ,	snake_case     ):
      copy_layer(snake_case    ,	snake_case     )
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						List[str]:


   '''simple docstring'''







   __A				 =       pt_model.token_embedding.weight
   __A				 =       pt_model.positional_embedding

   # copy layer norm
   copy_linear(hf_encoder.final_layer_norm    ,	pt_model.ln_final     )

   # copy hidden layers
   copy_layers(hf_encoder.encoder.layers    ,	pt_model.transformer.resblocks     )
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						str:


   '''simple docstring'''







   __A				 =       pt_model.text_projection.data.T

   # copy text encoder
   copy_encoder(hf_model.text_model    ,	snake_case     )
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						Optional[int]:


   '''simple docstring'''







   __A				 =       pt_model.visual.proj.data.T

   # copy layer norms
   copy_linear(hf_model.vision_model.pre_layrnorm    ,	pt_model.visual.ln_pre     )
   copy_linear(hf_model.vision_model.post_layernorm    ,	pt_model.visual.ln_post     )

   # copy embeds
   __A				 =       pt_model.visual.conva.weight.data
   __A				 =       pt_model.visual.class_embedding
   __A				 =       pt_model.visual.positional_embedding.data

   # copy encoder
   copy_layers(hf_model.vision_model.encoder.layers    ,	pt_model.visual.transformer.resblocks     )
@torch.no_grad()
def 				__UpperCamelCase  (		snake_case    ,	snake_case    ,	snake_case=None     )  ->						List[Any]:


   '''simple docstring'''







   if config_path is not None:
      __A				 =       CLIPConfig.from_pretrained(snake_case     )
   else:
      __A				 =       CLIPConfig(projection_dim=5_1_2    ,	text_config={}    ,	vision_config={}     )

   __A				 =       CLIPModel(snake_case     ).eval()

   __A ,						__A				 =       load(snake_case    ,	device='''cpu'''    ,	jit=snake_case     )
   __A				 =       pt_model.eval()

   copy_text_model_and_projection(snake_case    ,	snake_case     )
   copy_vison_model_and_projection(snake_case    ,	snake_case     )
   __A				 =       pt_model.logit_scale

   __A				 =       torch.arange(0    ,	7_7     ).unsqueeze(0     )
   __A				 =       torch.randn(1    ,	3    ,	2_2_4    ,	2_2_4     )

   __A				 =       hf_model(input_ids=snake_case    ,	pixel_values=snake_case    ,	return_dict=snake_case     )
   __A				 =       hf_outputs.logits_per_image
   __A				 =       hf_outputs.logits_per_text
   __A ,						__A				 =       pt_model(snake_case    ,	snake_case     )

   assert torch.allclose(snake_case    ,	snake_case    ,	atol=1E-3     )
   assert torch.allclose(snake_case    ,	snake_case    ,	atol=1E-3     )

   hf_model.save_pretrained(snake_case     )


if __name__ == "__main__":
    _UpperCamelCase   :							Union[str, Any]     =	argparse.ArgumentParser()
    parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
    parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
    parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
    _UpperCamelCase   :							List[Any]     =	parser.parse_args()

    convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)








def 				__UpperCamelCase  (		snake_case = 1_0_0     )  ->						int:


   '''simple docstring'''







   __A				 =       [[0 for _ in range(snake_case     )] for _ in range(m + 1     )]
   for i in range(m + 1     ):
      __A				 =       1

   for n in range(m + 1     ):
      for k in range(1    ,	snake_case     ):
         memo[n][k] += memo[n][k - 1]
         if n > k:
            memo[n][k] += memo[n - k - 1][k]

   return memo[m][m - 1] - 1


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

