
def 							__SCREAMING_SNAKE_CASE       (		SCREAMING_SNAKE_CASE	:				Any   ,							SCREAMING_SNAKE_CASE	:				Optional[int]      )					->						List[str]:
				if n == 0:
								return 1

				elif n % 2 == 1:
								return binary_exponentiation(SCREAMING_SNAKE_CASE   ,							n - 1      ) * a

				else:
								__lowercase								= binary_exponentiation(SCREAMING_SNAKE_CASE   ,							n / 2      )
								return b * b


if __name__ == "__main__":
							try:
														SCREAMING_SNAKE_CASE__							=    int(input("""Enter Base : """).strip())
														SCREAMING_SNAKE_CASE__							=    int(input("""Enter Power : """).strip())
							except ValueError:
														print("""Invalid literal for integer""")

							SCREAMING_SNAKE_CASE__							=    binary_exponentiation(BASE, POWER)
							print(F'''{BASE}^({POWER}) : {RESULT}''')







import unittest

from transformers import load_tool
from transformers.tools.agent_types import AGENT_TYPE_MAPPING

from .test_tools_common import ToolTesterMixin, output_types
class      A__       (						unittest.TestCase   ,						lowerCAmelCase__    ):





							def       a__			(			self  :       Any    )						->		Dict:



											"""simple docstring"""


											__lowercase								= load_tool('translation'    )
											self.tool.setup()
											__lowercase								= load_tool('translation'					,			remote=_UpperCAmelCase    )





							def       a__			(			self  :       int    )						->		Optional[Any]:



											"""simple docstring"""


											__lowercase								= self.tool('Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





							def       a__			(			self  :       Tuple    )						->		Optional[int]:



											"""simple docstring"""


											__lowercase								= self.remote_tool('Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





							def       a__			(			self  :       Union[str, Any]    )						->		Tuple:



											"""simple docstring"""


											__lowercase								= self.tool(text='Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





							def       a__			(			self  :       Tuple    )						->		Optional[Any]:



											"""simple docstring"""


											__lowercase								= self.remote_tool(text='Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





							def       a__			(			self  :       List[Any]    )						->		int:



											"""simple docstring"""


											__lowercase								= ['Hey, what\'s up?', 'English', 'Spanish']
											__lowercase								= self.tool(*_UpperCAmelCase    )

											# There is a single output
											if len(self.tool.outputs    ) == 1:
															__lowercase								= [outputs]

											self.assertListEqual(output_types(_UpperCAmelCase    )					,			self.tool.outputs    )





							def       a__			(			self  :       List[str]    )						->		Any:



											"""simple docstring"""


											__lowercase								= ['Hey, what\'s up?', 'English', 'Spanish']
											__lowercase								= self.tool(*_UpperCAmelCase    )

											if not isinstance(_UpperCAmelCase					,			_UpperCAmelCase    ):
															__lowercase								= [outputs]

											self.assertEqual(len(_UpperCAmelCase    )					,			len(self.tool.outputs    )    )

											for output, output_type in zip(_UpperCAmelCase					,			self.tool.outputs    ):
															__lowercase								= AGENT_TYPE_MAPPING[output_type]
															self.assertTrue(isinstance(_UpperCAmelCase					,			_UpperCAmelCase    )    )





							def       a__			(			self  :       Tuple    )						->		List[Any]:



											"""simple docstring"""


											__lowercase								= ['Hey, what\'s up?', 'English', 'Spanish']

											__lowercase								= []

											for _input, input_type in zip(_UpperCAmelCase					,			self.tool.inputs    ):
															if isinstance(_UpperCAmelCase					,			_UpperCAmelCase    ):
																			_inputs.append([AGENT_TYPE_MAPPING[_input_type](_input    ) for _input_type in input_type]    )
															else:
																			_inputs.append(AGENT_TYPE_MAPPING[input_type](_input    )    )

        # Should not raise an error
											__lowercase								= self.tool(*_UpperCAmelCase    )

											if not isinstance(_UpperCAmelCase					,			_UpperCAmelCase    ):
															__lowercase								= [outputs]

											self.assertEqual(len(_UpperCAmelCase    )					,			len(self.tool.outputs    )    )





