
import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin




class 				_lowerCamelCase (      UpperCamelCase_ ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE_		   =  '''MCTCTFeatureExtractor'''
     SCREAMING_SNAKE_CASE_		   =  '''AutoTokenizer'''






     def __init__(							self						,						__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )  ->   List[Any]:




           """simple docstring"""







           super().__init__(__SCREAMING_SNAKE_CASE						,						__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Optional[int]					=				self.feature_extractor
           UpperCamelCase__    :   str					=				False






     def __call__(							self						,						*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )  ->   List[Any]:




           """simple docstring"""







           if self._in_target_context_manager:
                 return self.current_processor(*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )

           if "raw_speech" in kwargs:
                 warnings.warn('''Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'''  )
                 UpperCamelCase__    :   Any					=				kwargs.pop('''raw_speech'''  )
           else:
                 UpperCamelCase__    :   Optional[int]					=				kwargs.pop('''audio'''						,						__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Dict					=				kwargs.pop('''sampling_rate'''						,						__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Union[str, Any]					=				kwargs.pop('''text'''						,						__SCREAMING_SNAKE_CASE  )
           if len(__SCREAMING_SNAKE_CASE  ) > 0:
                 UpperCamelCase__    :   Any					=				args[0]
                 UpperCamelCase__    :   Optional[Any]					=				args[1:]

           if audio is None and text is None:
                 raise ValueError('''You need to specify either an `audio` or `text` input to process.'''  )

           if audio is not None:
                 UpperCamelCase__    :   List[Any]					=				self.feature_extractor(__SCREAMING_SNAKE_CASE						,						*__SCREAMING_SNAKE_CASE						,						sampling_rate=__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )
           if text is not None:
                 UpperCamelCase__    :   Dict					=				self.tokenizer(__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )

           if text is None:
                 return inputs
           elif audio is None:
                 return encodings
           else:
                 UpperCamelCase__    :   List[Any]					=				encodings['''input_ids''']
                 return inputs






     def    __SCREAMING_SNAKE_CASE			(							self						,						*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )  ->   Optional[int]:




           """simple docstring"""







           return self.tokenizer.batch_decode(*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )






     def    __SCREAMING_SNAKE_CASE			(							self						,						*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )  ->   Union[str, Any]:




           """simple docstring"""







           if self._in_target_context_manager:
                 return self.current_processor.pad(*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )

           UpperCamelCase__    :   Tuple					=				kwargs.pop('''input_features'''						,						__SCREAMING_SNAKE_CASE  )
           UpperCamelCase__    :   Any					=				kwargs.pop('''labels'''						,						__SCREAMING_SNAKE_CASE  )
           if len(__SCREAMING_SNAKE_CASE  ) > 0:
                 UpperCamelCase__    :   Dict					=				args[0]
                 UpperCamelCase__    :   Dict					=				args[1:]

           if input_features is not None:
                 UpperCamelCase__    :   int					=				self.feature_extractor.pad(__SCREAMING_SNAKE_CASE						,						*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )
           if labels is not None:
                 UpperCamelCase__    :   Union[str, Any]					=				self.tokenizer.pad(__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )

           if labels is None:
                 return input_features
           elif input_features is None:
                 return labels
           else:
                 UpperCamelCase__    :   int					=				labels['''input_ids''']
                 return input_features






     def    __SCREAMING_SNAKE_CASE			(							self						,						*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )  ->   List[str]:




           """simple docstring"""







           return self.tokenizer.decode(*__SCREAMING_SNAKE_CASE						,						**__SCREAMING_SNAKE_CASE  )






     @contextmanager
     def    __SCREAMING_SNAKE_CASE			(							self  )  ->   List[str]:




           """simple docstring"""







           warnings.warn(
               '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '''
               '''labels by using the argument `text` of the regular `__call__` method (either in the same call as '''
               '''your audio inputs, or in a separate call.'''  )
           UpperCamelCase__    :   Optional[int]					=				True
           UpperCamelCase__    :   List[Any]					=				self.tokenizer
           yield
           UpperCamelCase__    :   int					=				self.feature_extractor
           UpperCamelCase__    :   Dict					=				False




def 							SCREAMING_SNAKE_CASE_      (			UpperCamelCase__ = 5_0_0_0_0_0_0_0		):
      UpperCamelCase__    :   Any					=				set()
      UpperCamelCase__    :   Any					=				int((limit - 2_4) ** (1 / 2)		)

      UpperCamelCase__    :   Dict					=				set(range(3 ,		prime_square_limit + 1 ,		2		)		)
      primes.add(2		)
      for p in range(3 ,		prime_square_limit + 1 ,		2		):
            if p not in primes:
                  continue
            primes.difference_update(set(range(p * p ,		prime_square_limit + 1 ,		UpperCamelCase__		)		)		)

      for primea in primes:
            UpperCamelCase__    :   Dict					=				primea * primea
            for primea in primes:
                  UpperCamelCase__    :   str					=				primea * primea * primea
                  if square + cube >= limit - 1_6:
                        break
                  for primea in primes:
                        UpperCamelCase__    :   Dict					=				primea * primea * primea * primea
                        UpperCamelCase__    :   Tuple					=				square + cube + tetr
                        if total >= limit:
                              break
                        ret.add(UpperCamelCase__		)

      return len(UpperCamelCase__		)


if __name__ == "__main__":
    print(F'''{solution() = }''')


