from math import pow




def       __magic_name__(  __UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase ,						__UpperCAmelCase ,						)						->    List[Any]:



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

      _lowerCamelCase			    =				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
            _lowerCamelCase    ,					_lowerCamelCase			    =				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.
            _lowerCamelCase    ,					_lowerCamelCase			    =				backtrack(
                lowerCAmelCase__ ,						lowerCAmelCase__ ,						current_number + 1 ,						lowerCAmelCase__ ,						lowerCAmelCase__		)
      return current_sum, solutions_count




def       __magic_name__(  __UpperCAmelCase ,						__UpperCAmelCase		)						->    Dict:



      '''simple docstring'''

      if not (1 <= needed_sum <= 1000 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()
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


snake_case__				= {
    'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'],
    'feature_extraction_whisper': ['WhisperFeatureExtractor'],
    'processing_whisper': ['WhisperProcessor'],
    'tokenization_whisper': ['WhisperTokenizer'],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= ['WhisperTokenizerFast']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'WhisperForConditionalGeneration',
         'WhisperModel',
         'WhisperPreTrainedModel',
         'WhisperForAudioClassification',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TFWhisperForConditionalGeneration',
         'TFWhisperModel',
         'TFWhisperPreTrainedModel',
     ]

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__				= [
         'FlaxWhisperForConditionalGeneration',
         'FlaxWhisperModel',
         'FlaxWhisperPreTrainedModel',
         'FlaxWhisperForAudioClassification',
     ]


if TYPE_CHECKING:
     from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
     from .feature_extraction_whisper import WhisperFeatureExtractor
     from .processing_whisper import WhisperProcessor
     from .tokenization_whisper import WhisperTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_whisper_fast import WhisperTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_whisper import (
              WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
              WhisperForAudioClassification,
              WhisperForConditionalGeneration,
              WhisperModel,
              WhisperPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_whisper import (
              TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFWhisperForConditionalGeneration,
              TFWhisperModel,
              TFWhisperPreTrainedModel,
          )

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_whisper import (
              FlaxWhisperForAudioClassification,
              FlaxWhisperForConditionalGeneration,
              FlaxWhisperModel,
              FlaxWhisperPreTrainedModel,
          )

else:
     import sys

     snake_case__				= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)