


'''simple docstring'''

from dataclasses import dataclass

__lowercase:		int    						=  "0.1"
__lowercase:		Optional[int]    						=  "Lucia Harcekova"







@dataclass
class 			UpperCAmelCase			:
 _lowerCamelCase			:       int
 _lowerCamelCase			:       int
 _lowerCamelCase			:       str

 def __repr__(			self			:						int       ):





    """simple docstring"""



    return f'({self.offset}, {self.length}, {self.indicator})'







class 			UpperCAmelCase			:

 def __init__(			self			:						List[Any],       a_			:						int = 13,       a_			:						int = 6       ):





    """simple docstring"""



    UpperCamelCase__			    =    window_size
    UpperCamelCase__			    =    lookahead_buffer_size
    UpperCamelCase__			    =    self.window_size - self.lookahead_buffer_size

 def 		lowercase_    (			self			:						Optional[Any],       a_			:						str       ):





    """simple docstring"""



    UpperCamelCase__			    =    []
    UpperCamelCase__			    =    ""

    # while there are still characters in text to compress
    while text:
       # find the next encoding phrase
       # - triplet with offset, length, indicator (the next encoding character)
       UpperCamelCase__			    =    self._find_encoding_token(a_,       a_       )

       # update the search buffer:
       # - add new characters from text into it
       # - check if size exceed the max search buffer size, if so, drop the
       #   oldest elements
       search_buffer += text[: token.length + 1]
       if len(a_       ) > self.search_buffer_size:
          UpperCamelCase__			    =    search_buffer[-self.search_buffer_size :]

       # update the text
       UpperCamelCase__			    =    text[token.length + 1 :]

       # append the token to output
       output.append(a_       )

    return output

 def 		lowercase_    (			self			:						Optional[Any],       a_			:						list[Token]       ):





    """simple docstring"""



    UpperCamelCase__			    =    ""

    for token in tokens:
       for _ in range(token.length       ):
          output += output[-token.offset]
       output += token.indicator

    return output

 def 		lowercase_    (			self			:						List[Any],       a_			:						str,       a_			:						str       ):





    """simple docstring"""



    if not text:
       raise ValueError("We need some text to work with."       )

    # Initialise result parameters to default values
    UpperCamelCase__    ,		UpperCamelCase__			    =    0, 0

    if not search_buffer:
       return Token(a_,       a_,       text[length]       )

    for i, character in enumerate(a_       ):
       UpperCamelCase__			    =    len(a_       ) - i
       if character == text[0]:
          UpperCamelCase__			    =    self._match_length_from_index(a_,       a_,       0,       a_       )
          # if the found length is bigger than the current or if it's equal,
          # which means it's offset is smaller: update offset and length
          if found_length >= length:
             UpperCamelCase__    ,		UpperCamelCase__			    =    found_offset, found_length

    return Token(a_,       a_,       text[length]       )

 def 		lowercase_    (			self			:						Optional[Any],       a_			:						str,       a_			:						str,       a_			:						int,       a_			:						int       ):





    """simple docstring"""



    if not text or text[text_index] != window[window_index]:
       return 0
    return 1 + self._match_length_from_index(
        a_,       window + text[text_index],       text_index + 1,       window_index + 1       )


if __name__ == "__main__":
       from doctest import testmod

       testmod()
       # Initialize compressor class
       __lowercase:		Optional[Any]    						=  LZaaCompressor(window_size=13, lookahead_buffer_size=6)

       # Example
       __lowercase:		Union[str, Any]    						=  "cabracadabrarrarrad"
       __lowercase:		Any    						=  lzaa_compressor.compress(TEXT)
       print(lzaa_compressor.compress("ababcbababaa"))
       __lowercase:		Any    						=  lzaa_compressor.decompress(compressed_text)
       assert decompressed_text == TEXT, "The LZ77 algorithm returned the invalid result."




'''simple docstring'''


from math import floor, sqrt






def 			UpperCAmelCase_							(		lowercase__							):


     '''simple docstring'''







     a_									=0.0
     a_									=1.0
     a_									=int(sqrt(lowercase__							)							)
     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_							(		lowercase__ = 1_0_0_0_0							):


     '''simple docstring'''







     a_									=0
     for i in range(2							,						n + 1							):
          a_									=sqrt(lowercase__							)
          if sr - floor(lowercase__							) != 0 and continuous_fraction_period(lowercase__							) % 2 == 1:
               count_odd_periods += 1
     return count_odd_periods


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


