• Dart

OUTER: for (var i = 0; i < m.length; i++) {
  for (var j = 0; j < m[i].length; j++) {
    if (m[i][j] < 0) {
      print("Negative value found at $i,$j: ${m[i][j]}");
      break OUTER;
    }
  }
}

• Ada

Outer_loop:
for A in M'Range (1) loop
   Inner_Loop:
   for B in M'Range (2) loop
      if M (A, B) < 0 then
         Put_Line (M (A, B)'Image);
         exit Outer_Loop;
      end if;
   end loop Inner_Loop;
end loop Outer_Loop;

• C

int i,j;
for(i=0;i<sizeof(m)/sizeof(*m);i++)
{
	for(j=0;j<sizeof(*m)/sizeof(**m);j++)
	{
		if(m[i][j]<0)
		{
			printf("%d\n",m[i][j]);
			goto end;
		}
	}
}
end:

• Clojure

(loop [rows m]
  (if-let [v (some #(when (neg? %) %) (first rows))]
    v
    (recur (rest rows))))

• C++

auto indices = findNegativeValue (m, 10, 20);
std::cout << m[indices.first][indices.second] << '\n';

std::pair<int, int> findNegativeValue (int **m, int rows, int columns) {
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < columns; ++j) {
      if (m[i][j] < 0) return make_pair (i, j);
    }
  }
  throw "No negative value!";
}

• C#

foreach (int v in m)
{
    if (v < 0)
    {
        Console.WriteLine(v);
        break;
    }
}

• C#

bool keepLooping = true;

for(int i = 0; i < m.length && keepLooping; i++)
{
	for(int j = 0; j < m[i].length && keepLooping; j++)
	{
		if(m[i][j] < 0)
		{
			Console.WriteLine(m[i][j]);
			keepLooping = false;
		}
	}
}

• C#

for (
        int i = 0,
        rows = m.GetLength(0),
        cols = m.GetLength(1); i < rows; i++)
{
    for (int j = 0; j < cols; j++)
    {
        if (m[i, j] < 0)
        {
            Console.WriteLine(m[i, j]);
            i = int.MaxValue - 1; // Break outer loop.
            break;
        }
    }
}

• C#

foreach (int[] row in m)
{
    foreach (int v in row)
    {
        if (v < 0)
        {
            Console.WriteLine(v);
            goto DONE;
        }
    }
}
DONE: ;

• D

outer:
foreach (i; 0 .. m.length)
{
	foreach (j; 0 .. m[i].length)
	{
		if (m[i][j] < 0)
		{
			writeln(m[i][j]);
			break outer;
		}
	}
}

• Elixir

  def main([]), do: nil
  def main([row | rows]), do: main(row, rows)
  def main([], rows), do: main(rows)
  def main([number | numbers], rows) when number >= 0, do: main(numbers, rows)
  def main([number | _], _), do: number

• Erlang

find_negative_in([]) -> undefined;
find_negative_in([Row|Rows]) -> find_negative_in(Row, Rows).

find_negative_in([], Rows) -> find_negative_in(Rows);
find_negative_in([Pos|Values], Rows) when Pos >= 0 ->
	find_negative_in(Values, Rows);
find_negative_in([Neg|_], _) -> Neg.

• Fortran

  outer: do j=1, size(m,2)
     do i=1, size(m,1)
        v = m(i,j)
        if (v < 0) then
           print *,v
           exit outer
        end if
     end do
  end do outer

• Go

mainloop:
	for i, line := range m {
		for _, v := range line {
			if v < 0 {
				fmt.Println(v)
				break mainloop
			}
		}
	}

• Haskell

(print . head . filter (<0) . concat) m

• JS

OUTER:
for (var i in m) {
   for (var j in m[i]) {
      if (m[i][j] < 0) {
         console.log("Negative value found: "+m[i][j]);
         break OUTER;
      }
   }
}

• Java

   int i, j, M = m.length, N = m[0].length, x;
a: for (i = 0; i < M; ++i)
       for (j = 0; j < N; ++j)
           if ((x = m[i][j]) < 0) {
               out.println(x);
               break a;
           }

• Java

int i, j, M = m.length, N = m[0].length, x;
boolean b = false;
for (i = 0; i < M; ++i) {
    for (j = 0; j < N; ++j)
        if ((x = m[i][j]) < 0) {
            out.println(x);
            b = true;
            break;
        }
    if (b) break;
}

• Java

mainloop: for(int i=0;i<m.length;i++)
	for(int j=0;j<m[i].length;j++)
		if(m[i][j]<0){
			System.out.println(m[i][j]);
			break mainloop;
		}

• Kotlin

loop@ for (x in 0..7) {
  for (y in 0..7) {
    val v = m[x][y]
    if ( v < 0) {
       println("found a negative value at [$x][$y]: $v")
       break@loop
     }
  }
}

• Lisp

(loop named outer
      for i below (array-dimension m 0)
      do (loop for j below (array-dimension m 1)
               for v = (aref m i j)
               when (minusp v)
               do (progn
                    (print v)
                    (return-from outer))))

• Lua

breakout = false
for i,v1 in ipairs(m) do
   for j,v2 in ipairs(v1) do
      if v2 < 0 then
         print(v2)
         state = "found"
         breakout = true
         break
      end
   end
   if breakout then break end
end

• Lua

for _,v1 in ipairs(m) do
 for _,v2 in ipairs(v1) do
  if v2<0 then
   print(v2)
   goto outer
  end
 end
end
::outer::

• Obj-C

[m enumerateObjectsUsingBlock:^(NSArray *row, NSUInteger rn, BOOL *stopr) {
  [row enumerateObjectsUsingBlock:^(NSNumber *v, NSUInteger cn, BOOL *stopc) {
    if (v.intValue<0) {
      NSLog(@"found %@ at row:%lu col:%lu",v,rn,cn);
      *stopr=*stopc=YES;
      return; // to quit the current block immediately
    }
  }];
}];

• PHP

for ($y = 0; $y < count($m); $y++) {
    for ($x = 0; $x < count($m[$y]); $x++) {
        if ($m[$y][$x] == $v) {
            break 2;
        }
    }
}

• Pascal

var i,j: integer;
   flag:boolean;
[...]
for i := 0 to length(m) * length(m[0]) - 1 do
begin
  v := m[i mod length(m), i div length(m)];
  if v < 0 then
  begin
    writeln(v);
    break;
  end;
end;

for i := 0 to high(m) do
begin
  for v in m[i] do
  begin
    flag := (v < 0);
    if flag then
    begin
      writeln(v);
      break;
    end;
  end;
  if flag then
    break;
end;

• Perl

OUTER: for my $row (@m) {
   INNER: for my $v (@$row) {
      if ($v < 0) {
         print "Negative value found: $v\n";
         last OUTER;
      }
   }
}

• Python

class BreakOuterLoop (Exception): pass

try:
    position = None
    for row in m:
        for column in m[row]:
            if m[row][column] == v:
                position = (row, column)
                raise BreakOuterLoop
except BreakOuterLoop:
    pass

• Python

matrix = [[1,2,3],[4,-5,6],[7,8,9]]
try:
    print(next(i for i in chain.from_iterable(matrix) if i < 0))
except StopIteration:
    pass

• Python

def loop_breaking(m, v): 
    for i, row in enumerate(m): 
        for j, value in enumerate(row): 
            if value == v: 
                return (i, j)
    return None

print(loop_breaking(([1,2,3],[4,5,6],[7,8,9]), 6))

• Python

z = False
for a in m:
    for b in a:
        if z := b < 0:
            print(b)
            break
    if z: break

• Ruby

negative_value = catch :negative do
  matrix.each do |row|
    row.each do |value|
      throw :negative, value if value < 0
    end
  end
end

puts negative_value

• Rust

'outer: for v in m {
    'inner: for i in v {
        if i < 0 {
            println!("Found {}", i);
            break 'outer;
        }
    }
}

• Smalltalk

| negativeValue |
negativeValue := [ :matrix || ctx |
    ctx := thisContext sender.
    matrix do: [ :row |
        row do: [ :value |
            (value < 0) ifTrue: [ ctx resumeWith: value ].
        ]
    ]
] value: m. "ex. m := #((1 2 -1 3))"
Transcript show: negativeValue; cr.

• VB

Select Case Nothing
    Case Else
        For Each row As Integer() in m
            For Each v As Integer In row
                If v < 0 Then
                    Console.WriteLine(v)
                    Exit Select
                End If
            Next
        Next
End Select

• VB

Dim colCount As Integer = m(0).Length
For Each row As Integer() In m
    Dim j = 0
    Do While j < colCount
        Dim v = row(j)
        If v < 0 Then
            Console.WriteLine(v)
            Exit For
        End If
        j += 1
    Loop
Next

• VB

    For Each row As Integer() in m
        For Each v As Integer In row
            If v < 0 Then
                Console.WriteLine(v)
                GoTo DONE
            End If
        Next
    Next
DONE:

• VB

For i As Integer = 0 To m.GetLength(0) - 1
    For j As Integer = 0 To m.GetLength(1) - 1
        If m(i, j) < 0 Then
            Console.WriteLine(m(i, j))
            i = Integer.MaxValue - 1 ' Break outer loop.
            Exit For
        End If
    Next
Next