def   a_					(_lowerCAmelCase  :   List[Any]       )->				str:


    if len(__snake_case       ) == 0 or not all(len(__snake_case       ) == 2 for pair in coordinates       ):
        raise ValueError("""The program cannot work out a fitting polynomial."""       )

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

    snake_case:						Tuple         =   {x for x, _ in coordinates}
    if len(__snake_case       ) == 1:
        return F"x={coordinates[0][0]}"

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

    snake_case:						Optional[Any]         =   len(__snake_case       )

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

    snake_case:						Optional[Any]         =   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:						Tuple         =   0

    while count < x:
        snake_case:						Tuple         =   0
        while zahlen < x:
            if count == zahlen:
                zahlen += 1
            if zahlen == x:
                break
            snake_case:						Tuple         =   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:						Union[str, Any]         =   0
    # make solutions
    snake_case:						Optional[Any]         =   []
    while count < x:
        solution.append(str(vector[count] / matrix[count][count]       )       )
        count += 1

    snake_case:						List[str]         =   0
    snake_case:						str         =   """f(x)="""

    while count < x:
        snake_case:						Any         =   solution[count].split("""E"""       )
        if len(__snake_case       ) > 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]]))






import math
def 							UpperCAmelCase_   (				__snake_case		)	->     int:







 """simple docstring"""


 return sum(int(__snake_case		) for digit in str(__snake_case		)		)
def 							UpperCAmelCase_   (				__snake_case = 30		)	->     int:







 """simple docstring"""


 _lowercase				 =[]
 for digit in range(2	,		100		):
  for power in range(2	,		100		):
   _lowercase				 =int(math.pow(__snake_case	,		__snake_case		)		)
   if digit == digit_sum(__snake_case		):
    digit_to_powers.append(__snake_case		)

 digit_to_powers.sort()
 return digit_to_powers[n - 1]


if __name__ == "__main__":
  print(solution())

