






import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


snake_case    				=		1e-4

if is_torch_available():
   import torch

   from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
   from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder


@require_torch
class  SCREAMING_SNAKE_CASE			:
     '''simple docstring'''


     def __init__(				self       :	Union[str, Any]					, UpperCAmelCase_       :	Optional[Any]					, UpperCAmelCase_       :	Union[str, Any]=16					, UpperCAmelCase_       :	Optional[Any]=13					, UpperCAmelCase_       :	Dict=7					, UpperCAmelCase_       :	List[Any]=14					, UpperCAmelCase_       :	Optional[Any]=10					, UpperCAmelCase_       :	Dict=19					, UpperCAmelCase_       :	Any=5					, UpperCAmelCase_       :	str=4					, UpperCAmelCase_       :	Tuple=True					, UpperCAmelCase_       :	List[Any]=16					, UpperCAmelCase_       :	Optional[int]=2					, UpperCAmelCase_       :	Dict=4					, UpperCAmelCase_       :	Dict=4					, UpperCAmelCase_       :	Any="gelu"					, UpperCAmelCase_       :	Optional[Any]=0.1					, UpperCAmelCase_       :	List[str]=0.1					, UpperCAmelCase_       :	Tuple=[1, 2, 3, 4, 5]					, UpperCAmelCase_       :	List[str]=25					, UpperCAmelCase_       :	str=5					, ):
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    d_model
       SCREAMING_SNAKE_CASE       :      Dict							=    parent
       SCREAMING_SNAKE_CASE       :      List[Any]							=    batch_size
       SCREAMING_SNAKE_CASE       :      Dict							=    prediction_length
       SCREAMING_SNAKE_CASE       :      List[Any]							=    context_length
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    cardinality
       SCREAMING_SNAKE_CASE       :      int							=    num_time_features
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    lags_sequence
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    embedding_dimension
       SCREAMING_SNAKE_CASE       :      Any							=    is_training
       SCREAMING_SNAKE_CASE       :      Dict							=    hidden_size
       SCREAMING_SNAKE_CASE       :      List[Any]							=    num_hidden_layers
       SCREAMING_SNAKE_CASE       :      List[str]							=    num_attention_heads
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    intermediate_size
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    hidden_act
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    hidden_dropout_prob
       SCREAMING_SNAKE_CASE       :      Any							=    attention_probs_dropout_prob

       SCREAMING_SNAKE_CASE       :      List[str]							=    context_length
       SCREAMING_SNAKE_CASE       :      Any							=    prediction_length + label_length
       SCREAMING_SNAKE_CASE       :      List[str]							=    label_length

       SCREAMING_SNAKE_CASE       :      str							=    moving_average
       SCREAMING_SNAKE_CASE       :      List[str]							=    autocorrelation_factor


     def 				_A       (				self       :	Optional[Any]      ):
       return AutoformerConfig(
           d_model=self.d_model					, encoder_layers=self.num_hidden_layers					, decoder_layers=self.num_hidden_layers					, encoder_attention_heads=self.num_attention_heads					, decoder_attention_heads=self.num_attention_heads					, encoder_ffn_dim=self.intermediate_size					, decoder_ffn_dim=self.intermediate_size					, dropout=self.hidden_dropout_prob					, attention_dropout=self.attention_probs_dropout_prob					, prediction_length=self.prediction_length					, context_length=self.context_length					, label_length=self.label_length					, lags_sequence=self.lags_sequence					, num_time_features=self.num_time_features					, num_static_categorical_features=1					, cardinality=[self.cardinality]					, embedding_dimension=[self.embedding_dimension]					, moving_average=self.moving_average					, )


     def 				_A       (				self       :	Optional[int]					, UpperCAmelCase_       :	List[str]      ):
       SCREAMING_SNAKE_CASE       :      int							=    config.context_length + max(config.lags_sequence      )

       SCREAMING_SNAKE_CASE       :      Any							=    ids_tensor([self.batch_size, 1]					, config.cardinality[0]      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    floats_tensor([self.batch_size, _past_length, config.num_time_features]      )
       SCREAMING_SNAKE_CASE       :      int							=    floats_tensor([self.batch_size, _past_length]      )
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    floats_tensor([self.batch_size, _past_length]      ) > 0.5

       # decoder inputs
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]      )
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    floats_tensor([self.batch_size, config.prediction_length]      )

       SCREAMING_SNAKE_CASE       :      str							=    {
           '''past_values''': past_values,
           '''static_categorical_features''': static_categorical_features,
           '''past_time_features''': past_time_features,
           '''past_observed_mask''': past_observed_mask,
           '''future_time_features''': future_time_features,
           '''future_values''': future_values,
       }
       return inputs_dict


     def 				_A       (				self       :	Optional[Any]      ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    self.get_config()
       SCREAMING_SNAKE_CASE       :      Tuple							=    self.prepare_autoformer_inputs_dict(UpperCamelCase__      )
       return config, inputs_dict


     def 				_A       (				self       :	List[str]      ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    self.prepare_config_and_inputs()
       return config, inputs_dict






     def 				_A       (				self       :	List[Any]					, UpperCAmelCase_       :	Any					, UpperCAmelCase_       :	Optional[int]      ):
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    AutoformerModel(config=UpperCamelCase__      ).to(UpperCamelCase__      ).eval()
       SCREAMING_SNAKE_CASE       :      List[str]							=    model(**UpperCamelCase__      )

       SCREAMING_SNAKE_CASE       :      Any							=    outputs.encoder_last_hidden_state
       SCREAMING_SNAKE_CASE       :      str							=    outputs.last_hidden_state

       with tempfile.TemporaryDirectory() as tmpdirname:
         SCREAMING_SNAKE_CASE       :      Tuple							=    model.get_encoder()
         encoder.save_pretrained(UpperCamelCase__      )
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    AutoformerEncoder.from_pretrained(UpperCamelCase__      ).to(UpperCamelCase__      )

       SCREAMING_SNAKE_CASE       :      str							=    model.create_network_inputs(**UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      Dict							=    model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]      )

       SCREAMING_SNAKE_CASE       :      Tuple							=    torch.cat(
           (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])					, dim=-1					, )
       SCREAMING_SNAKE_CASE       :      List[Any]							=    encoder(inputs_embeds=UpperCamelCase__      )[0]
       self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1E-3      )

       SCREAMING_SNAKE_CASE       :      Dict							=    (
           torch.mean(transformer_inputs[:, : config.context_length, ...]					, dim=1      )
           .unsqueeze(1      )
           .repeat(1					, config.prediction_length					, 1      )
       )
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    torch.zeros(
           [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]					, device=enc_input.device					, )

       SCREAMING_SNAKE_CASE       :      Tuple							=    torch.cat(
           (
               torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)					, dim=1      ),
               feature[:, config.context_length - config.label_length :, ...],
           )					, dim=-1					, )
       SCREAMING_SNAKE_CASE       :      str							=    torch.cat(
           (
               torch.cat((trend_input[:, -config.label_length :, ...], mean)					, dim=1      ),
               feature[:, config.context_length - config.label_length :, ...],
           )					, dim=-1					, )

       with tempfile.TemporaryDirectory() as tmpdirname:
         SCREAMING_SNAKE_CASE       :      str							=    model.get_decoder()
         decoder.save_pretrained(UpperCamelCase__      )
         SCREAMING_SNAKE_CASE       :      str							=    AutoformerDecoder.from_pretrained(UpperCamelCase__      ).to(UpperCamelCase__      )

       SCREAMING_SNAKE_CASE       :      Any							=    decoder(
           trend=UpperCamelCase__					, inputs_embeds=UpperCamelCase__					, encoder_hidden_states=UpperCamelCase__					, )[0]

       self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1E-3      )





@require_torch
class  SCREAMING_SNAKE_CASE			(			SCREAMING_SNAKE_CASE_      ,		SCREAMING_SNAKE_CASE_      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Any			=	(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
     UpperCamelCase_							:		Optional[int]			=	(AutoformerForPrediction,) if is_torch_available() else ()
     UpperCamelCase_							:		int			=	{'''feature-extraction''': AutoformerModel} if is_torch_available() else {}
     UpperCamelCase_							:		List[Any]			=	False
     UpperCamelCase_							:		Dict			=	False
     UpperCamelCase_							:		Any			=	False
     UpperCamelCase_							:		Optional[Any]			=	False
     UpperCamelCase_							:		Tuple			=	False
     UpperCamelCase_							:		Optional[int]			=	False


     def 				_A       (				self       :	Optional[Any]      ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    AutoformerModelTester(self      )
       SCREAMING_SNAKE_CASE       :      Dict							=    ConfigTester(self					, config_class=UpperCamelCase__					, has_text_modality=UpperCamelCase__      )


     def 				_A       (				self       :	Union[str, Any]      ):
       self.config_tester.run_common_tests()


     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    self.model_tester.prepare_config_and_inputs()
       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE       :      int							=    model_class(UpperCamelCase__      )

         with tempfile.TemporaryDirectory() as tmpdirname:
           model.save_pretrained(UpperCamelCase__      )
           SCREAMING_SNAKE_CASE       :      int							=    model_class.from_pretrained(UpperCamelCase__					, output_loading_info=UpperCamelCase__      )
         self.assertEqual(info["missing_keys"]					, []      )


     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      List[Any]							=    self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_encoder_decoder_model_standalone(*UpperCamelCase__      )


     @unittest.skip(reason="Model has no tokens embeddings"      )
     def 				_A       (				self       :	Optional[Any]      ):
       pass


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    inspect.signature(getattr(UpperCamelCase__					, "forward"      )      )
       # The main input is the name of the argument after `self`
       SCREAMING_SNAKE_CASE       :      Tuple							=    list(model_signature.parameters.keys()      )[1]
       self.assertEqual(AutoformerModel.main_input_name					, UpperCamelCase__      )


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Any							=    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE       :      str							=    model_class(UpperCamelCase__      )
         SCREAMING_SNAKE_CASE       :      Tuple							=    inspect.signature(model.forward      )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         SCREAMING_SNAKE_CASE       :      List[str]							=    [*signature.parameters.keys()]

         SCREAMING_SNAKE_CASE       :      int							=    [
             '''past_values''',
             '''past_time_features''',
             '''past_observed_mask''',
             '''static_categorical_features''',
             '''static_real_features''',
             '''future_values''',
             '''future_time_features''',
         ]

         if model.__class__.__name__ in ["AutoformerForPrediction"]:
           expected_arg_names.append("future_observed_mask"      )

         expected_arg_names.extend(
             [
                 "decoder_attention_mask",
                 "head_mask",
                 "decoder_head_mask",
                 "cross_attn_head_mask",
                 "encoder_outputs",
                 "past_key_values",
                 "output_hidden_states",
                 "output_attentions",
                 "use_cache",
                 "return_dict",
             ]      )

         self.assertListEqual(arg_names[: len(UpperCamelCase__      )]					, UpperCamelCase__      )


     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE       :      Dict							=    True

       SCREAMING_SNAKE_CASE       :      int							=    getattr(self.model_tester					, "seq_length"					, UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    getattr(self.model_tester					, "decoder_seq_length"					, UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      Tuple							=    getattr(self.model_tester					, "encoder_seq_length"					, UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      Dict							=    getattr(self.model_tester					, "d_model"					, UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      Dict							=    getattr(self.model_tester					, "num_attention_heads"					, UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    d_model // num_attention_heads

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE       :      List[Any]							=    True
         SCREAMING_SNAKE_CASE       :      Optional[int]							=    False
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    True
         SCREAMING_SNAKE_CASE       :      Any							=    model_class(UpperCamelCase__      )
         model.to(UpperCamelCase__      )
         model.eval()
         with torch.no_grad():
           SCREAMING_SNAKE_CASE       :      List[str]							=    model(**self._prepare_for_class(UpperCamelCase__					, UpperCamelCase__      )      )
         SCREAMING_SNAKE_CASE       :      List[Any]							=    outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(UpperCamelCase__      )					, self.model_tester.num_hidden_layers      )

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         SCREAMING_SNAKE_CASE       :      Dict							=    True
         SCREAMING_SNAKE_CASE       :      Tuple							=    model_class(UpperCamelCase__      )
         model.to(UpperCamelCase__      )
         model.eval()
         with torch.no_grad():
           SCREAMING_SNAKE_CASE       :      Tuple							=    model(**self._prepare_for_class(UpperCamelCase__					, UpperCamelCase__      )      )
         SCREAMING_SNAKE_CASE       :      Any							=    outputs.encoder_attentions
         self.assertEqual(len(UpperCamelCase__      )					, self.model_tester.num_hidden_layers      )

         self.assertListEqual(
             list(attentions[0].shape[-3:]      )					, [self.model_tester.num_attention_heads, encoder_seq_length, dim]					, )
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    len(UpperCamelCase__      )

         SCREAMING_SNAKE_CASE       :      List[Any]							=    7

         if "last_hidden_state" in outputs:
           correct_outlen += 1

         if "trend" in outputs:
           correct_outlen += 1

         if "past_key_values" in outputs:
           correct_outlen += 1  # past_key_values have been returned

         if "loss" in outputs:
           correct_outlen += 1

         if "params" in outputs:
           correct_outlen += 1

         self.assertEqual(UpperCamelCase__					, UpperCamelCase__      )

         # decoder attentions
         SCREAMING_SNAKE_CASE       :      str							=    outputs.decoder_attentions
         self.assertIsInstance(UpperCamelCase__					, (list, tuple)      )
         self.assertEqual(len(UpperCamelCase__      )					, self.model_tester.num_hidden_layers      )
         self.assertListEqual(
             list(decoder_attentions[0].shape[-3:]      )					, [self.model_tester.num_attention_heads, decoder_seq_length, dim]					, )

         # cross attentions
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    outputs.cross_attentions
         self.assertIsInstance(UpperCamelCase__					, (list, tuple)      )
         self.assertEqual(len(UpperCamelCase__      )					, self.model_tester.num_hidden_layers      )
         self.assertListEqual(
             list(cross_attentions[0].shape[-3:]      )					, [self.model_tester.num_attention_heads, decoder_seq_length, dim]					, )

       # Check attention is always last and order is fine
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    True
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    True
       SCREAMING_SNAKE_CASE       :      Tuple							=    model_class(UpperCamelCase__      )
       model.to(UpperCamelCase__      )
       model.eval()
       with torch.no_grad():
         SCREAMING_SNAKE_CASE       :      Dict							=    model(**self._prepare_for_class(UpperCamelCase__					, UpperCamelCase__      )      )

       self.assertEqual(out_len + 2					, len(UpperCamelCase__      )      )

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

       self.assertEqual(len(UpperCamelCase__      )					, self.model_tester.num_hidden_layers      )
       self.assertListEqual(
           list(self_attentions[0].shape[-3:]      )					, [self.model_tester.num_attention_heads, encoder_seq_length, dim]					, )






     @is_flaky()
     def 				_A       (				self       :	Optional[int]      ):
       super().test_retain_grad_hidden_states_attentions()





def   lowerCamelCase__			(     lowercase="train-batch.pt"				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Dict							=    hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch"						,     filename=__UpperCamelCase						,     repo_type="dataset"				)
  SCREAMING_SNAKE_CASE       :      Tuple							=    torch.load(__UpperCamelCase						,     map_location=__UpperCamelCase				)
  return batch


@require_torch
@slow
class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"      ).to(UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      int							=    prepare_batch()

       with torch.no_grad():
         SCREAMING_SNAKE_CASE       :      Any							=    model(
             past_values=batch["past_values"]					, past_time_features=batch["past_time_features"]					, past_observed_mask=batch["past_observed_mask"]					, static_categorical_features=batch["static_categorical_features"]					, future_values=batch["future_values"]					, future_time_features=batch["future_time_features"]					, )[0]

       SCREAMING_SNAKE_CASE       :      Any							=    torch.Size(
           (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)      )
       self.assertEqual(output.shape					, UpperCamelCase__      )

       SCREAMING_SNAKE_CASE       :      Any							=    torch.tensor(
           [[0.3_593, -1.3_398, 0.6_330], [0.2_279, 1.5_396, -0.1_792], [0.0_450, 1.3_225, -0.2_335]]					, device=UpperCamelCase__      )
       self.assertTrue(torch.allclose(output[0, :3, :3]					, UpperCamelCase__					, atol=UpperCamelCase__      )      )


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"      ).to(UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    prepare_batch("val-batch.pt"      )
       with torch.no_grad():
         SCREAMING_SNAKE_CASE       :      int							=    model(
             past_values=batch["past_values"]					, past_time_features=batch["past_time_features"]					, past_observed_mask=batch["past_observed_mask"]					, static_categorical_features=batch["static_categorical_features"]					, ).encoder_last_hidden_state
       SCREAMING_SNAKE_CASE       :      Tuple							=    torch.Size((64, model.config.context_length, model.config.d_model)      )
       self.assertEqual(output.shape					, UpperCamelCase__      )

       SCREAMING_SNAKE_CASE       :      Dict							=    torch.tensor(
           [[-0.0_734, -0.9_036, 0.8_358], [4.7_186, 2.4_113, 1.9_581], [1.7_953, 2.3_558, 1.2_970]]					, device=UpperCamelCase__      )
       self.assertTrue(torch.allclose(output[0, :3, :3]					, UpperCamelCase__					, atol=UpperCamelCase__      )      )






     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      int							=    AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"      ).to(UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      int							=    prepare_batch("val-batch.pt"      )
       with torch.no_grad():
         SCREAMING_SNAKE_CASE       :      Optional[int]							=    model.generate(
             static_categorical_features=batch["static_categorical_features"]					, past_time_features=batch["past_time_features"]					, past_values=batch["past_values"]					, future_time_features=batch["future_time_features"]					, past_observed_mask=batch["past_observed_mask"]					, )
       SCREAMING_SNAKE_CASE       :      Tuple							=    torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)      )
       self.assertEqual(outputs.sequences.shape					, UpperCamelCase__      )

       SCREAMING_SNAKE_CASE       :      str							=    torch.tensor([3130.6763, 4056.5293, 7053.0786]					, device=UpperCamelCase__      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    outputs.sequences.mean(dim=1      )
       self.assertTrue(torch.allclose(mean_prediction[0, -3:]					, UpperCamelCase__					, rtol=1E-1      )      )









from __future__ import annotations


def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Optional[Any]							=    str(lowercase				)
  return n == n[::-1]


def   lowerCamelCase__			(     lowercase = 1000000				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      int							=    0

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


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






