






import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
   import tensorflow as tf
   from tensorflow.python.eager import context
   from tensorflow.python.framework import ops

   from transformers import GradientAccumulator, create_optimizer


@require_tf
class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     def 				_A       (				self       :	Optional[Any]					, UpperCAmelCase_       :	Optional[Any]					, UpperCAmelCase_       :	int					, UpperCAmelCase_       :	Any      ):
       self.assertEqual(len(UpperCAmelCase_      )					, len(UpperCAmelCase_      )      )
       for a, b in zip(UpperCAmelCase_					, UpperCAmelCase_      ):
         self.assertAlmostEqual(UpperCAmelCase_					, UpperCAmelCase_					, delta=UpperCAmelCase_      )


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    GradientAccumulator()
       accumulator([tf.constant([1.0, 2.0]      )]      )
       accumulator([tf.constant([-2.0, 1.0]      )]      )
       accumulator([tf.constant([-1.0, 2.0]      )]      )
       with self.assertRaises(UpperCAmelCase_      ):
         accumulator([tf.constant([1.0, 1.0]      ), tf.constant([2.0, 2.0]      )]      )
       self.assertEqual(accumulator.step					, 3      )
       self.assertEqual(len(accumulator.gradients      )					, 1      )
       self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist()					, [-2.0, 5.0]					, tol=1E-2      )
       accumulator.reset()
       self.assertEqual(accumulator.step					, 0      )
       self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist()					, [0.0, 0.0]					, tol=1E-2      )






     def 				_A       (				self       :	int      ):
       SCREAMING_SNAKE_CASE       :      Any							=    None
       ops.enable_eager_execution_internal()
       SCREAMING_SNAKE_CASE       :      int							=    tf.config.list_physical_devices("CPU"      )
       if len(UpperCAmelCase_      ) == 1:
         tf.config.set_logical_device_configuration(
             physical_devices[0]					, [tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]      )
       SCREAMING_SNAKE_CASE       :      Any							=    tf.config.list_logical_devices(device_type="CPU"      )
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    tf.distribute.MirroredStrategy(devices=devices[:2]      )

       with strategy.scope():
         SCREAMING_SNAKE_CASE       :      Tuple							=    GradientAccumulator()
         SCREAMING_SNAKE_CASE       :      str							=    tf.Variable([4.0, 3.0]      )
         SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    create_optimizer(5E-5					, 10					, 5      )
         SCREAMING_SNAKE_CASE       :      Any							=    tf.Variable([0.0, 0.0]					, trainable=UpperCAmelCase_      )

       def accumulate_on_replica(UpperCAmelCase_       :	Union[str, Any]      ):
         accumulator([gradient]      )

       def apply_on_replica():
         optimizer.apply_gradients(list(zip(accumulator.gradients					, [variable]      )      )      )

       @tf.function
       def accumulate(UpperCAmelCase_       :	str					, UpperCAmelCase_       :	int      ):
         with strategy.scope():
           SCREAMING_SNAKE_CASE       :      Optional[int]							=    strategy.experimental_local_results(UpperCAmelCase_      )
           local_variables[0].assign(UpperCAmelCase_      )
           local_variables[1].assign(UpperCAmelCase_      )
           strategy.run(UpperCAmelCase_					, args=(gradient_placeholder,)      )

       @tf.function
       def apply_grad():
         with strategy.scope():
           strategy.run(UpperCAmelCase_      )

       def _check_local_values(UpperCAmelCase_       :	List[Any]					, UpperCAmelCase_       :	Dict      ):
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    strategy.experimental_local_results(accumulator._gradients[0]      )
         self.assertListAlmostEqual(values[0].value()					, UpperCAmelCase_					, tol=1E-2      )
         self.assertListAlmostEqual(values[1].value()					, UpperCAmelCase_					, tol=1E-2      )

       accumulate([1.0, 2.0]					, [-1.0, 1.0]      )
       accumulate([3.0, -1.0]					, [-1.0, -1.0]      )
       accumulate([-2.0, 2.0]					, [3.0, -2.0]      )
       self.assertEqual(accumulator.step					, 3      )
       _check_local_values([2.0, 3.0]					, [1.0, -2.0]      )
       apply_grad()
       self.assertListAlmostEqual(variable.value()					, [4.0, 3.0]					, tol=1E-2      )
       accumulator.reset()
       self.assertEqual(accumulator.step					, 0      )
       _check_local_values([0.0, 0.0]					, [0.0, 0.0]      )









from __future__ import annotations


def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Optional[Any]							=    str(lowercase				)
  return n == n[::-1]


def   lowerCamelCase__			(     lowercase = 1000000				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      int							=    0

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


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






