code: 
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  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.'				)
  
  						_a     =			{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.'				)
  
  						_a     =			len(_UpperCAmelCase				)
  
  						_a     =			0
  						_a     =			[]
  						# put the x and x to the power values in a matrix
  						while count_of_line < x:
  												_a     =			0
  												_a     =			coordinates[count_of_line][0]
  												_a     =			[]
  												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
  
  						_a     =			0
  						# put the y values into a vector
  						_a     =			[]
  						while count_of_line < x:
  												vector.append(coordinates[count_of_line][1]				)
  												count_of_line += 1
  
  						_a     =			0
  
  						while count < x:
  												_a     =			0
  												while zahlen < x:
  																		if count == zahlen:
  																								zahlen += 1
  																		if zahlen == x:
  																								break
  																		_a     =			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
  
  						_a     =			0
  						# make solutions
  						_a     =			[]
  						while count < x:
  												solution.append(str(vector[count] / matrix[count][count]				)				)
  												count += 1
  
  						_a     =			0
  						_a     =			'f(x)='
  
  						while count < x:
  												_a     =			solution[count].split('E'				)
  												if len(_UpperCAmelCase				) > 1:
  																		_a     =			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]]))
  
  
  
style_context: 
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  bool:
  						# must be
  						_a     =			[list(_UpperCAmelCase				) for row in matrix]
  						if matrix and isinstance(_UpperCAmelCase							,     _UpperCAmelCase				):
  												if isinstance(matrix[0]							,     _UpperCAmelCase				):
  																		_a     =			0
  																		for row in matrix:
  																								if prev_len == 0:
  																														_a     =			len(_UpperCAmelCase				)
  																														_a     =			True
  																								else:
  																														_a     =			prev_len == len(_UpperCAmelCase				)
  												else:
  																		_a     =			True
  						else:
  												_a     =			False
  
  						return result
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  None:
  						if check_matrix(_UpperCAmelCase				) and len(_UpperCAmelCase				) > 0:
  												_a     =			[list(_UpperCAmelCase				) for row in a]
  												_a     =			len(_UpperCAmelCase				)
  												if isinstance(a[0]							,     _UpperCAmelCase				):
  																		_a     =			len(a[0]				)
  												else:
  																		for dat in a:
  																								print(_UpperCAmelCase				)
  																		return
  
  												# horizotal printing increasing
  												for i in range(0							,     _UpperCAmelCase				):
  																		print(a[0][i]				)
  												# vertical printing down
  												for i in range(1							,     _UpperCAmelCase				):
  																		print(a[i][mat_col - 1]				)
  												# horizotal printing decreasing
  												if mat_row > 1:
  																		for i in range(mat_col - 2							,     -1							,     -1				):
  																								print(a[mat_row - 1][i]				)
          # vertical printing up
  												for i in range(mat_row - 2							,     0							,     -1				):
  																		print(a[i][0]				)
  												_a     =			[row[1 : mat_col - 1] for row in a[1 : mat_row - 1]]
  												if len(_UpperCAmelCase				) > 0:
  																		spiral_print_clockwise(_UpperCAmelCase				)
  												else:
  																		return
  						else:
  												print('Not a valid matrix'				)
  												return
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  list[int]:
  						if matrix:
  												return list(matrix.pop(0				)				) + spiral_traversal(list(zip(*_UpperCAmelCase				)				)[::-1]				)
  						else:
  												return []
  
  
  # driver code
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  		lowercase_								=    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
  		spiral_print_clockwise(a)
  
  
  