





import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
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 (
				    LiltForQuestionAnswering,
				    LiltForSequenceClassification,
				    LiltForTokenClassification,
				    LiltModel,
				)
				from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST





class 		_A:


				"""simple docstring"""


				def __init__(     self	,   _A	,   _A=13	,   _A=7	,   _A=True	,   _A=True	,   _A=True	,   _A=True	,   _A=99	,   _A=24	,   _A=2	,   _A=6	,   _A=37	,   _A="gelu"	,   _A=0.1	,   _A=0.1	,   _A=512	,   _A=16	,   _A=2	,   _A=0.0_2	,   _A=3	,   _A=None	,   _A=1000	,   ):
									__A      :		Dict         =							parent
									__A      :		int         =							batch_size
									__A      :		Union[str, Any]         =							seq_length
									__A      :		Optional[Any]         =							is_training
									__A      :		List[str]         =							use_input_mask
									__A      :		Tuple         =							use_token_type_ids
									__A      :		Union[str, Any]         =							use_labels
									__A      :		int         =							vocab_size
									__A      :		Optional[int]         =							hidden_size
									__A      :		Optional[Any]         =							num_hidden_layers
									__A      :		List[Any]         =							num_attention_heads
									__A      :		Union[str, Any]         =							intermediate_size
									__A      :		List[Any]         =							hidden_act
									__A      :		Dict         =							hidden_dropout_prob
									__A      :		List[str]         =							attention_probs_dropout_prob
									__A      :		str         =							max_position_embeddings
									__A      :		Tuple         =							type_vocab_size
									__A      :		Any         =							type_sequence_label_size
									__A      :		str         =							initializer_range
									__A      :		Dict         =							num_labels
									__A      :		List[Any]         =							scope
									__A      :		str         =							range_bbox



				def    UpperCAmelCase_						(     self	):
									__A      :		Optional[Any]         =							ids_tensor([self.batch_size, self.seq_length]	,   self.vocab_size	)

									__A      :		Tuple         =							ids_tensor([self.batch_size, self.seq_length, 4]	,   self.range_bbox	)
									# Ensure that bbox is legal
									for i in range(bbox.shape[0]	):
														for j in range(bbox.shape[1]	):
																			if bbox[i, j, 3] < bbox[i, j, 1]:
																								__A      :		List[Any]         =							bbox[i, j, 3]
																								__A      :		Optional[Any]         =							bbox[i, j, 1]
																								__A      :		int         =							t
																			if bbox[i, j, 2] < bbox[i, j, 0]:
																								__A      :		Dict         =							bbox[i, j, 2]
																								__A      :		Dict         =							bbox[i, j, 0]
																								__A      :		List[Any]         =							t

									__A      :		int         =							None
									if self.use_input_mask:
														__A      :		List[Any]         =							ids_tensor([self.batch_size, self.seq_length]	,   vocab_size=2	)

									__A      :		Optional[Any]         =							None
									if self.use_token_type_ids:
														__A      :		Any         =							ids_tensor([self.batch_size, self.seq_length]	,   self.type_vocab_size	)

									__A      :		str         =							None
									__A      :		Optional[Any]         =							None
									if self.use_labels:
														__A      :		Optional[int]         =							ids_tensor([self.batch_size]	,   self.type_sequence_label_size	)
														__A      :		Any         =							ids_tensor([self.batch_size, self.seq_length]	,   self.num_labels	)

									__A      :		int         =							self.get_config()

									return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels



				def    UpperCAmelCase_						(     self	):
									return LiltConfig(
									    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	,   )



				def    UpperCAmelCase_						(     self	,   _A	,   _A	,   _A	,   _A	,   _A	,   _A	,   _A	,   ):
									__A      :		List[Any]         =							LiltModel(config=UpperCamelCase__	)
									model.to(UpperCamelCase__	)
									model.eval()
									__A      :		List[Any]         =							model(UpperCamelCase__	,   bbox=UpperCamelCase__	,   attention_mask=UpperCamelCase__	,   token_type_ids=UpperCamelCase__	)
									__A      :		str         =							model(UpperCamelCase__	,   bbox=UpperCamelCase__	,   token_type_ids=UpperCamelCase__	)
									__A      :		int         =							model(UpperCamelCase__	,   bbox=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	,   _A	,   _A	,   _A	,   _A	,   _A	,   _A	,   _A	,   ):
									__A      :		str         =							self.num_labels
									__A      :		Dict         =							LiltForTokenClassification(config=UpperCamelCase__	)
									model.to(UpperCamelCase__	)
									model.eval()
									__A      :		Optional[Any]         =							model(
									    UpperCamelCase__	,   bbox=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	,   _A	,   _A	,   _A	,   _A	,   _A	,   _A	,   _A	,   ):
									__A      :		Dict         =							LiltForQuestionAnswering(config=UpperCamelCase__	)
									model.to(UpperCamelCase__	)
									model.eval()
									__A      :		Tuple         =							model(
									    UpperCamelCase__	,   bbox=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	):
									__A      :		Any         =							self.prepare_config_and_inputs()
									(
									    (
									    __A       
									)       ,							(
									    __A       
									)       ,							(
									    __A       
									)       ,							(
									    __A       
									)       ,							(
									    __A       
									)       ,							(
									    __A       
									)       ,							(
									    __A       
									)       ,							       
									)      :		Any         =							config_and_inputs
									__A      :		Optional[int]         =							{
									    'input_ids': input_ids,
									    'bbox': bbox,
									    'token_type_ids': token_type_ids,
									    'attention_mask': input_mask,
									}
									return config, inputs_dict





@require_torch
class 		_A(   _UpperCamelCase							,					_UpperCamelCase							,					_UpperCamelCase							,					unittest.TestCase  ):


				"""simple docstring"""


				UpperCamelCase       :    str          =      (
				    (
				        LiltModel,
				        LiltForSequenceClassification,
				        LiltForTokenClassification,
				        LiltForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				UpperCamelCase       :    int          =      (
				    {
				        '''feature-extraction''': LiltModel,
				        '''question-answering''': LiltForQuestionAnswering,
				        '''text-classification''': LiltForSequenceClassification,
				        '''token-classification''': LiltForTokenClassification,
				        '''zero-shot''': LiltForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				UpperCamelCase       :    Optional[int]          =      False
				UpperCamelCase       :    Tuple          =      False



				def    UpperCAmelCase_						(     self	,   _A	,   _A	,   _A	,   _A	,   _A	):
									return True



				def    UpperCAmelCase_						(     self	):
									__A      :		Optional[int]         =							LiltModelTester(self	)
									__A      :		Dict         =							ConfigTester(self	,   config_class=UpperCamelCase__	,   hidden_size=37	)



				def    UpperCAmelCase_						(     self	):
									self.config_tester.run_common_tests()



				def    UpperCAmelCase_						(     self	):
									__A      :		Any         =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*UpperCamelCase__	)



				def    UpperCAmelCase_						(     self	):
									__A      :		List[Any]         =							self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
														__A      :		Tuple         =							type
														self.model_tester.create_and_check_model(*UpperCamelCase__	)



				def    UpperCAmelCase_						(     self	):
									__A      :		int         =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__	)



				def    UpperCAmelCase_						(     self	):
									__A      :		List[Any]         =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__	)





				@slow
				def    UpperCAmelCase_						(     self	):
									for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														__A      :		Tuple         =							LiltModel.from_pretrained(UpperCamelCase__	)
														self.assertIsNotNone(UpperCamelCase__	)





@require_torch
@slow
class 		_A(   unittest.TestCase  ):


				"""simple docstring"""


				def    UpperCAmelCase_						(     self	):
									__A      :		Optional[Any]         =							LiltModel.from_pretrained('SCUT-DLVCLab/lilt-roberta-en-base'	).to(UpperCamelCase__	)

									__A      :		Union[str, Any]         =							torch.tensor([[1, 2]]	,   device=UpperCamelCase__	)
									__A      :		Optional[int]         =							torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]	,   device=UpperCamelCase__	)

									# forward pass
									with torch.no_grad():
														__A      :		Any         =							model(input_ids=UpperCamelCase__	,   bbox=UpperCamelCase__	)

									__A      :		Optional[Any]         =							torch.Size([1, 2, 768]	)
									__A      :		List[str]         =							torch.tensor(
									    [[-0.0_6_5_3, 0.0_9_5_0, -0.0_0_6_1], [-0.0_5_4_5, 0.0_9_2_6, -0.0_3_2_4]]	,   device=UpperCamelCase__	,   )

									self.assertTrue(outputs.last_hidden_state.shape	,   UpperCamelCase__	)
									self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]	,   UpperCamelCase__	,   atol=1e-3	)	)





'''simple docstring'''






from __future__ import annotations





def  _SCREAMING_SNAKE_CASE		(      __snake_case							:			int | str				):
     _A    		=  str(__snake_case				)
     return n == n[::-1]





def  _SCREAMING_SNAKE_CASE		(      __snake_case							:			int = 1_0_0_0_0_0_0				):
     _A    		=  0

     for i in range(1   ,		__snake_case				):
          if is_palindrome(__snake_case				) and is_palindrome(bin(__snake_case				).split('b'				)[1]				):
               total += i
     return total


if __name__ == "__main__":
   print(solution(int(str(input().strip()))))



