def     lowercase_       (    _lowerCamelCase							: int = 1000):
    lowercase__				:     Union[str, Any]					      =       [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__				:     Any					      =       [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

    lowercase__				:     Optional[Any]					      =       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())))




import unittest

from datasets import load_dataset

from transformers import load_tool

from .test_tools_common import ToolTesterMixin



class 						snake_case_ (	unittest.TestCase						,__A ):






   def    __UpperCamelCase  (   self       :  Optional[int]						)      ->		List[Any]:
       lowercase__				:     List[Any]					      =       load_tool("document-question-answering"						)
       self.tool.setup()
       lowercase__				:     Optional[int]					      =       load_tool("document-question-answering"			,		remote=lowercase_						)






   def    __UpperCamelCase  (   self       :  int						)      ->		Optional[int]:
       lowercase__				:     List[Any]					      =       load_dataset("hf-internal-testing/example-documents"			,		split="test"						)
       lowercase__				:     List[Any]					      =       dataset[0]["image"]

       lowercase__				:     int					      =       self.tool(lowercase_			,		"When is the coffee break?"						)
       self.assertEqual(lowercase_			,		"11-14 to 11:39 a.m."						)






   def    __UpperCamelCase  (   self       :  Optional[Any]						)      ->		List[Any]:
       lowercase__				:     str					      =       load_dataset("hf-internal-testing/example-documents"			,		split="test"						)
       lowercase__				:     str					      =       dataset[0]["image"]

       lowercase__				:     List[str]					      =       self.remote_tool(lowercase_			,		"When is the coffee break?"						)
       self.assertEqual(lowercase_			,		"11-14 to 11:39 a.m."						)






   def    __UpperCamelCase  (   self       :  List[Any]						)      ->		Dict:
       lowercase__				:     List[str]					      =       load_dataset("hf-internal-testing/example-documents"			,		split="test"						)
       lowercase__				:     List[str]					      =       dataset[0]["image"]

       self.tool(document=lowercase_			,		question="When is the coffee break?"						)







   def    __UpperCamelCase  (   self       :  str						)      ->		Optional[Any]:
       lowercase__				:     Optional[Any]					      =       load_dataset("hf-internal-testing/example-documents"			,		split="test"						)
       lowercase__				:     int					      =       dataset[0]["image"]

       lowercase__				:     Tuple					      =       self.remote_tool(document=lowercase_			,		question="When is the coffee break?"						)
       self.assertEqual(lowercase_			,		"11-14 to 11:39 a.m."						)



