


import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
							import torch_xla.core.xla_model as xm  # noqa: F401

							__magic_name__       					=      True
except ImportError:
							__magic_name__       					=      False


# Cache this result has it's a C FFI call which can be pretty time-consuming
__magic_name__       					=      torch.distributed.is_available()







def     __magic_name__  (      lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_			:							Any      =       importlib.util.find_spec(lowerCAmelCase_) is not None
	if package_exists:
		try:
			lowerCamelCase_			:							List[Any]      =       importlib.metadata.metadata(lowerCAmelCase_)
			return True
		except importlib.metadata.PackageNotFoundError:
			return False







def     __magic_name__  (      ):
	'''simple docstring'''


	return _torch_distributed_available







def     __magic_name__  (      ):
	'''simple docstring'''


	try:
		pass
	except ImportError:
		print(
		    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
		    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
		    " Bindings for PyTorch*.")
	return (
	    importlib.util.find_spec("torch_ccl") is not None
	    or importlib.util.find_spec("oneccl_bindings_for_pytorch") is not None
	)







def     __magic_name__  (      ):
	'''simple docstring'''


	return importlib.metadata.version("oneccl_bind_pt")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("transformer_engine")







@lru_cache
def     __magic_name__  (      lowerCAmelCase_=True):
	'''simple docstring'''


	if torch.cuda.is_available():
		return False
	if _tpu_available and check_device:
		try:
			# Will raise a RuntimeError if no XLA configuration is found
			lowerCamelCase_			:							Union[str, Any]      =       xm.xla_device()
			return True
		except RuntimeError:
			return False
	return _tpu_available







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("deepspeed")







def     __magic_name__  (      lowerCAmelCase_=False):
	'''simple docstring'''


	if is_tpu_available():
		return not ignore_tpu
	if torch.cuda.is_available():
		return torch.cuda.is_bfaa_supported()
	if is_npu_available():
		return False
	return True







def     __magic_name__  (      ):
	'''simple docstring'''


	lowerCamelCase_			:							List[str]      =       _is_package_available("bitsandbytes")
	if package_exists:
		lowerCamelCase_			:							Dict      =       version.parse(importlib.metadata.version("bitsandbytes"))
		return compare_versions(lowerCAmelCase_      ,					">="      ,					"0.39.0")
	return False







def     __magic_name__  (      ):
	'''simple docstring'''


	lowerCamelCase_			:							List[Any]      =       _is_package_available("bitsandbytes")
	if package_exists:
		lowerCamelCase_			:							List[Any]      =       version.parse(importlib.metadata.version("bitsandbytes"))
		return compare_versions(lowerCAmelCase_      ,					">="      ,					"0.37.2")
	return False







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("bitsandbytes")







def     __magic_name__  (      ):
	'''simple docstring'''


	if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"      ,					"False")) == 1:
		lowerCamelCase_			:							Union[str, Any]      =       importlib.util.find_spec("megatron") is not None
		if package_exists:
			try:
				lowerCamelCase_			:							Any      =       parse(importlib.metadata.version("megatron-lm"))
				return compare_versions(lowerCAmelCase_      ,					">="      ,					"2.2.0")
			except Exception as e:
				warnings.warn(F"""Parse Megatron version failed. Exception:{e}""")
				return False







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("safetensors")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("transformers")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("datasets")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("aim")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("tensorboard") or _is_package_available("tensorboardX")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("wandb")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("comet_ml")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("boto3")







def     __magic_name__  (      ):
	'''simple docstring'''


	if _is_package_available("rich"):
		if "ACCELERATE_DISABLE_RICH" in os.environ:
			warnings.warn(
			    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`.")
			return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"      ,					lowerCAmelCase_)
		return parse_flag_from_env("ACCELERATE_ENABLE_RICH"      ,					lowerCAmelCase_)
	return False







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("sagemaker")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("tqdm")







def     __magic_name__  (      ):
	'''simple docstring'''


	return _is_package_available("mlflow")







def     __magic_name__  (      ):
	'''simple docstring'''


	return is_torch_version(">="      ,					"1.12") and torch.backends.mps.is_available() and torch.backends.mps.is_built()







def     __magic_name__  (      ):
	'''simple docstring'''


	def get_major_and_minor_from_version(lowerCAmelCase_):
		return str(version.parse(lowerCAmelCase_).major) + "." + str(version.parse(lowerCAmelCase_).minor)

	lowerCamelCase_			:							Tuple      =       importlib.metadata.version("torch")
	if importlib.util.find_spec("intel_extension_for_pytorch") is None:
		return False
	lowerCamelCase_			:							Optional[Any]      =       "N/A"
	try:
		lowerCamelCase_			:							Optional[int]      =       importlib.metadata.version("intel_extension_for_pytorch")
	except importlib.metadata.PackageNotFoundError:
		return False
	lowerCamelCase_			:							Dict      =       get_major_and_minor_from_version(_torch_version)
	lowerCamelCase_			:							Dict      =       get_major_and_minor_from_version(_ipex_version)
	if torch_major_and_minor != ipex_major_and_minor:
		warnings.warn(
		    F"""Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"""
		    F""" but PyTorch {_torch_version} is found. Please switch to the matching version and run again.""")
		return False
	return True







@lru_cache
def     __magic_name__  (      lowerCAmelCase_=False):
	'''simple docstring'''


	if importlib.util.find_spec("torch") is None or importlib.util.find_spec("torch_npu") is None:
		return False

	import torch
	import torch_npu  # noqa: F401

	if check_device:
		try:
			# Will raise a RuntimeError if no NPU is found
			lowerCamelCase_			:							Optional[int]      =       torch.npu.device_count()
			return torch.npu.is_available()
		except RuntimeError:
			return False
	return hasattr(lowerCAmelCase_      ,					"npu") and torch.npu.is_available()







@lru_cache
def     __magic_name__  (      lowerCAmelCase_=False):
	'''simple docstring'''


	if not parse_flag_from_env("ACCELERATE_USE_XPU"      ,					default=lowerCAmelCase_):
		return False
	if is_ipex_available():
		import torch

		if is_torch_version("<="      ,					"1.12"):
			return False
	else:
		return False

	import intel_extension_for_pytorch  # noqa: F401

	if check_device:
		try:
			# Will raise a RuntimeError if no XPU  is found
			lowerCamelCase_			:							Any      =       torch.xpu.device_count()
			return torch.xpu.is_available()
		except RuntimeError:
			return False
	return hasattr(lowerCAmelCase_      ,					"xpu") and torch.xpu.is_available()





__magic_name__       					=      {
    '''0''': 1,
    '''1''': 1,
    '''2''': 2,
    '''3''': 6,
    '''4''': 2_4,
    '''5''': 1_2_0,
    '''6''': 7_2_0,
    '''7''': 5_0_4_0,
    '''8''': 4_0_3_2_0,
    '''9''': 3_6_2_8_8_0,
}

__magic_name__       					=      {1_4_5: 1_4_5}

__magic_name__       					=      {
    1_4_5: 0,
    1_6_9: 3,
    3_6_3_0_1: 3,
    1_4_5_4: 3,
    8_7_1: 2,
    4_5_3_6_1: 2,
    8_7_2: 2,
}







def     __magic_name__  (      lowerCAmelCase_):
	'''simple docstring'''


	if n in CACHE_SUM_DIGIT_FACTORIALS:
		return CACHE_SUM_DIGIT_FACTORIALS[n]
	lowerCamelCase_			:							List[str]      =       sum(DIGIT_FACTORIALS[let] for let in str(lowerCAmelCase_))
	lowerCamelCase_			:							List[str]      =       ret
	return ret







def     __magic_name__  (      lowerCAmelCase_      ,					lowerCAmelCase_ = None):
	'''simple docstring'''


	lowerCamelCase_			:							List[str]      =       previous or set()
	if n in CHAIN_LENGTH_CACHE:
		return CHAIN_LENGTH_CACHE[n]
	lowerCamelCase_			:							str      =       sum_digit_factorials(lowerCAmelCase_)
	if next_number in previous:
		lowerCamelCase_			:							List[str]      =       0
		return 0
	else:
		previous.add(lowerCAmelCase_)
		lowerCamelCase_			:							List[Any]      =       1 + chain_length(lowerCAmelCase_      ,					lowerCAmelCase_)
		lowerCamelCase_			:							Optional[int]      =       ret
		return ret







def     __magic_name__  (      lowerCAmelCase_ = 60      ,					lowerCAmelCase_ = 100_0000):
	'''simple docstring'''


	return sum(1 for i in range(1      ,					lowerCAmelCase_) if chain_length(lowerCAmelCase_) == num_terms)


if __name__ == "__main__":
							print(f'''{solution() = }''')

