"""simple docstring"""




def 			UpperCamelCase__						(    A__   )       -> List[str]:
				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.'   )

				snake_case__ :     Union[str, Any] 							=				{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.'   )

				snake_case__ :     List[str] 							=				len(__UpperCamelCase   )

				snake_case__ :     Any 							=				0
				snake_case__ :     List[Any] 							=				[]
				# put the x and x to the power values in a matrix
				while count_of_line < x:
								snake_case__ :     Optional[int] 							=				0
								snake_case__ :     Tuple 							=				coordinates[count_of_line][0]
								snake_case__ :     Any 							=				[]
								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

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

				snake_case__ :     Optional[int] 							=				0

				while count < x:
								snake_case__ :     List[str] 							=				0
								while zahlen < x:
												if count == zahlen:
																zahlen += 1
												if zahlen == x:
																break
												snake_case__ :     int 							=				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

				snake_case__ :     List[str] 							=				0
				# make solutions
				snake_case__ :     Union[str, Any] 							=				[]
				while count < x:
								solution.append(str(vector[count] / matrix[count][count]   )   )
								count += 1

				snake_case__ :     Tuple 							=				0
				snake_case__ :     Optional[Any] 							=				'f(x)='

				while count < x:
								snake_case__ :     int 							=				solution[count].split('E'   )
								if len(__UpperCamelCase   ) > 1:
												snake_case__ :     List[str] 							=				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]]))



def 			UpperCamelCase__						(    A__   )       -> int:
				if number != int(A__   ):
								raise ValueError('factorial() only accepts integral values'   )
				if number < 0:
								raise ValueError('factorial() not defined for negative values'   )
				snake_case__ :     Optional[Any] 							=				1
				for i in range(1      ,			number + 1   ):
								value *= i
				return value
def 			UpperCamelCase__						(    A__   )       -> int:
				if not isinstance(A__      ,			A__   ):
								raise ValueError('factorial() only accepts integral values'   )
				if n < 0:
								raise ValueError('factorial() not defined for negative values'   )
				return 1 if n == 0 or n == 1 else n * factorial(n - 1   )


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				lowerCAmelCase__					:       Any		=       int(input('''Enter a positive integer: ''').strip() or 0)
				print(F'''factorial{n} is {factorial(n)}''')


