






import unittest

from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow


if is_flax_available():
	import jax

	from transformers.models.auto.modeling_flax_auto import FlaxAutoModel
	from transformers.models.bert.modeling_flax_bert import FlaxBertModel
	from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel

@require_flax
class     _SCREAMING_SNAKE_CASE       (			unittest.TestCase      ):





	@slow
	def 						_A (		self				:					Any	):
		for model_name in ["bert-base-cased", "bert-large-uncased"]:
			with self.subTest(__lowerCamelCase	):
				UpperCamelCase     :List[str]          =	AutoConfig.from_pretrained(__lowerCamelCase	)
				self.assertIsNotNone(__lowerCamelCase	)
				self.assertIsInstance(__lowerCamelCase ,  __lowerCamelCase	)

				UpperCamelCase     :Optional[int]          =	FlaxAutoModel.from_pretrained(__lowerCamelCase	)
				self.assertIsNotNone(__lowerCamelCase	)
				self.assertIsInstance(__lowerCamelCase ,  __lowerCamelCase	)





	@slow
	def 						_A (		self				:					Optional[int]	):
		for model_name in ["roberta-base", "roberta-large"]:
			with self.subTest(__lowerCamelCase	):
				UpperCamelCase     :Dict          =	AutoConfig.from_pretrained(__lowerCamelCase	)
				self.assertIsNotNone(__lowerCamelCase	)
				self.assertIsInstance(__lowerCamelCase ,  __lowerCamelCase	)

				UpperCamelCase     :Union[str, Any]          =	FlaxAutoModel.from_pretrained(__lowerCamelCase	)
				self.assertIsNotNone(__lowerCamelCase	)
				self.assertIsInstance(__lowerCamelCase ,  __lowerCamelCase	)





	@slow
	def 						_A (		self				:					int	):
		for model_name in ["bert-base-cased", "bert-large-uncased"]:
			UpperCamelCase     :str          =	AutoTokenizer.from_pretrained(__lowerCamelCase	)
			UpperCamelCase     :Union[str, Any]          =	FlaxBertModel.from_pretrained(__lowerCamelCase	)
			UpperCamelCase     :List[Any]          =	tokenizer("""Do you support jax jitted function?""" ,  return_tensors=TensorType.JAX	)

			@jax.jit
			def eval(**__lowerCamelCase				:					int	):
				return model(**__lowerCamelCase	)

			eval(**__lowerCamelCase	).block_until_ready()





	@slow
	def 						_A (		self				:					Union[str, Any]	):
		for model_name in ["roberta-base", "roberta-large"]:
			UpperCamelCase     :Tuple          =	AutoTokenizer.from_pretrained(__lowerCamelCase	)
			UpperCamelCase     :Any          =	FlaxRobertaModel.from_pretrained(__lowerCamelCase	)
			UpperCamelCase     :List[str]          =	tokenizer("""Do you support jax jitted function?""" ,  return_tensors=TensorType.JAX	)

			@jax.jit
			def eval(**__lowerCamelCase				:					Any	):
				return model(**__lowerCamelCase	)

			eval(**__lowerCamelCase	).block_until_ready()





	def 						_A (		self				:					Any	):
		with self.assertRaisesRegex(
		    __lowerCamelCase ,  """bert-base is not a local folder and is not a valid model identifier"""	):
			UpperCamelCase     :Dict          =	FlaxAutoModel.from_pretrained("""bert-base"""	)





	def 						_A (		self				:					Union[str, Any]	):
		with self.assertRaisesRegex(
		    __lowerCamelCase ,  R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""	):
			UpperCamelCase     :Optional[int]          =	FlaxAutoModel.from_pretrained(__lowerCamelCase ,  revision="""aaaaaa"""	)





	def 						_A (		self				:					Any	):
		with self.assertRaisesRegex(
		    __lowerCamelCase ,  """hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack""" ,  ):
			UpperCamelCase     :int          =	FlaxAutoModel.from_pretrained("""hf-internal-testing/config-no-model"""	)





	def 						_A (		self				:					List[Any]	):
		with self.assertRaisesRegex(__lowerCamelCase ,  """Use `from_pt=True` to load this model"""	):
			UpperCamelCase     :str          =	FlaxAutoModel.from_pretrained("""hf-internal-testing/tiny-bert-pt-only"""	)



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