import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
      import tensorflow as tf

if is_tensorflow_text_available():
      from transformers.models.bert import TFBertTokenizer


A     :  List[Any]					     =       ["bert-base-uncased", "bert-base-cased"]
A     :  Dict					     =       "hf-internal-testing/tiny-bert-tf-only"

if is_tf_available():


      class   lowerCamelCase					(tf.keras.Model					):
        """simple docstring"""







        def __init__(							self :       Dict  ,     __magic_name__ :       str   )  ->	int:
              super().__init__()
              SCREAMING_SNAKE_CASE_          =  tokenizer
              SCREAMING_SNAKE_CASE_          =  AutoConfig.from_pretrained(__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  TFAutoModel.from_config(__magic_name__   )







        def    __A     (							self :       List[str]  ,     __magic_name__ :       List[str]   )  ->	Dict:
              SCREAMING_SNAKE_CASE_          =  self.tokenizer(__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  self.bert(**__magic_name__   )
              return out["pooler_output"]


@require_tf
@require_tensorflow_text
class   lowerCamelCase					(unittest.TestCase					):
  """simple docstring"""







  def    __A     (							self :       Tuple   )  ->	Dict:
        super().setUp()

        SCREAMING_SNAKE_CASE_          =  [
            BertTokenizer.from_pretrained(__magic_name__   ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
        ]  # repeat for when fast_bert_tokenizer=false
        SCREAMING_SNAKE_CASE_          =  [TFBertTokenizer.from_pretrained(__magic_name__   ) for checkpoint in TOKENIZER_CHECKPOINTS] + [
            TFBertTokenizer.from_pretrained(__magic_name__  ,     use_fast_bert_tokenizer=__magic_name__   )
            for checkpoint in TOKENIZER_CHECKPOINTS
        ]
        assert len(self.tokenizers   ) == len(self.tf_tokenizers   )

        SCREAMING_SNAKE_CASE_          =  [
            "This is a straightforward English test sentence.",
            "This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.",
            "Now we're going to add some Chinese: 一 二 三 一二三",
            "And some much more rare Chinese: 齉 堃 齉堃",
            "Je vais aussi écrire en français pour tester les accents",
            "Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ",
        ]
        SCREAMING_SNAKE_CASE_          =  list(zip(self.test_sentences  ,     self.test_sentences[::-1]   )   )







  def    __A     (							self :       Union[str, Any]   )  ->	str:
        for tokenizer, tf_tokenizer in zip(self.tokenizers  ,     self.tf_tokenizers   ):
              for test_inputs in (self.test_sentences, self.paired_sentences):
                    SCREAMING_SNAKE_CASE_          =  tokenizer(__magic_name__  ,     return_tensors="tf"  ,     padding="longest"   )
                    SCREAMING_SNAKE_CASE_          =  tf_tokenizer(__magic_name__   )

                    for key in python_outputs.keys():
                          self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape   )   )
                          self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]  ,     tf.intaa   ) == tf_outputs[key]   )   )







  @slow
  def    __A     (							self :       Dict   )  ->	Tuple:
        for tf_tokenizer in self.tf_tokenizers:
              SCREAMING_SNAKE_CASE_          =  tf_tokenizer(self.paired_sentences   )
              SCREAMING_SNAKE_CASE_          =  tf_tokenizer(
                  text=[sentence[0] for sentence in self.paired_sentences]  ,     text_pair=[sentence[1] for sentence in self.paired_sentences]  ,     )
              for key in merged_outputs.keys():
                    self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]  ,     tf.intaa   ) == separated_outputs[key]   )   )







  @slow
  def    __A     (							self :       Union[str, Any]   )  ->	Dict:
        for tf_tokenizer in self.tf_tokenizers:
              SCREAMING_SNAKE_CASE_          =  tf.function(__magic_name__   )
              for test_inputs in (self.test_sentences, self.paired_sentences):
                    SCREAMING_SNAKE_CASE_          =  tf.constant(__magic_name__   )
                    SCREAMING_SNAKE_CASE_          =  compiled_tokenizer(__magic_name__   )
                    SCREAMING_SNAKE_CASE_          =  tf_tokenizer(__magic_name__   )

                    for key in eager_outputs.keys():
                          self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]   )   )







  @slow
  def    __A     (							self :       List[Any]   )  ->	Union[str, Any]:
        for tf_tokenizer in self.tf_tokenizers:
              SCREAMING_SNAKE_CASE_          =  ModelToSave(tokenizer=__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  tf.convert_to_tensor(self.test_sentences   )
              SCREAMING_SNAKE_CASE_          =  model(__magic_name__   )  # Build model with some sample inputs
              with TemporaryDirectory() as tempdir:
                    SCREAMING_SNAKE_CASE_          =  Path(__magic_name__   ) / "saved.model"
                    model.save(__magic_name__   )
                    SCREAMING_SNAKE_CASE_          =  tf.keras.models.load_model(__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  loaded_model(__magic_name__   )
              # We may see small differences because the loaded model is compiled, so we need an epsilon for the test
              self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output   )   )  ,     1e-5   )



from __future__ import annotations


def      a__ (		__UpperCamelCase				):
      SCREAMING_SNAKE_CASE_          =  str(__UpperCamelCase				)
      return n == n[::-1]


def      a__ (		__UpperCamelCase = 1_0_0_0_0_0_0				):
      SCREAMING_SNAKE_CASE_          =  0

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


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


