





'''simple docstring'''


# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os
import subprocess

from packaging.version import Version, parse

from accelerate.commands.config.config_args import default_config_file, load_config_from_file


lowerCAmelCase					:     Optional[Any]												='''Run commands across TPU VMs for initial setup before running `accelerate launch`.'''
def 							UpperCAmelCase_  (						__lowerCamelCase					:					Union[str, Any]=None ):
   if subparsers is not None:
      lowercase_			:Optional[int]    			= subparsers.add_parser("tpu-config"	,description=_description )
   else:
      lowercase_			:Optional[int]    			= argparse.ArgumentParser("Accelerate tpu-config command"	,description=_description )
   # Core arguments
   lowercase_			:List[str]    			= parser.add_argument_group(
       "Config Arguments"	,"Arguments that can be configured through `accelerate config`." )
   config_args.add_argument(
       "--config_file"	,type=__lowerCamelCase	,default=__lowerCamelCase	,help="Path to the config file to use for accelerate."	,)
   config_args.add_argument(
       "--tpu_name"	,default=__lowerCamelCase	,help="The name of the TPU to use. If not specified, will use the TPU specified in the config file."	,)
   config_args.add_argument(
       "--tpu_zone"	,default=__lowerCamelCase	,help="The zone of the TPU to use. If not specified, will use the zone specified in the config file."	,)
   lowercase_			:Optional[int]    			= parser.add_argument_group("TPU Arguments"	,"Arguments for options ran inside the TPU." )
   pod_args.add_argument(
       "--use_alpha"	,action="store_true"	,help="Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`."	,)
   pod_args.add_argument(
       "--command_file"	,default=__lowerCamelCase	,help="The path to the file containing the commands to run on the pod on startup."	,)
   pod_args.add_argument(
       "--command"	,action="append"	,nargs="+"	,help="A command to run on the pod. Can be passed multiple times."	,)
   pod_args.add_argument(
       "--install_accelerate"	,action="store_true"	,help="Whether to install accelerate on the pod. Defaults to False."	,)
   pod_args.add_argument(
       "--accelerate_version"	,default="latest"	,help="The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify 'dev' to install from GitHub."	,)
   pod_args.add_argument(
       "--debug"	,action="store_true"	,help="If set, will print the command that would be run instead of running it." )

   if subparsers is not None:
      parser.set_defaults(func=__lowerCamelCase )
   return parser
def 							UpperCAmelCase_  (						__lowerCamelCase					:					Any ):
   lowercase_			:int    			= None

   # Get the default from the config file if it exists.
   if args.config_file is not None or os.path.isfile(__lowerCamelCase ):
      lowercase_			:List[str]    			= load_config_from_file(args.config_file )
      if not args.command_file and defaults.command_file is not None and not args.command:
         lowercase_			:str    			= defaults.command_file
      if not args.command and defaults.commands is not None:
         lowercase_			:Optional[Any]    			= defaults.commands
      if not args.tpu_name:
         lowercase_			:Dict    			= defaults.tpu_name
      if not args.tpu_zone:
         lowercase_			:Any    			= defaults.tpu_zone
   if args.accelerate_version == "dev":
      lowercase_			:int    			= "git+https://github.com/huggingface/accelerate.git"
   elif args.accelerate_version == "latest":
      lowercase_			:Optional[Any]    			= "accelerate -U"
   elif isinstance(parse(args.accelerate_version )	,__lowerCamelCase ):
      lowercase_			:Dict    			= F'accelerate=={args.accelerate_version}'

   if not args.command_file and not args.command:
      raise ValueError("You must specify either a command file or a command to run on the pod." )

   if args.command_file:
      with open(args.command_file	,"r" ) as f:
         lowercase_			:List[str]    			= [f.read().splitlines()]

    # To turn list of lists into list of strings
   if isinstance(args.command[0]	,__lowerCamelCase ):
      lowercase_			:str    			= [line for cmd in args.command for line in cmd]
   # Default to the shared folder and install accelerate
   lowercase_			:Union[str, Any]    			= ["cd /usr/share"]
   if args.install_accelerate:
      new_cmd += [F'pip install {args.accelerate_version}']
   new_cmd += args.command
   lowercase_			:List[str]    			= "; ".join(__lowerCamelCase )

   # Then send it to gcloud
   # Eventually try to use google-api-core to do this instead of subprocess
   lowercase_			:str    			= ["gcloud"]
   if args.use_alpha:
      cmd += ["alpha"]
   cmd += [
       "compute",
       "tpus",
       "tpu-vm",
       "ssh",
       args.tpu_name,
       "--zone",
       args.tpu_zone,
       "--command",
       args.command,
       "--worker",
       "all",
   ]
   if args.debug:
      print(F'Running {" ".join(__lowerCamelCase )}' )
      return
   subprocess.run(__lowerCamelCase )
   print("Successfully setup pod." )


def 							UpperCAmelCase_  (						):
   lowercase_			:Tuple    			= tpu_command_parser()
   lowercase_			:List[Any]    			= parser.parse_args()

   tpu_command_launcher(__lowerCamelCase )









'''simple docstring'''


def 							UpperCAmelCase_  (						__lowerCamelCase					:					int = 10_00 ):
   lowercase_			,							lowercase_			:str    			= 1, 1
   lowercase_			:Any    			= 2
   while True:
      lowercase_			:str    			= 0
      lowercase_			:Tuple    			= fa + fa
      lowercase_			,							lowercase_			:Tuple    			= fa, f
      index += 1
      for _ in str(__lowerCamelCase ):
         i += 1
      if i == n:
         break
   return index


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


