






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


UpperCAmelCase_ :						str      =      datasets.utils.logging.get_logger(__name__)

@dataclass
class     _SCREAMING_SNAKE_CASE       (			datasets.BuilderConfig      ):
	snake_case__							:     Optional[datasets.Features]     	=  None
	snake_case__							:     str     	=  "utf-8"
	snake_case__							:     Optional[str]     	=  None
	snake_case__							:     Optional[str]     	=  None
	snake_case__							:     bool     	=  True  # deprecated
	snake_case__							:     Optional[int]     	=  None  # deprecated
	snake_case__							:     int     	=  1_0 << 2_0  # 10MB
	snake_case__							:     Optional[bool]     	=  None

class     _SCREAMING_SNAKE_CASE       (			datasets.ArrowBasedBuilder      ):
	snake_case__							:     int     	=  JsonConfig





	def 						_A (		self				:					List[Any]	):
		if self.config.block_size is not None:
			logger.warning("""The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead"""	)
			UpperCamelCase     :Union[str, Any]          =	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 						_A (		self				:					int ,  __lowerCamelCase				:					Tuple	):
		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     :List[Any]          =	dl_manager.download_and_extract(self.config.data_files	)
		if isinstance(__lowerCamelCase ,  (str, list, tuple)	):
			UpperCamelCase     :Optional[int]          =	data_files
			if isinstance(__lowerCamelCase ,  __lowerCamelCase	):
				UpperCamelCase     :Optional[int]          =	[files]
			UpperCamelCase     :Optional[Any]          =	[dl_manager.iter_files(__lowerCamelCase	) for file in files]
			return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,  gen_kwargs={"""files""": files}	)]
		UpperCamelCase     :Tuple          =	[]
		for split_name, files in data_files.items():
			if isinstance(__lowerCamelCase ,  __lowerCamelCase	):
				UpperCamelCase     :Dict          =	[files]
			UpperCamelCase     :List[Any]          =	[dl_manager.iter_files(__lowerCamelCase	) for file in files]
			splits.append(datasets.SplitGenerator(name=__lowerCamelCase ,  gen_kwargs={"""files""": files}	)	)
		return splits





	def 						_A (		self				:					List[str] ,  __lowerCamelCase				:					pa.Table	):
		if self.config.features is not None:
			# adding missing columns
			for column_name in set(self.config.features	) - set(pa_table.column_names	):
				UpperCamelCase     :List[str]          =	self.config.features.arrow_schema.field(__lowerCamelCase	).type
				UpperCamelCase     :Union[str, Any]          =	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
			UpperCamelCase     :Any          =	table_cast(__lowerCamelCase ,  self.config.features.arrow_schema	)
		return pa_table





	def 						_A (		self				:					Tuple ,  __lowerCamelCase				:					int	):
		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:
					UpperCamelCase     :Dict          =	json.load(__lowerCamelCase	)

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

				# We accept two format: a list of dicts or a dict of lists
				if isinstance(__lowerCamelCase ,  (list, tuple)	):
					UpperCamelCase     :Optional[int]          =	set().union(*[row.keys() for row in dataset]	)
					UpperCamelCase     :Any          =	{col: [row.get(__lowerCamelCase	) for row in dataset] for col in keys}
				else:
					UpperCamelCase     :Optional[int]          =	dataset
				UpperCamelCase     :Optional[Any]          =	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:
					UpperCamelCase     :List[str]          =	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
					UpperCamelCase     :str          =	max(self.config.chunksize // 32 ,  16 << 10	)
					UpperCamelCase     :Optional[int]          =	(
					    self.config.encoding_errors if self.config.encoding_errors is not None else """strict"""
					)
					while True:
						UpperCamelCase     :int          =	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":
							UpperCamelCase     :List[str]          =	batch.decode(self.config.encoding ,  errors=__lowerCamelCase	).encode("""utf-8"""	)
						try:
							while True:
								try:
									UpperCamelCase     :int          =	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:
									UpperCamelCase     :Optional[Any]          =	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:
									UpperCamelCase     :Tuple          =	set().union(*[row.keys() for row in dataset]	)
									UpperCamelCase     :Dict          =	{col: [row.get(__lowerCamelCase	) for row in dataset] for col in keys}
									UpperCamelCase     :Any          =	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"""



def   __lowerCAmelCase						(						)	->						Union[str, Any]:


    """simple docstring"""





    snake_case    :      Dict      					=    []
    snake_case    :      List[Any]      					=    1

    while len(lowercase ) < 1e6:
        constant.append(str(lowercase ) )
        i += 1

    snake_case    :      Tuple      					=    "".join(lowercase )

    return (
        int(constant[0] )
        * int(constant[9] )
        * int(constant[99] )
        * int(constant[999] )
        * int(constant[9999] )
        * int(constant[9_9999] )
        * int(constant[99_9999] )
    )


if __name__ == "__main__":
  print(solution())





