






import json
import logging
import os
import socket

import git
import numpy as np
import torch


logging.basicConfig(
    format="""%(asctime)s - %(levelname)s - %(name)s - PID: %(process)d -  %(message)s""",
    datefmt="""%m/%d/%Y %H:%M:%S""",
    level=logging.INFO,
)
snake_case__      :	str       	=      logging.getLogger(__name__)






def     _snake_case    (__lowercase):
   UpperCamelCase_									=     git.Repo(search_parent_directories=__lowercase)
   UpperCamelCase_									=     {
       'repo_id': str(__lowercase),
       'repo_sha': str(repo.head.object.hexsha),
       'repo_branch': str(repo.active_branch),
   }

   with open(os.path.join(__lowercase    ,      'git_log.json')    ,      'w') as f:
      json.dump(__lowercase    ,      __lowercase    ,      indent=4)






def     _snake_case    (__lowercase):
   if params.n_gpu <= 0:
      UpperCamelCase_									=     0
      UpperCamelCase_									=     -1
      UpperCamelCase_									=     True
      UpperCamelCase_									=     False
      return

   assert torch.cuda.is_available()

   logger.info('Initializing GPUs')
   if params.n_gpu > 1:
      assert params.local_rank != -1

      UpperCamelCase_									=     int(os.environ['WORLD_SIZE'])
      UpperCamelCase_									=     int(os.environ['N_GPU_NODE'])
      UpperCamelCase_									=     int(os.environ['RANK'])

      # number of nodes / node ID
      UpperCamelCase_									=     params.world_size // params.n_gpu_per_node
      UpperCamelCase_									=     params.global_rank // params.n_gpu_per_node
      UpperCamelCase_									=     True

      assert params.n_nodes == int(os.environ['N_NODES'])
      assert params.node_id == int(os.environ['NODE_RANK'])

   # local job (single GPU)
   else:
      assert params.local_rank == -1

      UpperCamelCase_									=     1
      UpperCamelCase_									=     0
      UpperCamelCase_									=     0
      UpperCamelCase_									=     0
      UpperCamelCase_									=     1
      UpperCamelCase_									=     1
      UpperCamelCase_									=     False

   # sanity checks
   assert params.n_nodes >= 1
   assert 0 <= params.node_id < params.n_nodes
   assert 0 <= params.local_rank <= params.global_rank < params.world_size
   assert params.world_size == params.n_nodes * params.n_gpu_per_node

   # define whether this is the master process / if we are in multi-node distributed mode
   UpperCamelCase_									=     params.node_id == 0 and params.local_rank == 0
   UpperCamelCase_									=     params.n_nodes > 1

   # summary
   UpperCamelCase_									=     f"""--- Global rank: {params.global_rank} - """
   logger.info(PREFIX + 'Number of nodes: %i' % params.n_nodes)
   logger.info(PREFIX + 'Node ID        : %i' % params.node_id)
   logger.info(PREFIX + 'Local rank     : %i' % params.local_rank)
   logger.info(PREFIX + 'World size     : %i' % params.world_size)
   logger.info(PREFIX + 'GPUs per node  : %i' % params.n_gpu_per_node)
   logger.info(PREFIX + 'Master         : %s' % str(params.is_master))
   logger.info(PREFIX + 'Multi-node     : %s' % str(params.multi_node))
   logger.info(PREFIX + 'Multi-GPU      : %s' % str(params.multi_gpu))
   logger.info(PREFIX + 'Hostname       : %s' % socket.gethostname())

   # set GPU device
   torch.cuda.set_device(params.local_rank)

   # initialize multi-GPU
   if params.multi_gpu:
      logger.info('Initializing PyTorch distributed')
      torch.distributed.init_process_group(
          init_method='env://'    ,      backend='nccl'    ,      )






def     _snake_case    (__lowercase):
   np.random.seed(args.seed)
   torch.manual_seed(args.seed)
   if args.n_gpu > 0:
      torch.cuda.manual_seed_all(args.seed)













def     _snake_case    (__lowercase = 1000):
   UpperCamelCase_		,      UpperCamelCase_									=     1, 1
   UpperCamelCase_									=     2
   while True:
      UpperCamelCase_									=     0
      UpperCamelCase_									=     fa + fa
      UpperCamelCase_		,      UpperCamelCase_									=     fa, f
      index += 1
      for _ in str(__lowercase):
         i += 1
      if i == n:
         break
   return index


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





