



"""simple docstring"""






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__        =				datasets.utils.logging.get_logger(__name__)






@dataclass
class        __snake_case       (	datasets.BuilderConfig):
  snake_case__				:   List[Any]  			=						None
  snake_case__				:   Dict  			=						"utf-8"
  snake_case__				:   Union[str, Any]  			=						None
  snake_case__				:   str  			=						None
  snake_case__				:   int  			=						True  # deprecated
  snake_case__				:   Optional[Any]  			=						None  # deprecated
  snake_case__				:   Optional[Any]  			=						1_0 << 2_0  # 10MB
  snake_case__				:   str  			=						None






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




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




  def 						SCREAMING_SNAKE_CASE				( self     :						str						,					__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		):
                       _lowerCamelCase						:				List[str]    			= self.config.features.arrow_schema.field(__lowerCAmelCase		).type
                       _lowerCamelCase						:				List[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
                _lowerCamelCase						:				Union[str, Any]    			= table_cast(__lowerCAmelCase						,					self.config.features.arrow_schema		)
         return pa_table




  def 						SCREAMING_SNAKE_CASE				( self     :						List[str]						,					__lowerCAmelCase     :						List[str]		):






         """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						:				int    			= json.load(__lowerCAmelCase		)

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

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



def    a__       (						__UpperCamelCase ):
      if n == 1 or not isinstance(__UpperCamelCase   ,					__UpperCamelCase ):
            return 0
      elif n == 2:
            return 1
      else:
            SCREAMING_SNAKE_CASE_      =     [0, 1]
            for i in range(2   ,					n + 1 ):
                  sequence.append(sequence[i - 1] + sequence[i - 2] )

            return sequence[n]


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     2

      while digits < n:
            index += 1
            SCREAMING_SNAKE_CASE_      =     len(str(fibonacci(__UpperCamelCase ) ) )

      return index


def    a__       (						__UpperCamelCase = 1_0_0_0 ):
      return fibonacci_digits_index(__UpperCamelCase )


if __name__ == "__main__":
      print(solution(int(str(input()).strip())))


