


'''simple docstring'''
import collections
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__snake_case							      =     logging.get_logger(__name__)

__snake_case							      =     '''▁'''

__snake_case							      =     {'''vocab_file''': '''prophetnet.tokenizer'''}

__snake_case							      =     {
    '''vocab_file''': {
        '''microsoft/xprophetnet-large-wiki100-cased''': (
            '''https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/prophetnet.tokenizer'''
        ),
    }
}

__snake_case							      =     {
    '''microsoft/xprophetnet-large-wiki100-cased''': {'''do_lower_case''': False},
}

__snake_case							      =     {
    '''microsoft/xprophetnet-large-wiki100-cased''': 512,
}


def 			a      (			__a   )  ->	List[Any]:



					'''simple docstring'''






					UpperCamelCase__   :Optional[int]												= collections.OrderedDict()
					with open(__a ,					'''r''' ,					encoding='''utf-8'''   ) as reader:
										UpperCamelCase__   :int												= reader.readlines()
					for index, token in enumerate(__a   ):
										UpperCamelCase__   :Tuple												= token.rstrip('''\n'''   )
										UpperCamelCase__   :List[Any]												= index
					return vocab







class    lowercase	(							A__					):

		"""simple docstring"""

		_a     =				VOCAB_FILES_NAMES
		_a     =				PRETRAINED_VOCAB_FILES_MAP
		_a     =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		_a     =				['input_ids', 'attention_mask']




		def __init__(		self    ,   UpperCamelCase_    ,   UpperCamelCase_="[SEP]"    ,   UpperCamelCase_="[SEP]"    ,   UpperCamelCase_="[SEP]"    ,   UpperCamelCase_="[UNK]"    ,   UpperCamelCase_="[PAD]"    ,   UpperCamelCase_="[CLS]"    ,   UpperCamelCase_="[MASK]"    ,   UpperCamelCase_ = None    ,   **UpperCamelCase_    ,   ):

							'''simple docstring'''


							UpperCamelCase__   :Any												= {} if sp_model_kwargs is None else sp_model_kwargs

							super().__init__(
							    bos_token=UpperCamelCase_    ,   eos_token=UpperCamelCase_    ,   sep_token=UpperCamelCase_    ,   unk_token=UpperCamelCase_    ,   pad_token=UpperCamelCase_    ,   cls_token=UpperCamelCase_    ,   mask_token=UpperCamelCase_    ,   sp_model_kwargs=self.sp_model_kwargs    ,   **UpperCamelCase_    ,   )

							try:
												import sentencepiece as spm
							except ImportError:
												logger.warning(
												    '''You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'''
												    ''' pip install sentencepiece'''							)
												raise

							UpperCamelCase__   :str												= spm.SentencePieceProcessor(**self.sp_model_kwargs							)
							self.sp_model.Load(str(UpperCamelCase_							)							)
							UpperCamelCase__   :Dict												= vocab_file

							# Original fairseq vocab and spm vocab must be "aligned":
							# Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
							# -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
							# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
							# spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

							# put special tokens and [unused] tokens into the vocab
							UpperCamelCase__   :Any												= {'''[PAD]''': 0, '''[CLS]''': 1, '''[SEP]''': 2, '''[UNK]''': 3, '''[MASK]''': 4}

							for i in range(10							):
												UpperCamelCase__   :str												= F'''[unused{i}]'''
												UpperCamelCase__   :Dict												= 5 + i

							# The first "real" token "," has position 15 in the embedding vocab and position 3 in the spm vocab
							UpperCamelCase__   :str												= 12
							UpperCamelCase__   :int												= {v: k for k, v in self.fairseq_tokens_to_ids.items()}
							for k in self.fairseq_tokens_to_ids.keys():
												self.unique_no_split_tokens.append(UpperCamelCase_							)




		def __getstate__(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Tuple												= self.__dict__.copy()
							UpperCamelCase__   :Optional[Any]												= None
							return state




		def __setstate__(		self    ,   UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__   :Any												= d
							try:
												import sentencepiece as spm
							except ImportError:
												logger.warning(
												    '''You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'''
												    ''' pip install sentencepiece'''							)
												raise

							# for backward compatibility
							if not hasattr(self    ,   '''sp_model_kwargs'''							):
												UpperCamelCase__   :Optional[Any]												= {}

							UpperCamelCase__   :Any												= spm.SentencePieceProcessor(**self.sp_model_kwargs							)
							self.sp_model.Load(self.vocab_file							)




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_ = None    ,   UpperCamelCase_ = False							):

							'''simple docstring'''


							if already_has_special_tokens:
												return super().get_special_tokens_mask(
												    token_ids_a=UpperCamelCase_    ,   token_ids_a=UpperCamelCase_    ,   already_has_special_tokens=UpperCamelCase_							)

							if token_ids_a is None:
												return ([0] * len(UpperCamelCase_							)) + [1]
							return ([0] * len(UpperCamelCase_							)) + [1] + ([0] * len(UpperCamelCase_							)) + [1]




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_ = None							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[int]												= [self.sep_token_id]

							if token_ids_a is None:
												return len(token_ids_a + sep							) * [0]
							return len(token_ids_a + sep + sep + token_ids_a + sep							) * [0]




		@property
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							return len(self.sp_model							) + self.fairseq_offset




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[int]												= {self.convert_ids_to_tokens(UpperCamelCase_							): i for i in range(self.vocab_size							)}
							vocab.update(self.added_tokens_encoder							)
							return vocab




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_							):

							'''simple docstring'''


							return self.sp_model.encode(UpperCamelCase_    ,   out_type=UpperCamelCase_							)




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_							):

							'''simple docstring'''


							if token in self.fairseq_tokens_to_ids:
												return self.fairseq_tokens_to_ids[token]
							UpperCamelCase__   :Tuple												= self.sp_model.PieceToId(UpperCamelCase_							)

							# Need to return unknown token if the SP model returned 0
							return spm_id + self.fairseq_offset if spm_id else self.unk_token_id




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_							):

							'''simple docstring'''


							if index in self.fairseq_ids_to_tokens:
												return self.fairseq_ids_to_tokens[index]
							return self.sp_model.IdToPiece(index - self.fairseq_offset							)




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__   :Tuple												= ''''''.join(UpperCamelCase_							).replace(UpperCamelCase_    ,   ''' '''							).strip()
							return out_string




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_ = None							):

							'''simple docstring'''


							if not os.path.isdir(UpperCamelCase_							):
												logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''							)
												return
							UpperCamelCase__   :str												= os.path.join(
							    UpperCamelCase_    ,   (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']							)

							if os.path.abspath(self.vocab_file							) != os.path.abspath(UpperCamelCase_							) and os.path.isfile(self.vocab_file							):
												copyfile(self.vocab_file    ,   UpperCamelCase_							)
							elif not os.path.isfile(self.vocab_file							):
												with open(UpperCamelCase_    ,   '''wb'''							) as fi:
																	UpperCamelCase__   :Dict												= self.sp_model.serialized_model_proto()
																	fi.write(UpperCamelCase_							)

							return (out_vocab_file,)




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_ = None							):

							'''simple docstring'''


							if token_ids_a is None:
												return token_ids_a + [self.sep_token_id]
							UpperCamelCase__   :Tuple												= [self.sep_token_id]
							return token_ids_a + sep + token_ids_a + sep



'''simple docstring'''
def 			a      (			__a   )  ->	"list[int]":



					'''simple docstring'''






					if upper_limit < 0:
										raise ValueError('''Limit for the Catalan sequence must be ≥ 0'''   )

					UpperCamelCase__   :Optional[Any]												= [0] * (upper_limit + 1)

					# Base case: C(0) = C(1) = 1
					UpperCamelCase__   :int												= 1
					if upper_limit > 0:
										UpperCamelCase__   :int												= 1

					# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
					for i in range(2 ,					upper_limit + 1   ):
										for j in range(__a   ):
															catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

					return catalan_list


if __name__ == "__main__":
		print('''\n********* Catalan Numbers Using Dynamic Programming ************\n''')
		print('''\n*** Enter -1 at any time to quit ***''')
		print('''\nEnter the upper limit (≥ 0) for the Catalan number sequence: ''', end='''''')
		try:
				while True:
						__snake_case							      =     int(input().strip())
						if N < 0:
								print('''\n********* Goodbye!! ************''')
								break
						else:
								print(F"""The Catalan numbers from 0 through {N} are:""")
								print(catalan_numbers(N))
								print('''Try another upper limit for the sequence: ''', end='''''')
		except (NameError, ValueError):
				print('''\n********* Invalid input, goodbye! ************\n''')

		import doctest

		doctest.testmod()