

from math import pow



def   __UpperCAmelCase					(      __a :     int						,__a :     int						,__a :     int						,__a :     int						,__a :     int						,)     ->	tuple[int, int]:

					"""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      :       List[str]   =						int(pow(__a						,__a      )      )
					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      :       Optional[Any]   =						backtrack(
										    __a						,__a						,current_number + 1						,__a						,__a      )
										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      :       List[str]   =						backtrack(
										    __a						,__a						,current_number + 1						,__a						,__a      )
					return current_sum, solutions_count



def   __UpperCAmelCase					(      __a :     int						,__a :     int      )     ->	int:

					"""simple docstring"""

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

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


if __name__ == "__main__":
			import doctest

			doctest.testmod()








'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowerCAmelCase:   List[str]					=		{
    'configuration_falcon': ['FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FalconConfig'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:   str					=		[
         'FALCON_PRETRAINED_MODEL_ARCHIVE_LIST',
         'FalconForCausalLM',
         'FalconModel',
         'FalconPreTrainedModel',
         'FalconForSequenceClassification',
         'FalconForTokenClassification',
         'FalconForQuestionAnswering',
     ]


if TYPE_CHECKING:
     from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_falcon import (
              FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
              FalconForCausalLM,
              FalconForQuestionAnswering,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconModel,
              FalconPreTrainedModel,
          )


else:
     import sys

     lowerCAmelCase:   Optional[int]					=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)