

import argparse

import torch

from transformers import NystromformerConfig, NystromformerForMaskedLM


def 			__UpperCamelCase    (lowerCAmelCase					:  Union[str, Any]     )     ->  List[str]:
      if "model" in orig_key:
            A    =				orig_key.replace('model.',    ''     )
      if "norm1" in orig_key:
            A    =				orig_key.replace('norm1',    'attention.output.LayerNorm'     )
      if "norm2" in orig_key:
            A    =				orig_key.replace('norm2',    'output.LayerNorm'     )
      if "norm" in orig_key:
            A    =				orig_key.replace('norm',    'LayerNorm'     )
      if "transformer" in orig_key:
            A    =				orig_key.split('.'     )[0].split('_'     )[-1]
            A    =				orig_key.replace(f'''transformer_{layer_num}''',    f'''encoder.layer.{layer_num}'''     )
      if "mha.attn" in orig_key:
            A    =				orig_key.replace('mha.attn',    'attention.self'     )
      if "mha" in orig_key:
            A    =				orig_key.replace('mha',    'attention'     )
      if "W_q" in orig_key:
            A    =				orig_key.replace('W_q',    'self.query'     )
      if "W_k" in orig_key:
            A    =				orig_key.replace('W_k',    'self.key'     )
      if "W_v" in orig_key:
            A    =				orig_key.replace('W_v',    'self.value'     )
      if "ff1" in orig_key:
            A    =				orig_key.replace('ff1',    'intermediate.dense'     )
      if "ff2" in orig_key:
            A    =				orig_key.replace('ff2',    'output.dense'     )
      if "ff" in orig_key:
            A    =				orig_key.replace('ff',    'output.dense'     )
      if "mlm_class" in orig_key:
            A    =				orig_key.replace('mlm.mlm_class',    'cls.predictions.decoder'     )
      if "mlm" in orig_key:
            A    =				orig_key.replace('mlm',    'cls.predictions.transform'     )
      if "cls" not in orig_key:
            A    =				'nystromformer.' + orig_key

      return orig_key


def 			__UpperCamelCase    (lowerCAmelCase					:  Dict,    lowerCAmelCase					:  Tuple     )     ->  Tuple:
      for key in orig_state_dict.copy().keys():
            A    =				orig_state_dict.pop(lowerCAmelCase     )

            if ("pooler" in key) or ("sen_class" in key) or ("conv.bias" in key):
                  continue
            else:
                  A    =				val

      A    =				orig_state_dict['cls.predictions.decoder.bias']
      A    =				(
          torch.arange(config.max_position_embeddings     ).expand((1, -1)     ) + 2
      )

      return orig_state_dict


def 			__UpperCamelCase    (lowerCAmelCase					:  int,    lowerCAmelCase					:  Any,    lowerCAmelCase					:  Union[str, Any]     )     ->  Optional[int]:
      A    =				torch.load(lowerCAmelCase,    map_location='cpu'     )['model_state_dict']
      A    =				NystromformerConfig.from_json_file(lowerCAmelCase     )
      A    =				NystromformerForMaskedLM(lowerCAmelCase     )

      A    =				convert_checkpoint_helper(lowerCAmelCase,    lowerCAmelCase     )

      model.load_state_dict(lowerCAmelCase     )
      model.eval()
      model.save_pretrained(lowerCAmelCase     )

      print(f'''Checkpoint successfuly converted. Model saved at {pytorch_dump_path}'''     )


if __name__ == "__main__":
  _UpperCAmelCase    	=			argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--pytorch_model_path", default=None, type=str, required=True, help="Path to Nystromformer pytorch checkpoint."
  )
  parser.add_argument(
      "--config_file",
      default=None,
      type=str,
      required=True,
      help="The json file for Nystromformer model config.",
  )
  parser.add_argument(
      "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
  )
  _UpperCAmelCase    	=			parser.parse_args()
  convert_nystromformer_checkpoint(args.pytorch_model_path, args.config_file, args.pytorch_dump_path)






from math import floor, sqrt


def 			__UpperCamelCase    (lowerCAmelCase					:  int     )     ->  int:
      A    =				0.0
      A    =				1.0
      A    =				int(sqrt(lowerCAmelCase     )     )
      A    =				root
      A    =				0
      while integer_part != 2 * root:
            A    =				denominator * integer_part - numerator
            A    =				(n - numerator**2) / denominator
            A    =				int((root + numerator) / denominator     )
            period += 1
      return period


def 			__UpperCamelCase    (lowerCAmelCase					:  int = 10_000     )     ->  int:
      A    =				0
      for i in range(2,    n + 1     ):
            A    =				sqrt(lowerCAmelCase     )
            if sr - floor(lowerCAmelCase     ) != 0 and continuous_fraction_period(lowerCAmelCase     ) % 2 == 1:
                  count_odd_periods += 1
      return count_odd_periods


if __name__ == "__main__":
  print(F'''{solution(int(input().strip()))}''')



