



'''simple docstring'''




def 	a			( lowerCamelCase__    ):
			'''simple docstring'''





			A_	:						int	=     current_set.copy()
			for row_index, row in enumerate(lowerCamelCase__    ):
						A_	:						Union[str, Any]	=     row[0]
						for column_index, column in enumerate(lowerCamelCase__    ):
									if magnitude == 0:
												A_	:						Optional[Any]	=     column
												continue
									A_	:						int	=     column / magnitude
    # Subtract to cancel term
			A_	:						str	=     current_set[0]
			A_	:						Any	=     [first_row]
			A_	:						int	=     current_set[1::]
			for row in current_set:
						A_	:						Dict	=     []
						# If first term is 0, it is already in form we want, so we preserve it
						if row[0] == 0:
									final_set.append(lowerCamelCase__    )
									continue
						for column_index in range(len(lowerCamelCase__    )    ):
									temp_row.append(first_row[column_index] - row[column_index]    )
						final_set.append(lowerCamelCase__    )
			# Create next recursion iteration set
			if len(final_set[0]    ) != 3:
						A_	:						Dict	=     final_set[0]
						A_	:						Dict	=     []
						A_	:						Any	=     []
						for row in final_set[1::]:
									current_first_column.append(row[0]    )
									next_iteration.append(row[1::]    )
						A_	:						Union[str, Any]	=     simplify(lowerCamelCase__    )
						for i in range(len(lowerCamelCase__    )    ):
									resultant[i].insert(0						,      current_first_column[i]    )
						resultant.insert(0						,      lowerCamelCase__    )
						A_	:						Optional[int]	=     resultant
			return final_set



def 	a			( lowerCamelCase__    ):
			'''simple docstring'''





			if len(lowerCamelCase__    ) == 0:
						raise IndexError("""solve_simultaneous() requires n lists of length n+1"""    )
			A_	:						List[Any]	=     len(lowerCamelCase__    ) + 1
			if any(len(lowerCamelCase__    ) != _length for item in equations    ):
						raise IndexError("""solve_simultaneous() requires n lists of length n+1"""    )
			for row in equations:
						if any(not isinstance(lowerCamelCase__						,      (int, float)    ) for column in row    ):
									raise ValueError("""solve_simultaneous() requires lists of integers"""    )
			if len(lowerCamelCase__    ) == 1:
						return [equations[0][-1] / equations[0][0]]
			A_	:						Any	=     equations.copy()
			if any(0 in row for row in data_set    ):
						A_	:						Optional[Any]	=     data_set.copy()
						A_	:						Dict	=     []
						for row_index, row in enumerate(lowerCamelCase__    ):
									if 0 not in row:
												A_	:						Optional[int]	=     data_set.pop(lowerCamelCase__    )
												break
						if not full_row:
									raise ValueError("""solve_simultaneous() requires at least 1 full equation"""    )
						data_set.insert(0						,      lowerCamelCase__    )
			A_	:						str	=     data_set.copy()
			A_	:						int	=     simplify(lowerCamelCase__    )
			A_	:						str	=     simplified[::-1]
			A_	:						list	=     []
			for row in simplified:
						A_	:						Union[str, Any]	=     row[-1]
						if not solutions:
									if row[-2] == 0:
												solutions.append(0    )
												continue
									solutions.append(current_solution / row[-2]    )
									continue
						A_	:						Optional[int]	=     row.copy()[: len(lowerCamelCase__    ) - 1 :]
						while temp_row[0] == 0:
									temp_row.pop(0    )
						if len(lowerCamelCase__    ) == 0:
									solutions.append(0    )
									continue
						A_	:						int	=     temp_row[1::]
						A_	:						str	=     temp_row[::-1]
						for column_index, column in enumerate(lowerCamelCase__    ):
									current_solution -= column * solutions[column_index]
						solutions.append(lowerCamelCase__    )
			A_	:						Union[str, Any]	=     []
			for item in solutions:
						final.append(float(round(lowerCamelCase__						,      5    )    )    )
			return final[::-1]


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						lowerCamelCase							:Union[str, Any]				    =					[
						    [2, 1, 1, 1, 1, 4],
						    [1, 2, 1, 1, 1, 5],
						    [1, 1, 2, 1, 1, 6],
						    [1, 1, 1, 2, 1, 7],
						    [1, 1, 1, 1, 2, 8],
						]
						print(solve_simultaneous(eq))
						print(solve_simultaneous([[4, 2]]))




'''simple docstring'''




from math import pow



def 	a			( lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      ):
			'''simple docstring'''





			if current_sum == needed_sum:
						# If the sum of the powers is equal to needed_sum, then we have a solution.
						solutions_count += 1
						return current_sum, solutions_count

			A_	:						Optional[int]	=     int(pow(lowerCamelCase__						,      lowerCamelCase__    )    )
			if current_sum + i_to_n <= needed_sum:
						# If the sum of the powers is less than needed_sum, then continue adding powers.
						current_sum += i_to_n
						A_,    A_	:						int	=     backtrack(
						    lowerCamelCase__						,      lowerCamelCase__						,      current_number + 1						,      lowerCamelCase__						,      lowerCamelCase__    )
						current_sum -= i_to_n
			if i_to_n < needed_sum:
						# If the power of i is less than needed_sum, then try with the next power.
						A_,    A_	:						int	=     backtrack(
						    lowerCamelCase__						,      lowerCamelCase__						,      current_number + 1						,      lowerCamelCase__						,      lowerCamelCase__    )
			return current_sum, solutions_count



def 	a			( lowerCamelCase__						,      lowerCamelCase__    ):
			'''simple docstring'''





			if not (1 <= needed_sum <= 10_00 and 2 <= power <= 10):
						raise ValueError(
						    """Invalid input\n"""
						    """needed_sum must be between 1 and 1000, power between 2 and 10."""    )

			return backtrack(lowerCamelCase__						,      lowerCamelCase__						,      1						,      0						,      0    )[1]  # Return the solutions_count


if __name__ == "__main__":
						import doctest

						doctest.testmod()