





'''simple docstring'''


import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer
class 				a_       (    _lowerCAmelCase							):
     __A								=      "Wav2Vec2FeatureExtractor"
     __A								=      "AutoTokenizer"





     def __init__(			self		: List[str]     ,				lowercase		: Optional[Any]     ,				lowercase		: Union[str, Any]						):





        """simple docstring"""




        super().__init__(lowercase     ,				lowercase						)
        lowercase_      :Optional[int]         =			self.feature_extractor
        lowercase_      :Optional[Any]         =			False





     @classmethod
     def 							lowercase__				(			cls		: Dict     ,				lowercase		: Union[str, Any]     ,				**lowercase		: str						):





        """simple docstring"""




        try:
           return super().from_pretrained(lowercase     ,				**lowercase						)
        except OSError:
           warnings.warn(
               F'Loading a tokenizer inside {cls.__name__} from a config that does not'
               " include a `tokenizer_class` attribute is deprecated and will be "
               "removed in v5. Please add `'tokenizer_class': 'Wav2Vec2CTCTokenizer'`"
               " attribute to either your `config.json` or `tokenizer_config.json` "
               "file to suppress this warning: "     ,				lowercase     ,				)

           lowercase_      :Tuple         =			WavaVecaFeatureExtractor.from_pretrained(lowercase     ,				**lowercase						)
           lowercase_      :int         =			WavaVecaCTCTokenizer.from_pretrained(lowercase     ,				**lowercase						)

           return cls(feature_extractor=lowercase     ,				tokenizer=lowercase						)





     def __call__(			self		: int     ,				*lowercase		: List[str]     ,				**lowercase		: Union[str, Any]						):





        """simple docstring"""




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

        if "raw_speech" in kwargs:
           warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."						)
           lowercase_      :Union[str, Any]         =			kwargs.pop("raw_speech"						)
        else:
           lowercase_      :Any         =			kwargs.pop("audio"     ,				lowercase						)
        lowercase_      :List[str]         =			kwargs.pop("sampling_rate"     ,				lowercase						)
        lowercase_      :str         =			kwargs.pop("text"     ,				lowercase						)
        if len(lowercase						) > 0:
           lowercase_      :str         =			args[0]
           lowercase_      :Optional[int]         =			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:
           lowercase_      :str         =			self.feature_extractor(lowercase     ,				*lowercase     ,				sampling_rate=lowercase     ,				**lowercase						)
        if text is not None:
           lowercase_      :str         =			self.tokenizer(lowercase     ,				**lowercase						)

        if text is None:
           return inputs
        elif audio is None:
           return encodings
        else:
           lowercase_      :Union[str, Any]         =			encodings["input_ids"]
           return inputs





     def 							lowercase__				(			self		: int     ,				*lowercase		: Union[str, Any]     ,				**lowercase		: Any						):





        """simple docstring"""




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

        lowercase_      :List[Any]         =			kwargs.pop("input_features"     ,				lowercase						)
        lowercase_      :Any         =			kwargs.pop("labels"     ,				lowercase						)
        if len(lowercase						) > 0:
           lowercase_      :Any         =			args[0]
           lowercase_      :Union[str, Any]         =			args[1:]

        if input_features is not None:
           lowercase_      :Optional[int]         =			self.feature_extractor.pad(lowercase     ,				*lowercase     ,				**lowercase						)
        if labels is not None:
           lowercase_      :str         =			self.tokenizer.pad(lowercase     ,				**lowercase						)

        if labels is None:
           return input_features
        elif input_features is None:
           return labels
        else:
           lowercase_      :Dict         =			labels["input_ids"]
           return input_features





     def 							lowercase__				(			self		: Any     ,				*lowercase		: List[str]     ,				**lowercase		: List[Any]						):





        """simple docstring"""




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





     def 							lowercase__				(			self		: Optional[int]     ,				*lowercase		: Tuple     ,				**lowercase		: Optional[int]						):





        """simple docstring"""




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







     @contextmanager
     def 							lowercase__				(			self		: Union[str, Any]						):





        """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."						)
        lowercase_      :Any         =			True
        lowercase_      :Optional[int]         =			self.tokenizer
        yield
        lowercase_      :Optional[Any]         =			self.feature_extractor
        lowercase_      :List[Any]         =			False









'''simple docstring'''


import sys

lowerCAmelCase :					List[Any] 							=(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)
def 							UpperCAmelCase_  (						__lowerCamelCase : str			):
   lowercase_      :List[str]         =			1
   for digit in s:
      product *= int(__lowerCamelCase			)
   return product
def 							UpperCAmelCase_  (						__lowerCamelCase : str = N			):
   lowercase_      :Any         =			-sys.maxsize - 1
   lowercase_      :int         =			n[:13]
   lowercase_      :Optional[int]         =			13
   while cur_index < len(__lowerCamelCase			) - 13:
      if int(n[cur_index]			) >= int(substr[0]			):
         lowercase_      :str         =			substr[1:] + n[cur_index]
         cur_index += 1
      else:
         lowercase_      :List[str]         =			max(__lowerCamelCase     ,str_eval(__lowerCamelCase			)			)
         lowercase_      :Any         =			n[cur_index : cur_index + 13]
         cur_index += 13
   return largest_product


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


