

'''simple docstring'''






from dataclasses import asdict, dataclass
from typing import Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__SCREAMING_SNAKE_CASE     =						logging.get_logger(__name__)

# TODO Update this
__SCREAMING_SNAKE_CASE     =						{
    'facebook/esm-1b': 'https://huggingface.co/facebook/esm-1b/resolve/main/config.json',
    # See all ESM models at https://huggingface.co/models?filter=esm
}






class 			lowerCAmelCase__     (					snake_case_						):




     """simple docstring"""





     __UpperCamelCase									= "esm"







     def __init__(		self						:	Tuple      ,						A__						:	List[str]=None      ,						A__						:	Union[str, Any]=None      ,						A__						:	Dict=None      ,						A__						:	Optional[int]=7_6_8      ,						A__						:	Union[str, Any]=1_2      ,						A__						:	List[str]=1_2      ,						A__						:	Any=3_0_7_2      ,						A__						:	str=0.1      ,						A__						:	str=0.1      ,						A__						:	str=1_0_2_6      ,						A__						:	int=0.02      ,						A__						:	int=1E-12      ,						A__						:	Any="absolute"      ,						A__						:	str=True      ,						A__						:	Tuple=None      ,						A__						:	Dict=False      ,						A__						:	List[str]=False      ,						A__						:	Union[str, Any]=None      ,						A__						:	Any=None      ,						**A__						:	int      ,						)       ->			int:
          '''simple docstring'''




          super().__init__(pad_token_id=A__      ,						mask_token_id=A__      ,						**A__	)

          a__   :      List[str]     =						vocab_size
          a__   :      Union[str, Any]     =						hidden_size
          a__   :      Union[str, Any]     =						num_hidden_layers
          a__   :      int     =						num_attention_heads
          a__   :      List[str]     =						intermediate_size
          a__   :      Dict     =						hidden_dropout_prob
          a__   :      Tuple     =						attention_probs_dropout_prob
          a__   :      str     =						max_position_embeddings
          a__   :      List[str]     =						initializer_range
          a__   :      Dict     =						layer_norm_eps
          a__   :      Optional[int]     =						position_embedding_type
          a__   :      List[Any]     =						use_cache
          a__   :      Any     =						emb_layer_norm_before
          a__   :      Optional[int]     =						token_dropout
          a__   :      Optional[Any]     =						is_folding_model
          if is_folding_model:
               if esmfold_config is None:
                    logger.info('''No esmfold_config supplied for folding model, using default values.'''	)
                    a__   :      str     =						EsmFoldConfig()
               elif isinstance(A__      ,						A__	):
                    a__   :      Any     =						EsmFoldConfig(**A__	)
               a__   :      str     =						esmfold_config
               if vocab_list is None:
                    logger.warning('''No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!'''	)
                    a__   :      int     =						get_default_vocab_list()
               else:
                    a__   :      Any     =						vocab_list
          else:
               a__   :      Any     =						None
               a__   :      Any     =						None
          if self.esmfold_config is not None and getattr(self.esmfold_config      ,						'''use_esm_attn_map'''      ,						A__	):
               raise ValueError('''The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!'''	)







     def 			__lowerCAmelCase	(		self						:	List[Any]	)       ->			Any:
          '''simple docstring'''




          a__   :      Any     =						super().to_dict()
          if isinstance(self.esmfold_config      ,						A__	):
               a__   :      Optional[int]     =						self.esmfold_config.to_dict()
          return output






@dataclass
class 			lowerCAmelCase__     :




     """simple docstring"""





     __UpperCamelCase									= None
     __UpperCamelCase									= True
     __UpperCamelCase									= False
     __UpperCamelCase									= False
     __UpperCamelCase									= False
     __UpperCamelCase									= 0

     __UpperCamelCase									= True
     __UpperCamelCase									= False

     __UpperCamelCase									= 128
     __UpperCamelCase									= None







     def 			__lowerCAmelCase	(		self						:	str	)       ->			str:
          '''simple docstring'''




          if self.trunk is None:
               a__   :      Optional[Any]     =						TrunkConfig()
          elif isinstance(self.trunk      ,						A__	):
               a__   :      List[Any]     =						TrunkConfig(**self.trunk	)







     def 			__lowerCAmelCase	(		self						:	str	)       ->			Dict:
          '''simple docstring'''




          a__   :      Tuple     =						asdict(self	)
          a__   :      Dict     =						self.trunk.to_dict()
          return output






@dataclass
class 			lowerCAmelCase__     :




     """simple docstring"""





     __UpperCamelCase									= 48
     __UpperCamelCase									= 1024
     __UpperCamelCase									= 128
     __UpperCamelCase									= 32
     __UpperCamelCase									= 32
     __UpperCamelCase									= 32
     __UpperCamelCase									= 0
     __UpperCamelCase									= 0
     __UpperCamelCase									= False
     __UpperCamelCase									= 4
     __UpperCamelCase									= 128
     __UpperCamelCase									= None







     def 			__lowerCAmelCase	(		self						:	Optional[int]	)       ->			Dict:
          '''simple docstring'''




          if self.structure_module is None:
               a__   :      int     =						StructureModuleConfig()
          elif isinstance(self.structure_module      ,						A__	):
               a__   :      Dict     =						StructureModuleConfig(**self.structure_module	)

          if self.max_recycles <= 0:
               raise ValueError(F'`max_recycles` should be positive, got {self.max_recycles}.'	)
          if self.sequence_state_dim % self.sequence_state_dim != 0:
               raise ValueError(
                   '''`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got'''
                   F' {self.sequence_state_dim} and {self.sequence_state_dim}.'	)
          if self.pairwise_state_dim % self.pairwise_state_dim != 0:
               raise ValueError(
                   '''`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got'''
                   F' {self.pairwise_state_dim} and {self.pairwise_state_dim}.'	)

          a__   :      str     =						self.sequence_state_dim // self.sequence_head_width
          a__   :      Any     =						self.pairwise_state_dim // self.pairwise_head_width

          if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
               raise ValueError(
                   '''`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got'''
                   F' {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}.'	)
          if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
               raise ValueError(
                   '''`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got'''
                   F' {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}.'	)
          if self.pairwise_state_dim % 2 != 0:
               raise ValueError(F'`pairwise_state_dim` should be even, got {self.pairwise_state_dim}.'	)

          if self.dropout >= 0.4:
               raise ValueError(F'`dropout` should not be greater than 0.4, got {self.dropout}.'	)







     def 			__lowerCAmelCase	(		self						:	List[Any]	)       ->			str:
          '''simple docstring'''




          a__   :      Optional[int]     =						asdict(self	)
          a__   :      Any     =						self.structure_module.to_dict()
          return output






@dataclass
class 			lowerCAmelCase__     :




     """simple docstring"""





     __UpperCamelCase									= 384
     __UpperCamelCase									= 128
     __UpperCamelCase									= 16
     __UpperCamelCase									= 128
     __UpperCamelCase									= 12
     __UpperCamelCase									= 4
     __UpperCamelCase									= 8
     __UpperCamelCase									= 0.1
     __UpperCamelCase									= 8
     __UpperCamelCase									= 1
     __UpperCamelCase									= 2
     __UpperCamelCase									= 7
     __UpperCamelCase									= 10
     __UpperCamelCase									= 1e-8
     __UpperCamelCase									= 1e5







     def 			__lowerCAmelCase	(		self						:	str	)       ->			Union[str, Any]:
          '''simple docstring'''




          return asdict(self	)



def 			__a		(       ):
     return (
         "<cls>",
         "<pad>",
         "<eos>",
         "<unk>",
         "L",
         "A",
         "G",
         "V",
         "S",
         "E",
         "R",
         "T",
         "I",
         "D",
         "P",
         "K",
         "Q",
         "N",
         "F",
         "Y",
         "M",
         "H",
         "W",
         "C",
         "X",
         "B",
         "U",
         "Z",
         "O",
         ".",
         "-",
         "<null_1>",
         "<mask>",
     )


import math





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__       ):
				if 0 not in (x, y):
								# We use the relation x^y = y*log10(x), where 10 is the base.
								return y * math.logaa(lowerCamelCase__       )
				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.
			__A							='''Enter the base and the power separated by a comma: '''
			__A,		__A							=map(int, input(prompt).split(''','''))
			__A,		__A							=map(int, input(prompt).split(''','''))

			# We find the log of each number, using the function res(), which takes two
			# arguments.
			__A							=res(xa, ya)
			__A							=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''')


