
"""simple docstring"""
def 				lowercase      (_lowerCAmelCase		):
						if len(_lowerCAmelCase		) == 0 or not all(len(_lowerCAmelCase		) == 2 for pair in coordinates		):
												raise ValueError("""The program cannot work out a fitting polynomial."""		)

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

						__lowerCAmelCase        =       {x for x, _ in coordinates}
						if len(_lowerCAmelCase		) == 1:
												return f"""x={coordinates[0][0]}"""

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

						__lowerCAmelCase        =       len(_lowerCAmelCase		)

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

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

						__lowerCAmelCase        =       0

						while count < x:
												__lowerCAmelCase        =       0
												while zahlen < x:
																		if count == zahlen:
																								zahlen += 1
																		if zahlen == x:
																								break
																		__lowerCAmelCase        =       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

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

						__lowerCAmelCase        =       0
						__lowerCAmelCase        =       """f(x)="""

						while count < x:
												__lowerCAmelCase        =       solution[count].split("""E"""		)
												if len(_lowerCAmelCase		) > 1:
																		__lowerCAmelCase        =       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]]))


"""simple docstring"""
from __future__ import annotations
class      lowerCAmelCase_						:



							'''simple docstring'''





							def __init__(				self  ,							snake_case_							)   ->       None:
													__lowerCAmelCase        =       data
													__lowerCAmelCase        =       None
class      lowerCAmelCase_						:



							'''simple docstring'''





							def __init__(				self							)   ->       List[str]:
													__lowerCAmelCase        =       None




							def  A__		(				self  ,							snake_case_							)   ->       int:
													__lowerCAmelCase        =       Node(snake_case_							)
													__lowerCAmelCase        =       self.head
													__lowerCAmelCase        =       new_node
													return self.head.data




							def  A__		(				self							)   ->       int | None:
													__lowerCAmelCase        =       self.head
													__lowerCAmelCase        =       self.head
													if self.head:
																			while fast_pointer and fast_pointer.next:
																									__lowerCAmelCase        =       fast_pointer.next.next
																									__lowerCAmelCase        =       slow_pointer.next
																			return slow_pointer.data
													else:
																			print("""No element found."""							)
																			return None


if __name__ == "__main__":
			SCREAMING_SNAKE_CASE_			      =					LinkedList()
			for _ in range(int(input().strip())):
						SCREAMING_SNAKE_CASE_			      =					int(input().strip())
						link.push(data)
			print(link.middle_element())
