




import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


_UpperCAmelCase				:	List[Any]    						=    datasets.utils.logging.get_logger(__name__)


@dataclass
class 		lowerCAmelCase_							(     datasets.BuilderConfig   ):
     __lowerCamelCase					:						Optional[datasets.Features]     =    None




class 		lowerCAmelCase_							(     datasets.ArrowBasedBuilder   ):
     __lowerCamelCase					:						Union[str, Any]     =    ArrowConfig





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





     def 	lowerCamelCase       (  self       ,   _UpperCAmelCase     )		->							str:
        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(_UpperCAmelCase       ,   (str, list, tuple)     ):
           lowerCamelCase											=data_files
           if isinstance(_UpperCAmelCase       ,   _UpperCAmelCase     ):
              lowerCamelCase											=[files]
           # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
           lowerCamelCase											=[dl_manager.iter_files(_UpperCAmelCase     ) 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(_UpperCAmelCase       ,   _UpperCAmelCase     ):
              lowerCamelCase											=[files]
           # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
           lowerCamelCase											=[dl_manager.iter_files(_UpperCAmelCase     ) for file in files]
           # Infer features is they are stoed in the arrow schema
           if self.info.features is None:
              for file in itertools.chain.from_iterable(_UpperCAmelCase     ):
                 with open(_UpperCAmelCase       ,   """rb"""     ) as f:
                    lowerCamelCase											=datasets.Features.from_arrow_schema(pa.ipc.open_stream(_UpperCAmelCase     ).schema     )
                 break
           splits.append(datasets.SplitGenerator(name=_UpperCAmelCase       ,   gen_kwargs={"""files""": files}     )     )
        return splits





     def 	lowerCamelCase       (  self       ,   _UpperCAmelCase     )		->							pa.Table:
        if self.info.features is not None:
           # more expensive cast to support nested features with keys in a different order
           # allows str <-> int/float or str to Audio for example
           lowerCamelCase											=table_cast(_UpperCAmelCase       ,   self.info.features.arrow_schema     )
        return pa_table





     def 	lowerCamelCase       (  self       ,   _UpperCAmelCase     )		->							Optional[Any]:
        for file_idx, file in enumerate(itertools.chain.from_iterable(_UpperCAmelCase     )     ):
           with open(_UpperCAmelCase       ,   """rb"""     ) as f:
              try:
                 for batch_idx, record_batch in enumerate(pa.ipc.open_stream(_UpperCAmelCase     )     ):
                    lowerCamelCase											=pa.Table.from_batches([record_batch]     )
                    # 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 F'''{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







import math
from decimal import Decimal, getcontext






def    UpperCAmelCase__	(						lowerCamelCase  : int = 4_00_00_00						):

   try:
      lowerCamelCase											=int(lowerCamelCase						)
   except (TypeError, ValueError):
      raise TypeError("""Parameter n must be int or castable to int."""						)
   if n <= 0:
      raise ValueError("""Parameter n must be greater than or equal to one."""						)
   lowerCamelCase											=1_00
   lowerCamelCase											=(Decimal(5						) ** Decimal(0.5						) + 1) / Decimal(2						)

   lowerCamelCase											=(math.floor(math.log(n * (phi + 2) ,lowerCamelCase						) - 1						) // 3) * 3 + 2
   lowerCamelCase											=Decimal(round(phi ** Decimal(index + 1						)						)						) / (phi + 2)
   lowerCamelCase											=num // 2
   return int(lowerCamelCase						)


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