




from typing import Callable, Optional

from .. import Features
from ..packaged_modules.generator.generator import Generator
from .abc import AbstractDatasetInputStream




class 		UpperCamelCase__	(lowerCAmelCase__     ):

    '''simple docstring'''



    def __init__(    self     ,  UpperCamelCase__     ,  UpperCamelCase__ = None     ,  UpperCamelCase__ = None     ,  UpperCamelCase__ = False     ,  UpperCamelCase__ = False     ,  UpperCamelCase__ = None     ,  UpperCamelCase__ = None     ,  **UpperCamelCase__     ,  )     ->      Dict:
           super().__init__(
               features=UpperCamelCase__     ,  cache_dir=UpperCamelCase__     ,  keep_in_memory=UpperCamelCase__     ,  streaming=UpperCamelCase__     ,  num_proc=UpperCamelCase__     ,  **UpperCamelCase__     ,  )
           lowerCamelCase   :      Optional[int]			 =					Generator(
               cache_dir=UpperCamelCase__     ,  features=UpperCamelCase__     ,  generator=UpperCamelCase__     ,  gen_kwargs=UpperCamelCase__     ,  **UpperCamelCase__     ,  )







    def     _lowercase     (    self     )     ->      List[Any]:
           # Build iterable dataset
           if self.streaming:
                  lowerCamelCase   :      Tuple			 =					self.builder.as_streaming_dataset(split="train"     )
           # Build regular (map-style) dataset
           else:
                  lowerCamelCase   :      List[str]			 =					None
                  lowerCamelCase   :      Any			 =					None
                  lowerCamelCase   :      List[str]			 =					None
                  lowerCamelCase   :      str			 =					None

                  self.builder.download_and_prepare(
                      download_config=UpperCamelCase__     ,  download_mode=UpperCamelCase__     ,  verification_mode=UpperCamelCase__     ,  base_path=UpperCamelCase__     ,  num_proc=self.num_proc     ,  )
                  lowerCamelCase   :      Any			 =					self.builder.as_dataset(
                      split="train"     ,  verification_mode=UpperCamelCase__     ,  in_memory=self.keep_in_memory     )
           return dataset












import random

from .binary_exp_mod import bin_exp_mod

def      A      (      _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE=1000    )	-> List[str]:
       if n < 2:
              return False

       if n % 2 == 0:
              return n == 2

       # this means n is odd
       lowerCamelCase   :      List[Any]			 =					n - 1
       lowerCamelCase   :      Dict			 =					0
       while d % 2 == 0:
              d /= 2
              exp += 1

       # n - 1=d*(2**exp)
       lowerCamelCase   :      Optional[Any]			 =					0
       while count < prec:
              lowerCamelCase   :      str			 =					random.randint(2 ,n - 1    )
              lowerCamelCase   :      Dict			 =					bin_exp_mod(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )
              if b != 1:
                     lowerCamelCase   :      str			 =					True
                     for _ in range(_SCREAMING_SNAKE_CASE    ):
                            if b == n - 1:
                                   lowerCamelCase   :      Tuple			 =					False
                                   break
                            lowerCamelCase   :      int			 =					b * b
                            b %= n
                     if flag:
                            return False
                     count += 1
       return True


if __name__ == "__main__":
       SCREAMING_SNAKE_CASE__       :      Optional[int]  =   abs(int(input('Enter bound : ').strip()))
       print('Here\'s the list of primes:')
       print(', '.join(str(i) for i in range(n + 1) if is_prime_big(i)))






