

import argparse
import json
import os
from collections import OrderedDict

import torch

from transformers import LukeConfig, LukeForMaskedLM, MLukeTokenizer, XLMRobertaTokenizer
from transformers.tokenization_utils_base import AddedToken




@torch.no_grad()
def 			UpperCAmelCase__				(			_A      : Union[str, Any]	,      _A      : str	,      _A      : List[str]	,      _A      : Optional[int]	,      _A      : Union[str, Any]							):





  '''simple docstring'''







  with open(_A							) as metadata_file:
    a__  =json.load(_A							)
  a__  =LukeConfig(use_entity_aware_attention=_A	,      **metadata['''model_config''']							)

  # Load in the weights from the checkpoint_path
  a__  =torch.load(_A	,      map_location='''cpu'''							)['''module''']

  # Load the entity vocab file
  a__  =load_original_entity_vocab(_A							)
  # add an entry for [MASK2]
  a__  =max(entity_vocab.values()							) + 1
  config.entity_vocab_size += 1

  a__  =XLMRobertaTokenizer.from_pretrained(metadata['''model_config''']['''bert_model_name''']							)

  # Add special tokens to the token vocabulary for downstream tasks
  a__  =AddedToken('''<ent>'''	,      lstrip=_A	,      rstrip=_A							)
  a__  =AddedToken('''<ent2>'''	,      lstrip=_A	,      rstrip=_A							)
  tokenizer.add_special_tokens({'''additional_special_tokens''': [entity_token_a, entity_token_a]}							)
  config.vocab_size += 2

  print(F"""Saving tokenizer to {pytorch_dump_folder_path}"""							)
  tokenizer.save_pretrained(_A							)
  with open(os.path.join(_A	,      '''tokenizer_config.json'''							)	,      '''r'''							) as f:
    a__  =json.load(_A							)
  a__  ='''MLukeTokenizer'''
  with open(os.path.join(_A	,      '''tokenizer_config.json'''							)	,      '''w'''							) as f:
    json.dump(_A	,      _A							)

  with open(os.path.join(_A	,      MLukeTokenizer.vocab_files_names['''entity_vocab_file''']							)	,      '''w'''							) as f:
    json.dump(_A	,      _A							)

  a__  =MLukeTokenizer.from_pretrained(_A							)

  # Initialize the embeddings of the special tokens
  a__  =tokenizer.convert_tokens_to_ids(['''@''']							)[0]
  a__  =tokenizer.convert_tokens_to_ids(['''#''']							)[0]

  a__  =state_dict['''embeddings.word_embeddings.weight''']
  a__  =word_emb[ent_init_index].unsqueeze(0							)
  a__  =word_emb[enta_init_index].unsqueeze(0							)
  a__  =torch.cat([word_emb, ent_emb, enta_emb]							)
  # add special tokens for 'entity_predictions.bias'
  for bias_name in ["lm_head.decoder.bias", "lm_head.bias"]:
    a__  =state_dict[bias_name]
    a__  =decoder_bias[ent_init_index].unsqueeze(0							)
    a__  =decoder_bias[enta_init_index].unsqueeze(0							)
    a__  =torch.cat([decoder_bias, ent_decoder_bias, enta_decoder_bias]							)

  # Initialize the query layers of the entity-aware self-attention mechanism
  for layer_index in range(config.num_hidden_layers							):
    for matrix_name in ["query.weight", "query.bias"]:
      a__  =F"""encoder.layer.{layer_index}.attention.self."""
      a__  =state_dict[prefix + matrix_name]
      a__  =state_dict[prefix + matrix_name]
      a__  =state_dict[prefix + matrix_name]

    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
  a__  =state_dict['''entity_embeddings.entity_embeddings.weight''']
  a__  =entity_emb[entity_vocab['''[MASK]''']].unsqueeze(0							)
  a__  =torch.cat([entity_emb, entity_mask_emb]							)
  # add [MASK2] for 'entity_predictions.bias'
  a__  =state_dict['''entity_predictions.bias''']
  a__  =entity_prediction_bias[entity_vocab['''[MASK]''']].unsqueeze(0							)
  a__  =torch.cat([entity_prediction_bias, entity_mask_bias]							)

  a__  =LukeForMaskedLM(config=_A							).eval()

  state_dict.pop('''entity_predictions.decoder.weight'''							)
  state_dict.pop('''lm_head.decoder.weight'''							)
  state_dict.pop('''lm_head.decoder.bias'''							)
  a__  =OrderedDict()
  for key, value in state_dict.items():
    if not (key.startswith('''lm_head'''							) or key.startswith('''entity_predictions'''							)):
      a__  =state_dict[key]
    else:
      a__  =state_dict[key]

  a__,      a__  =model.load_state_dict(_A	,      strict=_A							)

  if set(_A							) != {"luke.embeddings.position_ids"}:
    raise ValueError(F"""Unexpected unexpected_keys: {unexpected_keys}"""							)
  if set(_A							) != {
      "lm_head.decoder.weight",
      "lm_head.decoder.bias",
      "entity_predictions.decoder.weight",
  }:
    raise ValueError(F"""Unexpected missing_keys: {missing_keys}"""							)

  model.tie_weights()
  assert (model.luke.embeddings.word_embeddings.weight == model.lm_head.decoder.weight).all()
  assert (model.luke.entity_embeddings.entity_embeddings.weight == model.entity_predictions.decoder.weight).all()

  # Check outputs
  a__  =MLukeTokenizer.from_pretrained(_A	,      task='''entity_classification'''							)

  a__  ='''ISO 639-3 uses the code fas for the dialects spoken across Iran and アフガニスタン (Afghanistan).'''
  a__  =(0, 9)
  a__  =tokenizer(_A	,      entity_spans=[span]	,      return_tensors='''pt'''							)

  a__  =model(**_A							)

  # Verify word hidden states
  if model_size == "large":
    raise NotImplementedError
  else:  # base
    a__  =torch.Size((1, 33, 7_68)							)
    a__  =torch.tensor([[0.0_892, 0.0_596, -0.2_819], [0.0_134, 0.1_199, 0.0_573], [-0.0_169, 0.0_927, 0.0_644]]							)

  if not (outputs.last_hidden_state.shape == expected_shape):
    raise ValueError(
        F"""Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}"""							)
  if not torch.allclose(outputs.last_hidden_state[0, :3, :3]	,      _A	,      atol=1E-4							):
    raise ValueError

  # Verify entity hidden states
  if model_size == "large":
    raise NotImplementedError
  else:  # base
    a__  =torch.Size((1, 1, 7_68)							)
    a__  =torch.tensor([[-0.1_482, 0.0_609, 0.0_322]]							)

  if not (outputs.entity_last_hidden_state.shape == expected_shape):
    raise ValueError(
        F"""Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is"""
        F""" {expected_shape}"""							)
  if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3]	,      _A	,      atol=1E-4							):
    raise ValueError

  # Verify masked word/entity prediction
  a__  =MLukeTokenizer.from_pretrained(_A							)
  a__  ='''Tokyo is the capital of <mask>.'''
  a__  =(24, 30)
  a__  =tokenizer(_A	,      entity_spans=[span]	,      return_tensors='''pt'''							)

  a__  =model(**_A							)

  a__  =encoding['''input_ids'''][0].tolist()
  a__  =input_ids.index(tokenizer.convert_tokens_to_ids('''<mask>'''							)							)
  a__  =outputs.logits[0][mask_position_id].argmax(dim=-1							)
  assert "Japan" == tokenizer.decode(_A							)

  a__  =outputs.entity_logits[0][0].argmax().item()
  a__  =[
      entity for entity, entity_id in tokenizer.entity_vocab.items() if entity_id == predicted_entity_id
  ]
  assert [e for e in multilingual_predicted_entities if e.startswith('''en:'''							)][0] == "en:Japan"

  # Finally, save our PyTorch model and tokenizer
  print('''Saving PyTorch model to {}'''.format(_A							)							)
  model.save_pretrained(_A							)




def 			UpperCAmelCase__				(			_A      : Optional[Any]							):





  '''simple docstring'''







  a__  =['''[MASK]''', '''[PAD]''', '''[UNK]''']

  a__  =[json.loads(_A							) for line in open(_A							)]

  a__  ={}
  for entry in data:
    a__  =entry['''id''']
    for entity_name, language in entry["entities"]:
      if entity_name in SPECIAL_TOKENS:
        a__  =entity_id
        break
      a__  =F"""{language}:{entity_name}"""
      a__  =entity_id
  return new_mapping


if __name__ == "__main__":
       lowerCamelCase           =					argparse.ArgumentParser()
       # Required parameters
       parser.add_argument('''--checkpoint_path''', type=str, help='''Path to a pytorch_model.bin file.''')
       parser.add_argument(
           '''--metadata_path''', default=None, type=str, help='''Path to a metadata.json file, defining the configuration.'''
       )
       parser.add_argument(
           '''--entity_vocab_path''',
           default=None,
           type=str,
           help='''Path to an entity_vocab.tsv file, containing the entity vocabulary.''',
       )
       parser.add_argument(
           '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to where to dump the output PyTorch model.'''
       )
       parser.add_argument(
           '''--model_size''', default='''base''', type=str, choices=['''base''', '''large'''], help='''Size of the model to be converted.'''
       )
       lowerCamelCase           =					parser.parse_args()
       convert_luke_checkpoint(
           args.checkpoint_path,
           args.metadata_path,
           args.entity_vocab_path,
           args.pytorch_dump_folder_path,
           args.model_size,
       )



from math import factorial




def 			UpperCAmelCase__				(			_A      : int = 1_00							):





  '''simple docstring'''







  return sum(int(_A							) for x in str(factorial(_A							)							)							)


if __name__ == "__main__":
       print(solution(int(input('''Enter the Number: ''').strip())))
