






from __future__ import annotations

import unittest

from transformers import BlenderbotConfig, BlenderbotTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotForConditionalGeneration, TFBlenderbotModel


@require_tf
class  SCREAMING_SNAKE_CASE			:
     '''simple docstring'''


     UpperCamelCase_							:		str			=	BlenderbotConfig
     UpperCamelCase_							:		Optional[Any]			=	{}
     UpperCamelCase_							:		Dict			=	'''gelu'''


     def __init__(				self       :	Tuple					, UpperCAmelCase_       :	Union[str, Any]					, UpperCAmelCase_       :	Any=13					, UpperCAmelCase_       :	Union[str, Any]=7					, UpperCAmelCase_       :	Union[str, Any]=True					, UpperCAmelCase_       :	str=False					, UpperCAmelCase_       :	Union[str, Any]=99					, UpperCAmelCase_       :	Optional[Any]=32					, UpperCAmelCase_       :	str=2					, UpperCAmelCase_       :	List[Any]=4					, UpperCAmelCase_       :	Union[str, Any]=37					, UpperCAmelCase_       :	Dict=0.1					, UpperCAmelCase_       :	Union[str, Any]=0.1					, UpperCAmelCase_       :	Optional[int]=20					, UpperCAmelCase_       :	List[Any]=2					, UpperCAmelCase_       :	Optional[Any]=1					, UpperCAmelCase_       :	Tuple=0					, ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    parent
       SCREAMING_SNAKE_CASE       :      str							=    batch_size
       SCREAMING_SNAKE_CASE       :      Tuple							=    seq_length
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    is_training
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    use_labels
       SCREAMING_SNAKE_CASE       :      List[str]							=    vocab_size
       SCREAMING_SNAKE_CASE       :      int							=    hidden_size
       SCREAMING_SNAKE_CASE       :      str							=    num_hidden_layers
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    num_attention_heads
       SCREAMING_SNAKE_CASE       :      Any							=    intermediate_size

       SCREAMING_SNAKE_CASE       :      int							=    hidden_dropout_prob
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE       :      List[Any]							=    max_position_embeddings
       SCREAMING_SNAKE_CASE       :      Tuple							=    eos_token_id
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    pad_token_id
       SCREAMING_SNAKE_CASE       :      List[str]							=    bos_token_id


     def 				_A       (				self       :	List[Any]      ):
       SCREAMING_SNAKE_CASE       :      List[Any]							=    ids_tensor([self.batch_size, self.seq_length - 1]					, self.vocab_size      )
       SCREAMING_SNAKE_CASE       :      str							=    tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size      )					, 1      )
       SCREAMING_SNAKE_CASE       :      str							=    tf.concat([input_ids, eos_tensor]					, axis=1      )

       SCREAMING_SNAKE_CASE       :      List[str]							=    ids_tensor([self.batch_size, self.seq_length]					, self.vocab_size      )

       SCREAMING_SNAKE_CASE       :      List[str]							=    self.config_cls(
           vocab_size=self.vocab_size					, d_model=self.hidden_size					, 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					, max_position_embeddings=self.max_position_embeddings					, eos_token_ids=[2]					, bos_token_id=self.bos_token_id					, pad_token_id=self.pad_token_id					, decoder_start_token_id=self.pad_token_id					, **self.config_updates					, )
       SCREAMING_SNAKE_CASE       :      Tuple							=    prepare_blenderbot_inputs_dict(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_      )
       return config, inputs_dict






     def 				_A       (				self       :	int					, UpperCAmelCase_       :	str					, UpperCAmelCase_       :	Any      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    TFBlenderbotModel(config=UpperCAmelCase_      ).get_decoder()
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    inputs_dict["input_ids"]

       SCREAMING_SNAKE_CASE       :      int							=    input_ids[:1, :]
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    inputs_dict["attention_mask"][:1, :]
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    inputs_dict["head_mask"]
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    1

       # first forward pass
       SCREAMING_SNAKE_CASE       :      str							=    model(UpperCAmelCase_					, attention_mask=UpperCAmelCase_					, head_mask=UpperCAmelCase_					, use_cache=UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Any							=    outputs.to_tuple()

       # create hypothetical next token and extent to next_input_ids
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    ids_tensor((self.batch_size, 3)					, config.vocab_size      )
       SCREAMING_SNAKE_CASE       :      int							=    tf.cast(ids_tensor((self.batch_size, 3)					, 2      )					, tf.inta      )

       # append to next input_ids and
       SCREAMING_SNAKE_CASE       :      int							=    tf.concat([input_ids, next_tokens]					, axis=-1      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    tf.concat([attention_mask, next_attn_mask]					, axis=-1      )

       SCREAMING_SNAKE_CASE       :      str							=    model(UpperCAmelCase_					, attention_mask=UpperCAmelCase_      )[0]
       SCREAMING_SNAKE_CASE       :      Any							=    model(UpperCAmelCase_					, attention_mask=UpperCAmelCase_					, past_key_values=UpperCAmelCase_      )[0]

       self.parent.assertEqual(next_tokens.shape[1]					, output_from_past.shape[1]      )

       # select random slice
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    int(ids_tensor((1,)					, output_from_past.shape[-1]      )      )
       SCREAMING_SNAKE_CASE       :      Any							=    output_from_no_past[:, -3:, random_slice_idx]
       SCREAMING_SNAKE_CASE       :      str							=    output_from_past[:, :, random_slice_idx]

       # test that outputs are equal for slice
       tf.debugging.assert_near(UpperCAmelCase_					, UpperCAmelCase_					, rtol=1E-3      )





def   lowerCamelCase__			(     lowercase						,     lowercase						,     lowercase						,     lowercase=None						,     lowercase=None						,     lowercase=None						,     lowercase=None						,     lowercase=None						,     ):

  """simple docstring"""






  if attention_mask is None:
    SCREAMING_SNAKE_CASE       :      Optional[int]							=    tf.cast(tf.math.not_equal(lowercase						,     config.pad_token_id				)						,     tf.inta				)
  if decoder_attention_mask is None:
    SCREAMING_SNAKE_CASE       :      int							=    tf.concat(
        [
            tf.ones(decoder_input_ids[:, :1].shape						,     dtype=tf.inta				),
            tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]						,     config.pad_token_id				)						,     tf.inta				),
        ]						,     axis=-1						,     )
  if head_mask is None:
    SCREAMING_SNAKE_CASE       :      str							=    tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
  if decoder_head_mask is None:
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
  if cross_attn_head_mask is None:
    SCREAMING_SNAKE_CASE       :      Any							=    tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
  return {
      "input_ids": input_ids,
      "decoder_input_ids": decoder_input_ids,
      "attention_mask": attention_mask,
      "decoder_attention_mask": decoder_attention_mask,
      "head_mask": head_mask,
      "decoder_head_mask": decoder_head_mask,
      "cross_attn_head_mask": cross_attn_head_mask,
  }


@require_tf
class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase      ,		lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		str			=	(TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
     UpperCamelCase_							:		Union[str, Any]			=	(TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
     UpperCamelCase_							:		List[Any]			=	(
         {
             '''conversational''': TFBlenderbotForConditionalGeneration,
             '''feature-extraction''': TFBlenderbotModel,
             '''summarization''': TFBlenderbotForConditionalGeneration,
             '''text2text-generation''': TFBlenderbotForConditionalGeneration,
             '''translation''': TFBlenderbotForConditionalGeneration,
         }
         if is_tf_available()
         else {}
     )
     UpperCamelCase_							:		List[Any]			=	True
     UpperCamelCase_							:		Union[str, Any]			=	False
     UpperCamelCase_							:		Dict			=	False


     def 				_A       (				self       :	List[str]      ):
       SCREAMING_SNAKE_CASE       :      int							=    TFBlenderbotModelTester(self      )
       SCREAMING_SNAKE_CASE       :      Tuple							=    ConfigTester(self					, config_class=UpperCAmelCase_      )


     def 				_A       (				self       :	str      ):
       self.config_tester.run_common_tests()






     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_decoder_model_past_large_inputs(*UpperCAmelCase_      )





@require_tokenizers
@require_tf
class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Optional[Any]			=	['''My friends are cool but they eat too many carbs.''']
     UpperCamelCase_							:		int			=	'''facebook/blenderbot-400M-distill'''


     @cached_property
     def 				_A       (				self       :	Dict      ):
       return BlenderbotTokenizer.from_pretrained(self.model_name      )


     @cached_property
     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name      )
       return model






     @slow
     def 				_A       (				self       :	Optional[int]      ):
       SCREAMING_SNAKE_CASE       :      List[Any]							=    self.tokenizer(self.src_text					, return_tensors="tf"      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    self.model.generate(
           model_inputs.input_ids					, )
       SCREAMING_SNAKE_CASE       :      List[str]							=    self.tokenizer.batch_decode(generated_ids.numpy()					, skip_special_tokens=UpperCAmelCase_      )[0]
       assert (
           generated_words
           == " That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?"
       )














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()))))






