






"""simple docstring"""



import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand




def      _lowerCAmelCase		(							UpperCAmelCase__       :					Tuple      )		->Optional[Any]:
						return EnvironmentCommand()




def      _lowerCAmelCase		(							UpperCAmelCase__       :					List[str]      )		->int:
						return EnvironmentCommand(args.accelerate_config_file      )






class 							__SCREAMING_SNAKE_CASE						(				__UpperCAmelCase		):


		@staticmethod
		def 						_UpperCamelCase       (			snake_case      :						Dict							):
								'''simple docstring'''





								A__						:  str		  =  parser.add_parser("""env"""							)
								download_parser.set_defaults(func=snake_case							)
								download_parser.add_argument(
								    """--accelerate-config_file"""			,    default=snake_case			,    help="""The accelerate config file to use for the default values in the launching script."""			,    )
								download_parser.set_defaults(func=snake_case							)


		def __init__(			self      :						Union[str, Any]			,    snake_case      :						Union[str, Any]			,    *snake_case      :						Optional[Any]							):
								'''simple docstring'''





								A__						:  str		  =  accelerate_config_file


		def 						_UpperCamelCase       (			self      :						Optional[Any]							):
								'''simple docstring'''





								A__						:  Union[str, Any]		  =  """not installed"""
								if is_safetensors_available():
														import safetensors

														A__						:  str		  =  safetensors.__version__
								elif importlib.util.find_spec("""safetensors"""							) is not None:
														import safetensors

														A__						:  Dict		  =  F'{safetensors.__version__} but is ignored because of PyTorch version too old.'

								A__						:  Any		  =  """not installed"""
								A__						:  List[str]		  =  """not found"""
								if is_accelerate_available():
														import accelerate
														from accelerate.commands.config import default_config_file, load_config_from_file

														A__						:  List[Any]		  =  accelerate.__version__
														# Get the default from the config file.
														if self._accelerate_config_file is not None or os.path.isfile(snake_case							):
																				A__						:  List[Any]		  =  load_config_from_file(self._accelerate_config_file							).to_dict()

														A__						:  Union[str, Any]		  =  (
														    """\n""".join([F'\t- {prop}: {val}' for prop, val in accelerate_config.items()]							)
														    if isinstance(snake_case			,    snake_case							)
														    else F'\t{accelerate_config}'
														)

								A__						:  List[str]		  =  """not installed"""
								A__						:  Tuple		  =  """NA"""
								if is_torch_available():
														import torch

														A__						:  int		  =  torch.__version__
														A__						:  Tuple		  =  torch.cuda.is_available()

								A__						:  str		  =  """not installed"""
								A__						:  List[str]		  =  """NA"""
								if is_tf_available():
														import tensorflow as tf

														A__						:  Union[str, Any]		  =  tf.__version__
														try:
																				# deprecated in v2.1
																				A__						:  Optional[int]		  =  tf.test.is_gpu_available()
														except AttributeError:
																				# returns list of devices, convert to bool
																				A__						:  Any		  =  bool(tf.config.list_physical_devices("""GPU"""							)							)

								A__						:  Union[str, Any]		  =  """not installed"""
								A__						:  Optional[Any]		  =  """not installed"""
								A__						:  str		  =  """not installed"""
								A__						:  Dict		  =  """NA"""
								if is_flax_available():
														import flax
														import jax
														import jaxlib

														A__						:  List[str]		  =  flax.__version__
														A__						:  str		  =  jax.__version__
														A__						:  List[Any]		  =  jaxlib.__version__
														A__						:  List[Any]		  =  jax.lib.xla_bridge.get_backend().platform

								A__						:  Any		  =  {
								    """`transformers` version""": version,
								    """Platform""": platform.platform(),
								    """Python version""": platform.python_version(),
								    """Huggingface_hub version""": huggingface_hub.__version__,
								    """Safetensors version""": F'{safetensors_version}',
								    """Accelerate version""": F'{accelerate_version}',
								    """Accelerate config""": F'{accelerate_config_str}',
								    """PyTorch version (GPU?)""": F'{pt_version} ({pt_cuda_available})',
								    """Tensorflow version (GPU?)""": F'{tf_version} ({tf_cuda_available})',
								    """Flax version (CPU?/GPU?/TPU?)""": F'{flax_version} ({jax_backend})',
								    """Jax version""": F'{jax_version}',
								    """JaxLib version""": F'{jaxlib_version}',
								    """Using GPU in script?""": """<fill in>""",
								    """Using distributed or parallel set-up in script?""": """<fill in>""",
								}

								print("""\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n"""							)
								print(self.format_dict(snake_case							)							)

								return info


		@staticmethod
		def 						_UpperCamelCase       (			snake_case      :						Any							):
								'''simple docstring'''





								return "\n".join([F'- {prop}: {val}' for prop, val in d.items()]							) + "\n"














"""simple docstring"""



def      _lowerCAmelCase		(							UpperCAmelCase__       :					int = 1_0_0_0      )		->int:
						A__						:  Optional[int]		  =  2**power
						A__						:  Dict		  =  0
						while n:
												A__  ,  A__						:  Tuple		  =  r + n % 1_0, n // 1_0
						return r


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






