





'''simple docstring'''







import json
import os
from functools import lru_cache
from typing import Dict, List, Optional, Tuple, Union

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...tokenization_utils_base import BatchEncoding, EncodedInput
from ...utils import PaddingStrategy, logging


lowerCAmelCase_   :       Tuple       =     logging.get_logger(__name__)


lowerCAmelCase_   :       int       =     {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

# See all LED models at https://huggingface.co/models?filter=LED
lowerCAmelCase_   :       str       =     {
    """vocab_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json""",
    },
    """merges_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt""",
    },
    """tokenizer_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json""",
    },
}

lowerCAmelCase_   :       List[str]       =     {
    """allenai/led-base-16384""": 1_63_84,
}






@lru_cache()
# Copied from transformers.models.bart.tokenization_bart.bytes_to_unicode
def 					_lowerCamelCase							(					)      ->      List[str]:
				_a				      =					(
				    list(range(ord("!"		)       ,				ord("~"		) + 1		)		) + list(range(ord("¡"		)       ,				ord("¬"		) + 1		)		) + list(range(ord("®"		)       ,				ord("ÿ"		) + 1		)		)
				)
				_a				      =					bs[:]
				_a				      =					0
				for b in range(2**8		):
								if b not in bs:
												bs.append(_lowerCAmelCase		)
												cs.append(2**8 + n		)
												n += 1
				_a				      =					[chr(_lowerCAmelCase		) for n in cs]
				return dict(zip(_lowerCAmelCase       ,				_lowerCAmelCase		)		)






def 					_lowerCamelCase							(					lowercase		: Optional[Any]		)      ->      Optional[Any]:
				_a				      =					set()
				_a				      =					word[0]
				for char in word[1:]:
								pairs.add((prev_char, char)		)
								_a				      =					char
				return pairs



class 							__SCREAMING_SNAKE_CASE    (__snake_case ):






				"""simple docstring"""







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




				def __init__(    self	:   List[str]   ,							__a	:   Optional[int]   ,							__a	:   Any   ,							__a	:   int="replace"   ,							__a	:   List[Any]="<s>"   ,							__a	:   int="</s>"   ,							__a	:   Any="</s>"   ,							__a	:   int="<s>"   ,							__a	:   Tuple="<unk>"   ,							__a	:   List[str]="<pad>"   ,							__a	:   Optional[int]="<mask>"   ,							__a	:   List[Any]=False   ,							**__a	:   Dict   ,							):
								_a				      =					AddedToken(A_   ,							lstrip=A_   ,							rstrip=A_   ) if isinstance(A_   ,							A_   ) else bos_token
								_a				      =					AddedToken(A_   ,							lstrip=A_   ,							rstrip=A_   ) if isinstance(A_   ,							A_   ) else eos_token
								_a				      =					AddedToken(A_   ,							lstrip=A_   ,							rstrip=A_   ) if isinstance(A_   ,							A_   ) else sep_token
								_a				      =					AddedToken(A_   ,							lstrip=A_   ,							rstrip=A_   ) if isinstance(A_   ,							A_   ) else cls_token
								_a				      =					AddedToken(A_   ,							lstrip=A_   ,							rstrip=A_   ) if isinstance(A_   ,							A_   ) else unk_token
								_a				      =					AddedToken(A_   ,							lstrip=A_   ,							rstrip=A_   ) if isinstance(A_   ,							A_   ) else pad_token

								# Mask token behave like a normal word, i.e. include the space before it
								_a				      =					AddedToken(A_   ,							lstrip=A_   ,							rstrip=A_   ) if isinstance(A_   ,							A_   ) else mask_token

								super().__init__(
								    errors=A_   ,							bos_token=A_   ,							eos_token=A_   ,							unk_token=A_   ,							sep_token=A_   ,							cls_token=A_   ,							pad_token=A_   ,							mask_token=A_   ,							add_prefix_space=A_   ,							**A_   ,							)

								with open(A_   ,							encoding="utf-8"   ) as vocab_handle:
												_a				      =					json.load(A_   )
								_a				      =					{v: k for k, v in self.encoder.items()}
								_a				      =					errors  # how to handle errors in decoding
								_a				      =					bytes_to_unicode()
								_a				      =					{v: k for k, v in self.byte_encoder.items()}
								with open(A_   ,							encoding="utf-8"   ) as merges_handle:
												_a				      =					merges_handle.read().split("\n"   )[1:-1]
								_a				      =					[tuple(merge.split()   ) for merge in bpe_merges]
								_a				      =					dict(zip(A_   ,							range(len(A_   )   )   )   )
								_a				      =					{}
								_a				      =					add_prefix_space

								# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
								_a				      =					re.compile(r"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"   )




				@property
				# Copied from transformers.models.bart.tokenization_bart.BartTokenizer.vocab_size
				def     UpperCamelCase__  (    self	:   Optional[Any]   ):
								return len(self.encoder   )




				def     UpperCamelCase__  (    self	:   str   ):
								return dict(self.encoder   ,							**self.added_tokens_encoder   )




				def     UpperCamelCase__  (    self	:   str   ,							__a	:   str   ):




								if token in self.cache:
												return self.cache[token]
								_a				      =					tuple(A_   )
								_a				      =					get_pairs(A_   )

								if not pairs:
												return token

								while True:
												_a				      =					min(A_   ,							key=lambda __a   : self.bpe_ranks.get(A_   ,							float("inf"   )   )   )
												if bigram not in self.bpe_ranks:
																break
												_a				      =					bigram
												_a				      =					[]
												_a				      =					0
												while i < len(A_   ):
																try:
																				_a				      =					word.index(A_   ,							A_   )
																except ValueError:
																				new_word.extend(word[i:]   )
																				break
																else:
																				new_word.extend(word[i:j]   )
																				_a				      =					j

																if word[i] == first and i < len(A_   ) - 1 and word[i + 1] == second:
																				new_word.append(first + second   )
																				i += 2
																else:
																				new_word.append(word[i]   )
																				i += 1
												_a				      =					tuple(A_   )
												_a				      =					new_word
												if len(A_   ) == 1:
																break
												else:
																_a				      =					get_pairs(A_   )
								_a				      =					" ".join(A_   )
								_a				      =					word
								return word




				def     UpperCamelCase__  (    self	:   Optional[Any]   ,							__a	:   str   ):
								_a				      =					[]
								for token in re.findall(self.pat   ,							A_   ):
												_a				      =					"".join(
												    self.byte_encoder[b] for b in token.encode("utf-8"   )   )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
												bpe_tokens.extend(bpe_token for bpe_token in self.bpe(A_   ).split(" "   )   )
								return bpe_tokens




				def     UpperCamelCase__  (    self	:   Union[str, Any]   ,							__a	:   Union[str, Any]   ):
								return self.encoder.get(A_   ,							self.encoder.get(self.unk_token   )   )




				def     UpperCamelCase__  (    self	:   Any   ,							__a	:   Any   ):
								return self.decoder.get(A_   )




				def     UpperCamelCase__  (    self	:   Dict   ,							__a	:   Union[str, Any]   ):
								_a				      =					"".join(A_   )
								_a				      =					bytearray([self.byte_decoder[c] for c in text]   ).decode("utf-8"   ,							errors=self.errors   )
								return text




				def     UpperCamelCase__  (    self	:   str   ,							__a	:   Dict   ,							__a	:   List[str] = None   ):




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

								with open(A_   ,							"w"   ,							encoding="utf-8"   ) as f:
												f.write(json.dumps(self.encoder   ,							indent=2   ,							sort_keys=A_   ,							ensure_ascii=A_   ) + "\n"   )

								_a				      =					0
								with open(A_   ,							"w"   ,							encoding="utf-8"   ) as writer:
												writer.write("#version: 0.2\n"   )
												for bpe_tokens, token_index in sorted(self.bpe_ranks.items()   ,							key=lambda __a   : kv[1]   ):
																if index != token_index:
																				logger.warning(
																				    f'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
																				    " Please check that the tokenizer is not corrupted!"   )
																				_a				      =					token_index
																writer.write(" ".join(A_   ) + "\n"   )
																index += 1

								return vocab_file, merge_file




				def     UpperCamelCase__  (    self	:   str   ,							__a	:   str   ,							__a	:   str = None   ):




								if token_ids_a is None:
												return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
								_a				      =					[self.cls_token_id]
								_a				      =					[self.sep_token_id]
								return cls + token_ids_a + sep + sep + token_ids_a + sep




				def     UpperCamelCase__  (    self	:   int   ,							__a	:   Any   ,							__a	:   Optional[int] = None   ,							__a	:   Optional[Any] = False   ):




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

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




				def     UpperCamelCase__  (    self	:   List[Any]   ,							__a	:   Optional[Any]   ,							__a	:   int = None   ):
								_a				      =					[self.sep_token_id]
								_a				      =					[self.cls_token_id]

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




				def     UpperCamelCase__  (    self	:   Dict   ,							__a	:   int   ,							__a	:   Any=False   ,							**__a	:   List[str]   ):
								_a				      =					kwargs.pop("add_prefix_space"   ,							self.add_prefix_space   )
								if (is_split_into_words or add_prefix_space) and (len(A_   ) > 0 and not text[0].isspace()):
												_a				      =					" " + text
								return (text, kwargs)




				def     UpperCamelCase__  (    self	:   Tuple   ,							__a	:   Any   ,							__a	:   List[str] = None   ,							__a	:   List[Any] = PaddingStrategy.DO_NOT_PAD   ,							__a	:   str = None   ,							__a	:   Any = None   ,							):
								_a				      =					super()._pad(
								    encoded_inputs=A_   ,							max_length=A_   ,							padding_strategy=A_   ,							pad_to_multiple_of=A_   ,							return_attention_mask=A_   ,							)

								# Load from model defaults
								if return_attention_mask is None:
												_a				      =					"attention_mask" in self.model_input_names

								if return_attention_mask and "global_attention_mask" in encoded_inputs:
												_a				      =					encoded_inputs[self.model_input_names[0]]
												# `global_attention_mask` need to have the same length as other (sequential) inputs.
												_a				      =					len(encoded_inputs["global_attention_mask"]   ) != len(A_   )

												if needs_to_be_padded:
																_a				      =					len(A_   ) - len(encoded_inputs["global_attention_mask"]   )

																if self.padding_side == "right":
																				# Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend`
																				_a				      =					(
																				    encoded_inputs["global_attention_mask"] + [-1] * difference
																				)
																elif self.padding_side == "left":
																				_a				      =					[-1] * difference + encoded_inputs[
																				    "global_attention_mask"
																				]
																else:
																				raise ValueError("Invalid padding strategy:" + str(self.padding_side   )   )

								return encoded_inputs







def 						A_							(	_lowerCAmelCase	)		->					bool:
 return str(_lowerCAmelCase	) == str(_lowerCAmelCase	)[::-1]



def 						A_							(	_lowerCAmelCase	)		->					int:
 return int(_lowerCAmelCase	) + int(str(_lowerCAmelCase	)[::-1]	)



def 						A_							(	_lowerCAmelCase = 1_0000	)		->					int:
 UpperCamelCase      :   List[Any]			      =  []
 for num in range(1				,  _lowerCAmelCase	):
  UpperCamelCase      :   Union[str, Any]			      =  0
  UpperCamelCase      :   List[str]			      =  num
  while iterations < 50:
   UpperCamelCase      :   int			      =  sum_reverse(_lowerCAmelCase	)
   iterations += 1
   if is_palindrome(_lowerCAmelCase	):
    break
  else:
   lychrel_nums.append(_lowerCAmelCase	)
 return len(_lowerCAmelCase	)


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