






from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
   import PIL

snake_case    				=		logging.get_logger(__name__)


def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  if isinstance(lowercase						,     (list, tuple)				) and isinstance(videos[0]						,     (list, tuple)				) and is_valid_image(videos[0][0]				):
    return videos

  elif isinstance(lowercase						,     (list, tuple)				) and is_valid_image(videos[0]				):
    return [videos]

  elif is_valid_image(lowercase				):
    return [[videos]]

  raise ValueError(F'''Could not make batched video from {videos}'''				)


class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Dict			=	['''pixel_values''']


     def __init__(				self       :	str					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	PILImageResampling = PILImageResampling.BILINEAR					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Union[int, float] = 1 / 255					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, **UpperCAmelCase_       :	Any					, ):
       super().__init__(**UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      str							=    size if size is not None else {"shortest_edge": 256}
       SCREAMING_SNAKE_CASE       :      Tuple							=    get_size_dict(UpperCAmelCase_					, default_to_square=UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    crop_size if crop_size is not None else {"height": 224, "width": 224}
       SCREAMING_SNAKE_CASE       :      List[str]							=    get_size_dict(UpperCAmelCase_					, param_name="crop_size"      )

       SCREAMING_SNAKE_CASE       :      str							=    do_resize
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    size
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    do_center_crop
       SCREAMING_SNAKE_CASE       :      Tuple							=    crop_size
       SCREAMING_SNAKE_CASE       :      Any							=    resample
       SCREAMING_SNAKE_CASE       :      str							=    do_rescale
       SCREAMING_SNAKE_CASE       :      int							=    rescale_factor
       SCREAMING_SNAKE_CASE       :      int							=    offset
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    do_normalize
       SCREAMING_SNAKE_CASE       :      Dict							=    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
       SCREAMING_SNAKE_CASE       :      Any							=    image_std if image_std is not None else IMAGENET_STANDARD_STD


     def 				_A       (				self       :	Optional[int]					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Dict[str, int]					, UpperCAmelCase_       :	PILImageResampling = PILImageResampling.BILINEAR					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	List[Any]					, ):
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    get_size_dict(UpperCAmelCase_					, default_to_square=UpperCAmelCase_      )
       if "shortest_edge" in size:
         SCREAMING_SNAKE_CASE       :      Dict							=    get_resize_output_image_size(UpperCAmelCase_					, size["shortest_edge"]					, default_to_square=UpperCAmelCase_      )
       elif "height" in size and "width" in size:
         SCREAMING_SNAKE_CASE       :      Tuple							=    (size["height"], size["width"])
       else:
         raise ValueError(f'''Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'''      )
       return resize(UpperCAmelCase_					, size=UpperCAmelCase_					, resample=UpperCAmelCase_					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


     def 				_A       (				self       :	int					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Dict[str, int]					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	List[str]					, ):
       SCREAMING_SNAKE_CASE       :      Dict							=    get_size_dict(UpperCAmelCase_      )
       if "height" not in size or "width" not in size:
         raise ValueError(f'''Size must have \'height\' and \'width\' as keys. Got {size.keys()}'''      )
       return center_crop(UpperCAmelCase_					, size=(size["height"], size["width"])					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


     def 				_A       (				self       :	List[Any]					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Union[int, float]					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	Union[str, Any]					, ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    image.astype(np.floataa      )
       if offset:
         SCREAMING_SNAKE_CASE       :      str							=    image - (scale / 2)
       return rescale(UpperCAmelCase_					, scale=UpperCAmelCase_					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


     def 				_A       (				self       :	Any					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Union[float, List[float]]					, UpperCAmelCase_       :	Union[float, List[float]]					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	List[Any]					, ):
       return normalize(UpperCAmelCase_					, mean=UpperCAmelCase_					, std=UpperCAmelCase_					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


     def 				_A       (				self       :	List[str]					, UpperCAmelCase_       :	ImageInput					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	PILImageResampling = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	float = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[ChannelDimension] = ChannelDimension.FIRST					, ):
       if do_resize and size is None or resample is None:
         raise ValueError("Size and resample must be specified if do_resize is True."      )

       if do_center_crop and crop_size is None:
         raise ValueError("Crop size must be specified if do_center_crop is True."      )

       if do_rescale and rescale_factor is None:
         raise ValueError("Rescale factor must be specified if do_rescale is True."      )

       if do_normalize and (image_mean is None or image_std is None):
         raise ValueError("Image mean and std must be specified if do_normalize is True."      )

       if offset and not do_rescale:
         raise ValueError("For offset, do_rescale must also be set to True."      )

       # All transformations expect numpy arrays.
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    to_numpy_array(UpperCAmelCase_      )

       if do_resize:
         SCREAMING_SNAKE_CASE       :      Dict							=    self.resize(image=UpperCAmelCase_					, size=UpperCAmelCase_					, resample=UpperCAmelCase_      )

       if do_center_crop:
         SCREAMING_SNAKE_CASE       :      Dict							=    self.center_crop(UpperCAmelCase_					, size=UpperCAmelCase_      )

       if do_rescale:
         SCREAMING_SNAKE_CASE       :      Tuple							=    self.rescale(image=UpperCAmelCase_					, scale=UpperCAmelCase_					, offset=UpperCAmelCase_      )

       if do_normalize:
         SCREAMING_SNAKE_CASE       :      Optional[int]							=    self.normalize(image=UpperCAmelCase_					, mean=UpperCAmelCase_					, std=UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    to_channel_dimension_format(UpperCAmelCase_					, UpperCAmelCase_      )
       return image






     def 				_A       (				self       :	Optional[int]					, UpperCAmelCase_       :	ImageInput					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	PILImageResampling = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	float = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[str, TensorType]] = None					, UpperCAmelCase_       :	ChannelDimension = ChannelDimension.FIRST					, **UpperCAmelCase_       :	int					, ):
       SCREAMING_SNAKE_CASE       :      Dict							=    do_resize if do_resize is not None else self.do_resize
       SCREAMING_SNAKE_CASE       :      Any							=    resample if resample is not None else self.resample
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    do_center_crop if do_center_crop is not None else self.do_center_crop
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    do_rescale if do_rescale is not None else self.do_rescale
       SCREAMING_SNAKE_CASE       :      List[str]							=    rescale_factor if rescale_factor is not None else self.rescale_factor
       SCREAMING_SNAKE_CASE       :      List[str]							=    offset if offset is not None else self.offset
       SCREAMING_SNAKE_CASE       :      str							=    do_normalize if do_normalize is not None else self.do_normalize
       SCREAMING_SNAKE_CASE       :      List[Any]							=    image_mean if image_mean is not None else self.image_mean
       SCREAMING_SNAKE_CASE       :      Any							=    image_std if image_std is not None else self.image_std

       SCREAMING_SNAKE_CASE       :      List[Any]							=    size if size is not None else self.size
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    get_size_dict(UpperCAmelCase_					, default_to_square=UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    crop_size if crop_size is not None else self.crop_size
       SCREAMING_SNAKE_CASE       :      List[Any]							=    get_size_dict(UpperCAmelCase_					, param_name="crop_size"      )

       if not valid_images(UpperCAmelCase_      ):
         raise ValueError(
             "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
             "torch.Tensor, tf.Tensor or jax.ndarray."      )

       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    make_batched(UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    [
           [
               self._preprocess_image(
                   image=UpperCAmelCase_					, do_resize=UpperCAmelCase_					, size=UpperCAmelCase_					, resample=UpperCAmelCase_					, do_center_crop=UpperCAmelCase_					, crop_size=UpperCAmelCase_					, do_rescale=UpperCAmelCase_					, rescale_factor=UpperCAmelCase_					, offset=UpperCAmelCase_					, do_normalize=UpperCAmelCase_					, image_mean=UpperCAmelCase_					, image_std=UpperCAmelCase_					, data_format=UpperCAmelCase_					, )
               for img in video
           ]
           for video in videos
       ]

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    {"pixel_values": videos}
       return BatchFeature(data=UpperCAmelCase_					, tensor_type=UpperCAmelCase_      )














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






