



from __future__ import annotations







def 				A			(		__UpperCAmelCase							,					__UpperCAmelCase							,					__UpperCAmelCase							,					__UpperCAmelCase	)       ->       None:



						'''simple docstring'''






						UpperCAmelCase_							,      UpperCAmelCase_     							=     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 				A			(		)       ->       None:



						'''simple docstring'''






						UpperCAmelCase_     							=     [[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
						UpperCAmelCase_     							=     int(input('''Enter the element to be searched:'''	)	)
						print(__UpperCAmelCase	)
						search_in_a_sorted_matrix(__UpperCAmelCase							,					len(__UpperCAmelCase	)							,					len(mat[0]	)							,					__UpperCAmelCase	)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()










from dataclasses import dataclass
from typing import Callable, Optional

import datasets







@dataclass
class 							a_  (		datasets.BuilderConfig				):
						UpperCamelCase__      :						Optional[Callable]				       =None
						UpperCamelCase__      :						Optional[dict]				       =None
						UpperCamelCase__      :						Optional[datasets.Features]				       =None

						def 	__a       (    self	:List[str])		->					List[str]:
												assert self.generator is not None, "generator must be specified"

												if self.gen_kwargs is None:
																		UpperCAmelCase_     							=     {}







class 							a_  (		datasets.GeneratorBasedBuilder				):
						UpperCamelCase__      :						List[str]				       =GeneratorConfig

						def 	__a       (    self	:List[str])		->					List[Any]:
												return datasets.DatasetInfo(features=self.config.features)

						def 	__a       (    self	:Optional[Any]   ,						_lowercase	:List[str])		->					Optional[Any]:
												return [datasets.SplitGenerator(name=datasets.Split.TRAIN   ,						gen_kwargs=self.config.gen_kwargs)]




						def 	__a       (    self	:Optional[int]   ,						**_lowercase	:str)		->					Union[str, Any]:
												for idx, ex in enumerate(self.config.generator(**_lowercase)):
																		yield idx, ex





