





import io
import itertools
import json
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa
import pyarrow.json as paj

import datasets
from datasets.table import table_cast
from datasets.utils.file_utils import readline


a__    :		Tuple      						=     datasets.utils.logging.get_logger(__name__)






@dataclass
class  lowercase    (      datasets.BuilderConfig       ):






					"""simple docstring"""



					snake_case_						  =			None
					snake_case_						  =			"utf-8"
					snake_case_						  =			None
					snake_case_						  =			None
					snake_case_						  =			True  # deprecated
					snake_case_						  =			None  # deprecated
					snake_case_						  =			1_0 << 2_0  # 10MB
					snake_case_						  =			None






class  lowercase    (      datasets.ArrowBasedBuilder       ):






					"""simple docstring"""



					snake_case_						  =			JsonConfig





					def       _UpperCamelCase       (    self						:     int							):

						"""simple docstring"""



						if self.config.block_size is not None:
							logger.warning("""The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead"""							)
							lowerCamelCase__										=			self.config.block_size
						if self.config.use_threads is not True:
							logger.warning(
							    """The JSON loader parameter `use_threads` is deprecated and doesn\'t have any effect anymore."""							)
						if self.config.newlines_in_values is not None:
							raise ValueError("""The JSON loader parameter `newlines_in_values` is no longer supported"""							)
						return datasets.DatasetInfo(features=self.config.features							)





					def       _UpperCamelCase       (    self						:     int ,					a_						:     Dict							):

						"""simple docstring"""



						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}'''							)
						lowerCamelCase__										=			dl_manager.download_and_extract(self.config.data_files							)
						if isinstance(__lowerCAmelCase ,					(str, list, tuple)							):
							lowerCamelCase__										=			data_files
							if isinstance(__lowerCAmelCase ,					__lowerCAmelCase							):
								lowerCamelCase__										=			[files]
							lowerCamelCase__										=			[dl_manager.iter_files(__lowerCAmelCase							) for file in files]
							return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,					gen_kwargs={"""files""": files}							)]
						lowerCamelCase__										=			[]
						for split_name, files in data_files.items():
							if isinstance(__lowerCAmelCase ,					__lowerCAmelCase							):
								lowerCamelCase__										=			[files]
							lowerCamelCase__										=			[dl_manager.iter_files(__lowerCAmelCase							) for file in files]
							splits.append(datasets.SplitGenerator(name=__lowerCAmelCase ,					gen_kwargs={"""files""": files}							)							)
						return splits





					def       _UpperCamelCase       (    self						:     List[str] ,					a_						:     pa.Table							):

						"""simple docstring"""



						if self.config.features is not None:
							# adding missing columns
							for column_name in set(self.config.features							) - set(pa_table.column_names							):
								lowerCamelCase__										=			self.config.features.arrow_schema.field(__lowerCAmelCase							).type
								lowerCamelCase__										=			pa_table.append_column(__lowerCAmelCase ,					pa.array([None] * len(__lowerCAmelCase							) ,					type=__lowerCAmelCase							)							)
							# more expensive cast to support nested structures with keys in a different order
							# allows str <-> int/float or str to Audio for example
							lowerCamelCase__										=			table_cast(__lowerCAmelCase ,					self.config.features.arrow_schema							)
						return pa_table





					def       _UpperCamelCase       (    self						:     Tuple ,					a_						:     Any							):

						"""simple docstring"""



						for file_idx, file in enumerate(itertools.chain.from_iterable(__lowerCAmelCase							)							):
							# If the file is one json object and if we need to look at the list of items in one specific field
							if self.config.field is not None:
								with open(__lowerCAmelCase ,					encoding=self.config.encoding ,					errors=self.config.encoding_errors							) as f:
									lowerCamelCase__										=			json.load(__lowerCAmelCase							)

								# We keep only the field we are interested in
								lowerCamelCase__										=			dataset[self.config.field]

								# We accept two format: a list of dicts or a dict of lists
								if isinstance(__lowerCAmelCase ,					(list, tuple)							):
									lowerCamelCase__										=			set().union(*[row.keys() for row in dataset]							)
									lowerCamelCase__										=			{col: [row.get(__lowerCAmelCase							) for row in dataset] for col in keys}
								else:
									lowerCamelCase__										=			dataset
								lowerCamelCase__										=			pa.Table.from_pydict(__lowerCAmelCase							)
								yield file_idx, self._cast_table(__lowerCAmelCase							)

							# If the file has one json object per line
							else:
								with open(__lowerCAmelCase ,					"""rb"""							) as f:
									lowerCamelCase__										=			0
									# Use block_size equal to the chunk size divided by 32 to leverage multithreading
									# Set a default minimum value of 16kB if the chunk size is really small
									lowerCamelCase__										=			max(self.config.chunksize // 32 ,					16 << 10							)
									lowerCamelCase__										=			(
									    self.config.encoding_errors if self.config.encoding_errors is not None else """strict"""
									)
									while True:
										lowerCamelCase__										=			f.read(self.config.chunksize							)
										if not batch:
											break
										# Finish current line
										try:
											batch += f.readline()
										except (AttributeError, io.UnsupportedOperation):
											batch += readline(__lowerCAmelCase							)
										# PyArrow only accepts utf-8 encoded bytes
										if self.config.encoding != "utf-8":
											lowerCamelCase__										=			batch.decode(self.config.encoding ,					errors=__lowerCAmelCase							).encode("""utf-8"""							)
										try:
											while True:
												try:
													lowerCamelCase__										=			paj.read_json(
													    io.BytesIO(__lowerCAmelCase							) ,					read_options=paj.ReadOptions(block_size=__lowerCAmelCase							)							)
													break
												except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
													if (
													    isinstance(__lowerCAmelCase ,					pa.ArrowInvalid							)
													    and "straddling" not in str(__lowerCAmelCase							)
													    or block_size > len(__lowerCAmelCase							)
													):
														raise
													else:
														# Increase the block size in case it was too small.
														# The block size will be reset for the next file.
														logger.debug(
														    F'''Batch of {len(__lowerCAmelCase							)} bytes couldn\'t be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}.'''							)
														block_size *= 2
										except pa.ArrowInvalid as e:
											try:
												with open(
												    __lowerCAmelCase ,					encoding=self.config.encoding ,					errors=self.config.encoding_errors							) as f:
													lowerCamelCase__										=			json.load(__lowerCAmelCase							)
											except json.JSONDecodeError:
												logger.error(F'''Failed to read file \'{file}\' with error {type(__lowerCAmelCase							)}: {e}'''							)
												raise e
											# If possible, parse the file as a list of json objects and exit the loop
											if isinstance(__lowerCAmelCase ,					__lowerCAmelCase							):  # list is the only sequence type supported in JSON
												try:
													lowerCamelCase__										=			set().union(*[row.keys() for row in dataset]							)
													lowerCamelCase__										=			{col: [row.get(__lowerCAmelCase							) for row in dataset] for col in keys}
													lowerCamelCase__										=			pa.Table.from_pydict(__lowerCAmelCase							)
												except (pa.ArrowInvalid, AttributeError) as e:
													logger.error(F'''Failed to read file \'{file}\' with error {type(__lowerCAmelCase							)}: {e}'''							)
													raise ValueError(F'''Not able to read records in the JSON file at {file}.'''							) from None
												yield file_idx, self._cast_table(__lowerCAmelCase							)
												break
											else:
												logger.error(F'''Failed to read file \'{file}\' with error {type(__lowerCAmelCase							)}: {e}'''							)
												raise ValueError(
												    F'''Not able to read records in the JSON file at {file}. '''
												    F'''You should probably indicate the field of the JSON file containing your records. '''
												    F'''This JSON file contain the following fields: {str(list(dataset.keys()							)							)}. '''
												    F'''Select the correct one and provide it as `field=\'XXX\'` to the dataset loading method. '''							) from None
                        # 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(__lowerCAmelCase							)
										batch_idx += 1






'''simple docstring'''


from math import isqrt, loga
def 						lowerCamelCase__   (				a							):
						__snake_case						 =   [True] * max_number
						for i in range(2    ,	isqrt(max_number - 1							) + 1							):
												if is_prime[i]:
																		for j in range(i**2    ,	a    ,	a							):
																								__snake_case						 =   False

						return [i for i in range(2    ,	a							) if is_prime[i]]
def 						lowerCamelCase__   (				a = 800800    ,	a = 800800							):
						__snake_case						 =   degree * loga(a							)
						__snake_case						 =   int(a							)
						__snake_case						 =   calculate_prime_numbers(a							)

						__snake_case						 =   0
						__snake_case						 =   0
						__snake_case						 =   len(a							) - 1
						while left < right:
												while (
												    prime_numbers[right] * loga(prime_numbers[left]							)
												    + prime_numbers[left] * loga(prime_numbers[right]							)
												    > upper_bound
												):
																		right -= 1
												hybrid_integers_count += right - left
												left += 1

						return hybrid_integers_count


if __name__ == "__main__":
	print(f'''{solution() = }''')

