

'''simple docstring'''

import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
 from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

 from .test_feature_extraction_speechta import floats_list


lowercase__            =     get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")




@require_torch
class 			A_					(							unittest.TestCase				):






     '''simple docstring'''



     def   UpperCAmelCase_			(						self					:	List[str]			)		->      Dict:
      UpperCAmelCase			:      List[str]		   =					tempfile.mkdtemp()

      UpperCAmelCase			:      Optional[Any]		   =					SpeechTaTokenizer(lowercase_			)
      tokenizer.save_pretrained(self.tmpdirname			)

      UpperCAmelCase			:      Optional[int]		   =					{
          'feature_size': 1,
          'padding_value': 0.0,
          'sampling_rate': 16_000,
          'do_normalize': False,
          'num_mel_bins': 80,
          'hop_length': 16,
          'win_length': 64,
          'win_function': 'hann_window',
          'fmin': 80,
          'fmax': 7_600,
          'mel_floor': 1E-10,
          'reduction_factor': 2,
          'return_attention_mask': True,
      }

      UpperCAmelCase			:      Union[str, Any]		   =					os.path.join(self.tmpdirname	,     lowercase_			)
      with open(self.feature_extraction_file	,     'w'	,     encoding='utf-8'			) as fp:
       fp.write(json.dumps(lowercase_			) + '\n'			)


     def   UpperCAmelCase_			(						self					:	Optional[int]	,     **lowercase_					:	Dict			)		->      List[Any]:
      return SpeechTaTokenizer.from_pretrained(self.tmpdirname	,     **lowercase_			)


     def   UpperCAmelCase_			(						self					:	int	,     **lowercase_					:	List[Any]			)		->      Union[str, Any]:
      return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname	,     **lowercase_			)


     def   UpperCAmelCase_			(						self					:	Optional[int]			)		->      List[Any]:
      shutil.rmtree(self.tmpdirname			)


     def   UpperCAmelCase_			(						self					:	Optional[Any]			)		->      Any:
      UpperCAmelCase			:      List[Any]		   =					self.get_tokenizer()
      UpperCAmelCase			:      Union[str, Any]		   =					self.get_feature_extractor()

      UpperCAmelCase			:      Dict		   =					SpeechTaProcessor(tokenizer=lowercase_	,     feature_extractor=lowercase_			)

      processor.save_pretrained(self.tmpdirname			)
      UpperCAmelCase			:      Optional[Any]		   =					SpeechTaProcessor.from_pretrained(self.tmpdirname			)

      self.assertEqual(processor.tokenizer.get_vocab()	,     tokenizer.get_vocab()			)
      self.assertIsInstance(processor.tokenizer	,     lowercase_			)

      self.assertEqual(processor.feature_extractor.to_json_string()	,     feature_extractor.to_json_string()			)
      self.assertIsInstance(processor.feature_extractor	,     lowercase_			)


     def   UpperCAmelCase_			(						self					:	str			)		->      int:
      UpperCAmelCase			:      Any		   =					SpeechTaProcessor(tokenizer=self.get_tokenizer()	,     feature_extractor=self.get_feature_extractor()			)
      processor.save_pretrained(self.tmpdirname			)

      UpperCAmelCase			:      List[Any]		   =					self.get_tokenizer(bos_token='(BOS)'	,     eos_token='(EOS)'			)
      UpperCAmelCase			:      Optional[Any]		   =					self.get_feature_extractor(do_normalize=lowercase_	,     padding_value=1.0			)

      UpperCAmelCase			:      int		   =					SpeechTaProcessor.from_pretrained(
          self.tmpdirname	,     bos_token='(BOS)'	,     eos_token='(EOS)'	,     do_normalize=lowercase_	,     padding_value=1.0			)

      self.assertEqual(processor.tokenizer.get_vocab()	,     tokenizer_add_kwargs.get_vocab()			)
      self.assertIsInstance(processor.tokenizer	,     lowercase_			)

      self.assertEqual(processor.feature_extractor.to_json_string()	,     feature_extractor_add_kwargs.to_json_string()			)
      self.assertIsInstance(processor.feature_extractor	,     lowercase_			)


     def   UpperCAmelCase_			(						self					:	List[str]			)		->      Any:
      UpperCAmelCase			:      List[str]		   =					self.get_feature_extractor()
      UpperCAmelCase			:      int		   =					self.get_tokenizer()

      UpperCAmelCase			:      Tuple		   =					SpeechTaProcessor(tokenizer=lowercase_	,     feature_extractor=lowercase_			)

      UpperCAmelCase			:      List[str]		   =					floats_list((3, 1_000)			)

      UpperCAmelCase			:      str		   =					feature_extractor(audio=lowercase_	,     return_tensors='np'			)
      UpperCAmelCase			:      Optional[int]		   =					processor(audio=lowercase_	,     return_tensors='np'			)

      for key in input_feat_extract.keys():
       self.assertAlmostEqual(input_feat_extract[key].sum()	,     input_processor[key].sum()	,     delta=1E-2			)


     def   UpperCAmelCase_			(						self					:	List[Any]			)		->      Tuple:
      UpperCAmelCase			:      int		   =					self.get_feature_extractor()
      UpperCAmelCase			:      Dict		   =					self.get_tokenizer()

      UpperCAmelCase			:      Tuple		   =					SpeechTaProcessor(tokenizer=lowercase_	,     feature_extractor=lowercase_			)

      UpperCAmelCase			:      Any		   =					floats_list((3, 1_000)			)

      UpperCAmelCase			:      int		   =					feature_extractor(audio_target=lowercase_	,     return_tensors='np'			)
      UpperCAmelCase			:      Dict		   =					processor(audio_target=lowercase_	,     return_tensors='np'			)

      for key in input_feat_extract.keys():
       self.assertAlmostEqual(input_feat_extract[key].sum()	,     input_processor[key].sum()	,     delta=1E-2			)


     def   UpperCAmelCase_			(						self					:	List[Any]			)		->      List[str]:
      UpperCAmelCase			:      List[str]		   =					self.get_feature_extractor()
      UpperCAmelCase			:      List[Any]		   =					self.get_tokenizer()

      UpperCAmelCase			:      Tuple		   =					SpeechTaProcessor(tokenizer=lowercase_	,     feature_extractor=lowercase_			)

      UpperCAmelCase			:      Optional[Any]		   =					'This is a test string'

      UpperCAmelCase			:      Any		   =					processor(text=lowercase_			)
      UpperCAmelCase			:      List[Any]		   =					tokenizer(lowercase_			)

      for key in encoded_tok.keys():
       self.assertListEqual(encoded_tok[key]	,     encoded_processor[key]			)


     def   UpperCAmelCase_			(						self					:	str			)		->      str:
      UpperCAmelCase			:      Dict		   =					self.get_feature_extractor()
      UpperCAmelCase			:      Any		   =					self.get_tokenizer()

      UpperCAmelCase			:      Dict		   =					SpeechTaProcessor(tokenizer=lowercase_	,     feature_extractor=lowercase_			)

      UpperCAmelCase			:      Union[str, Any]		   =					'This is a test string'

      UpperCAmelCase			:      Tuple		   =					processor(text_target=lowercase_			)
      UpperCAmelCase			:      List[str]		   =					tokenizer(lowercase_			)

      for key in encoded_tok.keys():
       self.assertListEqual(encoded_tok[key]	,     encoded_processor[key]			)


     def   UpperCAmelCase_			(						self					:	Tuple			)		->      Union[str, Any]:
      UpperCAmelCase			:      List[str]		   =					self.get_feature_extractor()
      UpperCAmelCase			:      Optional[Any]		   =					self.get_tokenizer()

      UpperCAmelCase			:      str		   =					SpeechTaProcessor(tokenizer=lowercase_	,     feature_extractor=lowercase_			)

      UpperCAmelCase			:      List[str]		   =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      UpperCAmelCase			:      Optional[Any]		   =					processor.batch_decode(lowercase_			)
      UpperCAmelCase			:      Any		   =					tokenizer.batch_decode(lowercase_			)

      self.assertListEqual(lowercase_	,     lowercase_			)




     def   UpperCAmelCase_			(						self					:	Tuple			)		->      List[str]:
      UpperCAmelCase			:      Optional[Any]		   =					self.get_feature_extractor()
      UpperCAmelCase			:      Dict		   =					self.get_tokenizer()

      UpperCAmelCase			:      Optional[Any]		   =					SpeechTaProcessor(tokenizer=lowercase_	,     feature_extractor=lowercase_			)

      self.assertListEqual(
          processor.model_input_names	,     feature_extractor.model_input_names	,     msg='`processor` and `feature_extractor` model input names do not match'	,     )







'''simple docstring'''

def  UpperCamelCase(	UpperCAmelCase_ = 1_00      ):
 UpperCAmelCase			:      Optional[Any]		   =					[[0 for _ in range(UpperCAmelCase_      )] for _ in range(m + 1      )]
 for i in range(m + 1      ):
  UpperCAmelCase			:      Optional[int]		   =					1

 for n in range(m + 1      ):
  for k in range(1    ,			UpperCAmelCase_      ):
   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())))




