





import sys

sys.set_int_max_str_digits(0)  # type: ignore





def  __UpperCamelCase   (     a)			->bool:
					lowerCamelCase__      =							[0] * 11
					lowerCamelCase__      =							[0] * 11

					# mark last 9 numbers
					for _ in range(9):
										lowerCamelCase__      =							1
										lowerCamelCase__      =							number // 10
					# flag
					lowerCamelCase__      =							True

					# check last 9 numbers for pandigitality

					for x in range(9):
										if not check_last[x + 1]:
															lowerCamelCase__      =							False
					if not f:
										return f

					# mark first 9 numbers
					lowerCamelCase__      =							int(str(a)[:9])

					for _ in range(9):
										lowerCamelCase__      =							1
										lowerCamelCase__      =							number // 10

					# check first 9 numbers for pandigitality

					for x in range(9):
										if not check_front[x + 1]:
															lowerCamelCase__      =							False
					return f





def  __UpperCamelCase   (     a)			->bool:
					lowerCamelCase__      =							[0] * 11

					# mark last 9 numbers
					for _ in range(9):
										lowerCamelCase__      =							1
										lowerCamelCase__      =							number // 10
					# flag
					lowerCamelCase__      =							True

					# check last 9 numbers for pandigitality

					for x in range(9):
										if not check_last[x + 1]:
															lowerCamelCase__      =							False
					return f





def  __UpperCamelCase   (     )			->int:
					lowerCamelCase__      =							1
					lowerCamelCase__      =							1
					lowerCamelCase__      =							2
					# temporary Fibonacci numbers

					lowerCamelCase__      =							1
					lowerCamelCase__      =							1
					lowerCamelCase__      =							2
					# temporary Fibonacci numbers mod 1e9

					# mod m=1e9, done for fast optimisation
					lowerCamelCase__      =							[0] * 1000000
					lowerCamelCase__      =							1000000000

					for x in range(1000000):
										lowerCamelCase__      =							(aa + ba) % m
										lowerCamelCase__      =							ba % m
										lowerCamelCase__      =							ca % m
										if checka(a):
															lowerCamelCase__      =							1

					for x in range(1000000):
										lowerCamelCase__      =							a + b
										lowerCamelCase__      =							b
										lowerCamelCase__      =							c
										# perform check only if in tocheck
										if tocheck[x + 3] and check(a):
															return x + 3  # first 2 already done
					return -1


if __name__ == "__main__":
						print(f"""{solution() = }""")








def  __UpperCamelCase   (     a)			->str:
					if len(a) == 0 or not all(len(a) == 2 for pair in coordinates):
										raise ValueError("The program cannot work out a fitting polynomial.")

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

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

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

					lowerCamelCase__      =							len(a)

					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(a)
										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(a) > 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, 1_1]]))
						print(points_to_polynomial([[1, -3], [2, -6], [3, -1_1]]))
						print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))

