"""simple docstring"""






def   a_						(					):
				return [list(range(1_0_0_0 - i					,			-1_0_0_0 - i					,			-1       )       ) for i in range(1_0_0_0       )]


lowerCAmelCase__  :  Any						     =	generate_large_matrix()
lowerCAmelCase__  :  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   a_						(					lowerCamelCase       ):
				assert all(row == sorted(lowerCamelCase					,			reverse=lowerCamelCase       ) for row in grid       )
				assert all(list(lowerCamelCase       ) == sorted(lowerCamelCase					,			reverse=lowerCamelCase       ) for col in zip(*lowerCamelCase       )       )



def   a_						(					lowerCamelCase       ):
				UpperCAmelCase__             =							0
				UpperCAmelCase__             =							len(lowerCamelCase       ) - 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:
								UpperCAmelCase__             =							(left + right) // 2
								UpperCAmelCase__             =							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:
												UpperCAmelCase__             =							mid + 1
								else:
												UpperCAmelCase__             =							mid - 1
    # No negative numbers so return the last index of the array + 1 which is the length.
				return len(lowerCamelCase       )



def   a_						(					lowerCamelCase       ):
				UpperCAmelCase__             =							0
				UpperCAmelCase__             =							len(grid[0]       )

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



def   a_						(					lowerCamelCase       ):
				return len([number for row in grid for number in row if number < 0]       )



def   a_						(					lowerCamelCase       ):
				UpperCAmelCase__             =							0
				for row in grid:
								for i, number in enumerate(lowerCamelCase       ):
												if number < 0:
																total += len(lowerCamelCase       ) - i
																break
				return total



def   a_						(					):
				from timeit import timeit

				print('Running benchmarks'       )
				UpperCAmelCase__             =							(
				    '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
				):
								UpperCAmelCase__             =							timeit(f'''{func}(grid=grid)'''					,			setup=lowerCamelCase					,			number=5_0_0       )
								print(f'''{func}() took {time:0.4f} seconds'''       )


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						benchmark()










"""simple docstring"""




import heapq as hq
import math
from collections.abc import Iterator


class        __UpperCamelCase				:






							def __init__(   self      ,					lowerCAmelCase__      )	-> Optional[int]:
								a      :		List[str]	=				str(id_      )
								a      :		Optional[Any]	=				None
								a      :		Tuple	=				None
								a      :		str	=				[]
								a      :		Any	=				{}  # {vertex:distance}






							def __lt__(   self      ,					lowerCAmelCase__      )	-> Any:
								return self.key < other.key






							def __repr__(   self      )	-> Optional[Any]:
								return self.id






							def     __a   (   self      ,					lowerCAmelCase__      )	-> Any:
								self.neighbors.append(lowerCAmelCase__      )






							def     __a   (   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )	-> Tuple:
								a      :		Optional[Any]	=				weight






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    int    ,       _lowercase						:    int    ,       _lowercase						:    int    ,       _lowercase						:    Union[str, Any]					) ->str:






	'''simple docstring'''






	graph[a - 1].add_neighbor(graph[b - 1]					)
	graph[b - 1].add_neighbor(graph[a - 1]					)
	# add the edges:
	graph[a - 1].add_edge(graph[b - 1]    ,       _lowercase					)
	graph[b - 1].add_edge(graph[a - 1]    ,       _lowercase					)






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    list    ,       _lowercase						:    Vertex					) ->list:






	'''simple docstring'''






	a      :		int	=				[]
	for u in graph:
		a      :		List[str]	=				math.inf
		a      :		int	=				None
	a      :		str	=				0
	a      :		Union[str, Any]	=				graph[:]
	while q:
		a      :		List[Any]	=				min(_lowercase					)
		q.remove(_lowercase					)
		for v in u.neighbors:
			if (v in q) and (u.edges[v.id] < v.key):
				a      :		List[Any]	=				u
				a      :		Optional[int]	=				u.edges[v.id]
	for i in range(1    ,       len(_lowercase					)					):
		a.append((int(graph[i].id					) + 1, int(graph[i].pi.id					) + 1)					)
	return a






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    list    ,       _lowercase						:    Vertex					) ->Iterator[tuple]:






	'''simple docstring'''






	for u in graph:
		a      :		str	=				math.inf
		a      :		Dict	=				None
	a      :		Dict	=				0

	a      :		List[Any]	=				list(_lowercase					)
	hq.heapify(_lowercase					)

	while h:
		a      :		Dict	=				hq.heappop(_lowercase					)
		for v in u.neighbors:
			if (v in h) and (u.edges[v.id] < v.key):
				a      :		Dict	=				u
				a      :		Optional[Any]	=				u.edges[v.id]
				hq.heapify(_lowercase					)

	for i in range(1    ,       len(_lowercase					)					):
		yield (int(graph[i].id					) + 1, int(graph[i].pi.id					) + 1)






def       _SCREAMING_SNAKE_CASE		(	) ->None:






	'''simple docstring'''








if __name__ == "__main__":
		import doctest

		doctest.testmod()


