"""simple docstring"""





from math import sqrt





def 				a_     (      _lowerCAmelCase  : int     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (
           number >= 0
       ), "'number' must been an int and positive"

       lowercase__			:		List[Any]       =	True

       # 0 and 1 are none primes.
       if number <= 1:
              lowercase__			:		List[Any]       =	False

       for divisor in range(2   , int(round(sqrt(_lowerCAmelCase     )     )     ) + 1     ):
              # if 'number' divisible by 'divisor' then sets 'status'
              # of false and break up the loop.
              if number % divisor == 0:
                     lowercase__			:		Any       =	False
                     break

    # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'status' must been from type bool"

       return status





def 				a_     (      _lowerCAmelCase  : Dict     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (n > 2), "'N' must been an int and > 2"

       # beginList: contains all natural numbers from 2 up to N
       lowercase__			:		int       =	list(range(2   , n + 1     )     )

       lowercase__			:		Optional[int]       =	[]  # this list will be returns.

       # actual sieve of erathostenes
       for i in range(len(_lowerCAmelCase     )     ):
              for j in range(i + 1   , len(_lowerCAmelCase     )     ):
                     if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
                            lowercase__			:		Optional[int]       =	0

    # filters actual prime numbers.
       lowercase__			:		Optional[Any]       =	[x for x in begin_list if x != 0]

       # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'ans' must been from type list"

       return ans





def 				a_     (      _lowerCAmelCase  : int     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (n > 2), "'N' must been an int and > 2"

       lowercase__			:		str       =	[]

       # iterates over all numbers between 2 up to N+1
       # if a number is prime then appends to list 'ans'
       for number in range(2   , n + 1     ):
              if is_prime(_lowerCAmelCase     ):
                     ans.append(_lowerCAmelCase     )

    # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'ans' must been from type list"

       return ans





def 				a_     (      _lowerCAmelCase  : Any     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and number >= 0, "'number' must been an int and >= 0"

       lowercase__			:		Union[str, Any]       =	[]  # this list will be returns of the function.

       # potential prime number factors.

       lowercase__			:		int       =	2

       lowercase__			:		List[Any]       =	number

       if number == 0 or number == 1:
              ans.append(_lowerCAmelCase     )

       # if 'number' not prime then builds the prime factorization of 'number'
       elif not is_prime(_lowerCAmelCase     ):
              while quotient != 1:
                     if is_prime(_lowerCAmelCase     ) and (quotient % factor == 0):
                            ans.append(_lowerCAmelCase     )
                            quotient /= factor
                     else:
                            factor += 1

       else:
              ans.append(_lowerCAmelCase     )

       # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'ans' must been from type list"

       return ans





def 				a_     (      _lowerCAmelCase  : Dict     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (
           number >= 0
       ), "'number' bust been an int and >= 0"

       lowercase__			:		Optional[int]       =	0

       # prime factorization of 'number'
       lowercase__			:		List[str]       =	prime_factorization(_lowerCAmelCase     )

       lowercase__			:		Any       =	max(_lowerCAmelCase     )

       # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'ans' must been from type int"

       return ans





def 				a_     (      _lowerCAmelCase  : Union[str, Any]     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (
           number >= 0
       ), "'number' bust been an int and >= 0"

       lowercase__			:		int       =	0

       # prime factorization of 'number'
       lowercase__			:		List[str]       =	prime_factorization(_lowerCAmelCase     )

       lowercase__			:		Union[str, Any]       =	min(_lowerCAmelCase     )

       # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'ans' must been from type int"

       return ans





def 				a_     (      _lowerCAmelCase  : Tuple     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'number' must been an int"
       assert isinstance(number % 2 == 0   , _lowerCAmelCase     ), "compare bust been from type bool"

       return number % 2 == 0





def 				a_     (      _lowerCAmelCase  : str     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ), "'number' must been an int"
       assert isinstance(number % 2 != 0   , _lowerCAmelCase     ), "compare bust been from type bool"

       return number % 2 != 0





def 				a_     (      _lowerCAmelCase  : Dict     ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (number > 2) and is_even(_lowerCAmelCase     )
       ), "'number' must been an int, even and > 2"

       lowercase__			:		List[Any]       =	[]  # this list will returned

       # creates a list of prime numbers between 2 up to 'number'
       lowercase__			:		List[str]       =	get_prime_numbers(_lowerCAmelCase     )
       lowercase__			:		Any       =	len(_lowerCAmelCase     )

       # run variable for while-loops.
       lowercase__			:		Optional[int]       =	0
       lowercase__			:		str       =	None

       # exit variable. for break up the loops
       lowercase__			:		Optional[int]       =	True

       while i < len_pn and loop:
              lowercase__			:		Any       =	i + 1

              while j < len_pn and loop:
                     if prime_numbers[i] + prime_numbers[j] == number:
                            lowercase__			:		Optional[Any]       =	False
                            ans.append(prime_numbers[i]     )
                            ans.append(prime_numbers[j]     )

                     j += 1

              i += 1

       # precondition
       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and (len(_lowerCAmelCase     ) == 2)
           and (ans[0] + ans[1] == number)
           and is_prime(ans[0]     )
           and is_prime(ans[1]     )
       ), "'ans' must contains two primes. And sum of elements must been eq 'number'"

       return ans





def 				a_     (      _lowerCAmelCase  : Any   , _lowerCAmelCase  : List[str]     ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and (numbera >= 0)
           and (numbera >= 0)
       ), "'number1' and 'number2' must been positive integer."

       lowercase__			:		List[Any]       =	0

       while numbera != 0:
              lowercase__			:		Optional[int]       =	numbera % numbera
              lowercase__			:		Optional[Any]       =	numbera
              lowercase__			:		Tuple       =	rest

       # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (
           numbera >= 0
       ), "'number' must been from type int and positive"

       return numbera





def 				a_     (      _lowerCAmelCase  : List[Any]   , _lowerCAmelCase  : int     ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and (numbera >= 1)
           and (numbera >= 1)
       ), "'number1' and 'number2' must been positive integer."

       lowercase__			:		List[str]       =	1  # actual answer that will be return.

       # for kgV (x,1)
       if numbera > 1 and numbera > 1:
              # builds the prime factorization of 'number1' and 'number2'
              lowercase__			:		Tuple       =	prime_factorization(_lowerCAmelCase     )
              lowercase__			:		int       =	prime_factorization(_lowerCAmelCase     )

       elif numbera == 1 or numbera == 1:
              lowercase__			:		Optional[Any]       =	[]
              lowercase__			:		Tuple       =	[]
              lowercase__			:		List[Any]       =	max(_lowerCAmelCase   , _lowerCAmelCase     )

       lowercase__			:		List[Any]       =	0
       lowercase__			:		List[Any]       =	0

       lowercase__			:		List[str]       =	[]  # captured numbers int both 'primeFac1' and 'primeFac2'

       # iterates through primeFac1
       for n in prime_fac_a:
              if n not in done:
                     if n in prime_fac_a:
                            lowercase__			:		Any       =	prime_fac_a.count(_lowerCAmelCase     )
                            lowercase__			:		int       =	prime_fac_a.count(_lowerCAmelCase     )

                            for _ in range(max(_lowerCAmelCase   , _lowerCAmelCase     )     ):
                                   ans *= n

                     else:
                            lowercase__			:		Optional[Any]       =	prime_fac_a.count(_lowerCAmelCase     )

                            for _ in range(_lowerCAmelCase     ):
                                   ans *= n

                     done.append(_lowerCAmelCase     )

    # iterates through primeFac2
       for n in prime_fac_a:
              if n not in done:
                     lowercase__			:		List[Any]       =	prime_fac_a.count(_lowerCAmelCase     )

                     for _ in range(_lowerCAmelCase     ):
                            ans *= n

                     done.append(_lowerCAmelCase     )

    # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (
           ans >= 0
       ), "'ans' must been from type int and positive"

       return ans





def 				a_     (      _lowerCAmelCase  : Dict     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (n >= 0), "'number' must been a positive int"

       lowercase__			:		Union[str, Any]       =	0
       lowercase__			:		int       =	2  # this variable holds the answer

       while index < n:
              index += 1

              ans += 1  # counts to the next number

              # if ans not prime then
              # runs to the next prime number.
              while not is_prime(_lowerCAmelCase     ):
                     ans += 1

    # precondition
       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and is_prime(
           _lowerCAmelCase     ), "'ans' must been a prime number and from type int"

       return ans





def 				a_     (      _lowerCAmelCase  : Any   , _lowerCAmelCase  : int     ):





       '''simple docstring'''

       assert (
           is_prime(_lowerCAmelCase     ) and is_prime(_lowerCAmelCase     ) and (p_number_a < p_number_a)
       ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

       lowercase__			:		Any       =	p_number_a + 1  # jump to the next number

       lowercase__			:		str       =	[]  # this list will be returns.

       # if number is not prime then
       # fetch the next prime number.
       while not is_prime(_lowerCAmelCase     ):
              number += 1

       while number < p_number_a:
              ans.append(_lowerCAmelCase     )

              number += 1

              # fetch the next prime number.
              while not is_prime(_lowerCAmelCase     ):
                     number += 1

    # precondition
       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and ans[0] != p_number_a
           and ans[len(_lowerCAmelCase     ) - 1] != p_number_a
       ), "'ans' must been a list without the arguments"

       # 'ans' contains not 'pNumber1' and 'pNumber2' !
       return ans





def 				a_     (      _lowerCAmelCase  : str     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (n >= 1), "'n' must been int and >= 1"

       lowercase__			:		Optional[int]       =	[]  # will be returned.

       for divisor in range(1   , n + 1     ):
              if n % divisor == 0:
                     ans.append(_lowerCAmelCase     )

    # precondition
       assert ans[0] == 1 and ans[len(_lowerCAmelCase     ) - 1] == n, "Error in function getDivisiors(...)"

       return ans





def 				a_     (      _lowerCAmelCase  : Any     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (
           number > 1
       ), "'number' must been an int and >= 1"

       lowercase__			:		List[str]       =	get_divisors(_lowerCAmelCase     )

       # precondition
       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and (divisors[0] == 1)
           and (divisors[len(_lowerCAmelCase     ) - 1] == number)
       ), "Error in help-function getDivisiors(...)"

       # summed all divisors up to 'number' (exclusive), hence [:-1]
       return sum(divisors[:-1]     ) == number





def 				a_     (      _lowerCAmelCase  : Union[str, Any]   , _lowerCAmelCase  : Any     ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and (denominator != 0)
       ), "The arguments must been from type int and 'denominator' != 0"

       # build the greatest common divisor of numerator and denominator.
       lowercase__			:		Dict       =	gcd(abs(_lowerCAmelCase     )   , abs(_lowerCAmelCase     )     )

       # precondition
       assert (
           isinstance(_lowerCAmelCase   , _lowerCAmelCase     )
           and (numerator % gcd_of_fraction == 0)
           and (denominator % gcd_of_fraction == 0)
       ), "Error in function gcd(...,...)"

       return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)





def 				a_     (      _lowerCAmelCase  : Any     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (n >= 0), "'n' must been a int and >= 0"

       lowercase__			:		Any       =	1  # this will be return.

       for factor in range(1   , n + 1     ):
              ans *= factor

       return ans






def 				a_     (      _lowerCAmelCase  : Optional[Any]     ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase   , _lowerCAmelCase     ) and (n >= 0), "'n' must been an int and >= 0"

       lowercase__			:		List[Any]       =	0
       lowercase__			:		Union[str, Any]       =	1
       lowercase__			:		List[str]       =	1  # this will be return

       for _ in range(n - 1     ):
              lowercase__			:		List[Any]       =	ans
              ans += fiba
              lowercase__			:		Tuple       =	tmp

       return ans






import pytest

from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs






@pytest.mark.parametrize(
    "kwargs, expected"				, [
        ({"num_shards": 0, "max_num_jobs": 1}, []),
        ({"num_shards": 10, "max_num_jobs": 1}, [range(10  )]),
        ({"num_shards": 10, "max_num_jobs": 10}, [range(_lowerCamelCase				, i + 1  ) for i in range(10  )]),
        ({"num_shards": 1, "max_num_jobs": 10}, [range(1  )]),
        ({"num_shards": 10, "max_num_jobs": 3}, [range(0				, 4  ), range(4				, 7  ), range(7				, 10  )]),
        ({"num_shards": 3, "max_num_jobs": 10}, [range(0				, 1  ), range(1				, 2  ), range(2				, 3  )]),
    ]				, )
def 				A				(					_lowerCamelCase				, _lowerCamelCase  ):





							'''simple docstring'''




							_lowerCAmelCase     :							List[Any]    =    _distribute_shards(**_lowerCamelCase  )
							assert out == expected






@pytest.mark.parametrize(
    "gen_kwargs, max_num_jobs, expected"				, [
        ({"foo": 0}, 10, [{"foo": 0}]),
        ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]),
        ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]),
        ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]),
        ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]),
    ]				, )
def 				A				(					_lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase  ):





							'''simple docstring'''




							_lowerCAmelCase     :							Optional[int]    =    _split_gen_kwargs(_lowerCamelCase				, _lowerCamelCase  )
							assert out == expected






@pytest.mark.parametrize(
    "gen_kwargs, expected"				, [
        ({"foo": 0}, 1),
        ({"shards": [0]}, 1),
        ({"shards": [0, 1, 2, 3]}, 4),
        ({"shards": [0, 1, 2, 3], "foo": 0}, 4),
        ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4),
        ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError),
    ]				, )
def 				A				(					_lowerCamelCase				, _lowerCamelCase  ):





							'''simple docstring'''




							if expected is RuntimeError:
														with pytest.raises(_lowerCamelCase  ):
																					_number_of_shards_in_gen_kwargs(_lowerCamelCase  )
							else:
														_lowerCAmelCase     :							Optional[int]    =    _number_of_shards_in_gen_kwargs(_lowerCamelCase  )
														assert out == expected
