






'''simple docstring'''
def 				a						( )					->					list[list[int]]:






					"""simple docstring"""







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


__lowerCAmelCase				=generate_large_matrix()
__lowerCAmelCase				=(
    [[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						( _UpperCAmelCase			)					->					None:






					"""simple docstring"""







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

def 				a						( _UpperCAmelCase			)					->					int:






					"""simple docstring"""







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

def 				a						( _UpperCAmelCase			)					->					int:






					"""simple docstring"""







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

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

def 				a						( _UpperCAmelCase			)					->					int:






					"""simple docstring"""







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

def 				a						( _UpperCAmelCase			)					->					int:






					"""simple docstring"""







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

def 				a						( )					->					None:






					"""simple docstring"""







					from timeit import timeit

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


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						benchmark()


'''simple docstring'''




from __future__ import annotations

import math






def 							snake_case__				(     _A:   int					)       ->      list[int]:

		'''simple docstring'''


		if num <= 0:
				lowerCAmelCase     =    f"{num}: Invalid input, please enter a positive integer."
				raise ValueError(_A					)

		lowerCAmelCase     =    [True] * (num + 1)
		lowerCAmelCase     =    []
		lowerCAmelCase     =    2
		lowerCAmelCase     =    int(math.sqrt(_A					)					)

		while start <= end:
				# If start is a prime
				if sieve[start] is True:
						prime.append(_A					)

						# Set multiples of start be False
						for i in range(start * start ,  num + 1 ,  _A					):
								if sieve[i] is True:
										lowerCAmelCase     =    False

				start += 1

		for j in range(end + 1 ,  num + 1					):
				if sieve[j] is True:
						prime.append(_A					)

		return prime


if __name__ == "__main__":
						print(prime_sieve(int(input('''Enter a positive integer: ''').strip())))




