





"""simple docstring"""
def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  int = 1000       ):
 lowerCAmelCase  							=      [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  							=      [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

 lowerCAmelCase  							=      0

 for i in range(1   ,			n + 1       ):
  if i < 1000:
   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 // 1000] + 8
 return count


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








'''simple docstring'''






from __future__ import annotations

import unittest
from collections.abc import Iterator
class 	SCREAMING_SNAKE_CASE__			:




    def __init__(					self				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			str     =       label
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       parent
          SCREAMING_SNAKE_CASE_      :			Node | None     =       None
          SCREAMING_SNAKE_CASE_      :			Node | None     =       None






class 	SCREAMING_SNAKE_CASE__			:




    def __init__(					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Node | None     =       None




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       None




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          return self.root is None




    def   __lowerCamelCase      (					self				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self._put(self.root				,     lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__ = None			):






          """simple docstring"""






          if node is None:
                SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       Node(lowercase__				,     lowercase__			)
          else:
                if label < node.label:
                      SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self._put(node.left				,     lowercase__				,     lowercase__			)
                elif label > node.label:
                      SCREAMING_SNAKE_CASE_      :			List[Any]     =       self._put(node.right				,     lowercase__				,     lowercase__			)
                else:
                      SCREAMING_SNAKE_CASE_      :			str     =       F"Node with label {label} already exists"
                      raise Exception(lowercase__			)

          return node




    def   __lowerCamelCase      (					self				,     lowercase__			):






          """simple docstring"""






          return self._search(self.root				,     lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          if node is None:
                SCREAMING_SNAKE_CASE_      :			Dict     =       F"Node with label {label} does not exist"
                raise Exception(lowercase__			)
          else:
                if label < node.label:
                      SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self._search(node.left				,     lowercase__			)
                elif label > node.label:
                      SCREAMING_SNAKE_CASE_      :			str     =       self._search(node.right				,     lowercase__			)

          return node




    def   __lowerCamelCase      (					self				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			str     =       self.search(lowercase__			)
          if node.right and node.left:
                SCREAMING_SNAKE_CASE_      :			Dict     =       self._get_lowest_node(node.right			)
                SCREAMING_SNAKE_CASE_      :			str     =       node.left
                SCREAMING_SNAKE_CASE_      :			str     =       node.right
                SCREAMING_SNAKE_CASE_      :			Dict     =       lowest_node
                if node.right:
                      SCREAMING_SNAKE_CASE_      :			Any     =       lowest_node
                self._reassign_nodes(lowercase__				,     lowercase__			)
          elif not node.right and node.left:
                self._reassign_nodes(lowercase__				,     node.left			)
          elif node.right and not node.left:
                self._reassign_nodes(lowercase__				,     node.right			)
          else:
                self._reassign_nodes(lowercase__				,     lowercase__			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          if new_children:
                SCREAMING_SNAKE_CASE_      :			str     =       node.parent

          if node.parent:
                if node.parent.right == node:
                      SCREAMING_SNAKE_CASE_      :			str     =       new_children
                else:
                      SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       new_children
          else:
                SCREAMING_SNAKE_CASE_      :			Tuple     =       new_children




    def   __lowerCamelCase      (					self				,     lowercase__			):






          """simple docstring"""






          if node.left:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       self._get_lowest_node(node.left			)
          else:
                SCREAMING_SNAKE_CASE_      :			Tuple     =       node
                self._reassign_nodes(lowercase__				,     node.right			)

          return lowest_node




    def   __lowerCamelCase      (					self				,     lowercase__			):






          """simple docstring"""






          try:
                self.search(lowercase__			)
                return True
          except Exception:
                return False




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          if self.root is None:
                raise Exception("Binary search tree is empty"			)

          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self.root
          while node.right is not None:
                SCREAMING_SNAKE_CASE_      :			Dict     =       node.right

          return node.label




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          if self.root is None:
                raise Exception("Binary search tree is empty"			)

          SCREAMING_SNAKE_CASE_      :			Any     =       self.root
          while node.left is not None:
                SCREAMING_SNAKE_CASE_      :			List[str]     =       node.left

          return node.label




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          return self._inorder_traversal(self.root			)




    def   __lowerCamelCase      (					self				,     lowercase__			):






          """simple docstring"""






          if node is not None:
                yield from self._inorder_traversal(node.left			)
                yield node
                yield from self._inorder_traversal(node.right			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          return self._preorder_traversal(self.root			)







    def   __lowerCamelCase      (					self				,     lowercase__			):






          """simple docstring"""






          if node is not None:
                yield node
                yield from self._preorder_traversal(node.left			)
                yield from self._preorder_traversal(node.right			)






class 	SCREAMING_SNAKE_CASE__			(				unittest.TestCase      ):




    @staticmethod
    def   __lowerCamelCase      (					):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			List[str]     =       BinarySearchTree()
          t.put(8			)
          t.put(3			)
          t.put(6			)
          t.put(1			)
          t.put(10			)
          t.put(14			)
          t.put(13			)
          t.put(4			)
          t.put(7			)
          t.put(5			)

          return t




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Any     =       BinarySearchTree()
          assert t.is_empty()

          t.put(8			)
          assert t.root is not None
          assert t.root.parent is None
          assert t.root.label == 8

          t.put(10			)
          assert t.root.right is not None
          assert t.root.right.parent == t.root
          assert t.root.right.label == 10

          t.put(3			)
          assert t.root.left is not None
          assert t.root.left.parent == t.root
          assert t.root.left.label == 3

          t.put(6			)
          assert t.root.left.right is not None
          assert t.root.left.right.parent == t.root.left
          assert t.root.left.right.label == 6

          t.put(1			)
          assert t.root.left.left is not None
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.left.label == 1

          with self.assertRaises(lowercase__			):  # noqa: B017
                t.put(1			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			List[Any]     =       self._get_binary_search_tree()

          SCREAMING_SNAKE_CASE_      :			str     =       t.search(6			)
          assert node.label == 6

          SCREAMING_SNAKE_CASE_      :			int     =       t.search(13			)
          assert node.label == 13

          with self.assertRaises(lowercase__			):  # noqa: B017
                t.search(2			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			List[str]     =       self._get_binary_search_tree()

          t.remove(13			)
          assert t.root is not None
          assert t.root.right is not None
          assert t.root.right.right is not None
          assert t.root.right.right.right is None
          assert t.root.right.right.left is None

          t.remove(7			)
          assert t.root.left is not None
          assert t.root.left.right is not None
          assert t.root.left.right.left is not None
          assert t.root.left.right.right is None
          assert t.root.left.right.left.label == 4

          t.remove(6			)
          assert t.root.left.left is not None
          assert t.root.left.right.right is not None
          assert t.root.left.left.label == 1
          assert t.root.left.right.label == 4
          assert t.root.left.right.right.label == 5
          assert t.root.left.right.left is None
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.right.parent == t.root.left

          t.remove(3			)
          assert t.root is not None
          assert t.root.left.label == 4
          assert t.root.left.right.label == 5
          assert t.root.left.left.label == 1
          assert t.root.left.parent == t.root
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.right.parent == t.root.left

          t.remove(4			)
          assert t.root.left is not None
          assert t.root.left.left is not None
          assert t.root.left.label == 5
          assert t.root.left.right is None
          assert t.root.left.left.label == 1
          assert t.root.left.parent == t.root
          assert t.root.left.left.parent == t.root.left




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       self._get_binary_search_tree()

          t.remove(3			)
          assert t.root is not None
          assert t.root.left is not None
          assert t.root.left.left is not None
          assert t.root.left.right is not None
          assert t.root.left.right.left is not None
          assert t.root.left.right.right is not None
          assert t.root.left.label == 4
          assert t.root.left.right.label == 6
          assert t.root.left.left.label == 1
          assert t.root.left.right.right.label == 7
          assert t.root.left.right.left.label == 5
          assert t.root.left.parent == t.root
          assert t.root.left.right.parent == t.root.left
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.right.left.parent == t.root.left.right




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Any     =       self._get_binary_search_tree()
          t.empty()
          assert t.root is None




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       self._get_binary_search_tree()
          assert not t.is_empty()

          t.empty()
          assert t.is_empty()




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			str     =       self._get_binary_search_tree()

          assert t.exists(6			)
          assert not t.exists(-1			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Tuple     =       self._get_binary_search_tree()

          assert t.get_max_label() == 14

          t.empty()
          with self.assertRaises(lowercase__			):  # noqa: B017
                t.get_max_label()




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Tuple     =       self._get_binary_search_tree()

          assert t.get_min_label() == 1

          t.empty()
          with self.assertRaises(lowercase__			):  # noqa: B017
                t.get_min_label()




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			List[str]     =       self._get_binary_search_tree()

          SCREAMING_SNAKE_CASE_      :			Dict     =       [i.label for i in t.inorder_traversal()]
          assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]







    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			int     =       self._get_binary_search_tree()

          SCREAMING_SNAKE_CASE_      :			Any     =       [i.label for i in t.preorder_traversal()]
          assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]






def 					__lowerCamelCase			(      )							->   None:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_      :			int     =       BinarySearchTree()
      t.put(8    )
      t.put(3    )
      t.put(6    )
      t.put(1    )
      t.put(1_0    )
      t.put(1_4    )
      t.put(1_3    )
      t.put(4    )
      t.put(7    )
      t.put(5    )

      print(
          "\n            8\n           / \\\n          3   10\n         / \\    \\\n        1   6    14\n           / \\   /\n          4   7 13\n           \\\n            5\n        "    )

      print("Label 6 exists:"  ,  t.exists(6    )    )
      print("Label 13 exists:"  ,  t.exists(1_3    )    )
      print("Label -1 exists:"  ,  t.exists(-1    )    )
      print("Label 12 exists:"  ,  t.exists(1_2    )    )

      # Prints all the elements of the list in inorder traversal
      SCREAMING_SNAKE_CASE_      :			Dict     =       [i.label for i in t.inorder_traversal()]
      print("Inorder traversal:"  ,  SCREAMING_SNAKE_CASE_    )

      # Prints all the elements of the list in preorder traversal
      SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       [i.label for i in t.preorder_traversal()]
      print("Preorder traversal:"  ,  SCREAMING_SNAKE_CASE_    )

      print("Max. label:"  ,  t.get_max_label()    )
      print("Min. label:"  ,  t.get_min_label()    )

      # Delete elements
      print("\nDeleting elements 13, 10, 8, 3, 6, 14"    )
      print(
          "\n          4\n         / \\\n        1   7\n             \\\n              5\n        "    )
      t.remove(1_3    )
      t.remove(1_0    )
      t.remove(8    )
      t.remove(3    )
      t.remove(6    )
      t.remove(1_4    )

      # Prints all the elements of the list in inorder traversal after delete
      SCREAMING_SNAKE_CASE_      :			Optional[int]     =       [i.label for i in t.inorder_traversal()]
      print("Inorder traversal after delete:"  ,  SCREAMING_SNAKE_CASE_    )

      # Prints all the elements of the list in preorder traversal after delete
      SCREAMING_SNAKE_CASE_      :			Optional[int]     =       [i.label for i in t.preorder_traversal()]
      print("Preorder traversal after delete:"  ,  SCREAMING_SNAKE_CASE_    )

      print("Max. label:"  ,  t.get_max_label()    )
      print("Min. label:"  ,  t.get_min_label()    )


if __name__ == "__main__":
      binary_search_tree_example()

