



'''simple docstring'''



def _lowercase				(					__A = 200    ):



 '''simple docstring'''



 __UpperCamelCase			 =					[1, 2, 5, 10, 20, 50, 100, 200]
 __UpperCamelCase			 =					[0] * (pence + 1)
 __UpperCamelCase			 =					1  # base case: 1 way to make 0 pence

 for coin in coins:
  for i in range(__A							,pence + 1							,1    ):
   number_of_ways[i] += number_of_ways[i - coin]
 return number_of_ways[pence]


if __name__ == "__main__":
 assert solution(2_0_0) == 7_3_6_8_2










'''simple docstring'''



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     UpperCAmelCase__					(      UpperCAmelCase_):



 def __init__(					self						,		lowercase=0.01						,		lowercase=1_0_0_0     )					->							List[Any]:
  __UpperCamelCase			 =					p_stop
  __UpperCamelCase			 =					max_length




 def __iter__(					self     )					->							Dict:
  __UpperCamelCase			 =					0
  __UpperCamelCase			 =					False
  while not stop and count < self.max_length:
   yield count
   count += 1
   __UpperCamelCase			 =					random.random() < self.p_stop


class     UpperCAmelCase__					(      unittest.TestCase):



 def 				__lowerCamelCase			(					self						,		lowercase						,		lowercase						,		lowercase=False						,		lowercase=True     )					->							List[str]:
  __UpperCamelCase			 =					[
      BatchSamplerShard(lowercase						,		2						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )
      for i in range(2     )
  ]
  __UpperCamelCase			 =					[list(lowercase     ) for batch_sampler_shard in batch_sampler_shards]
  if not split_batches:
   self.assertListEqual([len(lowercase     ) for shard in batch_sampler_shards]						,		[len(lowercase     ) for e in expected]     )
  self.assertListEqual(lowercase						,		lowercase     )



 def 				__lowerCamelCase			(					self     )					->							Optional[Any]:
  # Check the shards when the dataset is a round multiple of total batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9, 2_0]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7], [2_1, 2_2, 2_3]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=3						,		drop_last=lowercase     )
  # Expected shouldn't change
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

  # Check the shards when the dataset is a round multiple of batch size but not total batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9, 2_0]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7], [0, 1, 2]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
  # num_processes batch.
  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9, 2_0]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7], [2_1, 0, 1]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
  # num_processes batch.
  __UpperCamelCase			 =					BatchSampler(range(2_0     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9, 0]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7], [1, 2, 3]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_0     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )

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

  __UpperCamelCase			 =					BatchSampler(range(2     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[[], []]
  self.check_batch_sampler_shards(lowercase						,		lowercase     )



 def 				__lowerCamelCase			(					self     )					->							Dict:
  # Check the shards when the dataset is a round multiple of batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7], [2_0, 2_1]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9], [2_2, 2_3]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=4						,		drop_last=lowercase     )
  # Expected shouldn't change
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7], [2_0, 2_1]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9], [0, 1]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size or num_processes.
  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7], [2_0, 0]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9], [1, 2]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase     )

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

  __UpperCamelCase			 =					BatchSampler(range(2     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[[], []]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase     )



 def 				__lowerCamelCase			(					self     )					->							Optional[Any]:
  # Check the shards when the dataset is a round multiple of total batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9, 2_0]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7], [2_1, 2_2, 2_3]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=3						,		drop_last=lowercase     )
  # Expected shouldn't change
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

  # Check the shards when the dataset is a round multiple of batch size but not total batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9, 2_0]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
  # num_processes batch.
  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9, 2_0]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7], [2_1]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
  # num_processes batch.
  __UpperCamelCase			 =					BatchSampler(range(2_0     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4], [1_8, 1_9]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_0     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1, 2], [6, 7, 8], [1_2, 1_3, 1_4]],
      [[3, 4, 5], [9, 1_0, 1_1], [1_5, 1_6, 1_7]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )

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

  __UpperCamelCase			 =					BatchSampler(range(2     )						,		batch_size=3						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[[], []]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		even_batches=lowercase     )



 def 				__lowerCamelCase			(					self     )					->							str:
  # Check the shards when the dataset is a round multiple of batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7], [2_0, 2_1]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9], [2_2, 2_3]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_4     )						,		batch_size=4						,		drop_last=lowercase     )
  # Expected shouldn't change
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size.
  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7], [2_0, 2_1]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_2     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )

  # Check the shards when the dataset is not a round multiple of batch size or num_processes.
  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7], [2_0]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )

  __UpperCamelCase			 =					BatchSampler(range(2_1     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[
      [[0, 1], [4, 5], [8, 9], [1_2, 1_3], [1_6, 1_7]],
      [[2, 3], [6, 7], [1_0, 1_1], [1_4, 1_5], [1_8, 1_9]],
  ]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )

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

  __UpperCamelCase			 =					BatchSampler(range(2     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					[[], []]
  self.check_batch_sampler_shards(lowercase						,		lowercase						,		split_batches=lowercase						,		even_batches=lowercase     )



 def 				__lowerCamelCase			(					self     )					->							str:
  __UpperCamelCase			 =					[[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 1_0, 1_1], [1_2, 1_3]]
  __UpperCamelCase			 =					[BatchSamplerShard(lowercase						,		2						,		lowercase						,		even_batches=lowercase     ) 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], [1_2, 1_3]]     )
  self.assertListEqual(list(batch_sampler_shards[1]     )						,		[[3, 4], [9, 1_0, 1_1]]     )



 def 				__lowerCamelCase			(					self						,		lowercase						,		lowercase						,		lowercase						,		lowercase=False						,		lowercase=2						,		lowercase=False     )					->							List[str]:
  random.seed(lowercase     )
  __UpperCamelCase			 =					list(lowercase     )

  __UpperCamelCase			 =					[
      IterableDatasetShard(
          lowercase						,		batch_size=lowercase						,		drop_last=lowercase						,		num_processes=lowercase						,		process_index=lowercase						,		split_batches=lowercase						,		)
      for i in range(lowercase     )
  ]
  __UpperCamelCase			 =					[]
  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(lowercase     )
   iterable_dataset_lists.append(list(lowercase     )     )

  __UpperCamelCase			 =					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
  __UpperCamelCase			 =					iterable_dataset_lists[0]
  for l in iterable_dataset_lists[1:]:
   self.assertEqual(len(lowercase     )						,		len(lowercase     )     )
   self.assertTrue(len(lowercase     ) % shard_batch_size == 0     )

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

  if not drop_last:
   while len(lowercase     ) < len(lowercase     ):
    reference += reference
  self.assertListEqual(lowercase						,		reference[: len(lowercase     )]     )



 def 				__lowerCamelCase			(					self     )					->							Dict:
  __UpperCamelCase			 =					4_2
  __UpperCamelCase			 =					RandomIterableDataset()

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

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

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



 def 				__lowerCamelCase			(					self     )					->							List[Any]:
  __UpperCamelCase			 =					BatchSampler(range(1_6     )						,		batch_size=4						,		drop_last=lowercase     )
  __UpperCamelCase			 =					SkipBatchSampler(lowercase						,		2     )
  self.assertListEqual(list(lowercase     )						,		[[8, 9, 1_0, 1_1], [1_2, 1_3, 1_4, 1_5]]     )



 def 				__lowerCamelCase			(					self     )					->							List[Any]:
  __UpperCamelCase			 =					SkipDataLoader(list(range(1_6     )     )						,		batch_size=4						,		skip_batches=2     )
  self.assertListEqual([t.tolist() for t in dataloader]						,		[[8, 9, 1_0, 1_1], [1_2, 1_3, 1_4, 1_5]]     )



 def 				__lowerCamelCase			(					self     )					->							List[Any]:
  __UpperCamelCase			 =					DataLoader(list(range(1_6     )     )						,		batch_size=4     )
  __UpperCamelCase			 =					skip_first_batches(lowercase						,		num_batches=2     )
  self.assertListEqual([t.tolist() for t in new_dataloader]						,		[[8, 9, 1_0, 1_1], [1_2, 1_3, 1_4, 1_5]]     )



 def 				__lowerCamelCase			(					self     )					->							Tuple:
  __UpperCamelCase			 =					DataLoaderShard(list(range(1_6     )     )						,		batch_size=4     )
  for idx, _ in enumerate(lowercase     ):
   self.assertEqual(dataloader.end_of_dataloader						,		idx == 3     )

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




 def 				__lowerCamelCase			(					self     )					->							Tuple:
  Accelerator()
  __UpperCamelCase			 =					DataLoaderDispatcher(range(1_6     )						,		batch_size=4     )
  for idx, _ in enumerate(lowercase     ):
   self.assertEqual(dataloader.end_of_dataloader						,		idx == 3     )

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





