


import math



def        UpperCamelCase_(   lowerCamelCase_							,				lowerCamelCase_				)					->		Tuple:
    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.
 SCREAMING_SNAKE_CASE :   Union[str, Any]							      =				"Enter the base and the power separated by a comma: "
 SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE :   List[str]							      =				map(int, input(prompt).split(","))
 SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE :   Any							      =				map(int, input(prompt).split(","))

 # We find the log of each number, using the function res(), which takes two
 # arguments.
 SCREAMING_SNAKE_CASE :   Any							      =				res(xa, ya)
 SCREAMING_SNAKE_CASE :   List[Any]							      =				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")






from typing import Dict

from .base import GenericTensor, Pipeline






class _lowerCamelCase(		_a     ):
       def     UpperCamelCase  (      self,   lowerCamelCase=None,   lowerCamelCase=None,   lowerCamelCase=None,   **lowerCamelCase) ->     int:




           """simple docstring"""

           if tokenize_kwargs is None:
               _lowercase :							Any   	=	{}

           if truncation is not None:
               if "truncation" in tokenize_kwargs:
                   raise ValueError(
                       'truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)')
               _lowercase :							List[Any]   	=	truncation

           _lowercase :							Optional[Any]   	=	tokenize_kwargs

           _lowercase :							Tuple   	=	{}
           if return_tensors is not None:
               _lowercase :							Union[str, Any]   	=	return_tensors

           return preprocess_params, {}, postprocess_params
       def     UpperCamelCase  (      self,   lowerCamelCase,   **lowerCamelCase) ->     Dict[str, GenericTensor]:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	self.framework
           _lowercase :							Dict   	=	self.tokenizer(lowerCamelCase,   return_tensors=lowerCamelCase,   **lowerCamelCase)
           return model_inputs
       def     UpperCamelCase  (      self,   lowerCamelCase) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							str   	=	self.model(**lowerCamelCase)
           return model_outputs
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase=False) ->     Dict:




           """simple docstring"""

           if return_tensors:
               return model_outputs[0]
           if self.framework == "pt":
               return model_outputs[0].tolist()
           elif self.framework == "tf":
               return model_outputs[0].numpy().tolist()




       def __call__(      self,   *lowerCamelCase,   **lowerCamelCase) ->     Union[str, Any]:




           """simple docstring"""

           return super().__call__(*lowerCamelCase,   **lowerCamelCase)


