
import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)




class       __A(							unittest.TestCase					):

  """simple docstring"""







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 2, 3]		)
       self.assertEqual(x.component(0		)			,     1		)
       self.assertEqual(x.component(2		)			,     3		)
       UpperCamelCase__												=							Vector()







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([0, 0, 0, 0, 0, 1]		)
       self.assertEqual(str(a_		)			,     """(0,0,0,0,0,1)"""		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 2, 3, 4]		)
       self.assertEqual(len(a_		)			,     4		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 2]		)
       UpperCamelCase__												=							Vector([1, 2, 3, 4, 5]		)
       UpperCamelCase__												=							Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]		)
       UpperCamelCase__												=							Vector([1, -1, 1, -1, 2, -3, 4, -5]		)
       self.assertAlmostEqual(x.euclidean_length()			,     2.236			,     3		)
       self.assertAlmostEqual(y.euclidean_length()			,     7.416			,     3		)
       self.assertEqual(z.euclidean_length()			,     0		)
       self.assertAlmostEqual(w.euclidean_length()			,     7.616			,     3		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 2, 3]		)
       UpperCamelCase__												=							Vector([1, 1, 1]		)
       self.assertEqual((x + y).component(0		)			,     2		)
       self.assertEqual((x + y).component(1		)			,     3		)
       self.assertEqual((x + y).component(2		)			,     4		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 2, 3]		)
       UpperCamelCase__												=							Vector([1, 1, 1]		)
       self.assertEqual((x - y).component(0		)			,     0		)
       self.assertEqual((x - y).component(1		)			,     1		)
       self.assertEqual((x - y).component(2		)			,     2		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 2, 3]		)
       UpperCamelCase__												=							Vector([2, -1, 4]		)  # for test of dot product
       UpperCamelCase__												=							Vector([1, -2, -1]		)
       self.assertEqual(str(x * 3.0		)			,     """(3.0,6.0,9.0)"""		)
       self.assertEqual((a * b)			,     0		)







  def 			UpperCAmelCase_   (self		):
       self.assertEqual(str(zero_vector(10		)		).count("""0"""		)			,     10		)







  def 			UpperCAmelCase_   (self		):
       self.assertEqual(str(unit_basis_vector(3			,     1		)		)			,     """(0,1,0)"""		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 2, 3]		)
       UpperCamelCase__												=							Vector([1, 0, 1]		)
       self.assertEqual(str(axpy(2			,     a_			,     a_		)		)			,     """(3,4,7)"""		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 0, 0, 0, 0, 0]		)
       UpperCamelCase__												=							x.copy()
       self.assertEqual(str(a_		)			,     str(a_		)		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Vector([1, 0, 0]		)
       x.change_component(0			,     0		)
       x.change_component(1			,     1		)
       self.assertEqual(str(a_		)			,     """(0,1,0)"""		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       self.assertEqual("""|1,2,3|\n|2,4,5|\n|6,7,8|\n"""			,     str(a_		)		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       UpperCamelCase__												=							[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
       for x in range(a.height()		):
            for y in range(a.width()		):
                 self.assertEqual(minors[x][y]			,     a.minor(a_			,     a_		)		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       UpperCamelCase__												=							[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
       for x in range(a.height()		):
            for y in range(a.width()		):
                 self.assertEqual(cofactors[x][y]			,     a.cofactor(a_			,     a_		)		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       self.assertEqual(-5			,     a.determinant()		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]			,     3			,     3		)
       UpperCamelCase__												=							Vector([1, 2, 3]		)
       self.assertEqual("""(14,32,50)"""			,     str(a * x		)		)
       self.assertEqual("""|2,4,6|\n|8,10,12|\n|14,16,18|\n"""			,     str(a * 2		)		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       a.change_component(0			,     2			,     5		)
       self.assertEqual("""|1,2,5|\n|2,4,5|\n|6,7,8|\n"""			,     str(a_		)		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       self.assertEqual(7			,     a.component(2			,     1		)			,     0.01		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       UpperCamelCase__												=							Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]			,     3			,     3		)
       self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""			,     str(a + b		)		)







  def 			UpperCAmelCase_   (self		):
       UpperCamelCase__												=							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3		)
       UpperCamelCase__												=							Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]			,     3			,     3		)
       self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""			,     str(a - b		)		)







  def 			UpperCAmelCase_   (self		):
       self.assertEqual(
           """|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"""			,     str(square_zero_matrix(5		)		)			,     )


if __name__ == "__main__":
    unittest.main()








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


