


'''simple docstring'''



def    lowerCamelCase__   ( A     :    int  ):




						'''simple docstring'''






						if divisor % 5 == 0 or divisor % 2 == 0:
												return 0
						UpperCAmelCase         =			1
						UpperCAmelCase         =			1
						while repunit:
												UpperCAmelCase         =			(10 * repunit + 1) % divisor
												repunit_index += 1
						return repunit_index


def    lowerCamelCase__   ( A     :    int = 1_00_00_00  ):




						'''simple docstring'''






						UpperCAmelCase         =			limit - 1
						if divisor % 2 == 0:
												divisor += 1
						while least_divisible_repunit(A  ) <= limit:
												divisor += 2
						return divisor


if __name__ == "__main__":
	print(F"""{solution() = }""")






'''simple docstring'''



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

import sentencepiece as spm

from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer
from ...utils import logging


_lowercase    :    str			     =  logging.get_logger(__name__)

_lowercase    :    List[Any]			     =  """▁"""

_lowercase    :    Optional[Any]			     =  {"""vocab_file""": """sentencepiece.bpe.model"""}

_lowercase    :    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"""
        ),
    }
}

_lowercase    :    int			     =  {
    """facebook/mbart-large-50-one-to-many-mmt""": 1024,
}

# fmt: off
_lowercase    :    int			     =  ["""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  UpperCamelCase__(     lowerCAmelCase ):
				__magic_name__       :   Optional[int]							= VOCAB_FILES_NAMES
				__magic_name__       :   Union[str, Any]							= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__magic_name__       :   Optional[int]							= PRETRAINED_VOCAB_FILES_MAP
				__magic_name__       :   Union[str, Any]							= ["input_ids", "attention_mask"]

				__magic_name__       :   List[int]							= []
				__magic_name__       :   List[int]							= []




				def __init__(	self    :				List[str]   ,					lowerCAmelCase    :				Optional[int]   ,					lowerCAmelCase    :				Optional[int]=None   ,					lowerCAmelCase    :				str=None   ,					lowerCAmelCase    :				List[Any]="</s>"   ,					lowerCAmelCase    :				Union[str, Any]="</s>"   ,					lowerCAmelCase    :				Union[str, Any]="<s>"   ,					lowerCAmelCase    :				int="<unk>"   ,					lowerCAmelCase    :				str="<pad>"   ,					lowerCAmelCase    :				Optional[int]="<mask>"   ,					lowerCAmelCase    :				Optional[Dict[str, Any]] = None   ,					**lowerCAmelCase    :				List[Any]   ,					)->  None:

										"""simple docstring"""




										UpperCAmelCase         =			AddedToken(lowerCAmelCase   ,					lstrip=lowerCAmelCase   ,					rstrip=lowerCAmelCase   ) if isinstance(lowerCAmelCase   ,					lowerCAmelCase   ) else mask_token

										UpperCAmelCase         =			{} if sp_model_kwargs is None else sp_model_kwargs

										UpperCAmelCase         =			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__(
										    src_lang=lowerCAmelCase   ,					tgt_lang=lowerCAmelCase   ,					eos_token=lowerCAmelCase   ,					unk_token=lowerCAmelCase   ,					sep_token=lowerCAmelCase   ,					cls_token=lowerCAmelCase   ,					pad_token=lowerCAmelCase   ,					mask_token=lowerCAmelCase   ,					sp_model_kwargs=self.sp_model_kwargs   ,					**lowerCAmelCase   ,					)

										UpperCAmelCase         =			spm.SentencePieceProcessor(**self.sp_model_kwargs   )
										self.sp_model.Load(str(lowerCAmelCase   )   )
										UpperCAmelCase         =			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'

										# Mimic fairseq token-to-id alignment for the first 4 token
										UpperCAmelCase         =			{'''<s>''': 0, '''<pad>''': 1, '''</s>''': 2, '''<unk>''': 3}

										# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
										UpperCAmelCase         =			1

										UpperCAmelCase         =			len(self.sp_model   )
										UpperCAmelCase         =			{
										    code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(lowerCAmelCase   )
										}
										UpperCAmelCase         =			{v: k for k, v in self.lang_code_to_id.items()}
										UpperCAmelCase         =			len(self.sp_model   ) + len(self.lang_code_to_id   ) + self.fairseq_offset

										self.fairseq_tokens_to_ids.update(self.lang_code_to_id   )
										UpperCAmelCase         =			{v: k for k, v in self.fairseq_tokens_to_ids.items()}

										UpperCAmelCase         =			src_lang if src_lang is not None else '''en_XX'''
										UpperCAmelCase         =			self.lang_code_to_id[self._src_lang]
										UpperCAmelCase         =			tgt_lang
										self.set_src_lang_special_tokens(self._src_lang   )




				@property
				def   a__(	self    :				Union[str, Any]   )->  int:

										"""simple docstring"""




										return len(self.sp_model   ) + len(self.lang_code_to_id   ) + self.fairseq_offset + 1  # Plus 1 for the mask token




				@property
				def   a__(	self    :				str   )->  str:

										"""simple docstring"""




										return self._src_lang




				@src_lang.setter
				def   a__(	self    :				Any   ,					lowerCAmelCase    :				str   )->  None:

										"""simple docstring"""




										UpperCAmelCase         =			new_src_lang
										self.set_src_lang_special_tokens(self._src_lang   )




				def __getstate__(	self    :				Tuple   )->  Dict:

										"""simple docstring"""




										UpperCAmelCase         =			self.__dict__.copy()
										UpperCAmelCase         =			None
										return state




				def __setstate__(	self    :				Dict   ,					lowerCAmelCase    :				Dict   )->  None:

										"""simple docstring"""




										UpperCAmelCase         =			d

										# for backward compatibility
										if not hasattr(self   ,					'''sp_model_kwargs'''   ):
																UpperCAmelCase         =			{}

										UpperCAmelCase         =			spm.SentencePieceProcessor(**self.sp_model_kwargs   )
										self.sp_model.Load(self.vocab_file   )




				def   a__(	self    :				Union[str, Any]   )->  Dict:

										"""simple docstring"""




										UpperCAmelCase         =			{self.convert_ids_to_tokens(lowerCAmelCase   ): i for i in range(self.vocab_size   )}
										vocab.update(self.added_tokens_encoder   )
										return vocab




				def   a__(	self    :				str   ,					lowerCAmelCase    :				str   )->  List[str]:

										"""simple docstring"""




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




				def   a__(	self    :				Optional[int]   ,					lowerCAmelCase    :				str   )->  int:

										"""simple docstring"""




										if token in self.fairseq_tokens_to_ids:
																return self.fairseq_tokens_to_ids[token]
										UpperCAmelCase         =			self.sp_model.PieceToId(lowerCAmelCase   )

										# 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   a__(	self    :				List[Any]   ,					lowerCAmelCase    :				int   )->  str:

										"""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   a__(	self    :				int   ,					lowerCAmelCase    :				List[Any]   )->  Dict:

										"""simple docstring"""




										UpperCAmelCase         =			[]
										UpperCAmelCase         =			''''''
										UpperCAmelCase         =			False
										for token in tokens:
																# make sure that special tokens are not decoded using sentencepiece model
																if token in self.all_special_tokens:
																						if not prev_is_special:
																												out_string += " "
																						out_string += self.sp_model.decode(lowerCAmelCase   ) + token
																						UpperCAmelCase         =			True
																						UpperCAmelCase         =			[]
																else:
																						current_sub_tokens.append(lowerCAmelCase   )
																						UpperCAmelCase         =			False
										out_string += self.sp_model.decode(lowerCAmelCase   )
										return out_string.strip()




				def   a__(	self    :				Union[str, Any]   ,					lowerCAmelCase    :				str   ,					lowerCAmelCase    :				Optional[str] = None   )->  Tuple[str]:

										"""simple docstring"""




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

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

										return (out_vocab_file,)




				def   a__(	self    :				List[str]   ,					lowerCAmelCase    :				List[int]   ,					lowerCAmelCase    :				Optional[List[int]] = None   ,					lowerCAmelCase    :				bool = False   )->  List[int]:

										"""simple docstring"""




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

										UpperCAmelCase         =			[1] * len(self.prefix_tokens   )
										UpperCAmelCase         =			[1] * len(self.suffix_tokens   )
										if token_ids_a is None:
																return prefix_ones + ([0] * len(lowerCAmelCase   )) + suffix_ones
										return prefix_ones + ([0] * len(lowerCAmelCase   )) + ([0] * len(lowerCAmelCase   )) + suffix_ones




				def   a__(	self    :				Tuple   ,					lowerCAmelCase    :				List[int]   ,					lowerCAmelCase    :				Optional[List[int]] = None   )->  List[int]:

										"""simple docstring"""




										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    :				List[Any]   ,					lowerCAmelCase    :				Union[str, Any]   ,					lowerCAmelCase    :				str   ,					lowerCAmelCase    :				Optional[str]   ,					lowerCAmelCase    :				Optional[str]   ,					**lowerCAmelCase    :				Optional[int]   )->  Optional[Any]:

										"""simple docstring"""




										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         =			src_lang
										UpperCAmelCase         =			self(lowerCAmelCase   ,					add_special_tokens=lowerCAmelCase   ,					return_tensors=lowerCAmelCase   ,					**lowerCAmelCase   )
										UpperCAmelCase         =			self.convert_tokens_to_ids(lowerCAmelCase   )
										UpperCAmelCase         =			tgt_lang_id
										return inputs




				def   a__(	self    :				str   ,					lowerCAmelCase    :				List[str]   ,					lowerCAmelCase    :				str = "en_XX"   ,					lowerCAmelCase    :				Optional[List[str]] = None   ,					lowerCAmelCase    :				str = "ro_RO"   ,					**lowerCAmelCase    :				List[str]   ,					)->  BatchEncoding:

										"""simple docstring"""




										UpperCAmelCase         =			src_lang
										UpperCAmelCase         =			tgt_lang
										return super().prepare_seqaseq_batch(lowerCAmelCase   ,					lowerCAmelCase   ,					**lowerCAmelCase   )




				def   a__(	self    :				Optional[int]   )->  Union[str, Any]:

										"""simple docstring"""




										return self.set_src_lang_special_tokens(self.src_lang   )




				def   a__(	self    :				List[Any]   )->  int:

										"""simple docstring"""




										return self.set_tgt_lang_special_tokens(self.tgt_lang   )




				def   a__(	self    :				List[Any]   ,					lowerCAmelCase    :				str   )->  None:

										"""simple docstring"""




										UpperCAmelCase         =			self.lang_code_to_id[src_lang]
										UpperCAmelCase         =			[self.cur_lang_code_id]
										UpperCAmelCase         =			[self.eos_token_id]





				def   a__(	self    :				int   ,					lowerCAmelCase    :				str   )->  None:

										"""simple docstring"""




										UpperCAmelCase         =			self.lang_code_to_id[tgt_lang]
										UpperCAmelCase         =			[self.cur_lang_code_id]
										UpperCAmelCase         =			[self.eos_token_id]





