


'''simple docstring'''

def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					Dict     ,		_UpperCamelCase   :					List[str]     ,		_UpperCamelCase   :					Tuple )		->       str:





   '''simple docstring'''







   if power < 0:
      return -1
   base %= mod
   UpperCamelCase__			    =    1

   while power > 0:
      if power & 1:
         UpperCamelCase__			    =    (result * base) % mod
      UpperCamelCase__			    =    power >> 1
      UpperCamelCase__			    =    (base * base) % mod

   return result



def 							SCREAMING_SNAKE_CASE__(		)		->       Dict:





   '''simple docstring'''







   print(modular_exponential(3     ,		2_00     ,		13 ) )


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       main()






import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput

@dataclass
class 						UpperCamelCase__					( lowerCAmelCase_  ):



     '''simple docstring'''

     __snake_case       :      float
     __snake_case       :      Optional[float]						      =     None
     __snake_case       :      Optional[float]						      =     None

class 						UpperCamelCase__					( unittest.TestCase  ):



     '''simple docstring'''

     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           self.assertEqual(x.a		,30			)
           self.assertIsNone(x.b			)
           self.assertIsNone(x.c			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.d






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,b=10			)
           self.assertEqual(x[0]		,30			)
           self.assertEqual(x[1]		,10			)
           self.assertEqual(x[:2]		,(30, 10)			)
           self.assertEqual(x[:]		,(30, 10)			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,c=10			)
           self.assertEqual(x[0]		,30			)
           self.assertEqual(x[1]		,10			)
           self.assertEqual(x[:2]		,(30, 10)			)
           self.assertEqual(x[:]		,(30, 10)			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,b=10			)
           self.assertEqual(x["""a"""]		,30			)
           self.assertEqual(x["""b"""]		,10			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x["""c"""]

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,c=10			)
           self.assertEqual(x["""a"""]		,30			)
           self.assertEqual(x["""c"""]		,10			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x["""b"""]






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           self.assertEqual(list(x.keys()			)		,["""a"""]			)
           self.assertEqual(list(x.values()			)		,[30]			)
           self.assertEqual(list(x.items()			)		,[("""a""", 30)]			)
           self.assertEqual(list(lowerCamelCase__			)		,["""a"""]			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,b=10			)
           self.assertEqual(list(x.keys()			)		,["""a""", """b"""]			)
           self.assertEqual(list(x.values()			)		,[30, 10]			)
           self.assertEqual(list(x.items()			)		,[("""a""", 30), ("""b""", 10)]			)
           self.assertEqual(list(lowerCamelCase__			)		,["""a""", """b"""]			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30		,c=10			)
           self.assertEqual(list(x.keys()			)		,["""a""", """c"""]			)
           self.assertEqual(list(x.values()			)		,[30, 10]			)
           self.assertEqual(list(x.items()			)		,[("""a""", 30), ("""c""", 10)]			)
           self.assertEqual(list(lowerCamelCase__			)		,["""a""", """c"""]			)

           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.update({"""d""": 20}			)
           with self.assertRaises(lowerCamelCase__			):
                 del x["a"]
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.pop("""a"""			)
           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		x.setdefault("""d"""		,32			)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           SCREAMING_SNAKE_CASE						=		10
           self.assertEqual(x.a		,10			)
           self.assertEqual(x["""a"""]		,10			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=30			)
           SCREAMING_SNAKE_CASE						=		10
           self.assertEqual(x.a		,10			)
           self.assertEqual(x["""a"""]		,10			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest({"""a""": 30, """b""": 10}			)
           self.assertEqual(list(x.keys()			)		,["""a""", """b"""]			)
           self.assertEqual(x.a		,30			)
           self.assertEqual(x.b		,10			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		ModelOutputTest([("""a""", 30), ("""b""", 10)]			)
           self.assertEqual(list(x.keys()			)		,["""a""", """b"""]			)
           self.assertEqual(x.a		,30			)
           self.assertEqual(x.b		,10			)

           with self.assertRaises(lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		ModelOutputTest([("""a""", 30), (10, 10)]			)

           SCREAMING_SNAKE_CASE						=		ModelOutputTest(a=(30, 30)			)
           self.assertEqual(list(x.keys()			)		,["""a"""]			)
           self.assertEqual(x.a		,(30, 30)			)


