


"""simple docstring"""


def _lowerCamelCase      (						):

			'''simple docstring'''




			return [list(range(1000 - i       ,					-1000 - i       ,					-1 ) ) for i in range(1000 )]


A	:  Union[str, Any]            =     generate_large_matrix()
A	:  List[Any]            =     (
    [[4, 3, 2, -1], [3, 2, 1, -1], [1, 1, -1, -2], [-1, -1, -2, -3]],
    [[3, 2], [1, 0]],
    [[7, 7, 6]],
    [[7, 7, 6], [-1, -2, -3]],
    grid,
)


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert all(row == sorted(_UpperCamelCase       ,					reverse=_UpperCamelCase ) for row in grid )
			assert all(list(_UpperCamelCase ) == sorted(_UpperCamelCase       ,					reverse=_UpperCamelCase ) for col in zip(*_UpperCamelCase ) )


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			__lowerCAmelCase							       =     0
			__lowerCAmelCase							       =     len(_UpperCamelCase ) - 1

			# Edge cases such as no values or all numbers are negative.
			if not array or array[0] < 0:
						return 0

			while right + 1 > left:
						__lowerCAmelCase							       =     (left + right) // 2
						__lowerCAmelCase							       =     array[mid]

						# Num must be negative and the index must be greater than or equal to 0.
						if num < 0 and array[mid - 1] >= 0:
									return mid

						if num >= 0:
									__lowerCAmelCase							       =     mid + 1
						else:
									__lowerCAmelCase							       =     mid - 1
    # No negative numbers so return the last index of the array + 1 which is the length.
			return len(_UpperCamelCase )


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			__lowerCAmelCase							       =     0
			__lowerCAmelCase							       =     len(grid[0] )

			for i in range(len(_UpperCamelCase ) ):
						__lowerCAmelCase							       =     find_negative_index(grid[i][:bound] )
						total += bound
			return (len(_UpperCamelCase ) * len(grid[0] )) - total


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			return len([number for row in grid for number in row if number < 0] )


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			__lowerCAmelCase							       =     0
			for row in grid:
						for i, number in enumerate(_UpperCamelCase ):
									if number < 0:
												total += len(_UpperCamelCase ) - i
												break
			return total


def _lowerCamelCase      (						):

			'''simple docstring'''




			from timeit import timeit

			print("Running benchmarks" )
			__lowerCAmelCase							       =     (
			    "from __main__ import count_negatives_binary_search, "
			    "count_negatives_brute_force, count_negatives_brute_force_with_break, grid"
			)
			for func in (
			    "count_negatives_binary_search",  # took 0.7727 seconds
			    "count_negatives_brute_force_with_break",  # took 4.6505 seconds
			    "count_negatives_brute_force",  # took 12.8160 seconds
			):
						__lowerCAmelCase							       =     timeit(f"{func}(grid=grid)"       ,					setup=_UpperCamelCase       ,					number=500 )
						print(f"{func}() took {time:0.4f} seconds" )


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	benchmark()








"""simple docstring"""


from ..utils import DummyObject, requires_backends
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )




