





import os
from tempfile import TemporaryDirectory
from unittest import TestCase

import pytest
from absl.testing import parameterized

from datasets import config
from datasets.arrow_reader import HF_GCP_BASE_URL
from datasets.builder import DatasetBuilder
from datasets.dataset_dict import IterableDatasetDict
from datasets.iterable_dataset import IterableDataset
from datasets.load import dataset_module_factory, import_main_class
from datasets.utils.file_utils import cached_path


_A					:				Optional[int]				=			[
    {"""dataset""": """wikipedia""", """config_name""": """20220301.de"""},
    {"""dataset""": """wikipedia""", """config_name""": """20220301.en"""},
    {"""dataset""": """wikipedia""", """config_name""": """20220301.fr"""},
    {"""dataset""": """wikipedia""", """config_name""": """20220301.frr"""},
    {"""dataset""": """wikipedia""", """config_name""": """20220301.it"""},
    {"""dataset""": """wikipedia""", """config_name""": """20220301.simple"""},
    {"""dataset""": """snli""", """config_name""": """plain_text"""},
    {"""dataset""": """eli5""", """config_name""": """LFQA_reddit"""},
    {"""dataset""": """wiki40b""", """config_name""": """en"""},
    {"""dataset""": """wiki_dpr""", """config_name""": """psgs_w100.nq.compressed"""},
    {"""dataset""": """wiki_dpr""", """config_name""": """psgs_w100.nq.no_index"""},
    {"""dataset""": """wiki_dpr""", """config_name""": """psgs_w100.multiset.no_index"""},
    {"""dataset""": """natural_questions""", """config_name""": """default"""},
]


def 							__snake_case							(    lowerCAmelCase_=True	)				->						Union[str, Any]:
    if with_config:
        return [
            {
                "testcase_name": d["dataset"] + "/" + d["config_name"],
                "dataset": d["dataset"],
                "config_name": d["config_name"],
            }
            for d in DATASETS_ON_HF_GCP
        ]
    else:
        return [
            {"testcase_name": dataset, "dataset": dataset} for dataset in {d["dataset"] for d in DATASETS_ON_HF_GCP}
        ]



@parameterized.named_parameters(list_datasets_on_hf_gcp_parameters(with_config=__SCREAMING_SNAKE_CASE    )    )
class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    lowerCamelCase__    :		Any				=	None
    lowerCamelCase__    :		Optional[int]				=	None



    def  lowercase_					(       self   ,				A_   ,				A_     ):





        '''simple docstring'''

        with TemporaryDirectory() as tmp_dir:
            SCREAMING_SNAKE_CASE__											=			dataset_module_factory(A_   ,				cache_dir=A_     )

            SCREAMING_SNAKE_CASE__											=			import_main_class(dataset_module.module_path   ,				dataset=A_     )

            SCREAMING_SNAKE_CASE__											=			builder_cls(
                cache_dir=A_   ,				config_name=A_   ,				hash=dataset_module.hash   ,				)

            SCREAMING_SNAKE_CASE__											=			'''/'''.join(
                [
                    HF_GCP_BASE_URL,
                    builder_instance._relative_data_dir(with_hash=A_     ).replace(os.sep   ,				'''/'''     ),
                    config.DATASET_INFO_FILENAME,
                ]     )
            SCREAMING_SNAKE_CASE__											=			cached_path(A_   ,				cache_dir=A_     )
            self.assertTrue(os.path.exists(A_     )     )





@pytest.mark.integration
def 							__snake_case							(    lowerCAmelCase_	)				->						List[str]:
    SCREAMING_SNAKE_CASE__											=			tmp_path_factory.mktemp('''test_hf_gcp'''	) / '''test_wikipedia_simple'''
    SCREAMING_SNAKE_CASE__											=			dataset_module_factory('''wikipedia''' ,							cache_dir=lowerCAmelCase_	)
    SCREAMING_SNAKE_CASE__											=			import_main_class(dataset_module.module_path	)
    SCREAMING_SNAKE_CASE__											=			builder_cls(
        cache_dir=lowerCAmelCase_ ,							config_name='''20220301.frr''' ,							hash=dataset_module.hash ,							)
    # use the HF cloud storage, not the original download_and_prepare that uses apache-beam
    SCREAMING_SNAKE_CASE__											=			None
    builder_instance.download_and_prepare()
    SCREAMING_SNAKE_CASE__											=			builder_instance.as_dataset()
    assert ds



@pytest.mark.integration
def 							__snake_case							(    lowerCAmelCase_	)				->						Dict:
    SCREAMING_SNAKE_CASE__											=			dataset_module_factory('''wikipedia''' ,							cache_dir=lowerCAmelCase_	)
    SCREAMING_SNAKE_CASE__											=			import_main_class(dataset_module.module_path ,							dataset=lowerCAmelCase_	)
    SCREAMING_SNAKE_CASE__											=			builder_cls(
        cache_dir=lowerCAmelCase_ ,							config_name='''20220301.frr''' ,							hash=dataset_module.hash ,							)
    SCREAMING_SNAKE_CASE__											=			builder_instance.as_streaming_dataset()
    assert ds
    assert isinstance(lowerCAmelCase_ ,							lowerCAmelCase_	)
    assert "train" in ds
    assert isinstance(ds['''train'''] ,							lowerCAmelCase_	)
    assert next(iter(ds['''train''']	)	)







def 							__snake_case							(    )				->						int:
    return 1


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else two_pence(x - 2	) + one_pence()


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else five_pence(x - 5	) + two_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else ten_pence(x - 1_0	) + five_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else twenty_pence(x - 2_0	) + ten_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else fifty_pence(x - 5_0	) + twenty_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else one_pound(x - 1_0_0	) + fifty_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else two_pound(x - 2_0_0	) + one_pound(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_ = 2_0_0	)				->						int:
    return two_pound(lowerCAmelCase_	)


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