




import random
import unittest

from torch.utils.data import BatchSampler, DataLoader, IterableDataset

from accelerate import Accelerator
from accelerate.data_loader import (
    BatchSamplerShard,
    DataLoaderDispatcher,
    DataLoaderShard,
    IterableDatasetShard,
    SkipBatchSampler,
    SkipDataLoader,
    skip_first_batches,
)

class 		__lowerCAmelCase	(	__magic_name__ ):
							def __init__(						self						:List[str]		,      __magic_name__						:List[Any]=0.01		,      __magic_name__						:Dict=1000				):







								'''simple docstring'''







								a										=							p_stop
								a										=							max_length





							def __iter__(						self						:Union[str, Any]				):







								'''simple docstring'''







								a										=							0
								a										=							False
								while not stop and count < self.max_length:
									yield count
									count += 1
									a										=							random.random() < self.p_stop







class 		__lowerCAmelCase	(	unittest.TestCase ):
							def       lowerCamelCase__							(						self						:Optional[Any]		,      __magic_name__						:Union[str, Any]		,      __magic_name__						:Any		,      __magic_name__						:Tuple=False		,      __magic_name__						:Dict=True				):







								'''simple docstring'''







								a										=							[
								    BatchSamplerShard(__magic_name__		,      2		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)
								    for i in range(2				)
								]
								a										=							[list(__magic_name__				) for batch_sampler_shard in batch_sampler_shards]
								if not split_batches:
									self.assertListEqual([len(__magic_name__				) for shard in batch_sampler_shards]		,      [len(__magic_name__				) for e in expected]				)
								self.assertListEqual(__magic_name__		,      __magic_name__				)
							def       lowerCamelCase__							(						self						:str				):







								'''simple docstring'''







								a										=							BatchSampler(range(24				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								a										=							BatchSampler(range(24				)		,      batch_size=3		,      drop_last=__magic_name__				)
								# Expected shouldn't change
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								# Check the shards when the dataset is a round multiple of batch size but not total batch size.
								a										=							BatchSampler(range(21				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [0, 1, 2]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								a										=							BatchSampler(range(21				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size but has a multiple of
								# num_processes batch.
								a										=							BatchSampler(range(22				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 0, 1]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								a										=							BatchSampler(range(22				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
								# num_processes batch.
								a										=							BatchSampler(range(20				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 0]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [1, 2, 3]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								a										=							BatchSampler(range(20				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								# Check the shards when the dataset is very small.
								a										=							BatchSampler(range(2				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[[[0, 1, 0]], [[1, 0, 1]]]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)

								a										=							BatchSampler(range(2				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[[], []]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__				)
							def       lowerCamelCase__							(						self						:List[Any]				):







								'''simple docstring'''







								a										=							BatchSampler(range(24				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)

								a										=							BatchSampler(range(24				)		,      batch_size=4		,      drop_last=__magic_name__				)
								# Expected shouldn't change
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size.
								a										=							BatchSampler(range(22				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [0, 1]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)

								a										=							BatchSampler(range(22				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size or num_processes.
								a										=							BatchSampler(range(21				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 0]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [1, 2]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)

								a										=							BatchSampler(range(21				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)

								# Check the shards when the dataset is very small.
								a										=							BatchSampler(range(2				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[[[0, 1]], [[0, 1]]]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)

								a										=							BatchSampler(range(2				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[[], []]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__				)
							def       lowerCamelCase__							(						self						:Any				):







								'''simple docstring'''







								a										=							BatchSampler(range(24				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(24				)		,      batch_size=3		,      drop_last=__magic_name__				)
								# Expected shouldn't change
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								# Check the shards when the dataset is a round multiple of batch size but not total batch size.
								a										=							BatchSampler(range(21				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(21				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size but has a multiple of
								# num_processes batch.
								a										=							BatchSampler(range(22				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(22				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
								# num_processes batch.
								a										=							BatchSampler(range(20				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(20				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
								    [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								# Check the shards when the dataset is very small.
								a										=							BatchSampler(range(2				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[[[0, 1]], []]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(2				)		,      batch_size=3		,      drop_last=__magic_name__				)
								a										=							[[], []]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      even_batches=__magic_name__				)
							def       lowerCamelCase__							(						self						:List[str]				):







								'''simple docstring'''







								a										=							BatchSampler(range(24				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(24				)		,      batch_size=4		,      drop_last=__magic_name__				)
								# Expected shouldn't change
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size.
								a										=							BatchSampler(range(22				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(22				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)

								# Check the shards when the dataset is not a round multiple of batch size or num_processes.
								a										=							BatchSampler(range(21				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(21				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[
								    [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
								    [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
								]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)

								# Check the shards when the dataset is very small.
								a										=							BatchSampler(range(2				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[[[0, 1]], []]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)

								a										=							BatchSampler(range(2				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							[[], []]
								self.check_batch_sampler_shards(__magic_name__		,      __magic_name__		,      split_batches=__magic_name__		,      even_batches=__magic_name__				)
							def       lowerCamelCase__							(						self						:Optional[Any]				):







								'''simple docstring'''







								a										=							[[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
								a										=							[BatchSamplerShard(__magic_name__		,      2		,      __magic_name__		,      even_batches=__magic_name__				) for i in range(2				)]

								self.assertEqual(len(batch_sampler_shards[0]				)		,      3				)
								self.assertEqual(len(batch_sampler_shards[1]				)		,      2				)

								self.assertListEqual(list(batch_sampler_shards[0]				)		,      [[0, 1, 2], [5, 6, 7, 8], [12, 13]]				)
								self.assertListEqual(list(batch_sampler_shards[1]				)		,      [[3, 4], [9, 10, 11]]				)
							def       lowerCamelCase__							(						self						:str		,      __magic_name__						:str		,      __magic_name__						:List[Any]		,      __magic_name__						:Union[str, Any]		,      __magic_name__						:str=False		,      __magic_name__						:Union[str, Any]=2		,      __magic_name__						:Optional[int]=False				):







								'''simple docstring'''







								random.seed(__magic_name__				)
								a										=							list(__magic_name__				)

								a										=							[
								    IterableDatasetShard(
								        __magic_name__		,      batch_size=__magic_name__		,      drop_last=__magic_name__		,      num_processes=__magic_name__		,      process_index=__magic_name__		,      split_batches=__magic_name__		,      )
								    for i in range(__magic_name__				)
								]
								a										=							[]
								for iterable_dataset_shard in iterable_dataset_shards:
									# Since our random iterable dataset will be... random... we need to use a seed to get reproducible results.
									random.seed(__magic_name__				)
									iterable_dataset_lists.append(list(__magic_name__				)				)

								a										=							batch_size // num_processes if split_batches else batch_size
								# All iterable dataset shard should have the same length, a round multiple of shard_batch_size
								a										=							iterable_dataset_lists[0]
								for l in iterable_dataset_lists[1:]:
									self.assertEqual(len(__magic_name__				)		,      len(__magic_name__				)				)
									self.assertTrue(len(__magic_name__				) % shard_batch_size == 0				)

								a										=							[]
								for idx in range(0		,      len(__magic_name__				)		,      __magic_name__				):
									for l in iterable_dataset_lists:
										observed += l[idx : idx + shard_batch_size]

								if not drop_last:
									while len(__magic_name__				) < len(__magic_name__				):
										reference += reference
								self.assertListEqual(__magic_name__		,      reference[: len(__magic_name__				)]				)
							def       lowerCamelCase__							(						self						:int				):







								'''simple docstring'''







								a										=							42
								a										=							RandomIterableDataset()

								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)
								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)
								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)
								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)

								# Edge case with a very small dataset
								a										=							RandomIterableDataset(max_length=2				)

								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)
								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)
								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)
								self.check_iterable_dataset_shards(__magic_name__		,      __magic_name__		,      batch_size=4		,      drop_last=__magic_name__		,      split_batches=__magic_name__				)
							def       lowerCamelCase__							(						self						:Dict				):







								'''simple docstring'''







								a										=							BatchSampler(range(16				)		,      batch_size=4		,      drop_last=__magic_name__				)
								a										=							SkipBatchSampler(__magic_name__		,      2				)
								self.assertListEqual(list(__magic_name__				)		,      [[8, 9, 10, 11], [12, 13, 14, 15]]				)
							def       lowerCamelCase__							(						self						:List[Any]				):







								'''simple docstring'''







								a										=							SkipDataLoader(list(range(16				)				)		,      batch_size=4		,      skip_batches=2				)
								self.assertListEqual([t.tolist() for t in dataloader]		,      [[8, 9, 10, 11], [12, 13, 14, 15]]				)
							def       lowerCamelCase__							(						self						:Optional[Any]				):







								'''simple docstring'''







								a										=							DataLoader(list(range(16				)				)		,      batch_size=4				)
								a										=							skip_first_batches(__magic_name__		,      num_batches=2				)
								self.assertListEqual([t.tolist() for t in new_dataloader]		,      [[8, 9, 10, 11], [12, 13, 14, 15]]				)
							def       lowerCamelCase__							(						self						:int				):







								'''simple docstring'''







								a										=							DataLoaderShard(list(range(16				)				)		,      batch_size=4				)
								for idx, _ in enumerate(__magic_name__				):
									self.assertEqual(dataloader.end_of_dataloader		,      idx == 3				)

								# Test it also works on the second iteration
								for idx, _ in enumerate(__magic_name__				):
									self.assertEqual(dataloader.end_of_dataloader		,      idx == 3				)





							def       lowerCamelCase__							(						self						:Tuple				):







								'''simple docstring'''







								Accelerator()
								a										=							DataLoaderDispatcher(range(16				)		,      batch_size=4				)
								for idx, _ in enumerate(__magic_name__				):
									self.assertEqual(dataloader.end_of_dataloader		,      idx == 3				)

								# Test it also works on the second iteration
								for idx, _ in enumerate(__magic_name__				):
									self.assertEqual(dataloader.end_of_dataloader		,      idx == 3				)







from __future__ import annotations





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       float:
	a										=							sorted(numsa + numsa    )
	a				, a										=							divmod(len(__lowerCamelCase    )							,			2    )
	if mod == 1:
		return all_numbers[div]
	else:
		return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		__UpperCamelCase					:       Tuple    					=      [float(x) for x in input("Enter the elements of first array: ").split()]
		__UpperCamelCase					:       List[Any]    					=      [float(x) for x in input("Enter the elements of second array: ").split()]
		print(F'The median of two arrays is: {median_of_two_arrays(array_a, array_a)}')

