

'''simple docstring'''
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer
from ...utils import logging


_lowerCamelCase      					=     logging.get_logger(__name__)

_lowerCamelCase      					=     """▁"""

_lowerCamelCase      					=     {"""vocab_file""": """sentencepiece.bpe.model"""}

_lowerCamelCase      					=     {
    """vocab_file""": {
        """facebook/mbart-large-50-one-to-many-mmt""": (
            """https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model"""
        ),
    }
}

_lowerCamelCase      					=     {
    """facebook/mbart-large-50-one-to-many-mmt""": 1024,
}

# fmt: off
_lowerCamelCase      					=     ["""ar_AR""", """cs_CZ""", """de_DE""", """en_XX""", """es_XX""", """et_EE""", """fi_FI""", """fr_XX""", """gu_IN""", """hi_IN""", """it_IT""", """ja_XX""", """kk_KZ""", """ko_KR""", """lt_LT""", """lv_LV""", """my_MM""", """ne_NP""", """nl_XX""", """ro_RO""", """ru_RU""", """si_LK""", """tr_TR""", """vi_VN""", """zh_CN""", """af_ZA""", """az_AZ""", """bn_IN""", """fa_IR""", """he_IL""", """hr_HR""", """id_ID""", """ka_GE""", """km_KH""", """mk_MK""", """ml_IN""", """mn_MN""", """mr_IN""", """pl_PL""", """ps_AF""", """pt_XX""", """sv_SE""", """sw_KE""", """ta_IN""", """te_IN""", """th_TH""", """tl_XX""", """uk_UA""", """ur_PK""", """xh_ZA""", """gl_ES""", """sl_SI"""]
class 					_snake_case		(__SCREAMING_SNAKE_CASE):
			__A  :	List[Any]        =VOCAB_FILES_NAMES
			__A  :	int        =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			__A  :	Dict        =PRETRAINED_VOCAB_FILES_MAP
			__A  :	Dict        =["input_ids", "attention_mask"]

			__A  :	List[int]        =[]
			__A  :	List[int]        =[]






			def __init__(  self			,_snake_case			,_snake_case=None			,_snake_case=None			,_snake_case="</s>"			,_snake_case="</s>"			,_snake_case="<s>"			,_snake_case="<unk>"			,_snake_case="<pad>"			,_snake_case="<mask>"			,_snake_case = None			,**_snake_case			,):
				# Mask token behave like a normal word, i.e. include the space before it
				UpperCAmelCase_     :      Optional[Any]						=  AddedToken(_snake_case			,lstrip=_snake_case			,rstrip=_snake_case     ) if isinstance(_snake_case			,_snake_case     ) else mask_token

				UpperCAmelCase_     :      Any						=  {} if sp_model_kwargs is None else sp_model_kwargs

				UpperCAmelCase_     :      Optional[Any]						=  kwargs.get("additional_special_tokens"			,[]     )
				kwargs["additional_special_tokens"] += [
				    code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
				]

				super().__init__(
				    src_lang=_snake_case			,tgt_lang=_snake_case			,eos_token=_snake_case			,unk_token=_snake_case			,sep_token=_snake_case			,cls_token=_snake_case			,pad_token=_snake_case			,mask_token=_snake_case			,sp_model_kwargs=self.sp_model_kwargs			,**_snake_case			,)

				UpperCAmelCase_     :      List[str]						=  spm.SentencePieceProcessor(**self.sp_model_kwargs     )
				self.sp_model.Load(str(_snake_case     )     )
				UpperCAmelCase_     :      List[str]						=  vocab_file

				# Original fairseq vocab and spm vocab must be "aligned":
				# Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
				# -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
				# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
				# spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

				# Mimic fairseq token-to-id alignment for the first 4 token
				UpperCAmelCase_     :      Optional[int]						=  {"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

				# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
				UpperCAmelCase_     :      List[Any]						=  1

				UpperCAmelCase_     :      Union[str, Any]						=  len(self.sp_model     )
				UpperCAmelCase_     :      int						=  {
				    code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(_snake_case     )
				}
				UpperCAmelCase_     :      List[Any]						=  {v: k for k, v in self.lang_code_to_id.items()}
				UpperCAmelCase_     :      int						=  len(self.sp_model     ) + len(self.lang_code_to_id     ) + self.fairseq_offset

				self.fairseq_tokens_to_ids.update(self.lang_code_to_id     )
				UpperCAmelCase_     :      str						=  {v: k for k, v in self.fairseq_tokens_to_ids.items()}

				UpperCAmelCase_     :      Optional[int]						=  src_lang if src_lang is not None else "en_XX"
				UpperCAmelCase_     :      List[Any]						=  self.lang_code_to_id[self._src_lang]
				UpperCAmelCase_     :      str						=  tgt_lang
				self.set_src_lang_special_tokens(self._src_lang     )






			@property
			def 		UpperCamelCase__							(  self     ):
				return len(self.sp_model     ) + len(self.lang_code_to_id     ) + self.fairseq_offset + 1  # Plus 1 for the mask token






			@property
			def 		UpperCamelCase__							(  self     ):
				return self._src_lang






			@src_lang.setter
			def 		UpperCamelCase__							(  self			,_snake_case     ):
				UpperCAmelCase_     :      Tuple						=  new_src_lang
				self.set_src_lang_special_tokens(self._src_lang     )






			def __getstate__(  self     ):
				UpperCAmelCase_     :      List[Any]						=  self.__dict__.copy()
				UpperCAmelCase_     :      List[str]						=  None
				return state






			def __setstate__(  self			,_snake_case     ):
				UpperCAmelCase_     :      Union[str, Any]						=  d

				# for backward compatibility
				if not hasattr(self			,"sp_model_kwargs"     ):
					UpperCAmelCase_     :      int						=  {}

				UpperCAmelCase_     :      Dict						=  spm.SentencePieceProcessor(**self.sp_model_kwargs     )
				self.sp_model.Load(self.vocab_file     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Optional[Any]						=  {self.convert_ids_to_tokens(_snake_case     ): i for i in range(self.vocab_size     )}
				vocab.update(self.added_tokens_encoder     )
				return vocab






			def 		UpperCamelCase__							(  self			,_snake_case     ):
				return self.sp_model.encode(_snake_case			,out_type=_snake_case     )






			def 		UpperCamelCase__							(  self			,_snake_case     ):
				if token in self.fairseq_tokens_to_ids:
					return self.fairseq_tokens_to_ids[token]
				UpperCAmelCase_     :      Dict						=  self.sp_model.PieceToId(_snake_case     )

				# Need to return unknown token if the SP model returned 0
				return spm_id + self.fairseq_offset if spm_id else self.unk_token_id






			def 		UpperCamelCase__							(  self			,_snake_case     ):
				if index in self.fairseq_ids_to_tokens:
					return self.fairseq_ids_to_tokens[index]
				return self.sp_model.IdToPiece(index - self.fairseq_offset     )






			def 		UpperCamelCase__							(  self			,_snake_case     ):
				UpperCAmelCase_     :      Optional[int]						=  []
				UpperCAmelCase_     :      int						=  ""
				UpperCAmelCase_     :      Optional[int]						=  False
				for token in tokens:
					# make sure that special tokens are not decoded using sentencepiece model
					if token in self.all_special_tokens:
						if not prev_is_special:
							out_string += " "
						out_string += self.sp_model.decode(_snake_case     ) + token
						UpperCAmelCase_     :      int						=  True
						UpperCAmelCase_     :      List[Any]						=  []
					else:
						current_sub_tokens.append(_snake_case     )
						UpperCAmelCase_     :      Any						=  False
				out_string += self.sp_model.decode(_snake_case     )
				return out_string.strip()






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case = None     ):
				if not os.path.isdir(_snake_case     ):
					logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''     )
					return
				UpperCAmelCase_     :      Optional[Any]						=  os.path.join(
				    _snake_case			,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]     )

				if os.path.abspath(self.vocab_file     ) != os.path.abspath(_snake_case     ) and os.path.isfile(self.vocab_file     ):
					copyfile(self.vocab_file			,_snake_case     )
				elif not os.path.isfile(self.vocab_file     ):
					with open(_snake_case			,"wb"     ) as fi:
						UpperCAmelCase_     :      Union[str, Any]						=  self.sp_model.serialized_model_proto()
						fi.write(_snake_case     )

				return (out_vocab_file,)






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case = None			,_snake_case = False     ):

				if already_has_special_tokens:
					return super().get_special_tokens_mask(
					    token_ids_a=_snake_case			,token_ids_a=_snake_case			,already_has_special_tokens=_snake_case     )

				UpperCAmelCase_     :      Union[str, Any]						=  [1] * len(self.prefix_tokens     )
				UpperCAmelCase_     :      str						=  [1] * len(self.suffix_tokens     )
				if token_ids_a is None:
					return prefix_ones + ([0] * len(_snake_case     )) + suffix_ones
				return prefix_ones + ([0] * len(_snake_case     )) + ([0] * len(_snake_case     )) + suffix_ones






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case = None     ):
				if token_ids_a is None:
					return self.prefix_tokens + token_ids_a + self.suffix_tokens
				# We don't expect to process pairs, but leave the pair logic for API consistency
				return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case			,_snake_case			,_snake_case			,**_snake_case     ):
				if src_lang is None or tgt_lang is None:
					raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model"     )
				UpperCAmelCase_     :      str						=  src_lang
				UpperCAmelCase_     :      Dict						=  self(_snake_case			,add_special_tokens=_snake_case			,return_tensors=_snake_case			,**_snake_case     )
				UpperCAmelCase_     :      List[str]						=  self.convert_tokens_to_ids(_snake_case     )
				UpperCAmelCase_     :      Optional[Any]						=  tgt_lang_id
				return inputs






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case = "en_XX"			,_snake_case = None			,_snake_case = "ro_RO"			,**_snake_case			,):
				UpperCAmelCase_     :      Optional[Any]						=  src_lang
				UpperCAmelCase_     :      int						=  tgt_lang
				return super().prepare_seqaseq_batch(_snake_case			,_snake_case			,**_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				return self.set_src_lang_special_tokens(self.src_lang     )






			def 		UpperCamelCase__							(  self     ):
				return self.set_tgt_lang_special_tokens(self.tgt_lang     )






			def 		UpperCamelCase__							(  self			,_snake_case     ):
				UpperCAmelCase_     :      List[Any]						=  self.lang_code_to_id[src_lang]
				UpperCAmelCase_     :      List[str]						=  [self.cur_lang_code_id]
				UpperCAmelCase_     :      Dict						=  [self.eos_token_id]






			def 		UpperCamelCase__							(  self			,_snake_case     ):
				UpperCAmelCase_     :      int						=  self.lang_code_to_id[tgt_lang]
				UpperCAmelCase_     :      Optional[Any]						=  [self.cur_lang_code_id]
				UpperCAmelCase_     :      int						=  [self.eos_token_id]









from __future__ import annotations







def  lowerCAmelCase_	(lowerCAmelCase__:		int | str  ):





			"""simple docstring"""


			UpperCAmelCase_:		Optional[int]							      =     str(lowerCAmelCase__  )
			return n == n[::-1]







def  lowerCAmelCase_	(lowerCAmelCase__:		int = 1_0_0_0_0_0_0  ):





			"""simple docstring"""


			UpperCAmelCase_:		int							      =     0

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


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






