code: import unittest
  
  from transformers import MarkupLMConfig, is_torch_available
  from transformers.testing_utils import require_torch, slow, torch_device
  from transformers.utils import cached_property
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
  				import torch
  
  				from transformers import (
  				    MarkupLMForQuestionAnswering,
  				    MarkupLMForSequenceClassification,
  				    MarkupLMForTokenClassification,
  				    MarkupLMModel,
  				)
  
  # TODO check dependencies
  from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizer
  
  
  class _lowercase					:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							def __init__(    self     ,   UpperCAmelCase     ,   UpperCAmelCase=13     ,   UpperCAmelCase=7     ,   UpperCAmelCase=True     ,   UpperCAmelCase=True     ,   UpperCAmelCase=True     ,   UpperCAmelCase=True     ,   UpperCAmelCase=99     ,   UpperCAmelCase=32     ,   UpperCAmelCase=5     ,   UpperCAmelCase=4     ,   UpperCAmelCase=37     ,   UpperCAmelCase="gelu"     ,   UpperCAmelCase=0.1     ,   UpperCAmelCase=0.1     ,   UpperCAmelCase=512     ,   UpperCAmelCase=16     ,   UpperCAmelCase=2     ,   UpperCAmelCase=0.02     ,   UpperCAmelCase=3     ,   UpperCAmelCase=None     ,   UpperCAmelCase=20     ,   UpperCAmelCase=30     ,   UpperCAmelCase=2     ,   UpperCAmelCase=2     ,   UpperCAmelCase=10     ,   ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	parent
  														_lowercase				=	batch_size
  														_lowercase				=	seq_length
  														_lowercase				=	is_training
  														_lowercase				=	use_input_mask
  														_lowercase				=	use_token_type_ids
  														_lowercase				=	use_labels
  														_lowercase				=	vocab_size
  														_lowercase				=	hidden_size
  														_lowercase				=	num_hidden_layers
  														_lowercase				=	num_attention_heads
  														_lowercase				=	intermediate_size
  														_lowercase				=	hidden_act
  														_lowercase				=	hidden_dropout_prob
  														_lowercase				=	attention_probs_dropout_prob
  														_lowercase				=	max_position_embeddings
  														_lowercase				=	type_vocab_size
  														_lowercase				=	type_sequence_label_size
  														_lowercase				=	initializer_range
  														_lowercase				=	num_labels
  														_lowercase				=	scope
  														_lowercase				=	max_xpath_tag_unit_embeddings
  														_lowercase				=	max_xpath_subs_unit_embeddings
  														_lowercase				=	tag_pad_id
  														_lowercase				=	subs_pad_id
  														_lowercase				=	max_depth
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	ids_tensor([self.batch_size, self.seq_length]     ,   self.vocab_size  )
  
  														_lowercase				=	ids_tensor(
  														    [self.batch_size, self.seq_length, self.max_depth]     ,   self.max_xpath_tag_unit_embeddings  )
  
  														_lowercase				=	ids_tensor(
  														    [self.batch_size, self.seq_length, self.max_depth]     ,   self.max_xpath_subs_unit_embeddings  )
  
  														_lowercase				=	None
  														if self.use_input_mask:
  																					_lowercase				=	ids_tensor([self.batch_size, self.seq_length]     ,   vocab_size=2  )
  
  														_lowercase				=	None
  														if self.use_token_type_ids:
  																					_lowercase				=	ids_tensor([self.batch_size, self.seq_length]     ,   self.type_vocab_size  )
  
  														_lowercase				=	None
  														_lowercase				=	None
  														if self.use_labels:
  																					_lowercase				=	ids_tensor([self.batch_size]     ,   self.type_sequence_label_size  )
  																					_lowercase				=	ids_tensor([self.batch_size, self.seq_length]     ,   self.num_labels  )
  
  														_lowercase				=	self.get_config()
  
  														return (
  														    config,
  														    input_ids,
  														    xpath_tags_seq,
  														    xpath_subs_seq,
  														    token_type_ids,
  														    input_mask,
  														    sequence_labels,
  														    token_labels,
  														)
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return MarkupLMConfig(
  														    vocab_size=self.vocab_size     ,   hidden_size=self.hidden_size     ,   num_hidden_layers=self.num_hidden_layers     ,   num_attention_heads=self.num_attention_heads     ,   intermediate_size=self.intermediate_size     ,   hidden_act=self.hidden_act     ,   hidden_dropout_prob=self.hidden_dropout_prob     ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,   max_position_embeddings=self.max_position_embeddings     ,   type_vocab_size=self.type_vocab_size     ,   initializer_range=self.initializer_range     ,   max_xpath_tag_unit_embeddings=self.max_xpath_tag_unit_embeddings     ,   max_xpath_subs_unit_embeddings=self.max_xpath_subs_unit_embeddings     ,   tag_pad_id=self.tag_pad_id     ,   subs_pad_id=self.subs_pad_id     ,   max_depth=self.max_depth     ,   )
  
  
  
  							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	MarkupLMModel(config=UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  														print("""Configs:"""     ,   model.config.tag_pad_id     ,   model.config.subs_pad_id  )
  														_lowercase				=	model(UpperCAmelCase     ,   attention_mask=UpperCAmelCase     ,   token_type_ids=UpperCAmelCase  )
  														_lowercase				=	model(UpperCAmelCase     ,   token_type_ids=UpperCAmelCase  )
  														_lowercase				=	model(UpperCAmelCase  )
  														self.parent.assertEqual(result.last_hidden_state.shape     ,   (self.batch_size, self.seq_length, self.hidden_size)  )
  														self.parent.assertEqual(result.pooler_output.shape     ,   (self.batch_size, self.hidden_size)  )
  
  
  
  							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.num_labels
  														_lowercase				=	MarkupLMForSequenceClassification(UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  														_lowercase				=	model(
  														    UpperCAmelCase     ,   xpath_tags_seq=UpperCAmelCase     ,   xpath_subs_seq=UpperCAmelCase     ,   attention_mask=UpperCAmelCase     ,   token_type_ids=UpperCAmelCase     ,   labels=UpperCAmelCase     ,   )
  														self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.num_labels)  )
  
  
  
  							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.num_labels
  														_lowercase				=	MarkupLMForTokenClassification(config=UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  														_lowercase				=	model(
  														    UpperCAmelCase     ,   xpath_tags_seq=UpperCAmelCase     ,   xpath_subs_seq=UpperCAmelCase     ,   attention_mask=UpperCAmelCase     ,   token_type_ids=UpperCAmelCase     ,   labels=UpperCAmelCase     ,   )
  														self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.seq_length, self.num_labels)  )
  
  
  
  							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	MarkupLMForQuestionAnswering(config=UpperCAmelCase  )
  														model.to(UpperCAmelCase  )
  														model.eval()
  														_lowercase				=	model(
  														    UpperCAmelCase     ,   xpath_tags_seq=UpperCAmelCase     ,   xpath_subs_seq=UpperCAmelCase     ,   attention_mask=UpperCAmelCase     ,   token_type_ids=UpperCAmelCase     ,   start_positions=UpperCAmelCase     ,   end_positions=UpperCAmelCase     ,   )
  														self.parent.assertEqual(result.start_logits.shape     ,   (self.batch_size, self.seq_length)  )
  														self.parent.assertEqual(result.end_logits.shape     ,   (self.batch_size, self.seq_length)  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.prepare_config_and_inputs()
  														(
  														    (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       (
  														    _lowercase
  														)				,       
  														)				=	config_and_inputs
  														_lowercase				=	{
  														    """input_ids""": input_ids,
  														    """xpath_tags_seq""": xpath_tags_seq,
  														    """xpath_subs_seq""": xpath_subs_seq,
  														    """token_type_ids""": token_type_ids,
  														    """attention_mask""": input_mask,
  														}
  														return config, inputs_dict
  
  
  
  
  
  
  @require_torch
  class _lowercase					(       _UpperCAmelCase   ,				_UpperCAmelCase   ,				unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							lowerCAmelCase__       =					(
  							    (
  							        MarkupLMModel,
  							        MarkupLMForSequenceClassification,
  							        MarkupLMForTokenClassification,
  							        MarkupLMForQuestionAnswering,
  							    )
  							    if is_torch_available()
  							    else None
  							)
  							lowerCAmelCase__       =					(
  							    {
  							        'feature-extraction': MarkupLMModel,
  							        'question-answering': MarkupLMForQuestionAnswering,
  							        'text-classification': MarkupLMForSequenceClassification,
  							        'token-classification': MarkupLMForTokenClassification,
  							        'zero-shot': MarkupLMForSequenceClassification,
  							    }
  							    if is_torch_available()
  							    else {}
  							)
  
  
  
  							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return True
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	MarkupLMModelTester(self  )
  														_lowercase				=	ConfigTester(self     ,   config_class=UpperCAmelCase     ,   hidden_size=37  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														self.config_tester.run_common_tests()
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.model_tester.prepare_config_and_inputs()
  														self.model_tester.create_and_check_model(*UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.model_tester.prepare_config_and_inputs()
  														self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.model_tester.prepare_config_and_inputs()
  														self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.model_tester.prepare_config_and_inputs()
  														self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase  )
  
  
  
  
  
  
  def 					__lowerCAmelCase			(  ):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	"""
      <!DOCTYPE html>
      <html>
      <head>
      <title>Page Title</title>
      </head>
      <body>
  
      <h1>This is a Heading</h1>
      <p>This is a paragraph.</p>
  
      </body>
      </html>
      """
  
  							return html_string
  
  
  
  
  
  
  
  @require_torch
  class _lowercase					(       unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							@cached_property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	MarkupLMFeatureExtractor()
  														_lowercase				=	MarkupLMTokenizer.from_pretrained("""microsoft/markuplm-base"""  )
  
  														return MarkupLMProcessor(UpperCAmelCase     ,   UpperCAmelCase  )
  
  
  
  							@slow
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	MarkupLMModel.from_pretrained("""microsoft/markuplm-base"""  ).to(UpperCAmelCase  )
  
  														_lowercase				=	self.default_processor
  
  														_lowercase				=	processor(prepare_html_string()     ,   return_tensors="""pt"""  )
  														_lowercase				=	inputs.to(UpperCAmelCase  )
  
  														# forward pass
  														with torch.no_grad():
  																					_lowercase				=	model(**UpperCAmelCase  )
  
  														# verify the last hidden states
  														_lowercase				=	torch.Size([1, 14, 768]  )
  														self.assertEqual(outputs.last_hidden_state.shape     ,   UpperCAmelCase  )
  
  														_lowercase				=	torch.tensor(
  														    [[0.0_675, -0.0_052, 0.5_001], [-0.2_281, 0.0_802, 0.2_192], [-0.0_583, -0.3_311, 0.1_185]]  ).to(UpperCAmelCase  )
  
  														self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]     ,   UpperCAmelCase     ,   atol=1e-4  )  )
  
  
  
style_context: def 					__lowerCAmelCase			(  _A = 998_001					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	0
  							for i in range(999 ,99 ,-1					):  # 3 digit numbers range from 999 down to 100
  														for j in range(999 ,99 ,-1					):
  																					_lowercase				=	str(i * j					)
  																					if product_string == product_string[::-1] and i * j < n:
  																												_lowercase				=	max(_A ,i * j					)
  							return answer
  
  
  if __name__ == "__main__":
  				print(F'''{solution() = }''')
  
  
  