





import argparse

import torch

from transformers import RoFormerConfig, RoFormerForMaskedLM, load_tf_weights_in_roformer
from transformers.utils import logging


logging.set_verbosity_info()



def    SCREAMING_SNAKE_CASE							(			snake_case	,      snake_case	,      snake_case       )		->						List[Any]:
		# Initialise PyTorch model
		__lowercase					=    RoFormerConfig.from_json_file(snake_case       )
		print(F"Building PyTorch model from configuration: {config}"       )
		__lowercase					=    RoFormerForMaskedLM(snake_case       )

		# Load weights from tf checkpoint
		load_tf_weights_in_roformer(snake_case	,      snake_case	,      snake_case       )

		# Save pytorch-model
		print(F"Save PyTorch model to {pytorch_dump_path}"       )
		torch.save(model.state_dict()	,      snake_case	,      _use_new_zipfile_serialization=snake_case       )


if __name__ == "__main__":
		SCREAMING_SNAKE_CASE_      :			int		  =      argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
		)
		parser.add_argument(
		    '''--bert_config_file''',
		    default=None,
		    type=str,
		    required=True,
		    help=(
		        '''The config json file corresponding to the pre-trained BERT model. \n'''
		        '''This specifies the model architecture.'''
		    ),
		)
		parser.add_argument(
		    '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
		)
		SCREAMING_SNAKE_CASE_      :			Optional[int]		  =      parser.parse_args()
		convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)











from math import floor, sqrt



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



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


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




