




from collections import OrderedDict
from dataclasses import fields
from typing import Any, Tuple

import numpy as np

from .import_utils import is_torch_available




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						Dict:

    """simple docstring"""


    if is_torch_available():
        import torch

        if isinstance(lowercase_       ,  torch.Tensor   ):
            return True

    return isinstance(lowercase_       ,  np.ndarray   )


class 			_lowerCamelCase    (      _SCREAMING_SNAKE_CASE ):

      """simple docstring"""

      def    snake_case						(  self       :			Optional[Any]					):
          __UpperCamelCase			=    fields(self					)

          # Safety and consistency checks
          if not len(snake_case					):
              raise ValueError(F"{self.__class__.__name__} has no fields."					)

          __UpperCamelCase			=    getattr(self			,							class_fields[0].name					)
          __UpperCamelCase			=    all(getattr(self			,							field.name					) is None for field in class_fields[1:]					)

          if other_fields_are_none and isinstance(snake_case			,							snake_case					):
              for key, value in first_field.items():
                  __UpperCamelCase			=    value
          else:
              for field in class_fields:
                  __UpperCamelCase			=    getattr(self			,							field.name					)
                  if v is not None:
                      __UpperCamelCase			=    v







      def __delitem__(  self       :			Union[str, Any]			,							*snake_case       :			List[str]			,							**snake_case       :			List[str]					):
          raise Exception(F"You cannot use ``__delitem__`` on a {self.__class__.__name__} instance."					)







      def    snake_case						(  self       :			List[Any]			,							*snake_case       :			Optional[int]			,							**snake_case       :			Tuple					):
          raise Exception(F"You cannot use ``setdefault`` on a {self.__class__.__name__} instance."					)







      def    snake_case						(  self       :			Optional[int]			,							*snake_case       :			Union[str, Any]			,							**snake_case       :			str					):
          raise Exception(F"You cannot use ``pop`` on a {self.__class__.__name__} instance."					)







      def    snake_case						(  self       :			Any			,							*snake_case       :			Optional[Any]			,							**snake_case       :			int					):
          raise Exception(F"You cannot use ``update`` on a {self.__class__.__name__} instance."					)







      def __getitem__(  self       :			str			,							snake_case       :			List[str]					):
          if isinstance(snake_case			,							snake_case					):
              __UpperCamelCase			=    dict(self.items()					)
              return inner_dict[k]
          else:
              return self.to_tuple()[k]







      def __setattr__(  self       :			Dict			,							snake_case       :			List[Any]			,							snake_case       :			List[Any]					):
          if name in self.keys() and value is not None:
              # Don't call self.__setitem__ to avoid recursion errors
              super().__setitem__(snake_case			,							snake_case					)
          super().__setattr__(snake_case			,							snake_case					)







      def __setitem__(  self       :			Dict			,							snake_case       :			Optional[Any]			,							snake_case       :			Optional[Any]					):
          # Will raise a KeyException if needed
          super().__setitem__(snake_case			,							snake_case					)
          # Don't call self.__setattr__ to avoid recursion errors
          super().__setattr__(snake_case			,							snake_case					)







      def    snake_case						(  self       :			Any					):
          return tuple(self[k] for k in self.keys()					)







'''simple docstring'''




def _UpperCamelCase (							SCREAMING_SNAKE_CASE_ = 1_000				):
     lowercase_       :							Tuple  					=       [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8]
     # number of letters in twenty, thirty, ..., ninety (0 for numbers less than
     # 20 due to inconsistency in teens)
     lowercase_       :							List[Any]  					=       [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

     lowercase_       :							Optional[Any]  					=       0

     for i in range(1	,							n + 1				):
          if i < 1_000:
               if i >= 100:
                    # add number of letters for "n hundred"
                    count += ones_counts[i // 100] + 7

                    if i % 100 != 0:
                         # add number of letters for "and" if number is not multiple
                         # of 100
                         count += 3

               if 0 < i % 100 < 20:
                    # add number of letters for one, two, three, ..., nineteen
                    # (could be combined with below if not for inconsistency in
                    # teens)
                    count += ones_counts[i % 100]
               else:
                    # add number of letters for twenty, twenty one, ..., ninety
                    # nine
                    count += ones_counts[i % 10]
                    count += tens_counts[(i % 100 - i % 10) // 10]
          else:
               count += ones_counts[i // 1_000] + 8
     return count


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




