





def       A__(		):
    return [list(range(10_00 - i	,			-10_00 - i	,			-1 ) ) for i in range(10_00 )]


lowercase_		:				List[str]				=						generate_large_matrix()
lowercase_		:				Optional[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(lowercase_	,			reverse=lowercase_ ) for row in grid )
    assert all(list(lowercase_ ) == sorted(lowercase_	,			reverse=lowercase_ ) for col in zip(*lowercase_ ) )

def       A__(		__lowerCAmelCase ):
    _snake_case :			Optional[Any]  						=   0
    _snake_case :			str  						=   len(lowercase_ ) - 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:
        _snake_case :			Dict  						=   (left + right) // 2
        _snake_case :			str  						=   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:
            _snake_case :			Optional[Any]  						=   mid + 1
        else:
            _snake_case :			List[Any]  						=   mid - 1
    # No negative numbers so return the last index of the array + 1 which is the length.
    return len(lowercase_ )

def       A__(		__lowerCAmelCase ):
    _snake_case :			Any  						=   0
    _snake_case :			List[str]  						=   len(grid[0] )

    for i in range(len(lowercase_ ) ):
        _snake_case :			List[str]  						=   find_negative_index(grid[i][:bound] )
        total += bound
    return (len(lowercase_ ) * len(grid[0] )) - total

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

def       A__(		__lowerCAmelCase ):
    _snake_case :			List[Any]  						=   0
    for row in grid:
        for i, number in enumerate(lowercase_ ):
            if number < 0:
                total += len(lowercase_ ) - i
                break
    return total

def       A__(		):
    from timeit import timeit

    print('Running benchmarks' )
    _snake_case :			List[str]  						=   (
        "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
    ):
        _snake_case :			List[str]  						=   timeit(F'''{func}(grid=grid)'''	,			setup=lowercase_	,			number=5_00 )
        print(F'''{func}() took {time:0.4f} seconds''' )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  benchmark()













from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowercase_		:				Optional[int]				=						{
    '''configuration_mega''': ['''MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MegaConfig''', '''MegaOnnxConfig'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase_		:				Any				=						[
		    '''MEGA_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''MegaForCausalLM''',
		    '''MegaForMaskedLM''',
		    '''MegaForMultipleChoice''',
		    '''MegaForQuestionAnswering''',
		    '''MegaForSequenceClassification''',
		    '''MegaForTokenClassification''',
		    '''MegaModel''',
		    '''MegaPreTrainedModel''',
		]

if TYPE_CHECKING:
		from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_mega import (
				    MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
				    MegaForCausalLM,
				    MegaForMaskedLM,
				    MegaForMultipleChoice,
				    MegaForQuestionAnswering,
				    MegaForSequenceClassification,
				    MegaForTokenClassification,
				    MegaModel,
				    MegaPreTrainedModel,
				)

else:
		import sys

		lowercase_		:				str				=						_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






