

from .hash_table import HashTable
from .number_theory.prime_numbers import is_prime, next_prime






class 				A_					(						snake_case__   ):


     def __init__(				self     :						Optional[int]     ,    *UpperCAmelCase     :						int     ,    **UpperCAmelCase     :						Dict   )				->      Tuple:
      super().__init__(*UpperCAmelCase     ,    **UpperCAmelCase   )


     def     UpperCAmelCase    (				self     :						Optional[Any]     ,    UpperCAmelCase     :						Any     ,    UpperCAmelCase     :						int   )				->      Optional[Any]:
      __lowerCAmelCase:  Union[str, Any]        = (
          next_prime(value % self.size_table   )
          if not is_prime(value % self.size_table   )
          else value % self.size_table
      )  # gt = bigger than
      return next_prime_gt - (data % next_prime_gt)


     def     UpperCAmelCase    (				self     :						Union[str, Any]     ,    UpperCAmelCase     :						int     ,    UpperCAmelCase     :						Union[str, Any]     ,    UpperCAmelCase     :						Dict   )				->      str:
      return (increment * self.__hash_function_a(UpperCAmelCase     ,    UpperCAmelCase   )) % self.size_table


     def     UpperCAmelCase    (				self     :						Dict     ,    UpperCAmelCase     :						Union[str, Any]     ,    UpperCAmelCase     :						Tuple=None   )				->      int:
      __lowerCAmelCase:  int        = 1
      __lowerCAmelCase:  Tuple        = self.hash_function(UpperCAmelCase   )

      while self.values[new_key] is not None and self.values[new_key] != key:
       __lowerCAmelCase:  List[Any]        = (
           self.__hash_double_function(UpperCAmelCase     ,    UpperCAmelCase     ,    UpperCAmelCase   )
           if self.balanced_factor() >= self.lim_charge
           else None
       )
       if new_key is None:
        break
       else:
        i += 1

      return new_key








def _a					(			SCREAMING_SNAKE_CASE						:     int = 10_00						)       ->       int:

 """simple docstring"""






 __lowerCAmelCase:  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)
 __lowerCAmelCase:  List[Any]        = [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

 __lowerCAmelCase:  Dict        = 0

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

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

   if 0 < i % 1_00 < 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 % 1_00]
   else:
    # add number of letters for twenty, twenty one, ..., ninety
    # nine
    count += ones_counts[i % 10]
    count += tens_counts[(i % 1_00 - i % 10) // 10]
  else:
   count += ones_counts[i // 10_00] + 8
 return count


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





