


'''simple docstring'''

def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					int     ,		_UpperCamelCase   :					int )		->       int:





   '''simple docstring'''







   if a < b:
      return gcd(_UpperCamelCase     ,		_UpperCamelCase )
   if a % b == 0:
      return b
   return gcd(_UpperCamelCase     ,		a % b )



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					int     ,		_UpperCamelCase   :					int     ,		_UpperCamelCase   :					int )		->       int:





   '''simple docstring'''







   if y == 0:
      return 1
   UpperCamelCase__			    =    power(_UpperCamelCase     ,		y // 2     ,		_UpperCamelCase ) % mod
   UpperCamelCase__			    =    (temp * temp) % mod
   if y % 2 == 1:
      UpperCamelCase__			    =    (temp * x) % mod
   return temp



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					int )		->       bool:





   '''simple docstring'''







   UpperCamelCase__			    =    2
   while b < n:
      if gcd(_UpperCamelCase     ,		_UpperCamelCase ) == 1 and power(_UpperCamelCase     ,		n - 1     ,		_UpperCamelCase ) != 1:
         return False
      b += 1
   return True


if __name__ == "__main__":
       __lowercase:		str    						=  int(input("Enter number: ").strip())
       if is_carmichael_number(number):
              print(F"""{number} is a Carmichael Number.""")
       else:
              print(F"""{number} is not a Carmichael Number.""")





"""simple docstring"""

import torch
import trajectory.utils as utils

from transformers import TrajectoryTransformerModel
class      A__   (   utils.Parser  ):
	A_				:					str      =   "halfcheetah-medium-expert-v2"
	A_				:					str      =   "config.offline"




def    snake_case__						(							lowerCAmelCase :		Optional[int]					,       lowerCAmelCase :		List[Any]					,       lowerCAmelCase :		List[str]					,       lowerCAmelCase :		Optional[int]					,       lowerCAmelCase :		List[Any]		):
					__snake_case   ,   __snake_case        =						utils.load_model(lowerCAmelCase					,       lowerCAmelCase					,       lowerCAmelCase					,       epoch=lowerCAmelCase					,       device=lowerCAmelCase		)
					__snake_case        =						TrajectoryTransformerModel(gpt.config		)

					trajectory_transformer.tok_emb.load_state_dict(gpt.tok_emb.state_dict()		)
					__snake_case        =						gpt.pos_emb
					trajectory_transformer.drop.load_state_dict(gpt.drop.state_dict()		)
					trajectory_transformer.ln_f.load_state_dict(gpt.ln_f.state_dict()		)
					trajectory_transformer.head.load_state_dict(gpt.head.state_dict()		)

					for i, block in enumerate(gpt.blocks		):
										trajectory_transformer.blocks[i].lna.load_state_dict(gpt.blocks[i].lna.state_dict()		)
										trajectory_transformer.blocks[i].lna.load_state_dict(gpt.blocks[i].lna.state_dict()		)
										trajectory_transformer.blocks[i].attn.load_state_dict(gpt.blocks[i].attn.state_dict()		)

										trajectory_transformer.blocks[i].la.load_state_dict(gpt.blocks[i].mlp[0].state_dict()		)
										trajectory_transformer.blocks[i].act.load_state_dict(gpt.blocks[i].mlp[1].state_dict()		)
										trajectory_transformer.blocks[i].la.load_state_dict(gpt.blocks[i].mlp[2].state_dict()		)
										trajectory_transformer.blocks[i].drop.load_state_dict(gpt.blocks[i].mlp[3].state_dict()		)

					torch.save(trajectory_transformer.state_dict()					,       """pytorch_model.bin"""		)


if __name__ == "__main__":
		UpperCamelCase__			:     int			       =				Parser().parse_args("plan")
		convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch(
		    args.logbase, args.dataset, args.gpt_loadpath, args.gpt_epoch, args.device
		)


