





import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput

@dataclass
class 		snake_case_      (       UpperCAmelCase_	):







	'''simple docstring'''
	__UpperCamelCase        =		42
	__UpperCamelCase        =		None
	__UpperCamelCase        =		None





class 		snake_case_      (       unittest.TestCase	):







	'''simple docstring'''




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

			'''simple docstring'''




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




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

			'''simple docstring'''




			__lowercase					=    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)      )

			__lowercase					=    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       UpperCAmelCase (	self       :    Optional[Any]      )					->   Union[str, Any]:

			'''simple docstring'''




			__lowercase					=    ModelOutputTest(a=30				,			b=10      )
			self.assertEqual(x['a']				,			30      )
			self.assertEqual(x['b']				,			10      )
			with self.assertRaises(__lowerCamelCase      ):
					__lowercase					=    x['c']

			__lowercase					=    ModelOutputTest(a=30				,			c=10      )
			self.assertEqual(x['a']				,			30      )
			self.assertEqual(x['c']				,			10      )
			with self.assertRaises(__lowerCamelCase      ):
					__lowercase					=    x['b']




	def       UpperCAmelCase (	self       :    Tuple      )					->   List[str]:

			'''simple docstring'''




			__lowercase					=    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']      )

			__lowercase					=    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']      )

			__lowercase					=    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      ):
					__lowercase					=    x.update({'d': 20}      )
			with self.assertRaises(__lowerCamelCase      ):
					del x["a"]
			with self.assertRaises(__lowerCamelCase      ):
					__lowercase					=    x.pop('a'      )
			with self.assertRaises(__lowerCamelCase      ):
					__lowercase					=    x.setdefault('d'				,			32      )




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

			'''simple docstring'''




			__lowercase					=    ModelOutputTest(a=30      )
			__lowercase					=    10
			self.assertEqual(x.a				,			10      )
			self.assertEqual(x['a']				,			10      )




	def       UpperCAmelCase (	self       :    int      )					->   Dict:

			'''simple docstring'''




			__lowercase					=    ModelOutputTest(a=30      )
			__lowercase					=    10
			self.assertEqual(x.a				,			10      )
			self.assertEqual(x['a']				,			10      )




	def       UpperCAmelCase (	self       :    List[str]      )					->   Dict:

			'''simple docstring'''




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






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

			'''simple docstring'''




			__lowercase					=    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      ):
					__lowercase					=    ModelOutputTest([('a', 30), (10, 10)]      )

			__lowercase					=    ModelOutputTest(a=(30, 30)      )
			self.assertEqual(list(x.keys()      )				,			['a']      )
			self.assertEqual(x.a				,			(30, 30)      )











from __future__ import annotations



def    SCREAMING_SNAKE_CASE							(			snake_case	,      snake_case	,      snake_case	,      snake_case       )		->						None:
		__lowercase	,			__lowercase					=    m - 1, 0
		while i >= 0 and j < n:
				if key == mat[i][j]:
						print(F"Key {key} found at row- {i + 1} column- {j + 1}"       )
						return
				if key < mat[i][j]:
						i -= 1
				else:
						j += 1
		print(F"Key {key} not found"       )



def    SCREAMING_SNAKE_CASE							(			)		->						None:
		__lowercase					=    [[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
		__lowercase					=    int(input('Enter the element to be searched:'       )       )
		print(snake_case       )
		search_in_a_sorted_matrix(snake_case	,      len(snake_case       )	,      len(mat[0]       )	,      snake_case       )


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()




