code: 
  
  
  
  
  
  
  from __future__ import annotations
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			tuple[float, float]:
       assert (
           c % greatest_common_divisor(__lowerCamelCase      ,					__lowerCamelCase    ) == 0
       )  # greatest_common_divisor(a,b) function implemented below
       ((UpperCamelCase__)       ,  (UpperCamelCase__)       ,  (UpperCamelCase__))    :     int        =						extended_gcd(__lowerCamelCase      ,					__lowerCamelCase    )  # extended_gcd(a,b) function implemented below
       UpperCamelCase__    :     Any        =						c / d
       return (r * x, r * y)
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase = 2    )				->			None:
       ((UpperCamelCase__)       ,  (UpperCamelCase__))    :     Union[str, Any]        =						diophantine(__lowerCamelCase      ,					__lowerCamelCase      ,					__lowerCamelCase    )  # Initial value
       UpperCamelCase__    :     List[str]        =						greatest_common_divisor(__lowerCamelCase      ,					__lowerCamelCase    )
       UpperCamelCase__    :     Union[str, Any]        =						a // d
       UpperCamelCase__    :     str        =						b // d
  
       for i in range(__lowerCamelCase    ):
            UpperCamelCase__    :     Any        =						xa + i * q
            UpperCamelCase__    :     Dict        =						ya - i * p
            print(__lowerCamelCase      ,					__lowerCamelCase    )
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			int:
       if a < b:
            UpperCamelCase__       ,  UpperCamelCase__    :     Optional[int]        =						b, a
  
       while a % b != 0:
            UpperCamelCase__       ,  UpperCamelCase__    :     List[Any]        =						b, a % b
  
       return b
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			tuple[int, int, int]:
       assert a >= 0 and b >= 0
  
       if b == 0:
            UpperCamelCase__       ,  UpperCamelCase__       ,  UpperCamelCase__    :     Union[str, Any]        =						a, 1, 0
       else:
            ((UpperCamelCase__)       ,  (UpperCamelCase__)       ,  (UpperCamelCase__))    :     Dict        =						extended_gcd(__lowerCamelCase      ,					a % b    )
            UpperCamelCase__    :     int        =						q
            UpperCamelCase__    :     Tuple        =						p - q * (a // b)
  
       assert a % d == 0 and b % d == 0
       assert d == a * x + b * y
  
       return (d, x, y)
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod(name='''diophantine''', verbose=True)
   testmod(name='''diophantine_all_soln''', verbose=True)
   testmod(name='''extended_gcd''', verbose=True)
   testmod(name='''greatest_common_divisor''', verbose=True)
style_context: 
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			str:
       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."    )
  
       UpperCamelCase__    :     List[str]        =						{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."    )
  
       UpperCamelCase__    :     Any        =						len(__lowerCAmelCase    )
  
       UpperCamelCase__    :     str        =						0
       UpperCamelCase__    :     list[list[float]]        =						[]
       # put the x and x to the power values in a matrix
       while count_of_line < x:
            UpperCamelCase__    :     int        =						0
            UpperCamelCase__    :     List[Any]        =						coordinates[count_of_line][0]
            UpperCamelCase__    :     list[float]        =						[]
            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
  
       UpperCamelCase__    :     List[Any]        =						0
       # put the y values into a vector
       UpperCamelCase__    :     list[float]        =						[]
       while count_of_line < x:
            vector.append(coordinates[count_of_line][1]    )
            count_of_line += 1
  
       UpperCamelCase__    :     Tuple        =						0
  
       while count < x:
            UpperCamelCase__    :     Dict        =						0
            while zahlen < x:
                 if count == zahlen:
                      zahlen += 1
                 if zahlen == x:
                      break
                 UpperCamelCase__    :     Optional[Any]        =						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
  
       UpperCamelCase__    :     Tuple        =						0
       # make solutions
       UpperCamelCase__    :     list[str]        =						[]
       while count < x:
            solution.append(str(vector[count] / matrix[count][count]    )    )
            count += 1
  
       UpperCamelCase__    :     int        =						0
       UpperCamelCase__    :     List[str]        =						"f(x)="
  
       while count < x:
            UpperCamelCase__    :     list[str]        =						solution[count].split("E"    )
            if len(__lowerCAmelCase    ) > 1:
                 UpperCamelCase__    :     Union[str, Any]        =						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]]))