

'''simple docstring'''

def     __magic_name__       ( A = 9_9_8_0_0_1							)			->		int:

	# fetches the next number
	for number in range(n - 1					,   9_9_9_9					,   -1							):
		snake_case							 =				str(A							)

		# checks whether 'str_number' is a palindrome.
		if str_number == str_number[::-1]:
			snake_case							 =				9_9_9

			# if 'number' is a product of two 3-digit numbers
			# then number is the answer otherwise fetch next number.
			while divisor != 9_9:
				if (number % divisor == 0) and (len(str(number // divisor							)							) == 3.0):
					return number
				divisor -= 1
	raise ValueError('That number is larger than our acceptable range.'							)


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








'''simple docstring'''

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

import numpy as np
import regex as re

from ...utils import is_tf_available, is_torch_available, logging


if TYPE_CHECKING:
						if is_torch_available():
												import torch
						if is_tf_available():
												import tensorflow as tf

from ...tokenization_utils import AddedToken, PreTrainedTokenizer


lowerCAmelCase_						   =			logging.get_logger(__name__)

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

lowerCAmelCase_						   =			{
    "vocab_file": {
        "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/vocab.json",
    },
    "merges_file": {
        "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/merges.txt",
    },
}

lowerCAmelCase_						   =			{
    "Salesforce/codegen-350M-mono": 2_0_4_8,
}

@lru_cache()
def     __magic_name__       ( )			->		List[str]:
	snake_case							 =				(
	    list(range(ord('!'							)					,   ord('~'							) + 1							)							) + list(range(ord('¡'							)					,   ord('¬'							) + 1							)							) + list(range(ord('®'							)					,   ord('ÿ'							) + 1							)							)
	)
	snake_case							 =				bs[:]
	snake_case							 =				0
	for b in range(2**8							):
		if b not in bs:
			bs.append(A							)
			cs.append(2**8 + n							)
			n += 1
	snake_case							 =				[chr(A							) for n in cs]
	return dict(zip(A					,   A							)							)

def     __magic_name__       ( A							)			->		int:
	snake_case							 =				set()
	snake_case							 =				word[0]
	for char in word[1:]:
		pairs.add((prev_char, char)							)
		snake_case							 =				char
	return pairs







class lowerCamelCase      (						__lowerCAmelCase							):
				snake_case_           =   VOCAB_FILES_NAMES
				snake_case_           =   PRETRAINED_VOCAB_FILES_MAP
				snake_case_           =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				snake_case_           =   ['''input_ids''', '''attention_mask''']

				def __init__(					self,	lowercase_,	lowercase_,	lowercase_="replace",	lowercase_="<|endoftext|>",	lowercase_="<|endoftext|>",	lowercase_="<|endoftext|>",	lowercase_=None,	lowercase_=False,	lowercase_=False,	**lowercase_,	)						->       int:
					snake_case							 =				AddedToken(lowercase_,	lstrip=lowercase_,	rstrip=lowercase_   ) if isinstance(lowercase_,	lowercase_   ) else bos_token
					snake_case							 =				AddedToken(lowercase_,	lstrip=lowercase_,	rstrip=lowercase_   ) if isinstance(lowercase_,	lowercase_   ) else eos_token
					snake_case							 =				AddedToken(lowercase_,	lstrip=lowercase_,	rstrip=lowercase_   ) if isinstance(lowercase_,	lowercase_   ) else unk_token
					snake_case							 =				AddedToken(lowercase_,	lstrip=lowercase_,	rstrip=lowercase_   ) if isinstance(lowercase_,	lowercase_   ) else pad_token
					super().__init__(
					    errors=lowercase_,	unk_token=lowercase_,	bos_token=lowercase_,	eos_token=lowercase_,	pad_token=lowercase_,	add_prefix_space=lowercase_,	add_bos_token=lowercase_,	**lowercase_,	)
					snake_case							 =				add_bos_token

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

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

				@property
				def 				_lowerCamelCase						(					self   )						->       Tuple:
					return len(self.encoder   )

				def 				_lowerCamelCase						(					self   )						->       str:
					return dict(self.encoder,	**self.added_tokens_encoder   )

				def 				_lowerCamelCase						(					self,	lowercase_   )						->       Optional[int]:
					if token in self.cache:
						return self.cache[token]
					snake_case							 =				tuple(lowercase_   )
					snake_case							 =				get_pairs(lowercase_   )

					if not pairs:
						return token

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

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

				def 				_lowerCamelCase						(					self,	lowercase_,	lowercase_=None   )						->       int:
					if self.add_bos_token:
						snake_case							 =				[self.bos_token_id]
					else:
						snake_case							 =				[]

					snake_case							 =				bos_token_ids + token_ids_a

					if token_ids_a is None:
						return output

					return output + bos_token_ids + token_ids_a

				def 				_lowerCamelCase						(					self,	lowercase_   )						->       Union[str, Any]:
					snake_case							 =				[]
					for token in re.findall(self.pat,	lowercase_   ):
						snake_case							 =				''.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(lowercase_   ).split(' '   )   )
					return bpe_tokens

				def 				_lowerCamelCase						(					self,	lowercase_   )						->       int:
					return self.encoder.get(lowercase_,	self.encoder.get(self.unk_token   )   )

				def 				_lowerCamelCase						(					self,	lowercase_   )						->       Optional[int]:
					return self.decoder.get(lowercase_   )

				def 				_lowerCamelCase						(					self,	lowercase_   )						->       Optional[int]:
					snake_case							 =				''.join(lowercase_   )
					snake_case							 =				bytearray([self.byte_decoder[c] for c in text]   ).decode('utf-8',	errors=self.errors   )
					return text

				def 				_lowerCamelCase						(					self,	lowercase_,	lowercase_ = None   )						->       Tuple[str]:
					if not os.path.isdir(lowercase_   ):
						logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''   )
						return
					snake_case							 =				os.path.join(
					    lowercase_,	(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']   )
					snake_case							 =				os.path.join(
					    lowercase_,	(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']   )

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

					snake_case							 =				0
					with open(lowercase_,	'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 lowercase_   : 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!'   )
								snake_case							 =				token_index
							writer.write(' '.join(lowercase_   ) + '\n'   )
							index += 1

					return vocab_file, merge_file

				def 				_lowerCamelCase						(					self,	lowercase_,	lowercase_=False,	**lowercase_   )						->       List[str]:
					snake_case							 =				kwargs.pop('add_prefix_space',	self.add_prefix_space   )
					if is_split_into_words or add_prefix_space:
						snake_case							 =				' ' + text
					return (text, kwargs)

				def 				_lowerCamelCase						(					self,	lowercase_,	lowercase_ = False,	lowercase_ = None,	lowercase_ = None,	**lowercase_,	)						->       str:
					snake_case							 =				super()._decode(
					    token_ids=lowercase_,	skip_special_tokens=lowercase_,	clean_up_tokenization_spaces=lowercase_,	**lowercase_,	)

					if truncate_before_pattern is not None and len(lowercase_   ) > 0:
						snake_case							 =				self.truncate(lowercase_,	lowercase_   )

					return decoded_text






				def 				_lowerCamelCase						(					self,	lowercase_,	lowercase_   )						->       Optional[int]:
					def find_re(lowercase_,	lowercase_,	lowercase_   ):
						snake_case							 =				pattern.search(lowercase_,	lowercase_   )
						return m.start() if m else -1

					snake_case							 =				[re.compile(lowercase_,	re.MULTILINE   ) for pattern in truncate_before_pattern]

					snake_case							 =				list(re.finditer('^print',	lowercase_,	re.MULTILINE   )   )

					if len(lowercase_   ) > 1:
						snake_case							 =				completion[: prints[1].start()]

					snake_case							 =				list(re.finditer('^def',	lowercase_,	re.MULTILINE   )   )

					if len(lowercase_   ) > 1:
						snake_case							 =				completion[: defs[1].start()]

					snake_case							 =				0

					snake_case							 =				[
					    pos for pos in [find_re(lowercase_,	lowercase_,	lowercase_   ) for terminal in terminals] if pos != -1
					]

					if len(lowercase_   ) > 0:
						return completion[: min(lowercase_   )]
					else:
						return completion





