
lowerCamelCase_		      =	'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'






def 		__magic_name__					(       __a     :			bytes		):



     '''simple docstring'''




     if not isinstance(__a			,						__a		):
          UpperCamelCase__												=							f"a bytes-like object is required, not \'{data.__class__.__name__}\'"
          raise TypeError(__a		)

     UpperCamelCase__												=							"""""".join(bin(__a		)[2:].zfill(8		) for byte in data		)

     UpperCamelCase__												=							len(__a		) % 6 != 0

     if padding_needed:
          # The padding that will be added later
          UpperCamelCase__												=							b"""=""" * ((6 - len(__a		) % 6) // 2)

          # Append binary_stream with arbitrary binary digits (0's by default) to make its
          # length a multiple of 6.
          binary_stream += "0" * (6 - len(__a		) % 6)
     else:
          UpperCamelCase__												=							b""""""

     # Encode every 6 binary digits to their corresponding Base64 character
     return (
         "".join(
             B64_CHARSET[int(binary_stream[index : index + 6]			,						2		)]
             for index in range(0			,						len(__a		)			,						6		)		).encode()
         + padding
     )






def 		__magic_name__					(       __a     :			str		):



     '''simple docstring'''




     if not isinstance(__a			,						__a		) and not isinstance(__a			,						__a		):
          UpperCamelCase__												=							(
              """argument should be a bytes-like object or ASCII string, """
              f"not \'{encoded_data.__class__.__name__}\'"
          )
          raise TypeError(__a		)

     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object
     if isinstance(__a			,						__a		):
          try:
               UpperCamelCase__												=							encoded_data.decode("""utf-8"""		)
          except UnicodeDecodeError:
               raise ValueError("""base64 encoded data should only contain ASCII characters"""		)

     UpperCamelCase__												=							encoded_data.count("""="""		)

     # Check if the encoded string contains non base64 characters
     if padding:
          assert all(
              char in B64_CHARSET for char in encoded_data[:-padding]		), "Invalid base64 character(s) found."
     else:
          assert all(
              char in B64_CHARSET for char in encoded_data		), "Invalid base64 character(s) found."

     # Check the padding
     assert len(__a		) % 4 == 0 and padding < 3, "Incorrect padding"

     if padding:
          # Remove padding if there is one
          UpperCamelCase__												=							encoded_data[:-padding]

          UpperCamelCase__												=							"""""".join(
              bin(B64_CHARSET.index(__a		)		)[2:].zfill(6		) for char in encoded_data		)[: -padding * 2]
     else:
          UpperCamelCase__												=							"""""".join(
              bin(B64_CHARSET.index(__a		)		)[2:].zfill(6		) for char in encoded_data		)

     UpperCamelCase__												=							[
         int(binary_stream[index : index + 8]			,						2		)
         for index in range(0			,						len(__a		)			,						8		)
     ]

     return bytes(__a		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()








'''simple docstring'''




from __future__ import annotations


def    lowerCamelCase__		(    SCREAMING_SNAKE_CASE   : int | str    ):
  UpperCAmelCase    				=						str(SCREAMING_SNAKE_CASE    )
  return n == n[::-1]


def    lowerCamelCase__		(    SCREAMING_SNAKE_CASE   : int = 100_0000    ):
  UpperCAmelCase    				=						0

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


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


