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

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

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

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

						_lowercase									=				len(SCREAMING_SNAKE_CASE_					)

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

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

						_lowercase									=				0

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

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

						_lowercase									=				0
						_lowercase									=				"""f(x)="""

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




def   UpperCamelCase__     (    SCREAMING_SNAKE_CASE_  :  int					)     ->    list[int]:
						_lowercase									=				[1]
						for i in range(2		,      int(sqrt(SCREAMING_SNAKE_CASE_					)					) + 1		,      1					):
												if number % i == 0:
																		values.append(SCREAMING_SNAKE_CASE_					)
																		if int(number // i					) != i:
																								values.append(int(number // i					)					)
						return sorted(SCREAMING_SNAKE_CASE_					)




def   UpperCamelCase__     (    SCREAMING_SNAKE_CASE_  :  int					)     ->    bool:
						return sum(factors(SCREAMING_SNAKE_CASE_					)					) > n




def   UpperCamelCase__     (    SCREAMING_SNAKE_CASE_  :  int					)     ->    bool:
						_lowercase									=				factors(SCREAMING_SNAKE_CASE_					)
						_lowercase									=				len(SCREAMING_SNAKE_CASE_					)
						_lowercase									=				[[0 for i in range(number + 1					)] for j in range(r + 1					)]
						for i in range(r + 1					):
												_lowercase									=				True

						for i in range(1		,      number + 1					):
												_lowercase									=				False

						for i in range(1		,      r + 1					):
												for j in range(1		,      number + 1					):
																		if j < values[i - 1]:
																								_lowercase									=				subset[i - 1][j]
																		else:
																								_lowercase									=				subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

						return subset[r][number] != 0




def   UpperCamelCase__     (    SCREAMING_SNAKE_CASE_  :  int					)     ->    bool:
						return abundant(SCREAMING_SNAKE_CASE_					) and not semi_perfect(SCREAMING_SNAKE_CASE_					)


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)
		for number in (69, 70, 71):
				print(F'{number} is {"" if weird(number) else "not "}weird.')