import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_torch, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_torch_available, is_vision_available


if is_torch_available():
      import torch


if is_vision_available():
      from PIL import Image

      from transformers import MgpstrProcessor, ViTImageProcessor


@require_torch
@require_vision
class   lowerCamelCase					(unittest.TestCase					):
  """simple docstring"""







  lowerCamelCase__     =						ViTImageProcessor if is_vision_available() else None







  @property
  def    __A     (							self :       Dict   )  ->	str:
        return self.image_processor_tester.prepare_image_processor_dict()







  def    __A     (							self :       List[str]   )  ->	str:
        SCREAMING_SNAKE_CASE_          =  (3, 32, 128)
        SCREAMING_SNAKE_CASE_          =  tempfile.mkdtemp()

        # fmt: off
        SCREAMING_SNAKE_CASE_          =  ["[GO]", "[s]", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
        # fmt: on
        SCREAMING_SNAKE_CASE_          =  dict(zip(__magic_name__  ,     range(len(__magic_name__   )   )   )   )

        SCREAMING_SNAKE_CASE_          =  os.path.join(self.tmpdirname  ,     VOCAB_FILES_NAMES["vocab_file"]   )
        with open(self.vocab_file  ,     "w"  ,     encoding="utf-8"   ) as fp:
              fp.write(json.dumps(__magic_name__   ) + "\n"   )

        SCREAMING_SNAKE_CASE_          =  {
            "do_normalize": False,
            "do_resize": True,
            "image_processor_type": "ViTImageProcessor",
            "resample": 3,
            "size": {"height": 32, "width": 128},
        }
        SCREAMING_SNAKE_CASE_          =  os.path.join(self.tmpdirname  ,     __magic_name__   )
        with open(self.image_processor_file  ,     "w"  ,     encoding="utf-8"   ) as fp:
              json.dump(__magic_name__  ,     __magic_name__   )







  def    __A     (							self :       int  ,     **__magic_name__ :       List[str]   )  ->	Dict:
        return MgpstrTokenizer.from_pretrained(self.tmpdirname  ,     **__magic_name__   )







  def    __A     (							self :       List[str]  ,     **__magic_name__ :       Optional[Any]   )  ->	Dict:
        return ViTImageProcessor.from_pretrained(self.tmpdirname  ,     **__magic_name__   )







  def    __A     (							self :       str   )  ->	Any:
        shutil.rmtree(self.tmpdirname   )







  def    __A     (							self :       Tuple   )  ->	Dict:
        SCREAMING_SNAKE_CASE_          =  np.random.randint(255  ,     size=(3, 30, 400)  ,     dtype=np.uinta   )

        SCREAMING_SNAKE_CASE_          =  Image.fromarray(np.moveaxis(__magic_name__  ,     0  ,     -1   )   )

        return image_input







  def    __A     (							self :       Any   )  ->	str:
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )
        processor.save_pretrained(self.tmpdirname   )
        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor.from_pretrained(self.tmpdirname  ,     use_fast=__magic_name__   )

        self.assertEqual(processor.char_tokenizer.get_vocab()  ,     tokenizer.get_vocab()   )
        self.assertIsInstance(processor.char_tokenizer  ,     __magic_name__   )

        self.assertEqual(processor.image_processor.to_json_string()  ,     image_processor.to_json_string()   )
        self.assertIsInstance(processor.image_processor  ,     __magic_name__   )







  def    __A     (							self :       Dict   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )
        processor.save_pretrained(self.tmpdirname   )

        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer(bos_token="(BOS)"  ,     eos_token="(EOS)"   )
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor(do_normalize=__magic_name__  ,     padding_value=1.0   )

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor.from_pretrained(
            self.tmpdirname  ,     bos_token="(BOS)"  ,     eos_token="(EOS)"  ,     do_normalize=__magic_name__  ,     padding_value=1.0   )

        self.assertEqual(processor.char_tokenizer.get_vocab()  ,     tokenizer_add_kwargs.get_vocab()   )
        self.assertIsInstance(processor.char_tokenizer  ,     __magic_name__   )

        self.assertEqual(processor.image_processor.to_json_string()  ,     image_processor_add_kwargs.to_json_string()   )
        self.assertIsInstance(processor.image_processor  ,     __magic_name__   )







  def    __A     (							self :       List[str]   )  ->	Union[str, Any]:
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  self.prepare_image_inputs()

        SCREAMING_SNAKE_CASE_          =  image_processor(__magic_name__  ,     return_tensors="np"   )
        SCREAMING_SNAKE_CASE_          =  processor(images=__magic_name__  ,     return_tensors="np"   )

        for key in input_image_proc.keys():
              self.assertAlmostEqual(input_image_proc[key].sum()  ,     input_processor[key].sum()  ,     delta=1e-2   )







  def    __A     (							self :       Optional[Any]   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  "test"

        SCREAMING_SNAKE_CASE_          =  processor(text=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  tokenizer(__magic_name__   )
        for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key]  ,     encoded_processor[key]   )







  def    __A     (							self :       List[str]   )  ->	Union[str, Any]:
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  "test"
        SCREAMING_SNAKE_CASE_          =  self.prepare_image_inputs()

        SCREAMING_SNAKE_CASE_          =  processor(text=__magic_name__  ,     images=__magic_name__   )

        self.assertListEqual(list(inputs.keys()   )  ,     ["pixel_values", "labels"]   )

        # test if it raises when no input is passed
        with pytest.raises(__magic_name__   ):
              processor()







  def    __A     (							self :       List[Any]   )  ->	int:
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9], [3, 4, 3, 1, 1, 8, 9]]

        SCREAMING_SNAKE_CASE_          =  processor.char_decode(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  tokenizer.batch_decode(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  [seq.replace(" "  ,     ""   ) for seq in decoded_tok]

        self.assertListEqual(__magic_name__  ,     __magic_name__   )







  def    __A     (							self :       List[Any]   )  ->	str:
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  None
        SCREAMING_SNAKE_CASE_          =  self.prepare_image_inputs()

        SCREAMING_SNAKE_CASE_          =  processor(text=__magic_name__  ,     images=__magic_name__   )

        self.assertListEqual(list(inputs.keys()   )  ,     processor.model_input_names   )







  def    __A     (							self :       str   )  ->	Any:
        SCREAMING_SNAKE_CASE_          =  self.get_image_processor()
        SCREAMING_SNAKE_CASE_          =  self.get_tokenizer()

        SCREAMING_SNAKE_CASE_          =  MgpstrProcessor(tokenizer=__magic_name__  ,     image_processor=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  torch.randn(1  ,     27  ,     38   )
        SCREAMING_SNAKE_CASE_          =  torch.randn(1  ,     27  ,     50_257   )
        SCREAMING_SNAKE_CASE_          =  torch.randn(1  ,     27  ,     30_522   )

        SCREAMING_SNAKE_CASE_          =  processor.batch_decode([char_input, bpe_input, wp_input]   )

        self.assertListEqual(list(results.keys()   )  ,     ["generated_text", "scores", "char_preds", "bpe_preds", "wp_preds"]   )



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


