



"""simple docstring"""




import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin






class 	UpperCAmelCase_  (				__UpperCamelCase						):
      __SCREAMING_SNAKE_CASE						:   str      = 'AutoFeatureExtractor'
      __SCREAMING_SNAKE_CASE						:   Tuple      = 'Speech2Text2Tokenizer'



      def __init__(     self     :	Dict     ,	A     :	Tuple     ,	A     :	Optional[int]						):
           super().__init__(A     ,	A						)
           _UpperCAmelCase			:	str								=    self.feature_extractor
           _UpperCAmelCase			:	str								=    False



      def __call__(     self     :	Dict     ,	*A     :	str     ,	**A     :	List[Any]						):
           # For backward compatibility
           if self._in_target_context_manager:
                return self.current_processor(*A     ,	**A						)

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

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



      def 						snake_case_					(     self     :	List[Any]     ,	*A     :	List[Any]     ,	**A     :	List[str]						):
           return self.tokenizer.batch_decode(*A     ,	**A						)



      def 						snake_case_					(     self     :	Union[str, Any]     ,	*A     :	List[str]     ,	**A     :	Tuple						):
           return self.tokenizer.decode(*A     ,	**A						)



      @contextmanager
      def 						snake_case_					(     self     :	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."						)
           _UpperCAmelCase			:	str								=    True
           _UpperCAmelCase			:	Union[str, Any]								=    self.tokenizer
           yield
           _UpperCAmelCase			:	List[Any]								=    self.feature_extractor
           _UpperCAmelCase			:	int								=    False




def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__ = 100						):
 __lowerCamelCase		:							List[Any]							=						[[0 for _ in range(SCREAMING_SNAKE_CASE__						)] for _ in range(m + 1						)]
 for i in range(m + 1						):
  __lowerCamelCase		:							Any							=						1

 for n in range(m + 1						):
  for k in range(1			,       SCREAMING_SNAKE_CASE__						):
   memo[n][k] += memo[n][k - 1]
   if n > k:
    memo[n][k] += memo[n - k - 1][k]

 return memo[m][m - 1] - 1


if __name__ == "__main__":
       print(solution(int(input('Enter a number: ').strip())))

