





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


_lowerCAmelCase				:   Dict						       =						datasets.utils.logging.get_logger(__name__)


@dataclass
class        __magic_name__	(				datasets.BuilderConfig				):





     """simple docstring"""



     __UpperCamelCase            =  None
     __UpperCamelCase            =  "utf-8"
     __UpperCamelCase            =  None
     __UpperCamelCase            =  None
     __UpperCamelCase            =  True  # deprecated
     __UpperCamelCase            =  None  # deprecated
     __UpperCamelCase            =  10 << 20  # 10MB
     __UpperCamelCase            =  None




class        __magic_name__	(				datasets.ArrowBasedBuilder				):





     """simple docstring"""



     __UpperCamelCase            =  JsonConfig



     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        if self.config.block_size is not None:
           logger.warning("The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead"	)
           A_       :					Dict        =      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     SCREAMING_SNAKE_CASE		(				self							:int      ,   snake_case							:Tuple	):





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



     def     SCREAMING_SNAKE_CASE		(				self							:Tuple      ,   snake_case							: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	):
              A_       :					Union[str, Any]        =      self.config.features.arrow_schema.field(snake_case	).type
              A_       :					List[str]        =      pa_table.append_column(snake_case      ,   pa.array([None] * len(snake_case	)      ,   type=snake_case	)	)
           # more expensive cast to support nested structures with keys in a different order
           # allows str <-> int/float or str to Audio for example
           A_       :					Tuple        =      table_cast(snake_case      ,   self.config.features.arrow_schema	)
        return pa_table





     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]      ,   snake_case							:int	):





        '''simple docstring'''




        for file_idx, file in enumerate(itertools.chain.from_iterable(snake_case	)	):
           # 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(snake_case      ,   encoding=self.config.encoding      ,   errors=self.config.encoding_errors	) as f:
                 A_       :					Dict        =      json.load(snake_case	)

              # We keep only the field we are interested in
              A_       :					Optional[int]        =      dataset[self.config.field]

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

           # If the file has one json object per line
           else:
              with open(snake_case      ,   "rb"	) as f:
                 A_       :					Optional[int]        =      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
                 A_       :					List[str]        =      max(self.config.chunksize // 32      ,   16 << 10	)
                 A_       :					List[str]        =      (
                     self.config.encoding_errors if self.config.encoding_errors is not None else "strict"
                 )
                 while True:
                    A_       :					Optional[int]        =      f.read(self.config.chunksize	)
                    if not batch:
                       break
                    # Finish current line
                    try:
                       batch += f.readline()
                    except (AttributeError, io.UnsupportedOperation):
                       batch += readline(snake_case	)
                    # PyArrow only accepts utf-8 encoded bytes
                    if self.config.encoding != "utf-8":
                       A_       :					Optional[Any]        =      batch.decode(self.config.encoding      ,   errors=snake_case	).encode("utf-8"	)
                    try:
                       while True:
                          try:
                             A_       :					Union[str, Any]        =      paj.read_json(
                                 io.BytesIO(snake_case	)      ,   read_options=paj.ReadOptions(block_size=snake_case	)	)
                             break
                          except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
                             if (
                                 isinstance(snake_case      ,   pa.ArrowInvalid	)
                                 and "straddling" not in str(snake_case	)
                                 or block_size > len(snake_case	)
                             ):
                                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(snake_case	)} 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(
                              snake_case      ,   encoding=self.config.encoding      ,   errors=self.config.encoding_errors	) as f:
                             A_       :					Dict        =      json.load(snake_case	)
                       except json.JSONDecodeError:
                          logger.error(f"Failed to read file '{file}' with error {type(snake_case	)}: {e}"	)
                          raise e
                       # If possible, parse the file as a list of json objects and exit the loop
                       if isinstance(snake_case      ,   snake_case	):  # list is the only sequence type supported in JSON
                          try:
                             A_       :					Optional[Any]        =      set().union(*[row.keys() for row in dataset]	)
                             A_       :					str        =      {col: [row.get(snake_case	) for row in dataset] for col in keys}
                             A_       :					Union[str, Any]        =      pa.Table.from_pydict(snake_case	)
                          except (pa.ArrowInvalid, AttributeError) as e:
                             logger.error(f"Failed to read file '{file}' with error {type(snake_case	)}: {e}"	)
                             raise ValueError(f"Not able to read records in the JSON file at {file}."	) from None
                          yield file_idx, self._cast_table(snake_case	)
                          break
                       else:
                          logger.error(f"Failed to read file '{file}' with error {type(snake_case	)}: {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(snake_case	)
                    batch_idx += 1







from math import sqrt

def   __snake_case    (       _lowerCAmelCase			:			int						)			->    bool:

   if 1 < number < 4:
      # 2 and 3 are primes
      return True
   elif number < 2 or number % 2 == 0 or number % 3 == 0:
      # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
      return False

   # All primes number are in format of 6k +/- 1
   for i in range(5					,					int(sqrt(_lowerCAmelCase						) + 1						)					,					6						):
      if number % i == 0 or number % (i + 2) == 0:
         return False
   return True

def   __snake_case    (       _lowerCAmelCase			:			int = 10001						)			->    int:
   A_       :					Any        =      0
   A_       :					Tuple        =      1
   while count != nth and number < 3:
      number += 1
      if is_prime(_lowerCAmelCase						):
         count += 1
   while count != nth:
      number += 2
      if is_prime(_lowerCAmelCase						):
         count += 1
   return number


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