





from math import floor, sqrt





def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__				)						->       int:







			'''simple docstring'''

			UpperCAmelCase     	=       0.0
			UpperCAmelCase     	=       1.0
			UpperCAmelCase     	=       int(sqrt(UpperCamelCase__				)				)
			UpperCAmelCase     	=       root
			UpperCAmelCase     	=       0
			while integer_part != 2 * root:
						UpperCAmelCase     	=       denominator * integer_part - numerator
						UpperCAmelCase     	=       (n - numerator**2) / denominator
						UpperCAmelCase     	=       int((root + numerator) / denominator				)
						period += 1
			return period





def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__ = 1_0000				)						->       int:







			'''simple docstring'''

			UpperCAmelCase     	=       0
			for i in range(2    ,    n + 1				):
						UpperCAmelCase     	=       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()))}')










import os
from shutil import copyfile
from typing import Optional, Tuple

from ...file_utils import is_sentencepiece_available
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging


if is_sentencepiece_available():
				from .tokenization_deberta_va import DebertaVaTokenizer
else:
				__A       :					Optional[int]     					=     None

__A       :					Dict     					=     logging.get_logger(__name__)

__A       :					Union[str, Any]     					=     {"vocab_file": "spm.model", "tokenizer_file": "tokenizer.json"}

__A       :					Union[str, Any]     					=     {
    "vocab_file": {
        "microsoft/deberta-v2-xlarge": "https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/spm.model",
        "microsoft/deberta-v2-xxlarge": "https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/spm.model",
        "microsoft/deberta-v2-xlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/spm.model"
        ),
        "microsoft/deberta-v2-xxlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/spm.model"
        ),
    }
}

__A       :					List[Any]     					=     {
    "microsoft/deberta-v2-xlarge": 512,
    "microsoft/deberta-v2-xxlarge": 512,
    "microsoft/deberta-v2-xlarge-mnli": 512,
    "microsoft/deberta-v2-xxlarge-mnli": 512,
}

__A       :					Any     					=     {
    "microsoft/deberta-v2-xlarge": {"do_lower_case": False},
    "microsoft/deberta-v2-xxlarge": {"do_lower_case": False},
    "microsoft/deberta-v2-xlarge-mnli": {"do_lower_case": False},
    "microsoft/deberta-v2-xxlarge-mnli": {"do_lower_case": False},
}

class 			A_ (a_    ):
	UpperCAmelCase__      =    VOCAB_FILES_NAMES
	UpperCAmelCase__      =    PRETRAINED_VOCAB_FILES_MAP
	UpperCAmelCase__      =    PRETRAINED_INIT_CONFIGURATION
	UpperCAmelCase__      =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	UpperCAmelCase__      =    DebertaVaTokenizer
	def __init__(					self							,      _A=None							,      _A=None							,      _A=False							,      _A=False							,      _A="[CLS]"							,      _A="[SEP]"							,      _A="[UNK]"							,      _A="[SEP]"							,      _A="[PAD]"							,      _A="[CLS]"							,      _A="[MASK]"							,      **_A							,      ):






				'''simple docstring'''







				super().__init__(
				    _A							,      tokenizer_file=_A							,      do_lower_case=_A							,      bos_token=_A							,      eos_token=_A							,      unk_token=_A							,      sep_token=_A							,      pad_token=_A							,      cls_token=_A							,      mask_token=_A							,      split_by_punct=_A							,      **_A							,      )

				UpperCAmelCase     	=       do_lower_case
				UpperCAmelCase     	=       split_by_punct
				UpperCAmelCase     	=       vocab_file
				UpperCAmelCase     	=       False if not self.vocab_file else True
	def   _lowercase       (					self							,      _A							,      _A=None	):






				'''simple docstring'''







				if token_ids_a is None:
							return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
				UpperCAmelCase     	=       [self.cls_token_id]
				UpperCAmelCase     	=       [self.sep_token_id]
				return cls + token_ids_a + sep + token_ids_a + sep
	def   _lowercase       (					self							,      _A							,      _A=None							,      _A=False	):






				'''simple docstring'''







				if already_has_special_tokens:
							return super().get_special_tokens_mask(
							    token_ids_a=_A							,      token_ids_a=_A							,      already_has_special_tokens=_A	)

				if token_ids_a is not None:
							return [1] + ([0] * len(_A	)) + [1] + ([0] * len(_A	)) + [1]
				return [1] + ([0] * len(_A	)) + [1]
	def   _lowercase       (					self							,      _A							,      _A=None	):






				'''simple docstring'''







				UpperCAmelCase     	=       [self.sep_token_id]
				UpperCAmelCase     	=       [self.cls_token_id]
				if token_ids_a is None:
							return len(cls + token_ids_a + sep	) * [0]
				return len(cls + token_ids_a + sep	) * [0] + len(token_ids_a + sep	) * [1]







	def   _lowercase       (					self							,      _A							,      _A = None	):






				'''simple docstring'''







				if not self.can_save_slow_tokenizer:
							raise ValueError(
							    '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
							    '''tokenizer.'''	)

				if not os.path.isdir(_A	):
							logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""	)
							return
				UpperCAmelCase     	=       os.path.join(
				    _A							,      (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']	)

				if os.path.abspath(self.vocab_file	) != os.path.abspath(_A	):
							copyfile(self.vocab_file							,      _A	)

				return (out_vocab_file,)



