






def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__ = 99_8001				)						->       List[str]:







			'''simple docstring'''

			UpperCAmelCase     	=       0
			for i in range(999    ,    99    ,    -1				):  # 3 digit numbers range from 999 down to 100
						for j in range(999    ,    99    ,    -1				):
									UpperCAmelCase     	=       str(i * j				)
									if product_string == product_string[::-1] and i * j < n:
												UpperCAmelCase     	=       max(_A    ,    i * j				)
			return answer


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










import os
from typing import List, Union

import tensorflow as tf
from tensorflow_text import BertTokenizer as BertTokenizerLayer
from tensorflow_text import FastBertTokenizer, ShrinkLongestTrimmer, case_fold_utfa, combine_segments, pad_model_inputs

from .tokenization_bert import BertTokenizer

class 			A_ (tf.keras.layers.Layer    ):
	def __init__(					self							,      _A							,      _A							,      _A = None							,      _A = None							,      _A = None							,      _A = "longest"							,      _A = True							,      _A = 5_1_2							,      _A = None							,      _A = True							,      _A = True							,      _A = True							,      **_A							,      ):






				'''simple docstring'''







				super().__init__()
				if use_fast_bert_tokenizer:
							UpperCAmelCase     	=       FastBertTokenizer(
							    _A							,      token_out_type=tf.intaa							,      lower_case_nfd_strip_accents=_A							,      **_A	)
				else:
							UpperCAmelCase     	=       tf.lookup.StaticVocabularyTable(
							    tf.lookup.KeyValueTensorInitializer(
							        keys=_A							,      key_dtype=tf.string							,      values=tf.range(tf.size(_A							,      out_type=tf.intaa	)							,      dtype=tf.intaa	)							,      value_dtype=tf.intaa							,      )							,      num_oov_buckets=1							,      )
							UpperCAmelCase     	=       BertTokenizerLayer(
							    _A							,      token_out_type=tf.intaa							,      lower_case=_A							,      **_A	)

				UpperCAmelCase     	=       vocab_list
				UpperCAmelCase     	=       do_lower_case
				UpperCAmelCase     	=       cls_token_id or vocab_list.index('''[CLS]'''	)
				UpperCAmelCase     	=       sep_token_id or vocab_list.index('''[SEP]'''	)
				UpperCAmelCase     	=       pad_token_id or vocab_list.index('''[PAD]'''	)
				UpperCAmelCase     	=       ShrinkLongestTrimmer(max_length - 3							,      axis=1	)  # Allow room for special tokens
				UpperCAmelCase     	=       max_length
				UpperCAmelCase     	=       padding
				UpperCAmelCase     	=       truncation
				UpperCAmelCase     	=       pad_to_multiple_of
				UpperCAmelCase     	=       return_token_type_ids
				UpperCAmelCase     	=       return_attention_mask
	@classmethod
	def   _lowercase       (					cls							,      _A							,      **_A	):  # noqa: F821






				'''simple docstring'''







				UpperCAmelCase     	=       kwargs.pop('''do_lower_case'''							,      _A	)
				UpperCAmelCase     	=       tokenizer.do_lower_case if do_lower_case is None else do_lower_case
				UpperCAmelCase     	=       kwargs.pop('''cls_token_id'''							,      _A	)
				UpperCAmelCase     	=       tokenizer.cls_token_id if cls_token_id is None else cls_token_id
				UpperCAmelCase     	=       kwargs.pop('''sep_token_id'''							,      _A	)
				UpperCAmelCase     	=       tokenizer.sep_token_id if sep_token_id is None else sep_token_id
				UpperCAmelCase     	=       kwargs.pop('''pad_token_id'''							,      _A	)
				UpperCAmelCase     	=       tokenizer.pad_token_id if pad_token_id is None else pad_token_id

				UpperCAmelCase     	=       tokenizer.get_vocab()
				UpperCAmelCase     	=       sorted([(wordpiece, idx) for wordpiece, idx in vocab.items()]							,      key=lambda _A	: x[1]	)
				UpperCAmelCase     	=       [entry[0] for entry in vocab]
				return cls(
				    vocab_list=_A							,      do_lower_case=_A							,      cls_token_id=_A							,      sep_token_id=_A							,      pad_token_id=_A							,      **_A							,      )
	@classmethod
	def   _lowercase       (					cls							,      _A							,      *_A							,      **_A	):






				'''simple docstring'''







				try:
							UpperCAmelCase     	=       BertTokenizer.from_pretrained(_A							,      *_A							,      **_A	)
				except:  # noqa: E722
							from .tokenization_bert_fast import BertTokenizerFast

							UpperCAmelCase     	=       BertTokenizerFast.from_pretrained(_A							,      *_A							,      **_A	)
				return cls.from_tokenizer(_A							,      **_A	)
	def   _lowercase       (					self							,      _A	):






				'''simple docstring'''







				if self.do_lower_case:
							UpperCAmelCase     	=       case_fold_utfa(_A	)
				UpperCAmelCase     	=       self.tf_tokenizer.tokenize(_A	)
				return tokens.merge_dims(1							,      -1	)
	def   _lowercase       (					self							,      _A							,      _A=None							,      _A=None							,      _A=None							,      _A=None							,      _A=None							,      _A=None							,      _A=None							,      ):






				'''simple docstring'''







				if padding is None:
							UpperCAmelCase     	=       self.padding
				if padding not in ("longest", "max_length"):
							raise ValueError('''Padding must be either \'longest\' or \'max_length\'!'''	)
				if max_length is not None and text_pair is not None:
							# Because we have to instantiate a Trimmer to do it properly
							raise ValueError('''max_length cannot be overridden at call time when truncating paired texts!'''	)
				if max_length is None:
							UpperCAmelCase     	=       self.max_length
				if truncation is None:
							UpperCAmelCase     	=       self.truncation
				if pad_to_multiple_of is None:
							UpperCAmelCase     	=       self.pad_to_multiple_of
				if return_token_type_ids is None:
							UpperCAmelCase     	=       self.return_token_type_ids
				if return_attention_mask is None:
							UpperCAmelCase     	=       self.return_attention_mask
				if not isinstance(_A							,      tf.Tensor	):
							UpperCAmelCase     	=       tf.convert_to_tensor(_A	)
				if text_pair is not None and not isinstance(_A							,      tf.Tensor	):
							UpperCAmelCase     	=       tf.convert_to_tensor(_A	)
				if text_pair is not None:
							if text.shape.rank > 1:
										raise ValueError('''text argument should not be multidimensional when a text pair is supplied!'''	)
							if text_pair.shape.rank > 1:
										raise ValueError('''text_pair should not be multidimensional!'''	)
				if text.shape.rank == 2:
							UpperCAmelCase	,    UpperCAmelCase     	=       text[:, 0], text[:, 1]
				UpperCAmelCase     	=       self.unpaired_tokenize(_A	)
				if text_pair is None:  # Unpaired text
							if truncation:
										UpperCAmelCase     	=       text[:, : max_length - 2]  # Allow room for special tokens
							UpperCAmelCase	,    UpperCAmelCase     	=       combine_segments(
							    (text,)							,      start_of_sequence_id=self.cls_token_id							,      end_of_segment_id=self.sep_token_id	)
				else:  # Paired text
							UpperCAmelCase     	=       self.unpaired_tokenize(_A	)
							if truncation:
										UpperCAmelCase	,    UpperCAmelCase     	=       self.paired_trimmer.trim([text, text_pair]	)
							UpperCAmelCase	,    UpperCAmelCase     	=       combine_segments(
							    (text, text_pair)							,      start_of_sequence_id=self.cls_token_id							,      end_of_segment_id=self.sep_token_id	)
				if padding == "longest":
							UpperCAmelCase     	=       input_ids.bounding_shape(axis=1	)
							if pad_to_multiple_of is not None:
										# No ceiling division in tensorflow, so we negate floordiv instead
										UpperCAmelCase     	=       pad_to_multiple_of * (-tf.math.floordiv(-pad_length							,      _A	))
				else:
							UpperCAmelCase     	=       max_length

				UpperCAmelCase	,    UpperCAmelCase     	=       pad_model_inputs(_A							,      max_seq_length=_A							,      pad_value=self.pad_token_id	)
				UpperCAmelCase     	=       {'''input_ids''': input_ids}
				if return_attention_mask:
							UpperCAmelCase     	=       attention_mask
				if return_token_type_ids:
							UpperCAmelCase	,    UpperCAmelCase     	=       pad_model_inputs(
							    _A							,      max_seq_length=_A							,      pad_value=self.pad_token_id	)
							UpperCAmelCase     	=       token_type_ids
				return output







	def   _lowercase       (					self	):






				'''simple docstring'''







				return {
				    "vocab_list": self.vocab_list,
				    "do_lower_case": self.do_lower_case,
				    "cls_token_id": self.cls_token_id,
				    "sep_token_id": self.sep_token_id,
				    "pad_token_id": self.pad_token_id,
				}



