




def 	lowerCAmelCase_	(     lowerCamelCase:				list[list[int]]  )    ->	str:


      '''simple docstring'''




      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]]))





def 	lowerCAmelCase_	(     lowerCamelCase:				int  )    ->	int:


      '''simple docstring'''




      return n * (2 * n - 1)

def 	lowerCAmelCase_	(     lowerCamelCase:				int  )    ->	bool:


      '''simple docstring'''




      lowerCamelCase__					     = (1 + 24 * n) ** 0.5
      return ((1 + root) / 6) % 1 == 0

def 	lowerCAmelCase_	(     lowerCamelCase:				int = 1_44  )    ->	int:


      '''simple docstring'''




      lowerCamelCase__					     = start
      lowerCamelCase__					     = hexagonal_num(lowerCamelCase  )
      while not is_pentagonal(lowerCamelCase  ):
            n += 1
            lowerCamelCase__					     = hexagonal_num(lowerCamelCase  )
      return num


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