



import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput

@dataclass
class        __snake_case					(      __lowerCamelCase):







							'''simple docstring'''






							UpperCamelCase__ :					float
							UpperCamelCase__ :					Optional[float]			   =    None
							UpperCamelCase__ :					Optional[float]			   =    None




class        __snake_case					(      unittest.TestCase):







							'''simple docstring'''






							def _a					(							self						):
											a__ 					=						ModelOutputTest(a=30						)
											self.assertEqual(x.a     ,     30						)
											self.assertIsNone(x.b						)
											self.assertIsNone(x.c						)
											with self.assertRaises(_UpperCamelCase						):
															a__ 					=						x.d


							def _a					(							self						):
											a__ 					=						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)						)

											a__ 					=						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 _a					(							self						):
											a__ 					=						ModelOutputTest(a=30     ,     b=10						)
											self.assertEqual(x["""a"""]     ,     30						)
											self.assertEqual(x["""b"""]     ,     10						)
											with self.assertRaises(_UpperCamelCase						):
															a__ 					=						x["""c"""]

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


							def _a					(							self						):
											a__ 					=						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(_UpperCamelCase						)     ,     ["""a"""]						)

											a__ 					=						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(_UpperCamelCase						)     ,     ["""a""", """b"""]						)

											a__ 					=						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(_UpperCamelCase						)     ,     ["""a""", """c"""]						)

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


							def _a					(							self						):
											a__ 					=						ModelOutputTest(a=30						)
											a__ 					=						10
											self.assertEqual(x.a     ,     10						)
											self.assertEqual(x["""a"""]     ,     10						)


							def _a					(							self						):
											a__ 					=						ModelOutputTest(a=30						)
											a__ 					=						10
											self.assertEqual(x.a     ,     10						)
											self.assertEqual(x["""a"""]     ,     10						)


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







							def _a					(							self						):
											a__ 					=						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(_UpperCamelCase						):
															a__ 					=						ModelOutputTest([("""a""", 30), (10, 10)]						)

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







def 	UpperCAmelCase_    (	__UpperCamelCase,				__UpperCamelCase	):
    SCREAMING_SNAKE_CASE__								=1.0
    for i in range(1,				r + 1	):
        ret *= (n + 1 - i) / i
    return round(__UpperCamelCase	)



def 	UpperCAmelCase_    (	__UpperCamelCase	):
    return choose(8 + n,				__UpperCamelCase	) + choose(9 + n,				__UpperCamelCase	) - 10



def 	UpperCAmelCase_    (	__UpperCamelCase	):
    return sum(non_bouncy_exact(__UpperCamelCase	) for i in range(1,				n + 1	)	)



def 	UpperCAmelCase_    (	__UpperCamelCase = 100	):
    return non_bouncy_upto(__UpperCamelCase	)


if __name__ == "__main__":
    print(f"""{solution() = }""")






