

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     __snake_case    (				snake_case__  ):
       """simple docstring"""







       def __init__(		self      , _UpperCamelCase=0.01      , _UpperCamelCase=10_00   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							p_stop
              __snake_case       	=							max_length






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






              """simple docstring"""


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






class     __snake_case    (				unittest.TestCase  ):
       """simple docstring"""







       def 			a		(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase=False      , _UpperCamelCase=True   )      ->							Dict:






              """simple docstring"""


              __snake_case       	=							[
                  BatchSamplerShard(_UpperCamelCase      , 2      , _UpperCamelCase      , split_batches=_UpperCamelCase      , even_batches=_UpperCamelCase   )
                  for i in range(2   )
              ]
              __snake_case       	=							[list(_UpperCamelCase   ) for batch_sampler_shard in batch_sampler_shards]
              if not split_batches:
                     self.assertListEqual([len(_UpperCamelCase   ) for shard in batch_sampler_shards]      , [len(_UpperCamelCase   ) for e in expected]   )
              self.assertListEqual(_UpperCamelCase      , _UpperCamelCase   )


       def 			a		(		self   )      ->							Optional[Any]:






              """simple docstring"""


              __snake_case       	=							BatchSampler(range(24   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase   )

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

              # Check the shards when the dataset is a round multiple of batch size but not total batch size.
              __snake_case       	=							BatchSampler(range(21   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase   )

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

              # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
              # num_processes batch.
              __snake_case       	=							BatchSampler(range(22   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase   )

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

              # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
              # num_processes batch.
              __snake_case       	=							BatchSampler(range(20   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase   )

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

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

              __snake_case       	=							BatchSampler(range(2   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[[], []]
              self.check_batch_sampler_shards(_UpperCamelCase      , _UpperCamelCase   )


       def 			a		(		self   )      ->							Union[str, Any]:






              """simple docstring"""


              __snake_case       	=							BatchSampler(range(24   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase   )

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

              # Check the shards when the dataset is not a round multiple of batch size.
              __snake_case       	=							BatchSampler(range(22   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase   )

              __snake_case       	=							BatchSampler(range(22   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase   )

              # Check the shards when the dataset is not a round multiple of batch size or num_processes.
              __snake_case       	=							BatchSampler(range(21   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase   )

              __snake_case       	=							BatchSampler(range(21   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase   )

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

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


       def 			a		(		self   )      ->							str:






              """simple docstring"""


              __snake_case       	=							BatchSampler(range(24   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , even_batches=_UpperCamelCase   )

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

              # Check the shards when the dataset is a round multiple of batch size but not total batch size.
              __snake_case       	=							BatchSampler(range(21   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , even_batches=_UpperCamelCase   )

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

              # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
              # num_processes batch.
              __snake_case       	=							BatchSampler(range(22   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , even_batches=_UpperCamelCase   )

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

              # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
              # num_processes batch.
              __snake_case       	=							BatchSampler(range(20   )      , batch_size=3      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , even_batches=_UpperCamelCase   )

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

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

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


       def 			a		(		self   )      ->							int:






              """simple docstring"""


              __snake_case       	=							BatchSampler(range(24   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase      , even_batches=_UpperCamelCase   )

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

              # Check the shards when the dataset is not a round multiple of batch size.
              __snake_case       	=							BatchSampler(range(22   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase      , even_batches=_UpperCamelCase   )

              __snake_case       	=							BatchSampler(range(22   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase      , even_batches=_UpperCamelCase   )

              # Check the shards when the dataset is not a round multiple of batch size or num_processes.
              __snake_case       	=							BatchSampler(range(21   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase      , even_batches=_UpperCamelCase   )

              __snake_case       	=							BatchSampler(range(21   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							[
                  [[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(_UpperCamelCase      , _UpperCamelCase      , split_batches=_UpperCamelCase      , even_batches=_UpperCamelCase   )

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

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


       def 			a		(		self   )      ->							int:






              """simple docstring"""


              __snake_case       	=							[[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
              __snake_case       	=							[BatchSamplerShard(_UpperCamelCase      , 2      , _UpperCamelCase      , even_batches=_UpperCamelCase   ) 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 			a		(		self      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase=False      , _UpperCamelCase=2      , _UpperCamelCase=False   )      ->							int:






              """simple docstring"""


              random.seed(_UpperCamelCase   )
              __snake_case       	=							list(_UpperCamelCase   )

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

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

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

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


       def 			a		(		self   )      ->							str:






              """simple docstring"""


              __snake_case       	=							42
              __snake_case       	=							RandomIterableDataset()

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

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

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


       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              __snake_case       	=							BatchSampler(range(16   )      , batch_size=4      , drop_last=_UpperCamelCase   )
              __snake_case       	=							SkipBatchSampler(_UpperCamelCase      , 2   )
              self.assertListEqual(list(_UpperCamelCase   )      , [[8, 9, 10, 11], [12, 13, 14, 15]]   )


       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              __snake_case       	=							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 			a		(		self   )      ->							Union[str, Any]:






              """simple docstring"""


              __snake_case       	=							DataLoader(list(range(16   )   )      , batch_size=4   )
              __snake_case       	=							skip_first_batches(_UpperCamelCase      , num_batches=2   )
              self.assertListEqual([t.tolist() for t in new_dataloader]      , [[8, 9, 10, 11], [12, 13, 14, 15]]   )


       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


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

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






       def 			a		(		self   )      ->							Dict:






              """simple docstring"""


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

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




def 						lowerCamelCase__      ( __A    :int	,__A    :int		):


       """simple docstring"""




       if a < 0 or b < 0:
              raise ValueError("""the value of both inputs must be positive"""		)

       __snake_case       	=							str(bin(__A		)		)[2:]  # remove the leading "0b"
       __snake_case       	=							str(bin(__A		)		)[2:]  # remove the leading "0b"

       __snake_case       	=							max(len(__A		)	,len(__A		)		)

       return "0b" + "".join(
           str(int(char_a == """1""" and char_b == """1"""		)		)
           for char_a, char_b in zip(a_binary.zfill(__A		)	,b_binary.zfill(__A		)		)		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()

