





import os
import unittest

from transformers import MPNetTokenizerFast
from transformers.models.mpnet.tokenization_mpnet import VOCAB_FILES_NAMES, MPNetTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class UpperCAmelCase_							(   _SCREAMING_SNAKE_CASE    ,		unittest.TestCase   ):
  __lowerCAmelCase      :	List[Any]  	=      MPNetTokenizer
  __lowerCAmelCase      :	Tuple  	=      MPNetTokenizerFast
  __lowerCAmelCase      :	Dict  	=      True
  __lowerCAmelCase      :	int  	=      True


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       super().setUp()

       A_					      =					[
           '''[UNK]''',
           '''[CLS]''',
           '''[SEP]''',
           '''[PAD]''',
           '''[MASK]''',
           '''want''',
           '''##want''',
           '''##ed''',
           '''wa''',
           '''un''',
           '''runn''',
           '''##ing''',
           ''',''',
           '''low''',
           '''lowest''',
       ]
       A_					      =					os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES['''vocab_file''']   )
       with open(self.vocab_file   ,'''w'''   ,encoding='''utf-8'''   ) as vocab_writer:
            vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]   )   )


  def 	__UpperCAmelCase    (       self   ,__snake_case   ):



       """simple docstring"""





       A_					      =					'''UNwant\u00E9d,running'''
       A_					      =					'''unwanted, running'''
       return input_text, output_text


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.tokenizer_class(self.vocab_file   )

       A_					      =					tokenizer.tokenize('''UNwant\u00E9d,running'''   )
       self.assertListEqual(__snake_case   ,['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']   )
       self.assertListEqual(tokenizer.convert_tokens_to_ids(__snake_case   )   ,[9, 6, 7, 1_2, 1_0, 1_1]   )




  @slow
  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.tokenizer_class.from_pretrained('''microsoft/mpnet-base'''   )

       A_					      =					tokenizer.encode('''sequence builders'''   ,add_special_tokens=__snake_case   )
       A_					      =					tokenizer.encode('''multi-sequence build'''   ,add_special_tokens=__snake_case   )

       A_					      =					tokenizer.build_inputs_with_special_tokens(__snake_case   )
       A_					      =					tokenizer.build_inputs_with_special_tokens(__snake_case   ,__snake_case   )

       assert encoded_sentence == [0] + text + [2]
       assert encoded_pair == [0] + text + [2] + [2] + text_a + [2]










def     UpperCAmelCase_						(						_UpperCAmelCase       :int = 1000							)  ->							int:
     '''simple docstring'''


     A_					      =					[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)
     A_					      =					[0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

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



