

import importlib
import inspect
from functools import wraps
from typing import TYPE_CHECKING, Optional, Union

from .download.streaming_download_manager import (
    xbasename,
    xdirname,
    xet_parse,
    xexists,
    xgetsize,
    xglob,
    xgzip_open,
    xisdir,
    xisfile,
    xjoin,
    xlistdir,
    xnumpy_load,
    xopen,
    xpandas_read_csv,
    xpandas_read_excel,
    xPath,
    xrelpath,
    xsio_loadmat,
    xsplit,
    xsplitext,
    xwalk,
    xxml_dom_minidom_parse,
)
from .utils.logging import get_logger
from .utils.patching import patch_submodule
from .utils.py_utils import get_imports


lowercase_									=    get_logger(__name__)


if TYPE_CHECKING:
     from .builder import DatasetBuilder
def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      int       ,     SCREAMING_SNAKE_CASE__     :      Optional[Union[str, bool]] = None )				-> Union[str, Any]:





    '''simple docstring'''






    A__        =  importlib.import_module(UpperCamelCase__ )

    # TODO(QL): always update the module to add subsequent new authentication
    if hasattr(UpperCamelCase__       ,     '_patched_for_streaming' ) and module._patched_for_streaming:
        return

    def wrap_auth(SCREAMING_SNAKE_CASE__     :      int ):
        @wraps(UpperCamelCase__ )
        def wrapper(*SCREAMING_SNAKE_CASE__     :      Dict       ,     **SCREAMING_SNAKE_CASE__     :      Dict ):
            return function(*UpperCamelCase__       ,     use_auth_token=UpperCamelCase__       ,     **UpperCamelCase__ )

        A__        =  '''wrap_auth'''
        return wrapper

    # open files in a streaming fashion
    patch_submodule(UpperCamelCase__       ,     'open'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'os.listdir'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'os.walk'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'glob.glob'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    # allow to navigate in remote zip files
    patch_submodule(UpperCamelCase__       ,     'os.path.join'       ,     UpperCamelCase__ ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.dirname'       ,     UpperCamelCase__ ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.basename'       ,     UpperCamelCase__ ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.relpath'       ,     UpperCamelCase__ ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.split'       ,     UpperCamelCase__ ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.splitext'       ,     UpperCamelCase__ ).start()
    # allow checks on paths
    patch_submodule(UpperCamelCase__       ,     'os.path.exists'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.isdir'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.isfile'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'os.path.getsize'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'pathlib.Path'       ,     UpperCamelCase__ ).start()
    # file readers
    patch_submodule(UpperCamelCase__       ,     'gzip.open'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'numpy.load'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'pandas.read_csv'       ,     wrap_auth(UpperCamelCase__ )       ,     attrs=['__version__'] ).start()
    patch_submodule(UpperCamelCase__       ,     'pandas.read_excel'       ,     wrap_auth(UpperCamelCase__ )       ,     attrs=['__version__'] ).start()
    patch_submodule(UpperCamelCase__       ,     'scipy.io.loadmat'       ,     wrap_auth(UpperCamelCase__ )       ,     attrs=['__version__'] ).start()
    patch_submodule(UpperCamelCase__       ,     'xml.etree.ElementTree.parse'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    patch_submodule(UpperCamelCase__       ,     'xml.dom.minidom.parse'       ,     wrap_auth(UpperCamelCase__ ) ).start()
    A__        =  True

def 		_snake_case(       SCREAMING_SNAKE_CASE__     :      "DatasetBuilder" )				-> str:





    '''simple docstring'''






    extend_module_for_streaming(builder.__module__       ,     use_auth_token=builder.use_auth_token )
    # if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
    if not builder.__module__.startswith('datasets.' ):  # check that it's not a packaged builder like csv
        for imports in get_imports(inspect.getfile(builder.__class__ ) ):
            if imports[0] == "internal":
                A__        =  imports[1]
                A__        =  '''.'''.join(builder.__module__.split('.' )[:-1] + [internal_import_name] )
                extend_module_for_streaming(UpperCamelCase__       ,     use_auth_token=builder.use_auth_token )

    # builders can inherit from other builders that might use streaming functionality
    # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
    # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
    from .builder import DatasetBuilder

    A__        =  [
        cls.__module__
        for cls in type(UpperCamelCase__ ).__mro__[1:]  # make sure it's not the same module we've already patched
        if issubclass(cls       ,     UpperCamelCase__ ) and cls.__module__ != DatasetBuilder.__module__
    ]  # check it's not a standard builder from datasets.builder
    for module in parent_builder_modules:
        extend_module_for_streaming(UpperCamelCase__       ,     use_auth_token=builder.use_auth_token )








'''simple docstring'''






def 				_lowerCamelCase(	UpperCamelCase__     :			int = 1_000		)		->	int:
    A							:							Optional[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)
    A							:							Tuple				=    [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

    A							:							str				=    0

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


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