





from __future__ import annotations



def    SCREAMING_SNAKE_CASE							(			snake_case	,      snake_case       )		->						list:
		__lowercase					=    [None] * (len(__lowerCamelCase       ) + len(__lowerCamelCase       ))

		__lowercase					=    0  # pointer to current index for left Half
		__lowercase					=    0  # pointer to current index for the right Half
		__lowercase					=    0  # pointer to current index for the sorted array Half

		while pointera < len(__lowerCamelCase       ) and pointera < len(__lowerCamelCase       ):
				if left_half[pointera] < right_half[pointera]:
						__lowercase					=    left_half[pointera]
						pointera += 1
						index += 1
				else:
						__lowercase					=    right_half[pointera]
						pointera += 1
						index += 1
		while pointera < len(__lowerCamelCase       ):
				__lowercase					=    left_half[pointera]
				pointera += 1
				index += 1

		while pointera < len(__lowerCamelCase       ):
				__lowercase					=    right_half[pointera]
				pointera += 1
				index += 1

		return sorted_array



def    SCREAMING_SNAKE_CASE							(			snake_case       )		->						list:
		if len(__lowerCamelCase       ) <= 1:
				return array
		# the actual formula to calculate the middle element = left + (right - left) // 2
		# this avoids integer overflow in case of large N
		__lowercase					=    0 + (len(__lowerCamelCase       ) - 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
		__lowercase					=    array[:middle]
		__lowercase					=    array[middle:]

		return merge(merge_sort(__lowerCamelCase       )	,      merge_sort(__lowerCamelCase       )       )


if __name__ == "__main__":
				import doctest

				doctest.testmod()











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




