


# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


__a	 =      get_logger(__name__)






class 	__lowercase					:
      UpperCamelCase										=							'''dummy_data'''
      UpperCamelCase										=							'''datasets'''
      UpperCamelCase										=							False





      def __init__(		self    :       Union[str, Any]       ,							__lowerCamelCase    :       str       ,							__lowerCamelCase    :       str       ,							__lowerCamelCase    :       Union[Version, str]       ,							__lowerCamelCase    :       Optional[str] = None       ,							__lowerCamelCase    :       bool = False       ,							__lowerCamelCase    :       bool = True       ,							__lowerCamelCase    :       Optional[List[Callable]] = None       ,							)     -> Tuple:






         """simple docstring"""







         UpperCAmelCase      					=  0
         UpperCAmelCase      					=  dataset_name
         UpperCAmelCase      					=  cache_dir
         UpperCAmelCase      					=  use_local_dummy_data
         UpperCAmelCase      					=  config
         # download_callbacks take a single url as input
         UpperCAmelCase      					=  download_callbacks or []
         # if False, it doesn't load existing files and it returns the paths of the dummy files relative
         # to the dummy_data zip file root
         UpperCAmelCase      					=  load_existing_dummy_data

         # TODO(PVP, QL) might need to make this more general
         UpperCAmelCase      					=  str(__lowerCamelCase							)
         # to be downloaded
         UpperCAmelCase      					=  None
         UpperCAmelCase      					=  None





      @property
      def 							_lowercase					(		self    :       Any							)     -> str:






         """simple docstring"""







         if self._dummy_file is None:
            UpperCAmelCase      					=  self.download_dummy_data()
         return self._dummy_file





      @property
      def 							_lowercase					(		self    :       Tuple							)     -> Tuple:






         """simple docstring"""







         if self.config is not None:
            # structure is dummy / config_name / version_name
            return os.path.join("""dummy"""       ,							self.config.name       ,							self.version_name							)
         # structure is dummy / version_name
         return os.path.join("""dummy"""       ,							self.version_name							)





      @property
      def 							_lowercase					(		self    :       Union[str, Any]							)     -> List[str]:






         """simple docstring"""







         return os.path.join(self.dummy_data_folder       ,							"""dummy_data.zip"""							)





      def 							_lowercase					(		self    :       int							)     -> Optional[int]:






         """simple docstring"""







         UpperCAmelCase      					=  (
             self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
         )

         UpperCAmelCase      					=  cached_path(
             __lowerCamelCase       ,							cache_dir=self.cache_dir       ,							extract_compressed_file=__lowerCamelCase       ,							force_extract=__lowerCamelCase							)

         return os.path.join(__lowerCamelCase       ,							self.dummy_file_name							)





      @property
      def 							_lowercase					(		self    :       Dict							)     -> Dict:






         """simple docstring"""







         return os.path.join(self.datasets_scripts_dir       ,							self.dataset_name       ,							self.dummy_zip_file							)





      @property
      def 							_lowercase					(		self    :       Union[str, Any]							)     -> str:






         """simple docstring"""







         if self._bucket_url is None:
            UpperCAmelCase      					=  hf_github_url(self.dataset_name       ,							self.dummy_zip_file.replace(os.sep       ,							"""/"""							)							)
         return self._bucket_url





      @property
      def 							_lowercase					(		self    :       Any							)     -> int:






         """simple docstring"""







         if os.path.isdir(self.dummy_file							):
            return self.dummy_file
         # else cut off path to file -> example `xsum`.
         return "/".join(self.dummy_file.replace(os.sep       ,							"""/"""							).split("""/"""							)[:-1]							)





      def 							_lowercase					(		self    :       Union[str, Any]       ,							__lowerCamelCase    :       List[str]       ,							*__lowerCamelCase    :       Dict							)     -> List[str]:






         """simple docstring"""







         if self.load_existing_dummy_data:
            # dummy data is downloaded and tested
            UpperCAmelCase      					=  self.dummy_file
         else:
            # dummy data cannot be downloaded and only the path to dummy file is returned
            UpperCAmelCase      					=  self.dummy_file_name

         # special case when data_url is a dict
         if isinstance(__lowerCamelCase       ,							__lowerCamelCase							):
            return self.create_dummy_data_dict(__lowerCamelCase       ,							__lowerCamelCase							)
         elif isinstance(__lowerCamelCase       ,							(list, tuple)							):
            return self.create_dummy_data_list(__lowerCamelCase       ,							__lowerCamelCase							)
         else:
            return self.create_dummy_data_single(__lowerCamelCase       ,							__lowerCamelCase							)





      def 							_lowercase					(		self    :       Dict       ,							__lowerCamelCase    :       List[str]       ,							*__lowerCamelCase    :       str							)     -> str:






         """simple docstring"""







         return self.download_and_extract(__lowerCamelCase							)





      def 							_lowercase					(		self    :       int       ,							__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Tuple							)     -> Any:






         """simple docstring"""







         return self.download_and_extract(__lowerCamelCase							)





      def 							_lowercase					(		self    :       int       ,							__lowerCamelCase    :       Tuple       ,							*__lowerCamelCase    :       Any       ,							**__lowerCamelCase    :       List[str]							)     -> int:






         """simple docstring"""







         return path





      def 							_lowercase					(		self    :       Tuple							)     -> Union[str, Any]:






         """simple docstring"""







         return {}





      def 							_lowercase					(		self    :       int       ,							__lowerCamelCase    :       List[Any]       ,							__lowerCamelCase    :       Optional[int]							)     -> int:






         """simple docstring"""







         UpperCAmelCase      					=  {}
         for key, single_urls in data_url.items():
            for download_callback in self.download_callbacks:
               if isinstance(__lowerCamelCase       ,							__lowerCamelCase							):
                  for single_url in single_urls:
                     download_callback(__lowerCamelCase							)
               else:
                  UpperCAmelCase      					=  single_urls
                  download_callback(__lowerCamelCase							)
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
            if isinstance(__lowerCamelCase       ,							__lowerCamelCase							):
               UpperCAmelCase      					=  [os.path.join(__lowerCamelCase       ,							urllib.parse.quote_plus(Path(__lowerCamelCase							).name							)							) for x in single_urls]
            else:
               UpperCAmelCase      					=  single_urls
               UpperCAmelCase      					=  os.path.join(__lowerCamelCase       ,							urllib.parse.quote_plus(Path(__lowerCamelCase							).name							)							)
            UpperCAmelCase      					=  value

         # make sure that values are unique
         if all(isinstance(__lowerCamelCase       ,							__lowerCamelCase							) for i in dummy_data_dict.values()							) and len(set(dummy_data_dict.values()							)							) < len(
             dummy_data_dict.values()							):
            # append key to value to make its name unique
            UpperCAmelCase      					=  {key: value + key for key, value in dummy_data_dict.items()}

         return dummy_data_dict





      def 							_lowercase					(		self    :       List[str]       ,							__lowerCamelCase    :       str       ,							__lowerCamelCase    :       int							)     -> int:






         """simple docstring"""







         UpperCAmelCase      					=  []
         # trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
         UpperCAmelCase      					=  all(bool(re.findall("""[0-9]{3,}-of-[0-9]{3,}"""       ,							__lowerCamelCase							)							) for url in data_url							)
         UpperCAmelCase      					=  all(
             url.startswith("""https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed"""							) for url in data_url							)
         if data_url and (is_tf_records or is_pubmed_records):
            UpperCAmelCase      					=  [data_url[0]] * len(__lowerCamelCase							)
         for single_url in data_url:
            for download_callback in self.download_callbacks:
               download_callback(__lowerCamelCase							)
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
            UpperCAmelCase      					=  os.path.join(__lowerCamelCase       ,							urllib.parse.quote_plus(single_url.split("""/"""							)[-1]							)							)
            dummy_data_list.append(__lowerCamelCase							)
         return dummy_data_list





      def 							_lowercase					(		self    :       Optional[Any]       ,							__lowerCamelCase    :       str       ,							__lowerCamelCase    :       Tuple							)     -> Optional[Any]:






         """simple docstring"""







         for download_callback in self.download_callbacks:
            download_callback(__lowerCamelCase							)
         # we force the name of each key to be the last file / folder name of the url path
         # if the url has arguments, we need to encode them with urllib.parse.quote_plus
         UpperCAmelCase      					=  os.path.join(__lowerCamelCase       ,							urllib.parse.quote_plus(data_url.split("""/"""							)[-1]							)							)
         if os.path.exists(__lowerCamelCase							) or not self.load_existing_dummy_data:
            return value
         else:
            # Backward compatibility, maybe deprecate at one point.
            # For many datasets with single url calls to dl_manager.download_and_extract,
            # the dummy_data.zip file is actually the zipped downloaded file
            # while now we expected the dummy_data.zip file to be a directory containing
            # the downloaded file.
            return path_to_dummy_data





      def 							_lowercase					(		self    :       Tuple							)     -> Dict:






         """simple docstring"""







         pass





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






         """simple docstring"""







         pass





      def 							_lowercase					(		self    :       Optional[Any]       ,							__lowerCamelCase    :       Union[str, Any]							)     -> Dict:






         """simple docstring"""







         def _iter_archive_members(__lowerCamelCase    :       int							):
            # this preserves the order of the members inside the ZIP archive
            UpperCAmelCase      					=  Path(self.dummy_file							).parent
            UpperCAmelCase      					=  path.relative_to(__lowerCamelCase							)
            with ZipFile(self.local_path_to_dummy_data							) as zip_file:
               UpperCAmelCase      					=  zip_file.namelist()
            for member in members:
               if member.startswith(relative_path.as_posix()							):
                  yield dummy_parent_path.joinpath(__lowerCamelCase							)

         UpperCAmelCase      					=  Path(__lowerCamelCase							)
         UpperCAmelCase      					=  _iter_archive_members(__lowerCamelCase							) if self.use_local_dummy_data else path.rglob("""*"""							)
         for file_path in file_paths:
            if file_path.is_file() and not file_path.name.startswith((""".""", """__""")							):
               yield file_path.relative_to(__lowerCamelCase							).as_posix(), file_path.open("""rb"""							)





      def 							_lowercase					(		self    :       str       ,							__lowerCamelCase    :       List[Any]							)     -> str:






         """simple docstring"""







         if not isinstance(__lowerCamelCase       ,							__lowerCamelCase							):
            UpperCAmelCase      					=  [paths]
         for path in paths:
            if os.path.isfile(__lowerCamelCase							):
               if os.path.basename(__lowerCamelCase							).startswith((""".""", """__""")							):
                  return
               yield path
            else:
               for dirpath, dirnames, filenames in os.walk(__lowerCamelCase							):
                  if os.path.basename(__lowerCamelCase							).startswith((""".""", """__""")							):
                     continue
                  dirnames.sort()
                  for filename in sorted(__lowerCamelCase							):
                     if filename.startswith((""".""", """__""")							):
                        continue
                     yield os.path.join(__lowerCamelCase       ,							__lowerCamelCase							)







def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->int:
   if n == 1 or not isinstance(lowerCAmelCase_	,    lowerCAmelCase_ ):
      return 0
   elif n == 2:
      return 1
   else:
      UpperCAmelCase      					=  [0, 1]
      for i in range(2	,    n + 1 ):
         sequence.append(sequence[i - 1] + sequence[i - 2] )

      return sequence[n]
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->int:
   UpperCAmelCase      					=  0
   UpperCAmelCase      					=  2

   while digits < n:
      index += 1
      UpperCAmelCase      					=  len(str(fibonacci(lowerCAmelCase_ ) ) )

   return index
def 	_UpperCamelCase					(    lowerCAmelCase_ = 1_0_0_0 )    ->int:
   return fibonacci_digits_index(lowerCAmelCase_ )


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



