

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


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





@dataclass
class 					__lowerCAmelCase	(   datasets.BuilderConfig				):
  _a		     =    None
  _a		     =    "utf-8"
  _a		     =    None
  _a		     =    None
  _a		     =    True  # deprecated
  _a		     =    None  # deprecated
  _a		     =    10 << 20  # 10MB
  _a		     =    None





class 					__lowerCAmelCase	(   datasets.ArrowBasedBuilder				):
  _a		     =    JsonConfig




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




  def     A__	(							self				,  lowerCAmelCase   )    ->					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   ):
                    _lowercase      			=self.config.features.arrow_schema.field(lowerCAmelCase   ).type
                    _lowercase      			=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
              _lowercase      			=table_cast(lowerCAmelCase				,  self.config.features.arrow_schema   )
        return pa_table




  def     A__	(							self				,  lowerCAmelCase   )    ->					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:
                          _lowercase      			=json.load(lowerCAmelCase   )

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

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





import sys

lowercase_   							=  (
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)
def 	a (     A__      :  str = N	)       -> int:





      """simple docstring"""



      _lowercase      			=-sys.maxsize - 1
      for i in range(len(A__	) - 12	):
            _lowercase      			=1
            for j in range(13	):
                  product *= int(n[i + j]	)
            if product > largest_product:
                  _lowercase      			=product
      return largest_product


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


