






'''simple docstring'''





import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
						from .tokenization_mbartaa import MBartaaTokenizer
else:
						_UpperCamelCase		:		Dict								=			None


_UpperCamelCase		:		Optional[int]								=			logging.get_logger(__name__)

_UpperCamelCase		:		Tuple								=			{'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'}

_UpperCamelCase		:		Any								=			{
    'vocab_file': {
        'facebook/mbart-large-50-one-to-many-mmt': (
            'https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model'
        ),
    },
    'tokenizer_file': {
        'facebook/mbart-large-50-one-to-many-mmt': (
            'https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/tokenizer.json'
        ),
    },
}

_UpperCamelCase		:		Optional[Any]								=			{
    'facebook/mbart-large-50-one-to-many-mmt': 1_024,
}

# fmt: off
_UpperCamelCase		:		Any								=			['ar_AR', 'cs_CZ', 'de_DE', 'en_XX', 'es_XX', 'et_EE', 'fi_FI', 'fr_XX', 'gu_IN', 'hi_IN', 'it_IT', 'ja_XX', 'kk_KZ', 'ko_KR', 'lt_LT', 'lv_LV', 'my_MM', 'ne_NP', 'nl_XX', 'ro_RO', 'ru_RU', 'si_LK', 'tr_TR', 'vi_VN', 'zh_CN', 'af_ZA', 'az_AZ', 'bn_IN', 'fa_IR', 'he_IL', 'hr_HR', 'id_ID', 'ka_GE', 'km_KH', 'mk_MK', 'ml_IN', 'mn_MN', 'mr_IN', 'pl_PL', 'ps_AF', 'pt_XX', 'sv_SE', 'sw_KE', 'ta_IN', 'te_IN', 'th_TH', 'tl_XX', 'uk_UA', 'ur_PK', 'xh_ZA', 'gl_ES', 'sl_SI']


class 				snake_case__     (			UpperCamelCase):
					a_       =			VOCAB_FILES_NAMES
					a_       =			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					a_       =			PRETRAINED_VOCAB_FILES_MAP
					a_       =			["input_ids", "attention_mask"]
					a_       =			MBartaaTokenizer

					a_       =			[]
					a_       =			[]




					def __init__(       self       :						Dict							,				_A       :						str=None							,				_A       :						Union[str, Any]=None							,				_A       :						Optional[Any]=None							,				_A       :						str=None							,				_A       :						Any="</s>"							,				_A       :						int="</s>"							,				_A       :						Optional[Any]="<s>"							,				_A       :						Tuple="<unk>"							,				_A       :						Any="<pad>"							,				_A       :						Union[str, Any]="<mask>"							,				**_A       :						List[str]							,				)  ->    List[str]:
								# Mask token behave like a normal word, i.e. include the space before it
								UpperCAmelCase_     :   Union[str, Any]       =   AddedToken(_A							,				lstrip=_A							,				rstrip=_A     ) if isinstance(_A							,				_A     ) else mask_token

								UpperCAmelCase_     :   int       =   kwargs.get('''additional_special_tokens'''							,				[]     )
								kwargs["additional_special_tokens"] += [
								    code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
								]

								super().__init__(
								    _A							,				src_lang=_A							,				tgt_lang=_A							,				tokenizer_file=_A							,				eos_token=_A							,				sep_token=_A							,				cls_token=_A							,				unk_token=_A							,				pad_token=_A							,				mask_token=_A							,				**_A							,				)

								UpperCAmelCase_     :   Union[str, Any]       =   vocab_file
								UpperCAmelCase_     :   int       =   False if not self.vocab_file else True

								UpperCAmelCase_     :   List[Any]       =   {
								    lang_code: self.convert_tokens_to_ids(_A     ) for lang_code in FAIRSEQ_LANGUAGE_CODES
								}

								UpperCAmelCase_     :   Tuple       =   src_lang if src_lang is not None else '''en_XX'''
								UpperCAmelCase_     :   int       =   tgt_lang
								UpperCAmelCase_     :   Optional[int]       =   self.lang_code_to_id[self._src_lang]
								self.set_src_lang_special_tokens(self._src_lang     )




					@property
					def 						A     (       self       :						Tuple     )  ->    str:
								return self._src_lang




					@src_lang.setter
					def 						A     (       self       :						Dict							,				_A       :						str     )  ->    None:
								UpperCAmelCase_     :   int       =   new_src_lang
								self.set_src_lang_special_tokens(self._src_lang     )




					def 						A     (       self       :						Optional[Any]							,				_A       :						List[int]							,				_A       :						Optional[List[int]] = None     )  ->    List[int]:
								if token_ids_a is None:
											return self.prefix_tokens + token_ids_a + self.suffix_tokens
								# We don't expect to process pairs, but leave the pair logic for API consistency
								return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens




					def 						A     (       self       :						int							,				_A       :						List[str]							,				_A       :						str = "en_XX"							,				_A       :						Optional[List[str]] = None							,				_A       :						str = "ro_RO"							,				**_A       :						List[Any]							,				)  ->    BatchEncoding:
								UpperCAmelCase_     :   Any       =   src_lang
								UpperCAmelCase_     :   Union[str, Any]       =   tgt_lang
								return super().prepare_seqaseq_batch(_A							,				_A							,				**_A     )




					def 						A     (       self       :						List[Any]     )  ->    str:
								return self.set_src_lang_special_tokens(self.src_lang     )




					def 						A     (       self       :						Dict     )  ->    Optional[int]:
								return self.set_tgt_lang_special_tokens(self.tgt_lang     )




					def 						A     (       self       :						Optional[Any]							,				_A       :						str     )  ->    None:
								UpperCAmelCase_     :   int       =   self.convert_tokens_to_ids(_A     )
								UpperCAmelCase_     :   List[Any]       =   [self.cur_lang_code_id]
								UpperCAmelCase_     :   Optional[int]       =   [self.eos_token_id]

								UpperCAmelCase_     :   List[str]       =   self.convert_ids_to_tokens(self.prefix_tokens     )
								UpperCAmelCase_     :   List[str]       =   self.convert_ids_to_tokens(self.suffix_tokens     )

								UpperCAmelCase_     :   List[str]       =   processors.TemplateProcessing(
								    single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str							,				pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str							,				special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str							,				self.prefix_tokens + self.suffix_tokens     )     )							,				)




					def 						A     (       self       :						Optional[int]							,				_A       :						str     )  ->    None:
								UpperCAmelCase_     :   Optional[Any]       =   self.convert_tokens_to_ids(_A     )
								UpperCAmelCase_     :   Optional[Any]       =   [self.cur_lang_code_id]
								UpperCAmelCase_     :   str       =   [self.eos_token_id]

								UpperCAmelCase_     :   Union[str, Any]       =   self.convert_ids_to_tokens(self.prefix_tokens     )
								UpperCAmelCase_     :   Tuple       =   self.convert_ids_to_tokens(self.suffix_tokens     )

								UpperCAmelCase_     :   Optional[Any]       =   processors.TemplateProcessing(
								    single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str							,				pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str							,				special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str							,				self.prefix_tokens + self.suffix_tokens     )     )							,				)




					def 						A     (       self       :						Tuple							,				_A       :						List[Any]							,				_A       :						str							,				_A       :						Optional[str]							,				_A       :						Optional[str]							,				**_A       :						Any     )  ->    List[Any]:
								if src_lang is None or tgt_lang is None:
											raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model'''     )
								UpperCAmelCase_     :   str       =   src_lang
								UpperCAmelCase_     :   Tuple       =   self(_A							,				add_special_tokens=_A							,				return_tensors=_A							,				**_A     )
								UpperCAmelCase_     :   Any       =   self.convert_tokens_to_ids(_A     )
								UpperCAmelCase_     :   Optional[int]       =   tgt_lang_id
								return inputs





					def 						A     (       self       :						Dict							,				_A       :						str							,				_A       :						Optional[str] = None     )  ->    Tuple[str]:
								if not self.can_save_slow_tokenizer:
											raise ValueError(
											    '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
											    '''tokenizer.'''     )

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

								if os.path.abspath(self.vocab_file     ) != os.path.abspath(_A     ):
											copyfile(self.vocab_file							,				_A     )

								return (out_vocab_file,)










'''simple docstring'''





def __UpperCAmelCase (			)  -> Optional[Any]:
			UpperCAmelCase_     :   Union[str, Any]       =   1

			while True:
						if (
						    sorted(str(A						)						)
						    == 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())


