
'''simple docstring'''





from math import sqrt

def      A (       A_							:					int       ):
						assert isinstance(A_    ,							A_       ) and (
						    number >= 0
						), "'number' must been an int and positive"

						snake_case       :     Any =    True

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

						for divisor in range(2    ,							int(round(sqrt(A_       )       )       ) + 1       ):
												# if 'number' divisible by 'divisor' then sets 'status'
												# of false and break up the loop.
												if number % divisor == 0:
																		snake_case       :     List[str] =    False
																		break

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

						return status

def      A (       A_							:					int       ):
						assert isinstance(A_    ,							A_       ) and (n > 2), "'N' must been an int and > 2"

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

						snake_case       :     Optional[Any] =    []  # this list will be returns.

						# actual sieve of erathostenes
						for i in range(len(A_       )       ):
												for j in range(i + 1    ,							len(A_       )       ):
																		if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
																								snake_case       :     List[str] =    0

    # filters actual prime numbers.
						snake_case       :     Tuple =    [x for x in begin_list if x != 0]

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

						return ans

def      A (       A_							:					int       ):
						assert isinstance(A_    ,							A_       ) and (n > 2), "'N' must been an int and > 2"

						snake_case       :     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(A_       ):
																		ans.append(A_       )

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

						return ans

def      A (       A_							:					Optional[Any]       ):
						assert isinstance(A_    ,							A_       ) and number >= 0, "'number' must been an int and >= 0"

						snake_case       :     int =    []  # this list will be returns of the function.

						# potential prime number factors.

						snake_case       :     int =    2

						snake_case       :     List[Any] =    number

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

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

						else:
												ans.append(A_       )

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

						return ans

def      A (       A_							:					Optional[Any]       ):
						assert isinstance(A_    ,							A_       ) and (
						    number >= 0
						), "'number' bust been an int and >= 0"

						snake_case       :     Tuple =    0

						# prime factorization of 'number'
						snake_case       :     int =    prime_factorization(A_       )

						snake_case       :     str =    max(A_       )

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

						return ans

def      A (       A_							:					Union[str, Any]       ):
						assert isinstance(A_    ,							A_       ) and (
						    number >= 0
						), "'number' bust been an int and >= 0"

						snake_case       :     List[str] =    0

						# prime factorization of 'number'
						snake_case       :     Dict =    prime_factorization(A_       )

						snake_case       :     Union[str, Any] =    min(A_       )

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

						return ans

def      A (       A_							:					List[str]       ):
						assert isinstance(A_    ,							A_       ), "'number' must been an int"
						assert isinstance(number % 2 == 0    ,							A_       ), "compare bust been from type bool"

						return number % 2 == 0

def      A (       A_							:					Union[str, Any]       ):
						assert isinstance(A_    ,							A_       ), "'number' must been an int"
						assert isinstance(number % 2 != 0    ,							A_       ), "compare bust been from type bool"

						return number % 2 != 0

def      A (       A_							:					List[str]       ):
						assert (
						    isinstance(A_    ,							A_       ) and (number > 2) and is_even(A_       )
						), "'number' must been an int, even and > 2"

						snake_case       :     Dict =    []  # this list will returned

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

						# run variable for while-loops.
						snake_case       :     Dict =    0
						snake_case       :     Optional[Any] =    None

						# exit variable. for break up the loops
						snake_case       :     Any =    True

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

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

																		j += 1

												i += 1

						# precondition
						assert (
						    isinstance(A_    ,							A_       )
						    and (len(A_       ) == 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 (       A_							:					Tuple    ,							A_							:					Dict       ):
						assert (
						    isinstance(A_    ,							A_       )
						    and isinstance(A_    ,							A_       )
						    and (numbera >= 0)
						    and (numbera >= 0)
						), "'number1' and 'number2' must been positive integer."

						snake_case       :     Any =    0

						while numbera != 0:
												snake_case       :     Optional[int] =    numbera % numbera
												snake_case       :     Optional[Any] =    numbera
												snake_case       :     str =    rest

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

						return numbera

def      A (       A_							:					Optional[int]    ,							A_							:					int       ):
						assert (
						    isinstance(A_    ,							A_       )
						    and isinstance(A_    ,							A_       )
						    and (numbera >= 1)
						    and (numbera >= 1)
						), "'number1' and 'number2' must been positive integer."

						snake_case       :     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'
												snake_case       :     Any =    prime_factorization(A_       )
												snake_case       :     Dict =    prime_factorization(A_       )

						elif numbera == 1 or numbera == 1:
												snake_case       :     Tuple =    []
												snake_case       :     Optional[Any] =    []
												snake_case       :     int =    max(A_    ,							A_       )

						snake_case       :     Optional[int] =    0
						snake_case       :     str =    0

						snake_case       :     Any =    []  # 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:
																								snake_case       :     Optional[Any] =    prime_fac_a.count(A_       )
																								snake_case       :     str =    prime_fac_a.count(A_       )

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

																		else:
																								snake_case       :     str =    prime_fac_a.count(A_       )

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

																		done.append(A_       )

    # iterates through primeFac2
						for n in prime_fac_a:
												if n not in done:
																		snake_case       :     str =    prime_fac_a.count(A_       )

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

																		done.append(A_       )

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

						return ans

def      A (       A_							:					Any       ):
						assert isinstance(A_    ,							A_       ) and (n >= 0), "'number' must been a positive int"

						snake_case       :     int =    0
						snake_case       :     Union[str, Any] =    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(A_       ):
																		ans += 1

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

						return ans

def      A (       A_							:					List[Any]    ,							A_							:					Optional[Any]       ):
						assert (
						    is_prime(A_       ) and is_prime(A_       ) and (p_number_a < p_number_a)
						), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

						snake_case       :     Optional[Any] =    p_number_a + 1  # jump to the next number

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

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

						while number < p_number_a:
												ans.append(A_       )

												number += 1

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

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

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

def      A (       A_							:					Optional[int]       ):
						assert isinstance(A_    ,							A_       ) and (n >= 1), "'n' must been int and >= 1"

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

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

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

						return ans

def      A (       A_							:					Optional[Any]       ):
						assert isinstance(A_    ,							A_       ) and (
						    number > 1
						), "'number' must been an int and >= 1"

						snake_case       :     Tuple =    get_divisors(A_       )

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

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

def      A (       A_							:					Tuple    ,							A_							:					str       ):
						assert (
						    isinstance(A_    ,							A_       )
						    and isinstance(A_    ,							A_       )
						    and (denominator != 0)
						), "The arguments must been from type int and 'denominator' != 0"

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

						# precondition
						assert (
						    isinstance(A_    ,							A_       )
						    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 (       A_							:					List[str]       ):
						assert isinstance(A_    ,							A_       ) and (n >= 0), "'n' must been a int and >= 0"

						snake_case       :     int =    1  # this will be return.

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

						return ans





def      A (       A_							:					int       ):
						assert isinstance(A_    ,							A_       ) and (n >= 0), "'n' must been an int and >= 0"

						snake_case       :     Any =    0
						snake_case       :     Optional[int] =    1
						snake_case       :     Optional[int] =    1  # this will be return

						for _ in range(n - 1       ):
												snake_case       :     int =    ans
												ans += fiba
												snake_case       :     Union[str, Any] =    tmp

						return ans



'''simple docstring'''





import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE

class 						a   (				__magic_name__    ):
				_snake_case		    = ''''''
				_snake_case		    = (
				    None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
				)
				_snake_case		    = None  # compression type in fsspec. ex: "gzip"
				_snake_case		    = None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz




				def __init__(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				str = "",    SCREAMING_SNAKE_CASE_	:				Optional[str] = None,    SCREAMING_SNAKE_CASE_	:				Optional[dict] = None,    **SCREAMING_SNAKE_CASE_	:				Union[str, Any]      ):
										super().__init__(self,    **SCREAMING_SNAKE_CASE_      )
										# always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
										snake_case       :     List[Any] =    fsspec.open(
										    SCREAMING_SNAKE_CASE_,    mode='''rb''',    protocol=SCREAMING_SNAKE_CASE_,    compression=self.compression,    client_kwargs={
										        '''requote_redirect_url''': False,  # see https://github.com/huggingface/datasets/pull/5459
										        '''trust_env''': True,  # Enable reading proxy env variables.
										        **(target_options or {}).pop('''client_kwargs''',    {}      ),  # To avoid issues if it was already passed.
										    },    **(target_options or {}),    )
										snake_case       :     Tuple =    os.path.basename(self.file.path.split('''::'''      )[0]      )
										snake_case       :     Optional[Any] =    (
										    self.compressed_name[: self.compressed_name.rindex('''.'''      )]
										    if '''.''' in self.compressed_name
										    else self.compressed_name
										)
										snake_case       :     str =    None




				@classmethod
				def 	__snake_case							(							cls	:				Any,    SCREAMING_SNAKE_CASE_	:				int      ):
										# compressed file paths are always relative to the archive root
										return super()._strip_protocol(SCREAMING_SNAKE_CASE_      ).lstrip('''/'''      )




				def 	__snake_case							(							self	:				Optional[int]      ):
										if self.dir_cache is None:
																snake_case       :     Optional[int] =    {**self.file.fs.info(self.file.path      ), '''name''': self.uncompressed_name}
																snake_case       :     Tuple =    {f['''name''']: f}




				def 	__snake_case							(							self	:				List[Any],    SCREAMING_SNAKE_CASE_	:				str      ):
										return self.file.open().read()




				def 	__snake_case							(							self	:				List[Any],    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				str = "rb",    SCREAMING_SNAKE_CASE_	:				int=None,    SCREAMING_SNAKE_CASE_	:				Optional[int]=True,    SCREAMING_SNAKE_CASE_	:				List[Any]=None,    **SCREAMING_SNAKE_CASE_	:				Any,    ):
										snake_case       :     int =    self._strip_protocol(SCREAMING_SNAKE_CASE_      )
										if mode != "rb":
																raise ValueError(F"""Tried to read with mode {mode} on file {self.file.path} opened with mode 'rb'"""      )
										return self.file.open()




class 						a   (				__magic_name__    ):
				_snake_case		    = '''bz2'''
				_snake_case		    = '''bz2'''
				_snake_case		    = '''.bz2'''




class 						a   (				__magic_name__    ):
				_snake_case		    = '''gzip'''
				_snake_case		    = '''gzip'''
				_snake_case		    = '''.gz'''




class 						a   (				__magic_name__    ):
				_snake_case		    = '''lz4'''
				_snake_case		    = '''lz4'''
				_snake_case		    = '''.lz4'''




class 						a   (				__magic_name__    ):
				_snake_case		    = '''xz'''
				_snake_case		    = '''xz'''
				_snake_case		    = '''.xz'''




class 						a   (				__magic_name__    ):
				_snake_case		    = '''zstd'''
				_snake_case		    = '''zstd'''
				_snake_case		    = '''.zst'''




				def __init__(							self	:				int,    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				str = "rb",    SCREAMING_SNAKE_CASE_	:				Optional[str] = None,    SCREAMING_SNAKE_CASE_	:				Optional[dict] = None,    SCREAMING_SNAKE_CASE_	:				int = DEFAULT_BLOCK_SIZE,    **SCREAMING_SNAKE_CASE_	:				Optional[Any],    ):
										super().__init__(
										    fo=SCREAMING_SNAKE_CASE_,    mode=SCREAMING_SNAKE_CASE_,    target_protocol=SCREAMING_SNAKE_CASE_,    target_options=SCREAMING_SNAKE_CASE_,    block_size=SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_,    )
										# We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
										#
										# File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
										#     out.close = close
										# AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
										#
										# see https://github.com/intake/filesystem_spec/issues/725
										snake_case       :     List[Any] =    self.file.__enter__

										class 						a   :




														def __init__(							self	:				int,    SCREAMING_SNAKE_CASE_	:				Dict      ):
																				snake_case       :     Dict =    file_




														def __enter__(							self	:				Optional[Any]      ):
																				self._file.__enter__()
																				return self




														def __exit__(							self	:				Union[str, Any],    *SCREAMING_SNAKE_CASE_	:				Dict,    **SCREAMING_SNAKE_CASE_	:				Tuple      ):
																				self._file.__exit__(*SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_      )




														def __iter__(							self	:				Union[str, Any]      ):
																				return iter(self._file      )




														def 	__snake_case							(							self	:				Union[str, Any]      ):
																				return next(self._file      )




														def __getattr__(							self	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				Optional[int]      ):
																				return getattr(self._file,    SCREAMING_SNAKE_CASE_      )

										def fixed_enter(*SCREAMING_SNAKE_CASE_	:				Optional[Any],    **SCREAMING_SNAKE_CASE_	:				List[Any]      ):
																return WrappedFile(_enter(*SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_      )      )

										snake_case       :     Union[str, Any] =    fixed_enter

