import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCamelCase		:       int									=     logging.get_logger(__name__)
def       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						SCREAMING_SNAKE_CASE							:    Tuple							=							os.path.abspath(SCREAMING_SNAKE_CASE__						)
						logger.info(f"""Converting TensorFlow checkpoint from {tf_path}"""						)
						# Load weights from TF model
						SCREAMING_SNAKE_CASE							:    Any							=							tf.train.list_variables(SCREAMING_SNAKE_CASE__						)
						SCREAMING_SNAKE_CASE							:    str							=							[]
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							[]
						SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							[]
						for full_name, shape in init_vars:
												# logger.info(f"Loading TF weight {name} with shape {shape}")
												SCREAMING_SNAKE_CASE							:    Dict							=							full_name.split('''/'''						)
												if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
																		logger.info(f"""Skipping non-model layer {full_name}"""						)
																		continue
												if "optimizer" in full_name:
																		logger.info(f"""Skipping optimization layer {full_name}"""						)
																		continue
												if name[0] == "model":
																		# ignore initial 'model'
																		SCREAMING_SNAKE_CASE							:    Optional[Any]							=							name[1:]
												# figure out how many levels deep the name is
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							0
												for _name in name:
																		if _name.startswith('''layer_with_weights'''						):
																								depth += 1
																		else:
																								break
												layer_depth.append(SCREAMING_SNAKE_CASE__						)
												# read data
												SCREAMING_SNAKE_CASE							:    Tuple							=							tf.train.load_variable(SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__						)
												names.append('''/'''.join(SCREAMING_SNAKE_CASE__						)						)
												arrays.append(SCREAMING_SNAKE_CASE__						)
						logger.info(f"""Read a total of {len(SCREAMING_SNAKE_CASE__						):,} layers"""						)

						# Sanity check
						if len(set(SCREAMING_SNAKE_CASE__						)						) != 1:
												raise ValueError(f"""Found layer names with different depths (layer depth {list(set(SCREAMING_SNAKE_CASE__						)						)})"""						)
						SCREAMING_SNAKE_CASE							:    List[str]							=							list(set(SCREAMING_SNAKE_CASE__						)						)[0]
						if layer_depth != 1:
												raise ValueError(
												    '''The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP'''
												    ''' heads.'''						)

						# convert layers
						logger.info('''Converting weights...'''						)
						for full_name, array in zip(SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__						):
												SCREAMING_SNAKE_CASE							:    Dict							=							full_name.split('''/'''						)
												SCREAMING_SNAKE_CASE							:    Dict							=							model
												SCREAMING_SNAKE_CASE							:    List[str]							=							[]
												for i, m_name in enumerate(SCREAMING_SNAKE_CASE__						):
																		if m_name == ".ATTRIBUTES":
																								# variable names end with .ATTRIBUTES/VARIABLE_VALUE
																								break
																		if m_name.startswith('''layer_with_weights'''						):
																								SCREAMING_SNAKE_CASE							:    Tuple							=							int(m_name.split('''-'''						)[-1]						)
																								if layer_num <= 2:
																														# embedding layers
																														# layer_num 0: word_embeddings
																														# layer_num 1: position_embeddings
																														# layer_num 2: token_type_embeddings
																														continue
																								elif layer_num == 3:
																														# embedding LayerNorm
																														trace.extend(['''embeddings''', '''LayerNorm''']						)
																														SCREAMING_SNAKE_CASE							:    Optional[Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''embeddings'''						)
																														SCREAMING_SNAKE_CASE							:    List[Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''LayerNorm'''						)
																								elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
																														# encoder layers
																														trace.extend(['''encoder''', '''layer''', str(layer_num - 4						)]						)
																														SCREAMING_SNAKE_CASE							:    Any							=							getattr(SCREAMING_SNAKE_CASE__		,  '''encoder'''						)
																														SCREAMING_SNAKE_CASE							:    Any							=							getattr(SCREAMING_SNAKE_CASE__		,  '''layer'''						)
																														SCREAMING_SNAKE_CASE							:    Optional[int]							=							pointer[layer_num - 4]
																								elif layer_num == config.num_hidden_layers + 4:
																														# pooler layer
																														trace.extend(['''pooler''', '''dense''']						)
																														SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''pooler'''						)
																														SCREAMING_SNAKE_CASE							:    Dict							=							getattr(SCREAMING_SNAKE_CASE__		,  '''dense'''						)
																		elif m_name == "embeddings":
																								trace.append('''embeddings'''						)
																								SCREAMING_SNAKE_CASE							:    List[str]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''embeddings'''						)
																								if layer_num == 0:
																														trace.append('''word_embeddings'''						)
																														SCREAMING_SNAKE_CASE							:    Tuple							=							getattr(SCREAMING_SNAKE_CASE__		,  '''word_embeddings'''						)
																								elif layer_num == 1:
																														trace.append('''position_embeddings'''						)
																														SCREAMING_SNAKE_CASE							:    Optional[Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''position_embeddings'''						)
																								elif layer_num == 2:
																														trace.append('''token_type_embeddings'''						)
																														SCREAMING_SNAKE_CASE							:    List[str]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''token_type_embeddings'''						)
																								else:
																														raise ValueError(f"""Unknown embedding layer with name {full_name}"""						)
																								trace.append('''weight'''						)
																								SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''weight'''						)
																		elif m_name == "_attention_layer":
																								# self-attention layer
																								trace.extend(['''attention''', '''self''']						)
																								SCREAMING_SNAKE_CASE							:    int							=							getattr(SCREAMING_SNAKE_CASE__		,  '''attention'''						)
																								SCREAMING_SNAKE_CASE							:    Optional[int]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''self'''						)
																		elif m_name == "_attention_layer_norm":
																								# output attention norm
																								trace.extend(['''attention''', '''output''', '''LayerNorm''']						)
																								SCREAMING_SNAKE_CASE							:    Tuple							=							getattr(SCREAMING_SNAKE_CASE__		,  '''attention'''						)
																								SCREAMING_SNAKE_CASE							:    Optional[Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''output'''						)
																								SCREAMING_SNAKE_CASE							:    int							=							getattr(SCREAMING_SNAKE_CASE__		,  '''LayerNorm'''						)
																		elif m_name == "_attention_output_dense":
																								# output attention dense
																								trace.extend(['''attention''', '''output''', '''dense''']						)
																								SCREAMING_SNAKE_CASE							:    str							=							getattr(SCREAMING_SNAKE_CASE__		,  '''attention'''						)
																								SCREAMING_SNAKE_CASE							:    List[Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''output'''						)
																								SCREAMING_SNAKE_CASE							:    int							=							getattr(SCREAMING_SNAKE_CASE__		,  '''dense'''						)
																		elif m_name == "_output_dense":
																								# output dense
																								trace.extend(['''output''', '''dense''']						)
																								SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''output'''						)
																								SCREAMING_SNAKE_CASE							:    Dict							=							getattr(SCREAMING_SNAKE_CASE__		,  '''dense'''						)
																		elif m_name == "_output_layer_norm":
																								# output dense
																								trace.extend(['''output''', '''LayerNorm''']						)
																								SCREAMING_SNAKE_CASE							:    List[Any]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''output'''						)
																								SCREAMING_SNAKE_CASE							:    int							=							getattr(SCREAMING_SNAKE_CASE__		,  '''LayerNorm'''						)
																		elif m_name == "_key_dense":
																								# attention key
																								trace.append('''key'''						)
																								SCREAMING_SNAKE_CASE							:    Any							=							getattr(SCREAMING_SNAKE_CASE__		,  '''key'''						)
																		elif m_name == "_query_dense":
																								# attention query
																								trace.append('''query'''						)
																								SCREAMING_SNAKE_CASE							:    Optional[int]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''query'''						)
																		elif m_name == "_value_dense":
																								# attention value
																								trace.append('''value'''						)
																								SCREAMING_SNAKE_CASE							:    List[str]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''value'''						)
																		elif m_name == "_intermediate_dense":
																								# attention intermediate dense
																								trace.extend(['''intermediate''', '''dense''']						)
																								SCREAMING_SNAKE_CASE							:    Optional[int]							=							getattr(SCREAMING_SNAKE_CASE__		,  '''intermediate'''						)
																								SCREAMING_SNAKE_CASE							:    str							=							getattr(SCREAMING_SNAKE_CASE__		,  '''dense'''						)
																		elif m_name == "_output_layer_norm":
																								# output layer norm
																								trace.append('''output'''						)
																								SCREAMING_SNAKE_CASE							:    Any							=							getattr(SCREAMING_SNAKE_CASE__		,  '''output'''						)
																		# weights & biases
																		elif m_name in ["bias", "beta"]:
																								trace.append('''bias'''						)
																								SCREAMING_SNAKE_CASE							:    Any							=							getattr(SCREAMING_SNAKE_CASE__		,  '''bias'''						)
																		elif m_name in ["kernel", "gamma"]:
																								trace.append('''weight'''						)
																								SCREAMING_SNAKE_CASE							:    int							=							getattr(SCREAMING_SNAKE_CASE__		,  '''weight'''						)
																		else:
																								logger.warning(f"""Ignored {m_name}"""						)
        # for certain layers reshape is necessary
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							'''.'''.join(SCREAMING_SNAKE_CASE__						)
												if re.match(R'''(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)'''		,  SCREAMING_SNAKE_CASE__						) or re.match(
												    R'''(\S+)\.attention\.output\.dense\.weight'''		,  SCREAMING_SNAKE_CASE__						):
																		SCREAMING_SNAKE_CASE							:    str							=							array.reshape(pointer.data.shape						)
												if "kernel" in full_name:
																		SCREAMING_SNAKE_CASE							:    int							=							array.transpose()
												if pointer.shape == array.shape:
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							torch.from_numpy(SCREAMING_SNAKE_CASE__						)
												else:
																		raise ValueError(
																		    f"""Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:"""
																		    f""" {array.shape}"""						)
												logger.info(f"""Successfully set variable {full_name} to PyTorch layer {trace}"""						)
						return model
def       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						# Instantiate model
						logger.info(f"""Loading model based on config from {config_path}..."""						)
						SCREAMING_SNAKE_CASE							:    List[Any]							=							BertConfig.from_json_file(SCREAMING_SNAKE_CASE__						)
						SCREAMING_SNAKE_CASE							:    Dict							=							BertModel(SCREAMING_SNAKE_CASE__						)

						# Load weights from checkpoint
						logger.info(f"""Loading weights from checkpoint {tf_checkpoint_path}..."""						)
						load_tfa_weights_in_bert(SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__						)

						# Save pytorch-model
						logger.info(f"""Saving PyTorch model to {pytorch_dump_path}..."""						)
						torch.save(model.state_dict()		,  SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
					__UpperCamelCase		:       int									=     argparse.ArgumentParser()
					parser.add_argument(
					    '--tf_checkpoint_path', type=str, required=True, help='Path to the TensorFlow 2.x checkpoint path.'
					)
					parser.add_argument(
					    '--bert_config_file',
					    type=str,
					    required=True,
					    help='The config json file corresponding to the BERT model. This specifies the model architecture.',
					)
					parser.add_argument(
					    '--pytorch_dump_path',
					    type=str,
					    required=True,
					    help='Path to the output PyTorch model (must include filename).',
					)
					__UpperCamelCase		:       Any									=     parser.parse_args()
					convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)








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''')