



import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
 import torch_xla.core.xla_model as xm  # noqa: F401

 __snake_case		:List[str] 						=	True
except ImportError:
 __snake_case		:Dict 						=	False


# Cache this result has it's a C FFI call which can be pretty time-consuming
__snake_case		:str 						=	torch.distributed.is_available()





def 	__snake_case      (     _UpperCAmelCase							):
    # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
    __a					=							importlib.util.find_spec(_UpperCAmelCase							) is not None
    if package_exists:
        try:
            __a					=							importlib.metadata.metadata(_UpperCAmelCase							)
            return True
        except importlib.metadata.PackageNotFoundError:
            return False





def 	__snake_case      (     ):
    return _torch_distributed_available





def 	__snake_case      (     ):
    try:
        pass
    except ImportError:
        print(
            '''Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not'''
            ''' detected. If you see \"ValueError: Invalid backend: \'ccl\'\" error, please install Intel(R) oneCCL'''
            ''' Bindings for PyTorch*.'''							)
    return (
        importlib.util.find_spec('''torch_ccl'''							) is not None
        or importlib.util.find_spec('''oneccl_bindings_for_pytorch'''							) is not None
    )





def 	__snake_case      (     ):
    return importlib.metadata.version('''oneccl_bind_pt'''							)





def 	__snake_case      (     ):
    return _is_package_available('''transformer_engine'''							)





@lru_cache
def 	__snake_case      (     _UpperCAmelCase=True							):
    # Due to bugs on the amp series GPUs, we disable torch-xla on them
    if torch.cuda.is_available():
        return False
    if _tpu_available and check_device:
        try:
            # Will raise a RuntimeError if no XLA configuration is found
            __a					=							xm.xla_device()
            return True
        except RuntimeError:
            return False
    return _tpu_available





def 	__snake_case      (     ):
    return _is_package_available('''deepspeed'''							)





def 	__snake_case      (     _UpperCAmelCase=False							):
    if is_tpu_available():
        return not ignore_tpu
    if torch.cuda.is_available():
        return torch.cuda.is_bfaa_supported()
    if is_npu_available():
        return False
    return True





def 	__snake_case      (     ):
    __a					=							_is_package_available('''bitsandbytes'''							)
    if package_exists:
        __a					=							version.parse(importlib.metadata.version('''bitsandbytes'''							)							)
        return compare_versions(_UpperCAmelCase  ,					'''>='''  ,					'''0.39.0'''							)
    return False





def 	__snake_case      (     ):
    __a					=							_is_package_available('''bitsandbytes'''							)
    if package_exists:
        __a					=							version.parse(importlib.metadata.version('''bitsandbytes'''							)							)
        return compare_versions(_UpperCAmelCase  ,					'''>='''  ,					'''0.37.2'''							)
    return False





def 	__snake_case      (     ):
    return _is_package_available('''bitsandbytes'''							)





def 	__snake_case      (     ):
    if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''  ,					'''False'''							)							) == 1:
        __a					=							importlib.util.find_spec('''megatron'''							) is not None
        if package_exists:
            try:
                __a					=							parse(importlib.metadata.version('''megatron-lm'''							)							)
                return compare_versions(_UpperCAmelCase  ,					'''>='''  ,					'''2.2.0'''							)
            except Exception as e:
                warnings.warn(f'Parse Megatron version failed. Exception:{e}'							)
                return False





def 	__snake_case      (     ):
    return _is_package_available('''safetensors'''							)





def 	__snake_case      (     ):
    return _is_package_available('''transformers'''							)





def 	__snake_case      (     ):
    return _is_package_available('''datasets'''							)





def 	__snake_case      (     ):
    return _is_package_available('''aim'''							)





def 	__snake_case      (     ):
    return _is_package_available('''tensorboard'''							) or _is_package_available('''tensorboardX'''							)





def 	__snake_case      (     ):
    return _is_package_available('''wandb'''							)





def 	__snake_case      (     ):
    return _is_package_available('''comet_ml'''							)





def 	__snake_case      (     ):
    return _is_package_available('''boto3'''							)





def 	__snake_case      (     ):
    if _is_package_available('''rich'''							):
        if "ACCELERATE_DISABLE_RICH" in os.environ:
            warnings.warn(
                '''`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`.'''							)
            return not parse_flag_from_env('''ACCELERATE_DISABLE_RICH'''  ,					_UpperCAmelCase							)
        return parse_flag_from_env('''ACCELERATE_ENABLE_RICH'''  ,					_UpperCAmelCase							)
    return False





def 	__snake_case      (     ):
    return _is_package_available('''sagemaker'''							)





def 	__snake_case      (     ):
    return _is_package_available('''tqdm'''							)





def 	__snake_case      (     ):
    return _is_package_available('''mlflow'''							)





def 	__snake_case      (     ):
    return is_torch_version('''>='''  ,					'''1.12'''							) and torch.backends.mps.is_available() and torch.backends.mps.is_built()





def 	__snake_case      (     ):
    def get_major_and_minor_from_version(_UpperCAmelCase							):
        return str(version.parse(_UpperCAmelCase							).major							) + "." + str(version.parse(_UpperCAmelCase							).minor							)

    __a					=							importlib.metadata.version('''torch'''							)
    if importlib.util.find_spec('''intel_extension_for_pytorch'''							) is None:
        return False
    __a					=							'''N/A'''
    try:
        __a					=							importlib.metadata.version('''intel_extension_for_pytorch'''							)
    except importlib.metadata.PackageNotFoundError:
        return False
    __a					=							get_major_and_minor_from_version(_torch_version							)
    __a					=							get_major_and_minor_from_version(_ipex_version							)
    if torch_major_and_minor != ipex_major_and_minor:
        warnings.warn(
            f'Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,'
            f' but PyTorch {_torch_version} is found. Please switch to the matching version and run again.'							)
        return False
    return True





@lru_cache
def 	__snake_case      (     _UpperCAmelCase=False							):
    if importlib.util.find_spec('''torch'''							) is None or importlib.util.find_spec('''torch_npu'''							) is None:
        return False

    import torch
    import torch_npu  # noqa: F401

    if check_device:
        try:
            # Will raise a RuntimeError if no NPU is found
            __a					=							torch.npu.device_count()
            return torch.npu.is_available()
        except RuntimeError:
            return False
    return hasattr(_UpperCAmelCase  ,					'''npu'''							) and torch.npu.is_available()





@lru_cache
def 	__snake_case      (     _UpperCAmelCase=False							):
    if not parse_flag_from_env('''ACCELERATE_USE_XPU'''  ,					default=_UpperCAmelCase							):
        return False
    if is_ipex_available():
        import torch

        if is_torch_version('''<='''  ,					'''1.12'''							):
            return False
    else:
        return False

    import intel_extension_for_pytorch  # noqa: F401

    if check_device:
        try:
            # Will raise a RuntimeError if no XPU  is found
            __a					=							torch.xpu.device_count()
            return torch.xpu.is_available()
        except RuntimeError:
            return False
    return hasattr(_UpperCAmelCase  ,					'''xpu'''							) and torch.xpu.is_available()










from math import floor, sqrt





def 	__snake_case      (     _UpperCAmelCase							):
    __a					=							0.0
    __a					=							1.0
    __a					=							int(sqrt(_UpperCAmelCase							)							)
    __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 	__snake_case      (     _UpperCAmelCase = 10000							):
    __a					=							0
    for i in range(2  ,					n + 1							):
        __a					=							sqrt(_UpperCAmelCase							)
        if sr - floor(_UpperCAmelCase							) != 0 and continuous_fraction_period(_UpperCAmelCase							) % 2 == 1:
            count_odd_periods += 1
    return count_odd_periods


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





