


import argparse
import os
import re

import torch
from flax.traverse_util import flatten_dict
from tax import checkpoints

from transformers import (
    AutoTokenizer,
    PixaStructConfig,
    PixaStructForConditionalGeneration,
    PixaStructImageProcessor,
    PixaStructProcessor,
    PixaStructTextConfig,
    PixaStructVisionConfig,
)







def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Optional[int]									=  checkpoints.load_tax_checkpoint(_A      )
							__snake_case						:     Dict									=  flatten_dict(_A      )
							return flax_params







def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Optional[Any]									=  {}

							__snake_case						:     int									=  {
							    "token_embedder": "embeddings",
							    "encoder_norm": "layernorm",
							    "kernel": "weight",
							    ".out": ".output",
							    "scale": "weight",
							    "embedders_0.pos_embedding": "row_embedder.weight",
							    "embedders_1.pos_embedding": "column_embedder.weight",
							}

							__snake_case						:     Optional[Any]									=  {
							    "query": "attention.query",
							    "key": "attention.key",
							    "value": "attention.value",
							    "output.dense": "output",
							    "encoder_decoder_attention.o": "encoder_decoder_attention.attention.o",
							    "pre_self_attention_layer_norm": "self_attention.layer_norm",
							    "pre_cross_attention_layer_norm": "encoder_decoder_attention.layer_norm",
							    "mlp.": "mlp.DenseReluDense.",
							    "pre_mlp_layer_norm": "mlp.layer_norm",
							    "self_attention.o": "self_attention.attention.o",
							    "decoder.embeddings.embedding": "decoder.embed_tokens.weight",
							    "decoder.relpos_bias.rel_embedding": "decoder.layer.0.self_attention.attention.relative_attention_bias.weight",
							    "decoder.decoder_norm.weight": "decoder.final_layer_norm.weight",
							    "decoder.logits_dense.weight": "decoder.lm_head.weight",
							}

							for key in flax_dict.keys():
														if "target" in key:
																					# remove the first prefix from the key
																					__snake_case						:     List[Any]									=  ".".join(key[1:]      )

																					# rename the key
																					for old, new in CONVERSION_MAPPING.items():
																												__snake_case						:     str									=  new_key.replace(_A				,      _A      )

																					if "decoder" in new_key:
																												for old, new in DECODER_CONVERSION_MAPPING.items():
																																			__snake_case						:     Optional[Any]									=  new_key.replace(_A				,      _A      )

																					if "layers" in new_key and "decoder" not in new_key:
																												# use regex to replace the layer number
																												__snake_case						:     str									=  re.sub(R"layers_(\d+)"				,      R"layer.\1"				,      _A      )
																												__snake_case						:     Optional[int]									=  new_key.replace("encoder"				,      "encoder.encoder"      )

																					elif "layers" in new_key and "decoder" in new_key:
																												# use regex to replace the layer number
																												__snake_case						:     List[Any]									=  re.sub(R"layers_(\d+)"				,      R"layer.\1"				,      _A      )

																					__snake_case						:     Optional[int]									=  flax_dict[key]

							__snake_case						:     Any									=  {}
							# convert converted_dict into torch format
							for key in converted_dict.keys():
														if ("embed_tokens" not in key) and ("embedder" not in key):
																					__snake_case						:     Optional[Any]									=  torch.from_numpy(converted_dict[key].T      )
														else:
																					__snake_case						:     int									=  torch.from_numpy(converted_dict[key]      )

							return converted_torch_dict







def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase=False				,      __lowerCamelCase=False      ):
							__snake_case						:     Dict									=  get_flax_param(_A      )

							if not use_large:
														__snake_case						:     Tuple									=  PixaStructVisionConfig()
														__snake_case						:     Dict									=  PixaStructTextConfig()
							else:
														__snake_case						:     Any									=  PixaStructVisionConfig(
														    hidden_size=1_5_3_6				,      d_ff=3_9_6_8				,      num_attention_heads=2_4				,      num_hidden_layers=1_8      )
														__snake_case						:     Optional[Any]									=  PixaStructTextConfig(hidden_size=1_5_3_6				,      d_ff=3_9_6_8				,      num_heads=2_4				,      num_layers=1_8      )
							__snake_case						:     Union[str, Any]									=  PixaStructConfig(
							    vision_config=encoder_config.to_dict()				,      text_config=decoder_config.to_dict()				,      is_vqa=_A      )

							__snake_case						:     List[Any]									=  PixaStructForConditionalGeneration(_A      )

							__snake_case						:     Union[str, Any]									=  rename_and_convert_flax_params(_A      )
							model.load_state_dict(_A      )

							__snake_case						:     Dict									=  AutoTokenizer.from_pretrained("ybelkada/test-pix2struct-tokenizer"      )
							__snake_case						:     int									=  PixaStructImageProcessor()
							__snake_case						:     List[Any]									=  PixaStructProcessor(image_processor=_A				,      tokenizer=_A      )

							if use_large:
														__snake_case						:     Any									=  4_0_9_6

							__snake_case						:     Any									=  True

							# mkdir if needed
							os.makedirs(_A				,      exist_ok=_A      )

							model.save_pretrained(_A      )
							processor.save_pretrained(_A      )

							print("Model saved in {}".format(_A      )      )


if __name__ == "__main__":
			_snake_case	:						int         =							argparse.ArgumentParser()
			parser.add_argument("--t5x_checkpoint_path", default=None, type=str, help="Path to the original T5x checkpoint.")
			parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
			parser.add_argument("--use_large", action="store_true", help="Use large model.")
			parser.add_argument("--is_vqa", action="store_true", help="Use large model.")
			_snake_case	:						Dict         =							parser.parse_args()

			convert_pixastruct_original_pytorch_checkpoint_to_hf(
			    args.tax_checkpoint_path, args.pytorch_dump_folder_path, args.use_large
			)



"""simple docstring"""



def 			_UpperCamelCase						(    _A = 1_0_0_0   )     ->	int:





    """simple docstring"""

    _UpperCAmelCase     ,_UpperCAmelCase        = 1, 1
    _UpperCAmelCase        = 2
    while True:
        _UpperCAmelCase        = 0
        _UpperCAmelCase        = fa + fa
        _UpperCAmelCase     ,_UpperCAmelCase        = fa, f
        index += 1
        for _ in str(_A   ):
            i += 1
        if i == n:
            break
    return index


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