



from math import sqrt



def 	__a					(   lowerCAmelCase_       : int    )				->			bool:






						'''simple docstring'''



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

						UpperCAmelCase_=       True

						# 0 and 1 are none primes.
						if number <= 1:
												UpperCAmelCase_=       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:
																		UpperCAmelCase_=       False
																		break

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

						return status



def 	__a					(   lowerCAmelCase_       : List[Any]    )				->			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
						UpperCAmelCase_=       list(range(2      ,n + 1    )    )

						UpperCAmelCase_=       []  # 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):
																								UpperCAmelCase_=       0

    # filters actual prime numbers.
						UpperCAmelCase_=       [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_       : Tuple    )				->			Optional[int]:






						'''simple docstring'''



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

						UpperCAmelCase_=       []

						# 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_       : int    )				->			Dict:






						'''simple docstring'''



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

						UpperCAmelCase_=       []  # this list will be returns of the function.

						# potential prime number factors.

						UpperCAmelCase_=       2

						UpperCAmelCase_=       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_       : Optional[int]    )				->			List[Any]:






						'''simple docstring'''



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

						UpperCAmelCase_=       0

						# prime factorization of 'number'
						UpperCAmelCase_=       prime_factorization(lowerCAmelCase_    )

						UpperCAmelCase_=       max(lowerCAmelCase_    )

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

						return ans



def 	__a					(   lowerCAmelCase_       : Dict    )				->			List[str]:






						'''simple docstring'''



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

						UpperCAmelCase_=       0

						# prime factorization of 'number'
						UpperCAmelCase_=       prime_factorization(lowerCAmelCase_    )

						UpperCAmelCase_=       min(lowerCAmelCase_    )

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

						return ans



def 	__a					(   lowerCAmelCase_       : int    )				->			Optional[int]:






						'''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_       : Optional[Any]    )				->			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_       : List[str]    )				->			str:






						'''simple docstring'''



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

						UpperCAmelCase_=       []  # this list will returned

						# creates a list of prime numbers between 2 up to 'number'
						UpperCAmelCase_=       get_prime_numbers(lowerCAmelCase_    )
						UpperCAmelCase_=       len(lowerCAmelCase_    )

						# run variable for while-loops.
						UpperCAmelCase_=       0
						UpperCAmelCase_=       None

						# exit variable. for break up the loops
						UpperCAmelCase_=       True

						while i < len_pn and loop:
												UpperCAmelCase_=       i + 1

												while j < len_pn and loop:
																		if prime_numbers[i] + prime_numbers[j] == number:
																								UpperCAmelCase_=       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_       : Union[str, Any]      ,lowerCAmelCase_       : Dict    )				->			Union[str, Any]:






						'''simple docstring'''



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

						UpperCAmelCase_=       0

						while numbera != 0:
												UpperCAmelCase_=       numbera % numbera
												UpperCAmelCase_=       numbera
												UpperCAmelCase_=       rest

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

						return numbera



def 	__a					(   lowerCAmelCase_       : int      ,lowerCAmelCase_       : Optional[int]    )				->			List[str]:






						'''simple docstring'''



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

						UpperCAmelCase_=       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'
												UpperCAmelCase_=       prime_factorization(lowerCAmelCase_    )
												UpperCAmelCase_=       prime_factorization(lowerCAmelCase_    )

						elif numbera == 1 or numbera == 1:
												UpperCAmelCase_=       []
												UpperCAmelCase_=       []
												UpperCAmelCase_=       max(lowerCAmelCase_      ,lowerCAmelCase_    )

						UpperCAmelCase_=       0
						UpperCAmelCase_=       0

						UpperCAmelCase_=       []  # 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:
																								UpperCAmelCase_=       prime_fac_a.count(lowerCAmelCase_    )
																								UpperCAmelCase_=       prime_fac_a.count(lowerCAmelCase_    )

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

																		else:
																								UpperCAmelCase_=       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:
																		UpperCAmelCase_=       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_       : str    )				->			Union[str, Any]:






						'''simple docstring'''



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

						UpperCAmelCase_=       0
						UpperCAmelCase_=       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_       : List[Any]    )				->			Any:






						'''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'"

						UpperCAmelCase_=       p_number_a + 1  # jump to the next number

						UpperCAmelCase_=       []  # 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_       : Tuple    )				->			Tuple:






						'''simple docstring'''



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

						UpperCAmelCase_=       []  # 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    )				->			Tuple:






						'''simple docstring'''



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

						UpperCAmelCase_=       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_       : List[str]      ,lowerCAmelCase_       : Optional[Any]    )				->			Optional[int]:






						'''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.
						UpperCAmelCase_=       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_       : Optional[int]    )				->			Optional[Any]:






						'''simple docstring'''



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

						UpperCAmelCase_=       1  # this will be return.

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

						return ans



def 	__a					(   lowerCAmelCase_       : Any    )				->			Optional[int]:






						'''simple docstring'''



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

						UpperCAmelCase_=       0
						UpperCAmelCase_=       1
						UpperCAmelCase_=       1  # this will be return

						for _ in range(n - 1    ):
												UpperCAmelCase_=       ans
												ans += fiba
												UpperCAmelCase_=       tmp

						return ans









import itertools
from dataclasses import dataclass
from typing import Any, Callable, Dict, List, Optional, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast
from datasets.utils.py_utils import Literal


__A       =						datasets.utils.logging.get_logger(__name__)

__A       =						['''names''', '''prefix''']
__A       =						['''warn_bad_lines''', '''error_bad_lines''', '''mangle_dupe_cols''']
__A       =						['''encoding_errors''', '''on_bad_lines''']
__A       =						['''date_format''']






@dataclass
class 		lowercase						(			datasets.BuilderConfig):






	"""simple docstring"""


	a__				: str		       =							","
	a__				: Optional[str]		       =							None
	a__				: Optional[Union[int, List[int], str]]		       =							"infer"
	a__				: Optional[List[str]]		       =							None
	a__				: Optional[List[str]]		       =							None
	a__				: Optional[Union[int, str, List[int], List[str]]]		       =							None
	a__				: Optional[Union[List[int], List[str]]]		       =							None
	a__				: Optional[str]		       =							None
	a__				: bool		       =							True
	a__				: Optional[Literal["c", "python", "pyarrow"]]		       =							None
	a__				: Dict[Union[int, str], Callable[[Any], Any]]		       =							None
	a__				: Optional[list]		       =							None
	a__				: Optional[list]		       =							None
	a__				: bool		       =							False
	a__				: Optional[Union[int, List[int]]]		       =							None
	a__				: Optional[int]		       =							None
	a__				: Optional[Union[str, List[str]]]		       =							None
	a__				: bool		       =							True
	a__				: bool		       =							True
	a__				: bool		       =							False
	a__				: bool		       =							True
	a__				: Optional[str]		       =							None
	a__				: str		       =							"."
	a__				: Optional[str]		       =							None
	a__				: str		       =							'"'
	a__				: int		       =							0
	a__				: Optional[str]		       =							None
	a__				: Optional[str]		       =							None
	a__				: Optional[str]		       =							None
	a__				: Optional[str]		       =							None
	a__				: bool		       =							True
	a__				: bool		       =							True
	a__				: int		       =							0
	a__				: bool		       =							True
	a__				: bool		       =							False
	a__				: Optional[str]		       =							None
	a__				: int		       =							1_0000
	a__				: Optional[datasets.Features]		       =							None
	a__				: Optional[str]		       =							"strict"
	a__				: Literal["error", "warn", "skip"]		       =							"error"
	a__				: Optional[str]		       =							None




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[Any]					)      ->			int:
							if self.delimiter is not None:
													UpperCAmelCase_=       self.delimiter
							if self.column_names is not None:
													UpperCAmelCase_=       self.column_names




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						str					)      ->			Tuple:
							UpperCAmelCase_=       {
							    """sep""": self.sep,
							    """header""": self.header,
							    """names""": self.names,
							    """index_col""": self.index_col,
							    """usecols""": self.usecols,
							    """prefix""": self.prefix,
							    """mangle_dupe_cols""": self.mangle_dupe_cols,
							    """engine""": self.engine,
							    """converters""": self.converters,
							    """true_values""": self.true_values,
							    """false_values""": self.false_values,
							    """skipinitialspace""": self.skipinitialspace,
							    """skiprows""": self.skiprows,
							    """nrows""": self.nrows,
							    """na_values""": self.na_values,
							    """keep_default_na""": self.keep_default_na,
							    """na_filter""": self.na_filter,
							    """verbose""": self.verbose,
							    """skip_blank_lines""": self.skip_blank_lines,
							    """thousands""": self.thousands,
							    """decimal""": self.decimal,
							    """lineterminator""": self.lineterminator,
							    """quotechar""": self.quotechar,
							    """quoting""": self.quoting,
							    """escapechar""": self.escapechar,
							    """comment""": self.comment,
							    """encoding""": self.encoding,
							    """dialect""": self.dialect,
							    """error_bad_lines""": self.error_bad_lines,
							    """warn_bad_lines""": self.warn_bad_lines,
							    """skipfooter""": self.skipfooter,
							    """doublequote""": self.doublequote,
							    """memory_map""": self.memory_map,
							    """float_precision""": self.float_precision,
							    """chunksize""": self.chunksize,
							    """encoding_errors""": self.encoding_errors,
							    """on_bad_lines""": self.on_bad_lines,
							    """date_format""": self.date_format,
							}

							# some kwargs must not be passed if they don't have a default value
							# some others are deprecated and we can also not pass them if they are the default value
							for pd_read_csv_parameter in _PANDAS_READ_CSV_NO_DEFAULT_PARAMETERS + _PANDAS_READ_CSV_DEPRECATED_PARAMETERS:
													if pd_read_csv_kwargs[pd_read_csv_parameter] == getattr(CsvConfig()						,  __UpperCAmelCase					):
																			del pd_read_csv_kwargs[pd_read_csv_parameter]

        # Remove 2.0 new arguments
							if not (datasets.config.PANDAS_VERSION.major >= 2):
													for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_2_0_0_PARAMETERS:
																			del pd_read_csv_kwargs[pd_read_csv_parameter]

        # Remove 1.3 new arguments
							if not (datasets.config.PANDAS_VERSION.major >= 1 and datasets.config.PANDAS_VERSION.minor >= 3):
													for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_1_3_0_PARAMETERS:
																			del pd_read_csv_kwargs[pd_read_csv_parameter]

							return pd_read_csv_kwargs






class 		lowercase						(			datasets.ArrowBasedBuilder):






	"""simple docstring"""


	a__				: int		       =							CsvConfig




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[str]					)      ->			Any:
							return datasets.DatasetInfo(features=self.config.features					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Any						,  __UpperCAmelCase     :						Dict					)      ->			Optional[int]:
							if not self.config.data_files:
													raise ValueError(F"""At least one data file must be specified, but got data_files={self.config.data_files}"""					)
							UpperCAmelCase_=       dl_manager.download_and_extract(self.config.data_files					)
							if isinstance(__UpperCAmelCase						,  (str, list, tuple)					):
													UpperCAmelCase_=       data_files
													if isinstance(__UpperCAmelCase						,  __UpperCAmelCase					):
																			UpperCAmelCase_=       [files]
													UpperCAmelCase_=       [dl_manager.iter_files(__UpperCAmelCase					) for file in files]
													return [datasets.SplitGenerator(name=datasets.Split.TRAIN						,  gen_kwargs={"""files""": files}					)]
							UpperCAmelCase_=       []
							for split_name, files in data_files.items():
													if isinstance(__UpperCAmelCase						,  __UpperCAmelCase					):
																			UpperCAmelCase_=       [files]
													UpperCAmelCase_=       [dl_manager.iter_files(__UpperCAmelCase					) for file in files]
													splits.append(datasets.SplitGenerator(name=__UpperCAmelCase						,  gen_kwargs={"""files""": files}					)					)
							return splits




	def   _SCREAMING_SNAKE_CASE		(     self     :						Tuple						,  __UpperCAmelCase     :						pa.Table					)      ->			pa.Table:
							if self.config.features is not None:
													UpperCAmelCase_=       self.config.features.arrow_schema
													if all(not require_storage_cast(__UpperCAmelCase					) for feature in self.config.features.values()					):
																			# cheaper cast
																			UpperCAmelCase_=       pa.Table.from_arrays([pa_table[field.name] for field in schema]						,  schema=__UpperCAmelCase					)
													else:
																			# more expensive cast; allows str <-> int/float or str to Audio for example
																			UpperCAmelCase_=       table_cast(__UpperCAmelCase						,  __UpperCAmelCase					)
							return pa_table




	def   _SCREAMING_SNAKE_CASE		(     self     :						Any						,  __UpperCAmelCase     :						List[Any]					)      ->			List[str]:
							UpperCAmelCase_=       self.config.features.arrow_schema if self.config.features else None
							# dtype allows reading an int column as str
							UpperCAmelCase_=       (
							    {
							        name: dtype.to_pandas_dtype() if not require_storage_cast(__UpperCAmelCase					) else object
							        for name, dtype, feature in zip(schema.names						,  schema.types						,  self.config.features.values()					)
							    }
							    if schema is not None
							    else None
							)
							for file_idx, file in enumerate(itertools.chain.from_iterable(__UpperCAmelCase					)					):
													UpperCAmelCase_=       pd.read_csv(__UpperCAmelCase						,  iterator=__UpperCAmelCase						,  dtype=__UpperCAmelCase						,  **self.config.pd_read_csv_kwargs					)
													try:
																			for batch_idx, df in enumerate(__UpperCAmelCase					):
																									UpperCAmelCase_=       pa.Table.from_pandas(__UpperCAmelCase					)
																									# Uncomment for debugging (will print the Arrow table size and elements)
																									# logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
																									# logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
																									yield (file_idx, batch_idx), self._cast_table(__UpperCAmelCase					)
													except ValueError as e:
																			logger.error(F"""Failed to read file '{file}' with error {type(__UpperCAmelCase					)}: {e}"""					)
																			raise




