





def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__				)						->       str:







			'''simple docstring'''

			if len(UpperCamelCase__				) == 0 or not all(len(UpperCamelCase__				) == 2 for pair in coordinates				):
						raise ValueError('''The program cannot work out a fitting polynomial.'''				)

			if len({tuple(UpperCamelCase__				) for pair in coordinates}				) != len(UpperCamelCase__				):
						raise ValueError('''The program cannot work out a fitting polynomial.'''				)

			UpperCAmelCase     	=       {x for x, _ in coordinates}
			if len(UpperCamelCase__				) == 1:
						return F"""x={coordinates[0][0]}"""

			if len(UpperCamelCase__				) != len(UpperCamelCase__				):
						raise ValueError('''The program cannot work out a fitting polynomial.'''				)

			UpperCAmelCase     	=       len(UpperCamelCase__				)

			UpperCAmelCase     	=       0
			UpperCAmelCase     	=       []
			# put the x and x to the power values in a matrix
			while count_of_line < x:
						UpperCAmelCase     	=       0
						UpperCAmelCase     	=       coordinates[count_of_line][0]
						UpperCAmelCase     	=       []
						while count_in_line < x:
									count_line.append(a ** (x - (count_in_line + 1))				)
									count_in_line += 1
						matrix.append(UpperCamelCase__				)
						count_of_line += 1

			UpperCAmelCase     	=       0
			# put the y values into a vector
			UpperCAmelCase     	=       []
			while count_of_line < x:
						vector.append(coordinates[count_of_line][1]				)
						count_of_line += 1

			UpperCAmelCase     	=       0

			while count < x:
						UpperCAmelCase     	=       0
						while zahlen < x:
									if count == zahlen:
												zahlen += 1
									if zahlen == x:
												break
									UpperCAmelCase     	=       matrix[zahlen][count] / matrix[count][count]
									for counting_columns, item in enumerate(matrix[count]				):
												# manipulating all the values in the matrix
												matrix[zahlen][counting_columns] -= item * bruch
									# manipulating the values in the vector
									vector[zahlen] -= vector[count] * bruch
									zahlen += 1
						count += 1

			UpperCAmelCase     	=       0
			# make solutions
			UpperCAmelCase     	=       []
			while count < x:
						solution.append(str(vector[count] / matrix[count][count]				)				)
						count += 1

			UpperCAmelCase     	=       0
			UpperCAmelCase     	=       '''f(x)='''

			while count < x:
						UpperCAmelCase     	=       solution[count].split('''E'''				)
						if len(UpperCamelCase__				) > 1:
									UpperCAmelCase     	=       F"""{remove_e[0]}*10^{remove_e[1]}"""
						solved += F"""x^{x - (count + 1)}*{solution[count]}"""
						if count + 1 != x:
									solved += "+"
						count += 1

			return solved


if __name__ == "__main__":
				print(points_to_polynomial([]))
				print(points_to_polynomial([[]]))
				print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
				print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
				print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
				print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
				print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
				print(points_to_polynomial([[1, 3], [2, 6], [3, 11]]))
				print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
				print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))









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



