

import os

import torch

from ..logging import get_logger
from .constants import FSDP_PYTORCH_VERSION, MODEL_NAME, OPTIMIZER_NAME
from .versions import is_torch_version


if is_torch_version('''>=''', FSDP_PYTORCH_VERSION):
					import torch.distributed.checkpoint as dist_cp
					from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner, DefaultSavePlanner
					from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
					from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
					from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType


lowerCAmelCase_       	=	get_logger(__name__)


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__=0       ):
						os.makedirs(SCREAMING_SNAKE_CASE__  ,		exist_ok=SCREAMING_SNAKE_CASE__       )
						with FSDP.state_dict_type(
						    SCREAMING_SNAKE_CASE__  ,		fsdp_plugin.state_dict_type  ,		fsdp_plugin.state_dict_config  ,		fsdp_plugin.optim_state_dict_config       ):
												snake_case_   =	model.state_dict()
												if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
																		snake_case_   =	F'''{MODEL_NAME}.bin''' if model_index == 0 else F'''{MODEL_NAME}_{model_index}.bin'''
																		snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																		if accelerator.process_index == 0:
																								logger.info(F'''Saving model to {output_model_file}'''       )
																								torch.save(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																								logger.info(F'''Model saved to {output_model_file}'''       )
												elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
																		snake_case_   =	(
																		    F'''{MODEL_NAME}_rank{accelerator.process_index}.bin'''
																		    if model_index == 0
																		    else F'''{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'''
																		)
																		snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Saving model to {output_model_file}'''       )
																		torch.save(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Model saved to {output_model_file}'''       )
												elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
																		snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		F'''{MODEL_NAME}_{model_index}'''       )
																		os.makedirs(SCREAMING_SNAKE_CASE__  ,		exist_ok=SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Saving model to {ckpt_dir}'''       )
																		snake_case_   =	{'''model''': state_dict}

																		dist_cp.save_state_dict(
																		    state_dict=SCREAMING_SNAKE_CASE__  ,		storage_writer=dist_cp.FileSystemWriter(SCREAMING_SNAKE_CASE__       )  ,		planner=DefaultSavePlanner()  ,		)
																		logger.info(F'''Model saved to {ckpt_dir}'''       )


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__=0       ):
						accelerator.wait_for_everyone()
						with FSDP.state_dict_type(
						    SCREAMING_SNAKE_CASE__  ,		fsdp_plugin.state_dict_type  ,		fsdp_plugin.state_dict_config  ,		fsdp_plugin.optim_state_dict_config       ):
												if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
																		if type(SCREAMING_SNAKE_CASE__       ) != FSDP and accelerator.process_index != 0:
																								if not fsdp_plugin.sync_module_states:
																														raise ValueError(
																														    '''Set the `sync_module_states` flag to `True` so that model states are synced across processes when '''
																														    '''initializing FSDP object'''       )
																								return
																		snake_case_   =	F'''{MODEL_NAME}.bin''' if model_index == 0 else F'''{MODEL_NAME}_{model_index}.bin'''
																		snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Loading model from {input_model_file}'''       )
																		snake_case_   =	torch.load(SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Model loaded from {input_model_file}'''       )
												elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
																		snake_case_   =	(
																		    F'''{MODEL_NAME}_rank{accelerator.process_index}.bin'''
																		    if model_index == 0
																		    else F'''{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'''
																		)
																		snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Loading model from {input_model_file}'''       )
																		snake_case_   =	torch.load(SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Model loaded from {input_model_file}'''       )
												elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
																		snake_case_   =	(
																		    os.path.join(SCREAMING_SNAKE_CASE__  ,		F'''{MODEL_NAME}_{model_index}'''       )
																		    if F'''{MODEL_NAME}''' not in input_dir
																		    else input_dir
																		)
																		logger.info(F'''Loading model from {ckpt_dir}'''       )
																		snake_case_   =	{'''model''': model.state_dict()}
																		dist_cp.load_state_dict(
																		    state_dict=SCREAMING_SNAKE_CASE__  ,		storage_reader=dist_cp.FileSystemReader(SCREAMING_SNAKE_CASE__       )  ,		planner=DefaultLoadPlanner()  ,		)
																		snake_case_   =	state_dict['''model''']
																		logger.info(F'''Model loaded from {ckpt_dir}'''       )
												model.load_state_dict(SCREAMING_SNAKE_CASE__       )


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__=0       ):
						os.makedirs(SCREAMING_SNAKE_CASE__  ,		exist_ok=SCREAMING_SNAKE_CASE__       )
						with FSDP.state_dict_type(
						    SCREAMING_SNAKE_CASE__  ,		fsdp_plugin.state_dict_type  ,		fsdp_plugin.state_dict_config  ,		fsdp_plugin.optim_state_dict_config       ):
												snake_case_   =	FSDP.optim_state_dict(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
												if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
																		if accelerator.process_index == 0:
																								snake_case_   =	(
																								    F'''{OPTIMIZER_NAME}.bin''' if optimizer_index == 0 else F'''{OPTIMIZER_NAME}_{optimizer_index}.bin'''
																								)
																								snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																								logger.info(F'''Saving Optimizer state to {output_optimizer_file}'''       )
																								torch.save(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																								logger.info(F'''Optimizer state saved in {output_optimizer_file}'''       )
												else:
																		snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		F'''{OPTIMIZER_NAME}_{optimizer_index}'''       )
																		os.makedirs(SCREAMING_SNAKE_CASE__  ,		exist_ok=SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Saving Optimizer state to {ckpt_dir}'''       )
																		dist_cp.save_state_dict(
																		    state_dict={'''optimizer''': optim_state}  ,		storage_writer=dist_cp.FileSystemWriter(SCREAMING_SNAKE_CASE__       )  ,		planner=DefaultSavePlanner()  ,		)
																		logger.info(F'''Optimizer state saved in {ckpt_dir}'''       )


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__=0       ):
						accelerator.wait_for_everyone()
						with FSDP.state_dict_type(
						    SCREAMING_SNAKE_CASE__  ,		fsdp_plugin.state_dict_type  ,		fsdp_plugin.state_dict_config  ,		fsdp_plugin.optim_state_dict_config       ):
												if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
																		snake_case_   =	None
																		# below check should work but currently it isn't working (mostly opytorch issue),
																		# in the meantime disabling it at the cost of excess memory usage
																		# if accelerator.process_index == 0 or not fsdp_plugin.optim_state_dict_config.rank0_only:
																		snake_case_   =	(
																		    F'''{OPTIMIZER_NAME}.bin''' if optimizer_index == 0 else F'''{OPTIMIZER_NAME}_{optimizer_index}.bin'''
																		)
																		snake_case_   =	os.path.join(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Loading Optimizer state from {input_optimizer_file}'''       )
																		snake_case_   =	torch.load(SCREAMING_SNAKE_CASE__       )
																		logger.info(F'''Optimizer state loaded from {input_optimizer_file}'''       )
												else:
																		snake_case_   =	(
																		    os.path.join(SCREAMING_SNAKE_CASE__  ,		F'''{OPTIMIZER_NAME}_{optimizer_index}'''       )
																		    if F'''{OPTIMIZER_NAME}''' not in input_dir
																		    else input_dir
																		)
																		logger.info(F'''Loading Optimizer from {ckpt_dir}'''       )
																		snake_case_   =	load_sharded_optimizer_state_dict(
																		    model_state_dict=model.state_dict()  ,		optimizer_key='''optimizer'''  ,		storage_reader=dist_cp.FileSystemReader(SCREAMING_SNAKE_CASE__       )  ,		)
																		snake_case_   =	optim_state['''optimizer''']
																		logger.info(F'''Optimizer loaded from {ckpt_dir}'''       )
												snake_case_   =	FSDP.optim_state_dict_to_load(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )
												optimizer.load_state_dict(SCREAMING_SNAKE_CASE__       )


import math


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
						if 0 not in (x, y):
												# We use the relation x^y = y*log10(x), where 10 is the base.
												return y * math.logaa(SCREAMING_SNAKE_CASE__       )
						else:
												if x == 0:  # 0 raised to any number is 0
																		return 0
												elif y == 0:
																		return 1  # any number raised to 0 is 1
						raise AssertionError('''This should never happen'''       )


if __name__ == "__main__":  # Main function
					# Read two numbers from input and typecast them to int using map function.
					# Here x is the base and y is the power.
					lowerCAmelCase_       	=	'''Enter the base and the power separated by a comma: '''
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))

					# We find the log of each number, using the function res(), which takes two
					# arguments.
					lowerCAmelCase_       	=	res(xa, ya)
					lowerCAmelCase_       	=	res(xa, ya)

					# We check for the largest number
					if resa > resa:
										print('''Largest number is''', xa, '''^''', ya)
					elif resa > resa:
										print('''Largest number is''', xa, '''^''', ya)
					else:
										print('''Both are equal''')