



import math





class    __lowerCAmelCase					:




				def __init__(				self		,							_snake_case		,							_snake_case		,							_snake_case		,							_snake_case						):



									"""simple docstring"""





									_lowerCAmelCase         =       x
									_lowerCAmelCase         =       y
									_lowerCAmelCase         =       step_size
									_lowerCAmelCase         =       function_to_optimize




				def 				snake_case  (				self						):



									"""simple docstring"""





									return self.function(self.x		,							self.y						)




				def 				snake_case  (				self						):



									"""simple docstring"""





									_lowerCAmelCase         =       self.step_size
									return [
									    SearchProblem(_snake_case		,							_snake_case		,							_snake_case		,							self.function						)
									    for x, y in (
									        (self.x - step_size, self.y - step_size),
									        (self.x - step_size, self.y),
									        (self.x - step_size, self.y + step_size),
									        (self.x, self.y - step_size),
									        (self.x, self.y + step_size),
									        (self.x + step_size, self.y - step_size),
									        (self.x + step_size, self.y),
									        (self.x + step_size, self.y + step_size),
									    )
									]




				def __hash__(				self						):



									"""simple docstring"""





									return hash(str(self						)						)




				def __eq__(				self		,							_snake_case						):



									"""simple docstring"""





									if isinstance(_snake_case		,							_snake_case						):
														return hash(str(self						)						) == hash(str(_snake_case						)						)
									return False




				def __str__(				self						):



									"""simple docstring"""





									return F'x: {self.x} y: {self.y}'


def 						_UpperCAmelCase							( snake_case      ,		snake_case = True      ,		snake_case = math.inf      ,		snake_case = -math.inf      ,		snake_case = math.inf      ,		snake_case = -math.inf      ,		snake_case = False      ,		snake_case = 1_00_00      ,		):





					"""simple docstring"""

					_lowerCAmelCase         =       search_prob
					_lowerCAmelCase         =       []  # list to store the current score at each iteration
					_lowerCAmelCase         =       0
					_lowerCAmelCase         =       False
					_lowerCAmelCase         =       set()
					while not solution_found and iterations < max_iter:
										visited.add(snake_case     )
										iterations += 1
										_lowerCAmelCase         =       current_state.score()
										scores.append(snake_case     )
										_lowerCAmelCase         =       current_state.get_neighbors()
										_lowerCAmelCase         =       -math.inf
										_lowerCAmelCase         =       math.inf
										_lowerCAmelCase         =       None  # to hold the next best neighbor
										for neighbor in neighbors:
															if neighbor in visited:
																				continue  # do not want to visit the same state again
															if (
															    neighbor.x > max_x
															    or neighbor.x < min_x
															    or neighbor.y > max_y
															    or neighbor.y < min_y
															):
																				continue  # neighbor outside our bounds
															_lowerCAmelCase         =       neighbor.score() - current_score
															if find_max:  # finding max
																				# going to direction with greatest ascent
																				if change > max_change and change > 0:
																									_lowerCAmelCase         =       change
																									_lowerCAmelCase         =       neighbor
															else:  # finding min
																				# to direction with greatest descent
																				if change < min_change and change < 0:
																									_lowerCAmelCase         =       change
																									_lowerCAmelCase         =       neighbor
										if next_state is not None:
															# we found at least one neighbor which improved the current state
															_lowerCAmelCase         =       next_state
										else:
															# since we have no neighbor that improves the solution we stop the search
															_lowerCAmelCase         =       True

					if visualization:
										from matplotlib import pyplot as plt

										plt.plot(range(snake_case     )      ,		snake_case     )
										plt.xlabel("""Iterations"""     )
										plt.ylabel("""Function values"""     )
										plt.show()

					return current_state


if __name__ == "__main__":
	import doctest

	doctest.testmod()


	def 						_UpperCAmelCase							( snake_case      ,		snake_case     ):





						"""simple docstring"""

						return (x**2) + (y**2)

	# starting the problem with initial coordinates (3, 4)
	A__       =			SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
	A__       =			hill_climbing(prob, find_max=False)
	print(
	    """The minimum score for f(x, y) = x^2 + y^2 found via hill climbing: """
	    f"{local_min.score()}"
	)

	# starting the problem with initial coordinates (12, 47)
	A__       =			SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
	A__       =			hill_climbing(
	    prob, find_max=False, max_x=1_00, min_x=5, max_y=50, min_y=-5, visualization=True
	)
	print(
	    """The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 """
	    f"and 50 > y > - 5 found via hill climbing: {local_min.score()}"
	)


	def 						_UpperCAmelCase							( snake_case      ,		snake_case     ):





						"""simple docstring"""

						return (3 * x**2) - (6 * y)

	A__       =			SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
	A__       =			hill_climbing(prob, find_max=True)
	print(
	    """The maximum score for f(x, y) = x^2 + y^2 found via hill climbing: """
	    f"{local_min.score()}"
	)








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





