



"""simple docstring"""




def   lowercase__     (			)     ->			Optional[int]:






      '''simple docstring'''


      lowercase  :      Any					=   1

      while True:
            if (
                sorted(str(_UpperCAmelCase				)				)
                == sorted(str(2 * i				)				)
                == sorted(str(3 * i				)				)
                == sorted(str(4 * i				)				)
                == sorted(str(5 * i				)				)
                == sorted(str(6 * i				)				)
            ):
                  return i

            i += 1


if __name__ == "__main__":
     print(solution())





"""simple docstring"""




import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin


class   a__		(						SCREAMING_SNAKE_CASE__     ):
   _lowerCamelCase												=				'AutoFeatureExtractor'
   _lowerCamelCase												=				'Speech2Text2Tokenizer'


   def __init__(							self      :							str,     lowerCAmelCase      :							List[str],     lowerCAmelCase      :							Optional[Any]			)    ->       Dict:
         super().__init__(lowerCAmelCase,     lowerCAmelCase			)
         lowercase  :      Tuple					=   self.feature_extractor
         lowercase  :      Any					=   False


   def __call__(							self      :							Tuple,     *lowerCAmelCase      :							Tuple,     **lowerCAmelCase      :							Tuple			)    ->       Dict:
         # For backward compatibility
         if self._in_target_context_manager:
               return self.current_processor(*lowerCAmelCase,     **lowerCAmelCase			)

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

         if text is None:
               return inputs
         elif audio is None:
               return encodings
         else:
               lowercase  :      Tuple					=   encodings['input_ids']
               return inputs


   def        lowercase				(							self      :							str,     *lowerCAmelCase      :							List[str],     **lowerCAmelCase      :							Union[str, Any]			)    ->       str:
         return self.tokenizer.batch_decode(*lowerCAmelCase,     **lowerCAmelCase			)


   def        lowercase				(							self      :							Tuple,     *lowerCAmelCase      :							Union[str, Any],     **lowerCAmelCase      :							int			)    ->       Dict:
         return self.tokenizer.decode(*lowerCAmelCase,     **lowerCAmelCase			)






   @contextmanager
   def        lowercase				(							self      :							str			)    ->       Any:
         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  :      Optional[Any]					=   True
         lowercase  :      Any					=   self.tokenizer
         yield
         lowercase  :      Any					=   self.feature_extractor
         lowercase  :      Any					=   False
