



import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
class 				_a				(   _lowerCAmelCase ,		unittest.TestCase					):
			A      		=	CLIPTokenizer
			A      		=	CLIPTokenizerFast
			A      		=	True
			A      		=	{}
			A      		=	False

			def      __snake_case       (self					)       ->   Dict:
						super().setUp()

						# fmt: off
						UpperCAmelCase_:		Tuple							      =     ["""l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
						# fmt: on
						UpperCAmelCase_:		List[Any]							      =     dict(zip(SCREAMING_SNAKE_CASE_,   range(len(SCREAMING_SNAKE_CASE_					)					)					)					)
						UpperCAmelCase_:		Optional[Any]							      =     ["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>"""]
						UpperCAmelCase_:		List[Any]							      =     {"""unk_token""": """<unk>"""}

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

			def      __snake_case       (self,   **SCREAMING_SNAKE_CASE_					)       ->   List[str]:
						kwargs.update(self.special_tokens_map					)
						return CLIPTokenizer.from_pretrained(self.tmpdirname,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   **SCREAMING_SNAKE_CASE_					)       ->   Tuple:
						kwargs.update(self.special_tokens_map					)
						return CLIPTokenizerFast.from_pretrained(self.tmpdirname,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   List[str]:
						UpperCAmelCase_:		Optional[Any]							      =     """lower newer"""
						UpperCAmelCase_:		Any							      =     """lower newer"""
						return input_text, output_text

			def      __snake_case       (self					)       ->   Optional[Any]:
						UpperCAmelCase_:		List[str]							      =     CLIPTokenizer(self.vocab_file,   self.merges_file,   **self.special_tokens_map					)
						UpperCAmelCase_:		Optional[int]							      =     """lower newer"""
						UpperCAmelCase_:		str							      =     ["""lo""", """w""", """er</w>""", """n""", """e""", """w""", """er</w>"""]
						UpperCAmelCase_:		int							      =     tokenizer.tokenize(SCREAMING_SNAKE_CASE_					)
						self.assertListEqual(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		List[Any]							      =     tokens + [tokenizer.unk_token]
						UpperCAmelCase_:		List[str]							      =     [10, 2, 16, 9, 3, 2, 16, 20]
						self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_					),   SCREAMING_SNAKE_CASE_					)

			@require_ftfy
			def      __snake_case       (self					)       ->   List[Any]:
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'					):
												UpperCAmelCase_:		str							      =     self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)
												UpperCAmelCase_:		Optional[int]							      =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

												UpperCAmelCase_:		Optional[Any]							      =     """A\n'll 11p223RF☆ho!!to?'d'd''d of a cat to-$''d."""
												UpperCAmelCase_:		int							      =     tokenizer_s.tokenize(SCREAMING_SNAKE_CASE_					)
												UpperCAmelCase_:		int							      =     tokenizer_r.tokenize(SCREAMING_SNAKE_CASE_					)

												self.assertListEqual(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					)

												# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
												# with Tilde) encoded in 2 different ways
												UpperCAmelCase_:		int							      =     """xa\u0303y""" + """ """ + """x\xe3y"""
												UpperCAmelCase_:		Optional[Any]							      =     tokenizer_s.tokenize(SCREAMING_SNAKE_CASE_					)
												UpperCAmelCase_:		Any							      =     tokenizer_r.tokenize(SCREAMING_SNAKE_CASE_					)

												self.assertListEqual(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					)

												# Test that the tokenization is identical on unicode of space type
												UpperCAmelCase_:		Optional[int]							      =     [
												    """\u0009""",  # (horizontal tab, '\t')
												    """\u000B""",  # (vertical tab)
												    """\u000C""",  # (form feed)
												    """\u0020""",  # (space, ' ')
												    """\u200E""",  # (left-to-right mark):w
												    """\u200F""",  # (right-to-left mark)
												]
												for unicode_seq in spaces_unicodes:
															UpperCAmelCase_:		str							      =     tokenizer_s.tokenize(SCREAMING_SNAKE_CASE_					)
															UpperCAmelCase_:		Optional[Any]							      =     tokenizer_r.tokenize(SCREAMING_SNAKE_CASE_					)

															self.assertListEqual(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					)

												# Test that the tokenization is identical on unicode of line break type
												UpperCAmelCase_:		List[Any]							      =     [
												    """\u000A""",  # (line feed, '\n')
												    """\r\n""",  # (carriage return and line feed, '\r\n')
												    """\u000D""",  # (carriage return, '\r')
												    """\r""",  # (carriage return, '\r')
												    """\u000D""",  # (carriage return, '\r')
												    """\u2028""",  # (line separator)
												    """\u2029""",  # (paragraph separator)
												    # "\u0085", # (next line)
												]

												# The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
												# it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
												# space (and thus into an empty list).

												for unicode_seq in line_break_unicodes:
															UpperCAmelCase_:		List[Any]							      =     tokenizer_s.tokenize(SCREAMING_SNAKE_CASE_					)
															UpperCAmelCase_:		List[str]							      =     tokenizer_r.tokenize(SCREAMING_SNAKE_CASE_					)

															self.assertListEqual(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self					)       ->   Union[str, Any]:
						# Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'					):
												UpperCAmelCase_:		Optional[Any]							      =     """hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
												UpperCAmelCase_:		List[str]							      =     f'{text_of_1_token} {text_of_1_token}'

												UpperCAmelCase_:		str							      =     self.rust_tokenizer_class.from_pretrained(
												    SCREAMING_SNAKE_CASE_,   use_fast=SCREAMING_SNAKE_CASE_,   )
												UpperCAmelCase_:		Tuple							      =     tokenizer_r(SCREAMING_SNAKE_CASE_,   return_offsets_mapping=SCREAMING_SNAKE_CASE_,   add_special_tokens=SCREAMING_SNAKE_CASE_					)
												self.assertEqual(encoding.offset_mapping[0],   (0, len(SCREAMING_SNAKE_CASE_					))					)
												self.assertEqual(
												    encoding.offset_mapping[1],   (len(SCREAMING_SNAKE_CASE_					) + 1, len(SCREAMING_SNAKE_CASE_					) + 1 + len(SCREAMING_SNAKE_CASE_					)),   )

												UpperCAmelCase_:		List[str]							      =     f' {text}'

												UpperCAmelCase_:		Tuple							      =     self.rust_tokenizer_class.from_pretrained(
												    SCREAMING_SNAKE_CASE_,   use_fast=SCREAMING_SNAKE_CASE_,   )
												UpperCAmelCase_:		str							      =     tokenizer_r(SCREAMING_SNAKE_CASE_,   return_offsets_mapping=SCREAMING_SNAKE_CASE_,   add_special_tokens=SCREAMING_SNAKE_CASE_					)
												self.assertEqual(encoding.offset_mapping[0],   (1, 1 + len(SCREAMING_SNAKE_CASE_					))					)
												self.assertEqual(
												    encoding.offset_mapping[1],   (1 + len(SCREAMING_SNAKE_CASE_					) + 1, 1 + len(SCREAMING_SNAKE_CASE_					) + 1 + len(SCREAMING_SNAKE_CASE_					)),   )

			def      __snake_case       (self					)       ->   Optional[Any]:
						# Test related to the breaking change introduced in transformers v4.17.0
						# We need to check that an error in raised when the user try to load a previous version of the tokenizer.
						with self.assertRaises(SCREAMING_SNAKE_CASE_					) as context:
									self.rust_tokenizer_class.from_pretrained("""robot-test/old-clip-tokenizer"""					)

						self.assertTrue(
						    context.exception.args[0].startswith(
						        """The `backend_tokenizer` provided does not match the expected format."""					)					)

			@require_ftfy
			def      __snake_case       (self					)       ->   Dict:
						super().test_tokenization_python_rust_equals()

			def      __snake_case       (self					)       ->   int:
						# CLIP always lower cases letters
						pass











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






