code: 
  """simple docstring"""
  
  
  
  
  
  
  
  from __future__ import annotations
  def 			__UpperCAmelCase		(		a_			:		list    ,  a_			:		list				)     ->       list:
     _UpperCAmelCase   	=					[None] * (len(a_				) + len(a_				))
  
     _UpperCAmelCase   	=					0  # pointer to current index for left Half
     _UpperCAmelCase   	=					0  # pointer to current index for the right Half
     _UpperCAmelCase   	=					0  # pointer to current index for the sorted array Half
  
     while pointera < len(a_				) and pointera < len(a_				):
        if left_half[pointera] < right_half[pointera]:
           _UpperCAmelCase   	=					left_half[pointera]
           pointera += 1
           index += 1
        else:
           _UpperCAmelCase   	=					right_half[pointera]
           pointera += 1
           index += 1
     while pointera < len(a_				):
        _UpperCAmelCase   	=					left_half[pointera]
        pointera += 1
        index += 1
  
     while pointera < len(a_				):
        _UpperCAmelCase   	=					right_half[pointera]
        pointera += 1
        index += 1
  
     return sorted_array
  def 			__UpperCAmelCase		(		a_			:		list				)     ->       list:
     if len(a_				) <= 1:
        return array
     # the actual formula to calculate the middle element = left + (right - left) // 2
     # this avoids integer overflow in case of large N
     _UpperCAmelCase   	=					0 + (len(a_				) - 0) // 2
  
     # Split the array into halves till the array length becomes equal to One
     # merge the arrays of single length returned by mergeSort function and
     # pass them into the merge arrays function which merges the array
     _UpperCAmelCase   	=					array[:middle]
     _UpperCAmelCase   	=					array[middle:]
  
     return merge(merge_sort(a_				)    ,  merge_sort(a_				)				)
  
  
  if __name__ == "__main__":
        import doctest
  
        doctest.testmod()
  
  
style_context: 
  """simple docstring"""
  
  
  
  
  
  
  
  from math import floor, sqrt
  def 			__UpperCAmelCase		(		a_			:		int				)     ->       int:
     _UpperCAmelCase   	=					0.0
     _UpperCAmelCase   	=					1.0
     _UpperCAmelCase   	=					int(sqrt(a_				)				)
     _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 			__UpperCAmelCase		(		a_			:		int = 1_00_00				)     ->       int:
     _UpperCAmelCase   	=					0
     for i in range(2    ,  n + 1				):
        _UpperCAmelCase   	=					sqrt(a_				)
        if sr - floor(a_				) != 0 and continuous_fraction_period(a_				) % 2 == 1:
           count_odd_periods += 1
     return count_odd_periods
  
  
  if __name__ == "__main__":
    print(f'''{solution(int(input().strip()))}''')
  
  