


from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

UpperCAmelCase_      : str  					=       TypeVar('T')
class  SCREAMING_SNAKE_CASE__  (				Generic[T]			):
      def __init__(       self				:       Optional[Any]     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any] = True     )		->			int:
             a_					:		dict[T, list[T]]							=  {}  # dictionary of lists
             a_					:		Any							=  directed
      def        SCREAMING_SNAKE_CASE							(       self				:       List[str]     ,							SCREAMING_SNAKE_CASE__				:       List[Any]     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]     )		->			List[Any]:

             if not self.directed:  # For undirected graphs
                    # if both source vertex and destination vertex are both present in the
                    # adjacency list, add destination vertex to source vertex list of adjacent
                    # vertices and add source vertex to destination vertex list of adjacent
                    # vertices.
                    if source_vertex in self.adj_list and destination_vertex in self.adj_list:
                           self.adj_list[source_vertex].append(SCREAMING_SNAKE_CASE__     )
                           self.adj_list[destination_vertex].append(SCREAMING_SNAKE_CASE__     )
                    # if only source vertex is present in adjacency list, add destination vertex
                    # to source vertex list of adjacent vertices, then create a new vertex with
                    # destination vertex as key and assign a list containing the source vertex
                    # as it's first adjacent vertex.
                    elif source_vertex in self.adj_list:
                           self.adj_list[source_vertex].append(SCREAMING_SNAKE_CASE__     )
                           a_					:		Dict							=  [source_vertex]
                    # if only destination vertex is present in adjacency list, add source vertex
                    # to destination vertex list of adjacent vertices, then create a new vertex
                    # with source vertex as key and assign a list containing the source vertex
                    # as it's first adjacent vertex.
                    elif destination_vertex in self.adj_list:
                           self.adj_list[destination_vertex].append(SCREAMING_SNAKE_CASE__     )
                           a_					:		int							=  [destination_vertex]
                    # if both source vertex and destination vertex are not present in adjacency
                    # list, create a new vertex with source vertex as key and assign a list
                    # containing the destination vertex as it's first adjacent vertex also
                    # create a new vertex with destination vertex as key and assign a list
                    # containing the source vertex as it's first adjacent vertex.
                    else:
                           a_					:		Optional[Any]							=  [destination_vertex]
                           a_					:		Tuple							=  [source_vertex]
             else:  # For directed graphs
                    # if both source vertex and destination vertex are present in adjacency
                    # list, add destination vertex to source vertex list of adjacent vertices.
                    if source_vertex in self.adj_list and destination_vertex in self.adj_list:
                           self.adj_list[source_vertex].append(SCREAMING_SNAKE_CASE__     )
                    # if only source vertex is present in adjacency list, add destination
                    # vertex to source vertex list of adjacent vertices and create a new vertex
                    # with destination vertex as key, which has no adjacent vertex
                    elif source_vertex in self.adj_list:
                           self.adj_list[source_vertex].append(SCREAMING_SNAKE_CASE__     )
                           a_					:		Tuple							=  []
                    # if only destination vertex is present in adjacency list, create a new
                    # vertex with source vertex as key and assign a list containing destination
                    # vertex as first adjacent vertex
                    elif destination_vertex in self.adj_list:
                           a_					:		Tuple							=  [destination_vertex]
                    # if both source vertex and destination vertex are not present in adjacency
                    # list, create a new vertex with source vertex as key and a list containing
                    # destination vertex as it's first adjacent vertex. Then create a new vertex
                    # with destination vertex as key, which has no adjacent vertex
                    else:
                           a_					:		int							=  [destination_vertex]
                           a_					:		List[str]							=  []

             return self

      def __repr__(       self				:       str     )		->			Union[str, Any]:
             return pformat(self.adj_list     )







'''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()