


import argparse

import tensorflow as tf
import torch

from transformers import BertConfig, BertForMaskedLM
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertPooler,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


logging.set_verbosity_info()







def 						lowerCamelCase(   a__	,a__	,a__):
				def get_masked_lm_array(a__):
								_SCREAMING_SNAKE_CASE			  =f"masked_lm/{name}/.ATTRIBUTES/VARIABLE_VALUE"
								_SCREAMING_SNAKE_CASE			  =tf.train.load_variable(a__	,a__)

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE			  =array.transpose()

								return torch.from_numpy(a__)

				def get_encoder_array(a__):
								_SCREAMING_SNAKE_CASE			  =f"encoder/{name}/.ATTRIBUTES/VARIABLE_VALUE"
								_SCREAMING_SNAKE_CASE			  =tf.train.load_variable(a__	,a__)

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE			  =array.transpose()

								return torch.from_numpy(a__)

				def get_encoder_layer_array(a__	,a__):
								_SCREAMING_SNAKE_CASE			  =f"encoder/_transformer_layers/{layer_index}/{name}/.ATTRIBUTES/VARIABLE_VALUE"
								_SCREAMING_SNAKE_CASE			  =tf.train.load_variable(a__	,a__)

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE			  =array.transpose()

								return torch.from_numpy(a__)

				def get_encoder_attention_layer_array(a__	,a__	,a__):
								_SCREAMING_SNAKE_CASE			  =f"encoder/_transformer_layers/{layer_index}/_attention_layer/{name}/.ATTRIBUTES/VARIABLE_VALUE"
								_SCREAMING_SNAKE_CASE			  =tf.train.load_variable(a__	,a__)
								_SCREAMING_SNAKE_CASE			  =array.reshape(a__)

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE			  =array.transpose()

								return torch.from_numpy(a__)

				print(f"Loading model based on config from {config_path}...")
				_SCREAMING_SNAKE_CASE			  =BertConfig.from_json_file(a__)
				_SCREAMING_SNAKE_CASE			  =BertForMaskedLM(a__)

				# Layers
				for layer_index in range(0	,config.num_hidden_layers):
								_SCREAMING_SNAKE_CASE			  =model.bert.encoder.layer[layer_index]

								# Self-attention
								_SCREAMING_SNAKE_CASE			  =layer.attention.self

								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_query_dense/kernel'''	,self_attn.query.weight.data.shape)
								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_query_dense/bias'''	,self_attn.query.bias.data.shape)
								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_key_dense/kernel'''	,self_attn.key.weight.data.shape)
								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_key_dense/bias'''	,self_attn.key.bias.data.shape)
								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_value_dense/kernel'''	,self_attn.value.weight.data.shape)
								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_value_dense/bias'''	,self_attn.value.bias.data.shape)

								# Self-attention Output
								_SCREAMING_SNAKE_CASE			  =layer.attention.output

								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_output_dense/kernel'''	,self_output.dense.weight.data.shape)
								_SCREAMING_SNAKE_CASE			  =get_encoder_attention_layer_array(
								    a__	,'''_output_dense/bias'''	,self_output.dense.bias.data.shape)

								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_attention_layer_norm/gamma''')
								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_attention_layer_norm/beta''')

								# Intermediate
								_SCREAMING_SNAKE_CASE			  =layer.intermediate

								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_intermediate_dense/kernel''')
								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_intermediate_dense/bias''')

								# Output
								_SCREAMING_SNAKE_CASE			  =layer.output

								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_output_dense/kernel''')
								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_output_dense/bias''')

								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_output_layer_norm/gamma''')
								_SCREAMING_SNAKE_CASE			  =get_encoder_layer_array(a__	,'''_output_layer_norm/beta''')

				# Embeddings
				_SCREAMING_SNAKE_CASE			  =get_encoder_array('''_position_embedding_layer/embeddings''')
				_SCREAMING_SNAKE_CASE			  =get_encoder_array('''_type_embedding_layer/embeddings''')
				_SCREAMING_SNAKE_CASE			  =get_encoder_array('''_embedding_norm_layer/gamma''')
				_SCREAMING_SNAKE_CASE			  =get_encoder_array('''_embedding_norm_layer/beta''')

				# LM Head
				_SCREAMING_SNAKE_CASE			  =model.cls.predictions.transform

				_SCREAMING_SNAKE_CASE			  =get_masked_lm_array('''dense/kernel''')
				_SCREAMING_SNAKE_CASE			  =get_masked_lm_array('''dense/bias''')

				_SCREAMING_SNAKE_CASE			  =get_masked_lm_array('''layer_norm/gamma''')
				_SCREAMING_SNAKE_CASE			  =get_masked_lm_array('''layer_norm/beta''')

				_SCREAMING_SNAKE_CASE			  =get_masked_lm_array('''embedding_table''')

				# Pooling
				_SCREAMING_SNAKE_CASE			  =BertPooler(config=a__)
				_SCREAMING_SNAKE_CASE			  =get_encoder_array('''_pooler_layer/kernel''')
				_SCREAMING_SNAKE_CASE			  =get_encoder_array('''_pooler_layer/bias''')

				# Export final model
				model.save_pretrained(a__)

				# Integration test - should load without any errors ;)
				_SCREAMING_SNAKE_CASE			  =BertForMaskedLM.from_pretrained(a__)
				print(new_model.eval())

				print('''Model conversion was done sucessfully!''')


if __name__ == "__main__":
							snake_case_						:			Optional[int]													=							argparse.ArgumentParser()
							parser.add_argument(
							    '''--tf_checkpoint_path''', type=str, required=True, help='''Path to the TensorFlow Token Dropping checkpoint path.'''
							)
							parser.add_argument(
							    '''--bert_config_file''',
							    type=str,
							    required=True,
							    help='''The config json file corresponding to the BERT model. This specifies the model architecture.''',
							)
							parser.add_argument(
							    '''--pytorch_dump_path''',
							    type=str,
							    required=True,
							    help='''Path to the output PyTorch model.''',
							)
							snake_case_						:			int													=							parser.parse_args()
							convert_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)



from collections.abc import Generator







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =0, 1
				while True:
								_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =b, a + b
								yield b







def 						lowerCamelCase(   a__ = 1000):
				_SCREAMING_SNAKE_CASE			  =1
				_SCREAMING_SNAKE_CASE			  =fibonacci_generator()
				while len(str(next(a__))) < n:
								answer += 1
				return answer + 1


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