

"""simple docstring"""


import inspect
import os

import torch
from transformers import AutoModel
from transformers.testing_utils import mockenv_context
from transformers.trainer_utils import set_seed

import accelerate
from accelerate.accelerator import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils.testing import (
    AccelerateTestCase,
    TempDirTestCase,
    execute_subprocess_async,
    require_cuda,
    require_fsdp,
    require_multi_gpu,
    slow,
)
from accelerate.utils.constants import (
    FSDP_AUTO_WRAP_POLICY,
    FSDP_BACKWARD_PREFETCH,
    FSDP_SHARDING_STRATEGY,
    FSDP_STATE_DICT_TYPE,
)
from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin
from accelerate.utils.other import patch_environment


set_seed(42)

__A						   =			"bert-base-cased"
__A						   =			"fp16"
__A						   =			"bf16"
__A						   =			[FPaa, BFaa]





@require_fsdp
@require_cuda
class     snake_case	(				__snake_case  ):

				def 							lowercase_     (	self							:				List[Any])->   Dict:



						'''simple docstring'''


						super().setUp()

						__lowerCAmelCase:       Tuple          =			dict(
						    ACCELERATE_USE_FSDP="true"     ,  MASTER_ADDR="localhost"     ,  MASTER_PORT="10999"     ,  RANK="0"     ,  LOCAL_RANK="0"     ,  WORLD_SIZE="1"     ,  )

				def 							lowercase_     (	self							:				Optional[Any])->   Optional[int]:



						'''simple docstring'''


						from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy

						for i, strategy in enumerate(UpperCamelCase__):
								__lowerCAmelCase:       Union[str, Any]          =			self.dist_env.copy()
								__lowerCAmelCase:       Tuple          =			f"{i + 1}"
								__lowerCAmelCase:       str          =			strategy
								with mockenv_context(**UpperCamelCase__):
										__lowerCAmelCase:       str          =			FullyShardedDataParallelPlugin()
										self.assertEqual(fsdp_plugin.sharding_strategy     ,  ShardingStrategy(i + 1))

				def 							lowercase_     (	self							:				Dict)->   int:



						'''simple docstring'''


						from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch

						for i, prefetch_policy in enumerate(UpperCamelCase__):
								__lowerCAmelCase:       str          =			self.dist_env.copy()
								__lowerCAmelCase:       Any          =			prefetch_policy
								with mockenv_context(**UpperCamelCase__):
										__lowerCAmelCase:       Optional[Any]          =			FullyShardedDataParallelPlugin()
										if prefetch_policy == "NO_PREFETCH":
												self.assertIsNone(fsdp_plugin.backward_prefetch)
										else:
												self.assertEqual(fsdp_plugin.backward_prefetch     ,  BackwardPrefetch(i + 1))

				def 							lowercase_     (	self							:				List[Any])->   List[Any]:



						'''simple docstring'''


						from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType

						for i, state_dict_type in enumerate(UpperCamelCase__):
								__lowerCAmelCase:       Optional[int]          =			self.dist_env.copy()
								__lowerCAmelCase:       Optional[Any]          =			state_dict_type
								with mockenv_context(**UpperCamelCase__):
										__lowerCAmelCase:       Tuple          =			FullyShardedDataParallelPlugin()
										self.assertEqual(fsdp_plugin.state_dict_type     ,  StateDictType(i + 1))
										if state_dict_type == "FULL_STATE_DICT":
												self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu)
												self.assertTrue(fsdp_plugin.state_dict_config.ranka_only)

				def 							lowercase_     (	self							:				Dict)->   List[str]:



						'''simple docstring'''


						__lowerCAmelCase:       Tuple          =			AutoModel.from_pretrained(UpperCamelCase__)
						for policy in FSDP_AUTO_WRAP_POLICY:
								__lowerCAmelCase:       Optional[Any]          =			self.dist_env.copy()
								__lowerCAmelCase:       Dict          =			policy
								if policy == "TRANSFORMER_BASED_WRAP":
										__lowerCAmelCase:       Any          =			"BertLayer"
								elif policy == "SIZE_BASED_WRAP":
										__lowerCAmelCase:       List[str]          =			"2000"
								with mockenv_context(**UpperCamelCase__):
										__lowerCAmelCase:       str          =			FullyShardedDataParallelPlugin()
										fsdp_plugin.set_auto_wrap_policy(UpperCamelCase__)
										if policy == "NO_WRAP":
												self.assertIsNone(fsdp_plugin.auto_wrap_policy)
										else:
												self.assertIsNotNone(fsdp_plugin.auto_wrap_policy)

						__lowerCAmelCase:       List[str]          =			self.dist_env.copy()
						__lowerCAmelCase:       Optional[Any]          =			"TRANSFORMER_BASED_WRAP"
						__lowerCAmelCase:       List[str]          =			"T5Layer"
						with mockenv_context(**UpperCamelCase__):
								__lowerCAmelCase:       List[Any]          =			FullyShardedDataParallelPlugin()
								with self.assertRaises(UpperCamelCase__) as cm:
										fsdp_plugin.set_auto_wrap_policy(UpperCamelCase__)
								self.assertTrue("Could not find the transformer layer class to wrap in the model." in str(cm.exception))

						__lowerCAmelCase:       Tuple          =			self.dist_env.copy()
						__lowerCAmelCase:       Any          =			"SIZE_BASED_WRAP"
						__lowerCAmelCase:       Optional[Any]          =			"0"
						with mockenv_context(**UpperCamelCase__):
								__lowerCAmelCase:       int          =			FullyShardedDataParallelPlugin()
								fsdp_plugin.set_auto_wrap_policy(UpperCamelCase__)
								self.assertIsNone(fsdp_plugin.auto_wrap_policy)

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



						'''simple docstring'''


						from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision
						from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler

						for mp_dtype in dtypes:
								__lowerCAmelCase:       Union[str, Any]          =			self.dist_env.copy()
								__lowerCAmelCase:       List[str]          =			mp_dtype
								with mockenv_context(**UpperCamelCase__):
										__lowerCAmelCase:       Optional[int]          =			Accelerator()
										if mp_dtype == "fp16":
												__lowerCAmelCase:       Any          =			torch.floataa
										elif mp_dtype == "bf16":
												__lowerCAmelCase:       List[str]          =			torch.bfloataa
										__lowerCAmelCase:       int          =			MixedPrecision(param_dtype=UpperCamelCase__     ,  reduce_dtype=UpperCamelCase__     ,  buffer_dtype=UpperCamelCase__)
										self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy     ,  UpperCamelCase__)
										if mp_dtype == FPaa:
												self.assertTrue(isinstance(accelerator.scaler     ,  UpperCamelCase__))
										elif mp_dtype == BFaa:
												self.assertIsNone(accelerator.scaler)
										AcceleratorState._reset_state(UpperCamelCase__)




				def 							lowercase_     (	self							:				str)->   Any:



						'''simple docstring'''


						from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload

						for flag in [True, False]:
								__lowerCAmelCase:       Any          =			self.dist_env.copy()
								__lowerCAmelCase:       Any          =			str(UpperCamelCase__).lower()
								with mockenv_context(**UpperCamelCase__):
										__lowerCAmelCase:       Dict          =			FullyShardedDataParallelPlugin()
										self.assertEqual(fsdp_plugin.cpu_offload     ,  CPUOffload(offload_params=UpperCamelCase__))





@require_fsdp
@require_multi_gpu
@slow
class     snake_case	(				__snake_case  ):

				def 							lowercase_     (	self							:				Dict)->   str:



						'''simple docstring'''


						super().setUp()
						__lowerCAmelCase:       Tuple          =			0.82
						__lowerCAmelCase:       Union[str, Any]          =			[
						    "fsdp_shard_grad_op_transformer_based_wrap",
						    "fsdp_full_shard_transformer_based_wrap",
						]
						__lowerCAmelCase:       Union[str, Any]          =			{
						    "multi_gpu_fp16": 3_2_0_0,
						    "fsdp_shard_grad_op_transformer_based_wrap_fp16": 2_0_0_0,
						    "fsdp_full_shard_transformer_based_wrap_fp16": 1_9_0_0,
						    # Disabling below test as it overwhelms the RAM memory usage
						    # on CI self-hosted runner leading to tests getting killed.
						    # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500,  # fp16 was leading to indefinite hang
						}
						__lowerCAmelCase:       Dict          =			1_6_0
						__lowerCAmelCase:       Any          =			1_6_0

						__lowerCAmelCase:       Tuple          =			inspect.getfile(accelerate.test_utils)
						__lowerCAmelCase:       Optional[Any]          =			os.path.sep.join(mod_file.split(os.path.sep)[:-1] + ["scripts", "external_deps"])

				def 							lowercase_     (	self							:				Dict)->   Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[int]          =			os.path.join(self.test_scripts_folder     ,  "test_performance.py")
						__lowerCAmelCase:       Optional[int]          =			["accelerate", "launch", "--num_processes=2", "--num_machines=1", "--machine_rank=0", "--use_fsdp"]
						for config in self.performance_configs:
								__lowerCAmelCase:       List[str]          =			cmd.copy()
								for i, strategy in enumerate(UpperCamelCase__):
										if strategy.lower() in config:
												cmd_config.append(f"--fsdp_sharding_strategy={i+1}")
												break

								if "fp32" in config:
										cmd_config.append("--mixed_precision=no")
								else:
										cmd_config.append("--mixed_precision=fp16")

								if "cpu_offload" in config:
										cmd_config.append("--fsdp_offload_params=True")

								for policy in FSDP_AUTO_WRAP_POLICY:
										if policy.lower() in config:
												cmd_config.append(f"--fsdp_auto_wrap_policy={policy}")
												break

								if policy == "TRANSFORMER_BASED_WRAP":
										cmd_config.append("--fsdp_transformer_layer_cls_to_wrap=BertLayer")
								elif policy == "SIZE_BASED_WRAP":
										cmd_config.append("--fsdp_min_num_params=2000")

								cmd_config.extend(
								    [
								        self.test_file_path,
								        f"--output_dir={self.tmpdir}",
								        f"--performance_lower_bound={self.performance_lower_bound}",
								    ])
								with patch_environment(omp_num_threads=1):
										execute_subprocess_async(UpperCamelCase__     ,  env=os.environ.copy())

				def 							lowercase_     (	self							:				List[str])->   int:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[Any]          =			os.path.join(self.test_scripts_folder     ,  "test_checkpointing.py")
						__lowerCAmelCase:       List[str]          =			[
						    "accelerate",
						    "launch",
						    "--num_processes=2",
						    "--num_machines=1",
						    "--machine_rank=0",
						    "--use_fsdp",
						    "--mixed_precision=fp16",
						    "--fsdp_transformer_layer_cls_to_wrap=BertLayer",
						]

						for i, strategy in enumerate(UpperCamelCase__):
								__lowerCAmelCase:       Dict          =			cmd.copy()
								cmd_config.append(f"--fsdp_sharding_strategy={i+1}")
								if strategy != "FULL_SHARD":
										continue
								__lowerCAmelCase:       Tuple          =			len(UpperCamelCase__)
								for state_dict_type in FSDP_STATE_DICT_TYPE:
										__lowerCAmelCase:       List[Any]          =			cmd_config[:state_dict_config_index]
										cmd_config.append(f"--fsdp_state_dict_type={state_dict_type}")
										cmd_config.extend(
										    [
										        self.test_file_path,
										        f"--output_dir={self.tmpdir}",
										        "--partial_train_epoch=1",
										    ])
										with patch_environment(omp_num_threads=1):
												execute_subprocess_async(UpperCamelCase__     ,  env=os.environ.copy())

										__lowerCAmelCase:       str          =			cmd_config[:-1]
										__lowerCAmelCase:       Tuple          =			os.path.join(self.tmpdir     ,  "epoch_0")
										cmd_config.extend(
										    [
										        f"--resume_from_checkpoint={resume_from_checkpoint}",
										    ])
										with patch_environment(omp_num_threads=1):
												execute_subprocess_async(UpperCamelCase__     ,  env=os.environ.copy())




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



						'''simple docstring'''


						__lowerCAmelCase:       List[Any]          =			os.path.join(self.test_scripts_folder     ,  "test_peak_memory_usage.py")
						__lowerCAmelCase:       Union[str, Any]          =			[
						    "accelerate",
						    "launch",
						    "--num_processes=2",
						    "--num_machines=1",
						    "--machine_rank=0",
						]
						for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items():
								__lowerCAmelCase:       Union[str, Any]          =			cmd.copy()
								if "fp16" in spec:
										cmd_config.extend(["--mixed_precision=fp16"])
								else:
										cmd_config.extend(["--mixed_precision=no"])

								if "multi_gpu" in spec:
										continue
								else:
										cmd_config.extend(["--use_fsdp"])
										for i, strategy in enumerate(UpperCamelCase__):
												if strategy.lower() in spec:
														cmd_config.append(f"--fsdp_sharding_strategy={i+1}")
														break

										if "cpu_offload" in spec:
												cmd_config.append("--fsdp_offload_params=True")

										for policy in FSDP_AUTO_WRAP_POLICY:
												if policy.lower() in spec:
														cmd_config.append(f"--fsdp_auto_wrap_policy={policy}")
														break

										if policy == "TRANSFORMER_BASED_WRAP":
												cmd_config.append("--fsdp_transformer_layer_cls_to_wrap=BertLayer")
										elif policy == "SIZE_BASED_WRAP":
												cmd_config.append("--fsdp_min_num_params=2000")

								cmd_config.extend(
								    [
								        self.test_file_path,
								        f"--output_dir={self.tmpdir}",
								        f"--peak_memory_upper_bound={peak_mem_upper_bound}",
								        f"--n_train={self.n_train}",
								        f"--n_val={self.n_val}",
								    ])
								with patch_environment(omp_num_threads=1):
										execute_subprocess_async(UpperCamelCase__     ,  env=os.environ.copy())





"""simple docstring"""


def     a__    (    __SCREAMING_SNAKE_CASE )	->	int:
		__lowerCAmelCase:       Optional[Any]          =			1
		for i in range(1					, num + 1 ):
				fact *= i
		return fact






def     a__    (    __SCREAMING_SNAKE_CASE )	->	int:
		__lowerCAmelCase:       List[str]          =			0
		while number > 0:
				__lowerCAmelCase:       Any          =			number % 1_0
				sum_of_digits += last_digit
				__lowerCAmelCase:       List[Any]          =			number // 1_0  # Removing the last_digit from the given number
		return sum_of_digits






def     a__    (    __SCREAMING_SNAKE_CASE = 1_0_0 )	->	int:
		__lowerCAmelCase:       Tuple          =			factorial(__SCREAMING_SNAKE_CASE )
		__lowerCAmelCase:       Optional[int]          =			split_and_add(__SCREAMING_SNAKE_CASE )
		return result


if __name__ == "__main__":
			print(solution(int(input("Enter the Number: ").strip())))


