






import importlib
from typing import List, Optional, Union

from seqeval.metrics import accuracy_score, classification_report

import datasets


lowerCamelCase					    =	'''\
@inproceedings{ramshaw-marcus-1995-text,
    title = \"Text Chunking using Transformation-Based Learning\",
    author = \"Ramshaw, Lance  and
      Marcus, Mitch\",
    booktitle = \"Third Workshop on Very Large Corpora\",
    year = \"1995\",
    url = \"https://www.aclweb.org/anthology/W95-0107\",
}
@misc{seqeval,
  title={{seqeval}: A Python framework for sequence labeling evaluation},
  url={https://github.com/chakki-works/seqeval},
  note={Software available from https://github.com/chakki-works/seqeval},
  author={Hiroki Nakayama},
  year={2018},
}
'''

lowerCamelCase					    =	'''\
seqeval is a Python framework for sequence labeling evaluation.
seqeval can evaluate the performance of chunking tasks such as named-entity recognition, part-of-speech tagging, semantic role labeling and so on.

This is well-tested by using the Perl script conlleval, which can be used for
measuring the performance of a system that has processed the CoNLL-2000 shared task data.

seqeval supports following formats:
IOB1
IOB2
IOE1
IOE2
IOBES

See the [README.md] file at https://github.com/chakki-works/seqeval for more information.
'''

lowerCamelCase					    =	'''
Produces labelling scores along with its sufficient statistics
from a source against one or more references.

Args:
    predictions: List of List of predicted labels (Estimated targets as returned by a tagger)
    references: List of List of reference labels (Ground truth (correct) target values)
    suffix: True if the IOB prefix is after type, False otherwise. default: False
    scheme: Specify target tagging scheme. Should be one of [\"IOB1\", \"IOB2\", \"IOE1\", \"IOE2\", \"IOBES\", \"BILOU\"].
        default: None
    mode: Whether to count correct entity labels with incorrect I/B tags as true positives or not.
        If you want to only count exact matches, pass mode=\"strict\". default: None.
    sample_weight: Array-like of shape (n_samples,), weights for individual samples. default: None
    zero_division: Which value to substitute as a metric value when encountering zero division. Should be on of 0, 1,
        \"warn\". \"warn\" acts as 0, but the warning is raised.

Returns:
    \'scores\': dict. Summary of the scores for overall and per type
        Overall:
            \'accuracy\': accuracy,
            \'precision\': precision,
            \'recall\': recall,
            \'f1\': F1 score, also known as balanced F-score or F-measure,
        Per type:
            \'precision\': precision,
            \'recall\': recall,
            \'f1\': F1 score, also known as balanced F-score or F-measure
Examples:

    >>> predictions = [[\'O\', \'O\', \'B-MISC\', \'I-MISC\', \'I-MISC\', \'I-MISC\', \'O\'], [\'B-PER\', \'I-PER\', \'O\']]
    >>> references = [[\'O\', \'O\', \'O\', \'B-MISC\', \'I-MISC\', \'I-MISC\', \'O\'], [\'B-PER\', \'I-PER\', \'O\']]
    >>> seqeval = datasets.load_metric(\"seqeval\")
    >>> results = seqeval.compute(predictions=predictions, references=references)
    >>> print(list(results.keys()))
    [\'MISC\', \'PER\', \'overall_precision\', \'overall_recall\', \'overall_f1\', \'overall_accuracy\']
    >>> print(results[\"overall_f1\"])
    0.5
    >>> print(results[\"PER\"][\"f1\"])
    1.0
'''

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,      _KWARGS_DESCRIPTION   )
class        snake_case_				(							datasets.Metric   ):







   """simple docstring"""



   def       SCREAMING_SNAKE_CASE__					(     self:						Tuple						)	->		Union[str, Any]:


       """simple docstring"""



       return datasets.MetricInfo(
           description=_DESCRIPTION ,							citation=_CITATION ,							homepage='https://github.com/chakki-works/seqeval' ,							inputs_description=_KWARGS_DESCRIPTION ,							features=datasets.Features(
               {
                   'predictions': datasets.Sequence(datasets.Value('string' ,							id='label'						) ,							id='sequence'						),
                   'references': datasets.Sequence(datasets.Value('string' ,							id='label'						) ,							id='sequence'						),
               }						) ,							codebase_urls=['https://github.com/chakki-works/seqeval'] ,							reference_urls=['https://github.com/chakki-works/seqeval'] ,							)

   def       SCREAMING_SNAKE_CASE__					(     self:						int ,							snake_case__:						int ,							snake_case__:						str ,							snake_case__:						Optional[Any] = False ,							snake_case__:						List[Any] = None ,							snake_case__:						str = None ,							snake_case__:						Optional[int] = None ,							snake_case__:						Dict = "warn" ,							)	->		List[str]:


       """simple docstring"""



       if scheme is not None:
           try:
               _lowercase     			=						importlib.import_module('seqeval.scheme'						)
               _lowercase     			=						getattr(_UpperCAmelCase ,							_UpperCAmelCase						)
           except AttributeError:
               raise ValueError(f'''Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {scheme}'''						)
       _lowercase     			=						classification_report(
           y_true=_UpperCAmelCase ,							y_pred=_UpperCAmelCase ,							suffix=_UpperCAmelCase ,							output_dict=_UpperCAmelCase ,							scheme=_UpperCAmelCase ,							mode=_UpperCAmelCase ,							sample_weight=_UpperCAmelCase ,							zero_division=_UpperCAmelCase ,							)
       report.pop('macro avg'						)
       report.pop('weighted avg'						)
       _lowercase     			=						report.pop('micro avg'						)

       _lowercase     			=						{
           type_name: {
               'precision': score['precision'],
               'recall': score['recall'],
               'f1': score['f1-score'],
               'number': score['support'],
           }
           for type_name, score in report.items()
       }
       _lowercase     			=						overall_score['precision']
       _lowercase     			=						overall_score['recall']
       _lowercase     			=						overall_score['f1-score']
       _lowercase     			=						accuracy_score(y_true=_UpperCAmelCase ,							y_pred=_UpperCAmelCase						)

       return scores




def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE = 1000   )->    int:




      """simple docstring"""

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

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