"""simple docstring"""


from itertools import combinations_with_replacement


def   __UpperCAmelCase     (	_snake_case		:       int = 1_0_0       ):
   _lowercase							     =       [*list(range(1,				2_1       )       ), 2_5]
   _lowercase							     =       [2 * x for x in range(1,				2_1       )] + [5_0]
   _lowercase							     =       [3 * x for x in range(1,				2_1       )]
   _lowercase							     =       singles + doubles + triples + [0]

   _lowercase							     =       0
   _lowercase							     =       42
   _lowercase							     =       42
   _lowercase							     =       42
   _lowercase							     =       42

   for double in doubles:
      for throwa, throwa in combinations_with_replacement(__lowerCAmelCase,				2       ):
         _lowercase							     =       double + throwa + throwa
         if checkout_total < limit:
            num_checkouts += 1

   return num_checkouts


if __name__ == "__main__":
  print(f'''{solution() = }''')



'''simple docstring'''


import os
import sys
from pathlib import Path

import pytest

from datasets import Dataset, IterableDataset
from datasets.distributed import split_dataset_by_node

from .utils import execute_subprocess_async, get_torch_dist_unique_port, require_torch






def 			__lowerCAmelCase			():
		_UpperCAmelCase		:							Optional[int]             =   Dataset.from_dict({"i": range(17 )} )
		_UpperCAmelCase		:							int             =   len(__lowerCAmelCase )
		_UpperCAmelCase		:							Dict             =   3
		_UpperCAmelCase		:							str             =   [
		    split_dataset_by_node(__lowerCAmelCase   ,			rank=__lowerCAmelCase   ,			world_size=__lowerCAmelCase ) for rank in range(__lowerCAmelCase )
		]
		assert sum(len(__lowerCAmelCase ) for ds in datasets_per_rank ) == full_size
		assert len({tuple(x.values() ) for ds in datasets_per_rank for x in ds} ) == full_size






def 			__lowerCAmelCase			():
		def gen():
				return ({"i": i} for i in range(17 ))

		_UpperCAmelCase		:							Any             =   3
		_UpperCAmelCase		:							Any             =   IterableDataset.from_generator(__lowerCAmelCase )
		_UpperCAmelCase		:							str             =   len(list(__lowerCAmelCase ) )
		_UpperCAmelCase		:							Tuple             =   [
		    split_dataset_by_node(__lowerCAmelCase   ,			rank=__lowerCAmelCase   ,			world_size=__lowerCAmelCase ) for rank in range(__lowerCAmelCase )
		]
		assert sum(len(list(__lowerCAmelCase ) ) for ds in datasets_per_rank ) == full_size
		assert len({tuple(x.values() ) for ds in datasets_per_rank for x in ds} ) == full_size






@pytest.mark.parametrize("shards_per_node"   ,			[1, 2, 3] )
def 			__lowerCAmelCase			(__lowerCAmelCase ):
		def gen(__lowerCAmelCase ):
				for shard in shards:
						yield from ({"i": i, "shard": shard} for i in range(17 ))

		_UpperCAmelCase		:							Tuple             =   3
		_UpperCAmelCase		:							Tuple             =   shards_per_node * world_size
		_UpperCAmelCase		:							Optional[int]             =   {"shards": [F"""shard_{shard_idx}.txt""" for shard_idx in range(__lowerCAmelCase )]}
		_UpperCAmelCase		:							int             =   IterableDataset.from_generator(__lowerCAmelCase   ,			gen_kwargs=__lowerCAmelCase )
		_UpperCAmelCase		:							Any             =   len(list(__lowerCAmelCase ) )
		assert full_ds.n_shards == world_size * shards_per_node
		_UpperCAmelCase		:							Optional[Any]             =   [
		    split_dataset_by_node(__lowerCAmelCase   ,			rank=__lowerCAmelCase   ,			world_size=__lowerCAmelCase ) for rank in range(__lowerCAmelCase )
		]
		assert [ds.n_shards for ds in datasets_per_rank] == [shards_per_node] * world_size
		assert sum(len(list(__lowerCAmelCase ) ) for ds in datasets_per_rank ) == full_size
		assert len({tuple(x.values() ) for ds in datasets_per_rank for x in ds} ) == full_size






def 			__lowerCAmelCase			():
		def gen():
				return ({"i": i} for i in range(17 ))

		_UpperCAmelCase		:							List[str]             =   2
		_UpperCAmelCase		:							int             =   IterableDataset.from_generator(__lowerCAmelCase )
		_UpperCAmelCase		:							Union[str, Any]             =   len(list(__lowerCAmelCase ) )

		_UpperCAmelCase		:							int             =   split_dataset_by_node(__lowerCAmelCase   ,			rank=0   ,			world_size=__lowerCAmelCase ).shuffle(seed=42 )
		assert len(list(__lowerCAmelCase ) ) == 1 + full_size // world_size
		with pytest.raises(__lowerCAmelCase ):
				split_dataset_by_node(__lowerCAmelCase   ,			rank=0   ,			world_size=__lowerCAmelCase ).shuffle()

		_UpperCAmelCase		:							Dict             =   split_dataset_by_node(full_ds.shuffle(seed=42 )   ,			rank=0   ,			world_size=__lowerCAmelCase )
		assert len(list(__lowerCAmelCase ) ) == 1 + full_size // world_size
		with pytest.raises(__lowerCAmelCase ):
				split_dataset_by_node(full_ds.shuffle()   ,			rank=0   ,			world_size=__lowerCAmelCase )






@pytest.mark.parametrize("streaming"   ,			[False, True] )
@require_torch
@pytest.mark.skipif(os.name == "nt"   ,			reason="execute_subprocess_async doesn't support windows" )
@pytest.mark.integration
def 			__lowerCAmelCase			(__lowerCAmelCase ):
		_UpperCAmelCase		:							Union[str, Any]             =   2
		_UpperCAmelCase		:							Dict             =   get_torch_dist_unique_port()
		_UpperCAmelCase		:							int             =   Path(__lowerCAmelCase ).resolve().parent / "distributed_scripts" / "launch_torch_distributed.py"
		_UpperCAmelCase		:							List[Any]             =   F"""
        -m torch.distributed.launch
        --nproc_per_node={nproc_per_node}
        --master_port={master_port}
        {test_script}
    """.split()
		_UpperCAmelCase		:							List[str]             =   F"""
        --streaming={streaming}
    """.split()
		_UpperCAmelCase		:							Tuple             =   [sys.executable] + distributed_args + args
		execute_subprocess_async(__lowerCAmelCase   ,			env=os.environ.copy() )






@pytest.mark.parametrize(
    "nproc_per_node, num_workers"   ,			[
        (2, 2),  # each node has 2 shards and each worker has 1 shards
        (3, 2),  # each node uses all the shards but skips examples, and each worker has 2 shards
    ]   ,			)
@require_torch
@pytest.mark.skipif(os.name == "nt"   ,			reason="execute_subprocess_async doesn't support windows" )
@pytest.mark.integration
def 			__lowerCAmelCase			(__lowerCAmelCase   ,			__lowerCAmelCase ):
		_UpperCAmelCase		:							Tuple             =   True
		_UpperCAmelCase		:							int             =   get_torch_dist_unique_port()
		_UpperCAmelCase		:							Optional[int]             =   Path(__lowerCAmelCase ).resolve().parent / "distributed_scripts" / "launch_torch_distributed.py"
		_UpperCAmelCase		:							List[str]             =   F"""
        -m torch.distributed.launch
        --nproc_per_node={nproc_per_node}
        --master_port={master_port}
        {test_script}
    """.split()
		_UpperCAmelCase		:							int             =   F"""
        --streaming={streaming}
        --num_workers={num_workers}
    """.split()
		_UpperCAmelCase		:							Optional[int]             =   [sys.executable] + distributed_args + args
		execute_subprocess_async(__lowerCAmelCase   ,			env=os.environ.copy() )



