





import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp



def    SCREAMING_SNAKE_CASE							(			)		->						Any:
		__lowercase					=    ArgumentParser(
		    description=(
		        'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
		    )       )

		# Optional arguments for the launch helper
		parser.add_argument('--num_cores'	,      type=snake_case	,      default=1	,      help='Number of TPU cores to use (1 or 8).'       )

		# positional
		parser.add_argument(
		    'training_script'	,      type=snake_case	,      help=(
		        'The full path to the single TPU training '
		        'program/script to be launched in parallel, '
		        'followed by all the arguments for the '
		        'training script'
		    )	,      )

		# rest from the training program
		parser.add_argument('training_script_args'	,      nargs=snake_case       )

		return parser.parse_args()



def    SCREAMING_SNAKE_CASE							(			)		->						str:
		__lowercase					=    parse_args()

		# Import training_script as a module.
		__lowercase					=    Path(args.training_script       )
		sys.path.append(str(script_fpath.parent.resolve()       )       )
		__lowercase					=    script_fpath.stem
		__lowercase					=    importlib.import_module(snake_case       )

		# Patch sys.argv
		__lowercase					=    [args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores       )]

		xmp.spawn(mod._mp_fn	,      args=()	,      nprocs=args.num_cores       )


if __name__ == "__main__":
		main()











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()))}""")




