

import math

def    A_  (							a					,   a  ):

      """simple docstring"""



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

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









import argparse

from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta
from transformers.utils import logging


logging.set_verbosity_info()

def    A_  (							a					,   a					,   a  ):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_				:  int           =     TaConfig.from_json_file(a  )
      print(f"Building PyTorch model from configuration: {config}"  )
      SCREAMING_SNAKE_CASE_				:  Tuple           =     TaForConditionalGeneration(a  )

      # Load weights from tf checkpoint
      load_tf_weights_in_ta(a					,   a					,   a  )

      # Save pytorch-model
      print(f"Save PyTorch model to {pytorch_dump_path}"  )
      model.save_pretrained(a  )


if __name__ == "__main__":
    lowerCAmelCase     :   int						     =  argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
    )
    parser.add_argument(
        '--config_file',
        default=None,
        type=str,
        required=True,
        help=(
            'The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture.'
        ),
    )
    parser.add_argument(
        '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
    )
    lowerCAmelCase     :   List[str]						     =  parser.parse_args()
    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)






