int ScoreBoard(int scores[][7]) {
  int counters[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
  int x, y;
  for (y = 0; y < 6; y++) {
    int score = scores[y][0] + scores[y][1] + scores[y][2];
    for (x = 3; x < 7; x++) {
      score += scores[y][x];
      counters[score + 4]++;
      score -= scores[y][x - 3];
    }
  }
  for (x = 0; x < 7; x++) {
    int score = scores[0][x] + scores[1][x] + scores[2][x];
    for (y = 3; y < 6; y++) {
      score += scores[y][x];
      counters[score + 4]++;
      score -= scores[y - 3][x];
    }
  }
  for (y = 0; y < 6 - 3; y++) {
    for (x = 0; x < 7 - 3; x++) {
      int score = 0, idx = 0;
      for (idx = 0; idx < 4; idx++) {
        score += scores[y + idx][x + idx];
      }
      counters[score + 4]++;
    }
  }
  for (y = 3; y < 6; y++) {
    for (x = 0; x < 7 - 3; x++) {
      int score = 0, idx = 0;
      for (idx = 0; idx < 4; idx++) {
        score += scores[y - idx][x + idx];
      }
      counters[score + 4]++;
    }
  }
  if (counters[0] != 0)
    return -1000000;
  else if (counters[8] != 0)
    return 1000000;
  else
    return counters[5] + 2 * counters[6] + 5 * counters[7] - counters[3] -
           2 * counters[2] - 5 * counters[1];
}


x86 assembly (clang, -O0):
<ScoreBoard>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
lea    -0x40(%rbp),%rdi
xor    %esi,%esi
mov    $0x24,%edx
call   1030 <memset@plt>
movl   $0x0,-0x48(%rbp)
cmpl   $0x6,-0x48(%rbp)
jge    11f9 <ScoreBoard+0xe9>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    -0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
imul   $0x1c,%rdx,%rdx
add    %rdx,%rcx
add    0x4(%rcx),%eax
mov    -0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
imul   $0x1c,%rdx,%rdx
add    %rdx,%rcx
add    0x8(%rcx),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x3,-0x44(%rbp)
cmpl   $0x7,-0x44(%rbp)
jge    11e6 <ScoreBoard+0xd6>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x4,%eax
cltq
mov    -0x40(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    117c <ScoreBoard+0x6c>
jmp    11eb <ScoreBoard+0xdb>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1133 <ScoreBoard+0x23>
movl   $0x0,-0x44(%rbp)
cmpl   $0x7,-0x44(%rbp)
jge    12b4 <ScoreBoard+0x1a4>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
add    0x1c(%rcx,%rdx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
add    0x38(%rcx,%rdx,4),%eax
mov    %eax,-0x50(%rbp)
movl   $0x3,-0x48(%rbp)
cmpl   $0x6,-0x48(%rbp)
jge    12a1 <ScoreBoard+0x191>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    $0x4,%eax
cltq
mov    -0x40(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1237 <ScoreBoard+0x127>
jmp    12a6 <ScoreBoard+0x196>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1200 <ScoreBoard+0xf0>
movl   $0x0,-0x48(%rbp)
cmpl   $0x3,-0x48(%rbp)
jge    135d <ScoreBoard+0x24d>
movl   $0x0,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jge    134a <ScoreBoard+0x23a>
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x58(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    1329 <ScoreBoard+0x219>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12eb <ScoreBoard+0x1db>
mov    -0x54(%rbp),%eax
add    $0x4,%eax
cltq
mov    -0x40(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12cc <ScoreBoard+0x1bc>
jmp    134f <ScoreBoard+0x23f>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12bb <ScoreBoard+0x1ab>
movl   $0x3,-0x48(%rbp)
cmpl   $0x6,-0x48(%rbp)
jge    1406 <ScoreBoard+0x2f6>
movl   $0x0,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jge    13f3 <ScoreBoard+0x2e3>
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    13d2 <ScoreBoard+0x2c2>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1394 <ScoreBoard+0x284>
mov    -0x5c(%rbp),%eax
add    $0x4,%eax
cltq
mov    -0x40(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1375 <ScoreBoard+0x265>
jmp    13f8 <ScoreBoard+0x2e8>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1364 <ScoreBoard+0x254>
cmpl   $0x0,-0x40(%rbp)
je     141c <ScoreBoard+0x30c>
movl   $0xfff0bdc0,-0x4(%rbp)
jmp    1457 <ScoreBoard+0x347>
cmpl   $0x0,-0x20(%rbp)
je     1432 <ScoreBoard+0x322>
movl   $0xf4240,-0x4(%rbp)
jmp    1457 <ScoreBoard+0x347>
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
imul   $0x5,-0x24(%rbp),%ecx
add    %ecx,%eax
sub    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
imul   $0x5,-0x3c(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ScoreBoard>:
xorps  %xmm0,%xmm0
movaps %xmm0,-0x18(%rsp)
movaps %xmm0,-0x28(%rsp)
movl   $0x0,-0x8(%rsp)
mov    $0x18,%eax
nopw   0x0(%rax,%rax,1)
mov    -0x18(%rdi,%rax,1),%ecx
mov    -0x14(%rdi,%rax,1),%r9d
lea    (%r9,%rcx,1),%esi
mov    -0x10(%rdi,%rax,1),%r8d
add    %r8d,%esi
movslq -0xc(%rdi,%rax,1),%rdx
movslq %esi,%rsi
add    %rdx,%rsi
addl   $0x1,-0x18(%rsp,%rsi,4)
sub    %ecx,%esi
movslq -0x8(%rdi,%rax,1),%rcx
movslq %esi,%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
sub    %r9d,%edx
movslq -0x4(%rdi,%rax,1),%rcx
movslq %edx,%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
sub    %r8d,%edx
movslq (%rdi,%rax,1),%rcx
movslq %edx,%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
add    $0x1c,%rax
cmp    $0xc0,%rax
jne    1120 <ScoreBoard+0x20>
mov    $0xfffffffffffffff9,%rax
nop
mov    0x1c(%rdi,%rax,4),%ecx
mov    0x38(%rdi,%rax,4),%r8d
lea    (%r8,%rcx,1),%esi
movslq 0x54(%rdi,%rax,4),%rdx
movslq %esi,%rsi
add    %rdx,%rsi
movslq 0x70(%rdi,%rax,4),%rdx
add    %rsi,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
sub    %ecx,%edx
movslq 0x8c(%rdi,%rax,4),%rcx
movslq %edx,%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
sub    %r8d,%edx
movslq 0xa8(%rdi,%rax,4),%rcx
movslq %edx,%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
inc    %rax
jne    1190 <ScoreBoard+0x90>
mov    0x4(%rdi),%esi
mov    0x8(%rdi),%r11d
mov    0xc(%rdi),%r10d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rdi,%rax,1),%r9
movslq 0x20(%rdi,%rax,1),%r8
add    %r8,%r9
movslq 0x40(%rdi,%rax,1),%rdx
add    %r9,%rdx
movslq 0x60(%rdi,%rax,1),%rcx
add    %rdx,%rcx
addl   $0x1,-0x18(%rsp,%rcx,4)
mov    0x24(%rdi,%rax,1),%r9d
add    %r9d,%esi
movslq 0x44(%rdi,%rax,1),%rcx
movslq %esi,%rdx
add    %rcx,%rdx
movslq 0x64(%rdi,%rax,1),%rcx
add    %rdx,%rcx
addl   $0x1,-0x18(%rsp,%rcx,4)
movslq %r10d,%rcx
mov    0x28(%rdi,%rax,1),%r10d
add    %r10d,%r11d
movslq 0x48(%rdi,%rax,1),%rdx
movslq %r11d,%rsi
add    %rdx,%rsi
movslq 0x68(%rdi,%rax,1),%rdx
add    %rsi,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
movslq 0x2c(%rdi,%rax,1),%rdx
add    %rdx,%rcx
movslq 0x4c(%rdi,%rax,1),%rdx
add    %rcx,%rdx
movslq 0x6c(%rdi,%rax,1),%rcx
add    %rdx,%rcx
addl   $0x1,-0x18(%rsp,%rcx,4)
add    $0x1c,%rax
mov    %r9d,%r11d
mov    %r8d,%esi
cmp    $0x54,%rax
jne    1200 <ScoreBoard+0x100>
mov    $0xffffffffffffffac,%rax
nopl   0x0(%rax)
movslq 0xa8(%rdi,%rax,1),%rcx
movslq 0x90(%rdi,%rax,1),%rdx
add    %rcx,%rdx
movslq 0x78(%rdi,%rax,1),%rcx
add    %rdx,%rcx
movslq 0x60(%rdi,%rax,1),%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
movslq 0xac(%rdi,%rax,1),%rcx
movslq 0x94(%rdi,%rax,1),%rdx
add    %rcx,%rdx
movslq 0x7c(%rdi,%rax,1),%rcx
add    %rdx,%rcx
movslq 0x64(%rdi,%rax,1),%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
movslq 0xb0(%rdi,%rax,1),%rcx
movslq 0x98(%rdi,%rax,1),%rdx
add    %rcx,%rdx
movslq 0x80(%rdi,%rax,1),%rcx
add    %rdx,%rcx
movslq 0x68(%rdi,%rax,1),%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
movslq 0xb4(%rdi,%rax,1),%rcx
movslq 0x9c(%rdi,%rax,1),%rdx
add    %rcx,%rdx
movslq 0x84(%rdi,%rax,1),%rcx
add    %rdx,%rcx
movslq 0x6c(%rdi,%rax,1),%rdx
add    %rcx,%rdx
addl   $0x1,-0x18(%rsp,%rdx,4)
add    $0x1c,%rax
jne    12a0 <ScoreBoard+0x1a0>
mov    $0xfff0bdc0,%eax
cmpl   $0x0,-0x28(%rsp)
je     135d <ScoreBoard+0x25d>
ret
mov    $0xf4240,%eax
cmpl   $0x0,-0x8(%rsp)
jne    135c <ScoreBoard+0x25c>
mov    -0x14(%rsp),%eax
mov    -0xc(%rsp),%ecx
sub    -0x24(%rsp),%ecx
mov    -0x10(%rsp),%edx
lea    (%rcx,%rcx,4),%ecx
sub    -0x20(%rsp),%edx
sub    -0x1c(%rsp),%eax
lea    (%rax,%rdx,2),%eax
add    %ecx,%eax
ret

LLVM IR (-O0):
define i32 @ScoreBoard([7 x i32]* %0) {
%2 = alloca i32
%3 = alloca [7 x i32]*
%4 = alloca [9 x i32]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store [7 x i32]* %0, [7 x i32]** %3
%13 = bitcast [9 x i32]* %4 to i8*
store i32 0, i32* %6
br label %14
14: ; preds = %73, %1
%15 = load i32, i32* %6
%16 = icmp slt i32 %15, 6
br i1 %16, label %17, label %76
17: ; preds = %14
%18 = load [7 x i32]*, [7 x i32]** %3
%19 = load i32, i32* %6
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 %20
%22 = getelementptr inbounds [7 x i32], [7 x i32]* %21, i64 0, i64 0
%23 = load i32, i32* %22
%24 = load [7 x i32]*, [7 x i32]** %3
%25 = load i32, i32* %6
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [7 x i32], [7 x i32]* %24, i64 %26
%28 = getelementptr inbounds [7 x i32], [7 x i32]* %27, i64 0, i64 1
%29 = load i32, i32* %28
%30 = add nsw i32 %23, %29
%31 = load [7 x i32]*, [7 x i32]** %3
%32 = load i32, i32* %6
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [7 x i32], [7 x i32]* %31, i64 %33
%35 = getelementptr inbounds [7 x i32], [7 x i32]* %34, i64 0, i64 2
%36 = load i32, i32* %35
%37 = add nsw i32 %30, %36
store i32 %37, i32* %7
store i32 3, i32* %5
br label %38
38: ; preds = %69, %17
%39 = load i32, i32* %5
%40 = icmp slt i32 %39, 7
br i1 %40, label %41, label %72
41: ; preds = %38
%42 = load [7 x i32]*, [7 x i32]** %3
%43 = load i32, i32* %6
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [7 x i32], [7 x i32]* %42, i64 %44
%46 = load i32, i32* %5
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [7 x i32], [7 x i32]* %45, i64 0, i64 %47
%49 = load i32, i32* %48
%50 = load i32, i32* %7
%51 = add nsw i32 %50, %49
store i32 %51, i32* %7
%52 = load i32, i32* %7
%53 = add nsw i32 %52, 4
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 %54
%56 = load i32, i32* %55
%57 = add nsw i32 %56, 1
store i32 %57, i32* %55
%58 = load [7 x i32]*, [7 x i32]** %3
%59 = load i32, i32* %6
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [7 x i32], [7 x i32]* %58, i64 %60
%62 = load i32, i32* %5
%63 = sub nsw i32 %62, 3
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [7 x i32], [7 x i32]* %61, i64 0, i64 %64
%66 = load i32, i32* %65
%67 = load i32, i32* %7
%68 = sub nsw i32 %67, %66
store i32 %68, i32* %7
br label %69
69: ; preds = %41
%70 = load i32, i32* %5
%71 = add nsw i32 %70, 1
store i32 %71, i32* %5
br label %38
72: ; preds = %38
br label %73
73: ; preds = %72
%74 = load i32, i32* %6
%75 = add nsw i32 %74, 1
store i32 %75, i32* %6
br label %14
76: ; preds = %14
store i32 0, i32* %5
br label %77
77: ; preds = %136, %76
%78 = load i32, i32* %5
%79 = icmp slt i32 %78, 7
br i1 %79, label %80, label %139
80: ; preds = %77
%81 = load [7 x i32]*, [7 x i32]** %3
%82 = getelementptr inbounds [7 x i32], [7 x i32]* %81, i64 0
%83 = load i32, i32* %5
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [7 x i32], [7 x i32]* %82, i64 0, i64 %84
%86 = load i32, i32* %85
%87 = load [7 x i32]*, [7 x i32]** %3
%88 = getelementptr inbounds [7 x i32], [7 x i32]* %87, i64 1
%89 = load i32, i32* %5
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [7 x i32], [7 x i32]* %88, i64 0, i64 %90
%92 = load i32, i32* %91
%93 = add nsw i32 %86, %92
%94 = load [7 x i32]*, [7 x i32]** %3
%95 = getelementptr inbounds [7 x i32], [7 x i32]* %94, i64 2
%96 = load i32, i32* %5
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [7 x i32], [7 x i32]* %95, i64 0, i64 %97
%99 = load i32, i32* %98
%100 = add nsw i32 %93, %99
store i32 %100, i32* %8
store i32 3, i32* %6
br label %101
101: ; preds = %132, %80
%102 = load i32, i32* %6
%103 = icmp slt i32 %102, 6
br i1 %103, label %104, label %135
104: ; preds = %101
%105 = load [7 x i32]*, [7 x i32]** %3
%106 = load i32, i32* %6
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [7 x i32], [7 x i32]* %105, i64 %107
%109 = load i32, i32* %5
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [7 x i32], [7 x i32]* %108, i64 0, i64 %110
%112 = load i32, i32* %111
%113 = load i32, i32* %8
%114 = add nsw i32 %113, %112
store i32 %114, i32* %8
%115 = load i32, i32* %8
%116 = add nsw i32 %115, 4
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 %117
%119 = load i32, i32* %118
%120 = add nsw i32 %119, 1
store i32 %120, i32* %118
%121 = load [7 x i32]*, [7 x i32]** %3
%122 = load i32, i32* %6
%123 = sub nsw i32 %122, 3
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [7 x i32], [7 x i32]* %121, i64 %124
%126 = load i32, i32* %5
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [7 x i32], [7 x i32]* %125, i64 0, i64 %127
%129 = load i32, i32* %128
%130 = load i32, i32* %8
%131 = sub nsw i32 %130, %129
store i32 %131, i32* %8
br label %132
132: ; preds = %104
%133 = load i32, i32* %6
%134 = add nsw i32 %133, 1
store i32 %134, i32* %6
br label %101
135: ; preds = %101
br label %136
136: ; preds = %135
%137 = load i32, i32* %5
%138 = add nsw i32 %137, 1
store i32 %138, i32* %5
br label %77
139: ; preds = %77
store i32 0, i32* %6
br label %140
140: ; preds = %180, %139
%141 = load i32, i32* %6
%142 = icmp slt i32 %141, 3
br i1 %142, label %143, label %183
143: ; preds = %140
store i32 0, i32* %5
br label %144
144: ; preds = %176, %143
%145 = load i32, i32* %5
%146 = icmp slt i32 %145, 4
br i1 %146, label %147, label %179
147: ; preds = %144
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %10
br label %148
148: ; preds = %166, %147
%149 = load i32, i32* %10
%150 = icmp slt i32 %149, 4
br i1 %150, label %151, label %169
151: ; preds = %148
%152 = load [7 x i32]*, [7 x i32]** %3
%153 = load i32, i32* %6
%154 = load i32, i32* %10
%155 = add nsw i32 %153, %154
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [7 x i32], [7 x i32]* %152, i64 %156
%158 = load i32, i32* %5
%159 = load i32, i32* %10
%160 = add nsw i32 %158, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [7 x i32], [7 x i32]* %157, i64 0, i64 %161
%163 = load i32, i32* %162
%164 = load i32, i32* %9
%165 = add nsw i32 %164, %163
store i32 %165, i32* %9
br label %166
166: ; preds = %151
%167 = load i32, i32* %10
%168 = add nsw i32 %167, 1
store i32 %168, i32* %10
br label %148
169: ; preds = %148
%170 = load i32, i32* %9
%171 = add nsw i32 %170, 4
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 %172
%174 = load i32, i32* %173
%175 = add nsw i32 %174, 1
store i32 %175, i32* %173
br label %176
176: ; preds = %169
%177 = load i32, i32* %5
%178 = add nsw i32 %177, 1
store i32 %178, i32* %5
br label %144
179: ; preds = %144
br label %180
180: ; preds = %179
%181 = load i32, i32* %6
%182 = add nsw i32 %181, 1
store i32 %182, i32* %6
br label %140
183: ; preds = %140
store i32 3, i32* %6
br label %184
184: ; preds = %224, %183
%185 = load i32, i32* %6
%186 = icmp slt i32 %185, 6
br i1 %186, label %187, label %227
187: ; preds = %184
store i32 0, i32* %5
br label %188
188: ; preds = %220, %187
%189 = load i32, i32* %5
%190 = icmp slt i32 %189, 4
br i1 %190, label %191, label %223
191: ; preds = %188
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %12
br label %192
192: ; preds = %210, %191
%193 = load i32, i32* %12
%194 = icmp slt i32 %193, 4
br i1 %194, label %195, label %213
195: ; preds = %192
%196 = load [7 x i32]*, [7 x i32]** %3
%197 = load i32, i32* %6
%198 = load i32, i32* %12
%199 = sub nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [7 x i32], [7 x i32]* %196, i64 %200
%202 = load i32, i32* %5
%203 = load i32, i32* %12
%204 = add nsw i32 %202, %203
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [7 x i32], [7 x i32]* %201, i64 0, i64 %205
%207 = load i32, i32* %206
%208 = load i32, i32* %11
%209 = add nsw i32 %208, %207
store i32 %209, i32* %11
br label %210
210: ; preds = %195
%211 = load i32, i32* %12
%212 = add nsw i32 %211, 1
store i32 %212, i32* %12
br label %192
213: ; preds = %192
%214 = load i32, i32* %11
%215 = add nsw i32 %214, 4
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 %216
%218 = load i32, i32* %217
%219 = add nsw i32 %218, 1
store i32 %219, i32* %217
br label %220
220: ; preds = %213
%221 = load i32, i32* %5
%222 = add nsw i32 %221, 1
store i32 %222, i32* %5
br label %188
223: ; preds = %188
br label %224
224: ; preds = %223
%225 = load i32, i32* %6
%226 = add nsw i32 %225, 1
store i32 %226, i32* %6
br label %184
227: ; preds = %184
%228 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 0
%229 = load i32, i32* %228
%230 = icmp ne i32 %229, 0
br i1 %230, label %231, label %232
231: ; preds = %227
store i32 -1000000, i32* %2
br label %259
232: ; preds = %227
%233 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 8
%234 = load i32, i32* %233
%235 = icmp ne i32 %234, 0
br i1 %235, label %236, label %237
236: ; preds = %232
store i32 1000000, i32* %2
br label %259
237: ; preds = %232
%238 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 5
%239 = load i32, i32* %238
%240 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 6
%241 = load i32, i32* %240
%242 = mul nsw i32 2, %241
%243 = add nsw i32 %239, %242
%244 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 7
%245 = load i32, i32* %244
%246 = mul nsw i32 5, %245
%247 = add nsw i32 %243, %246
%248 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 3
%249 = load i32, i32* %248
%250 = sub nsw i32 %247, %249
%251 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 2
%252 = load i32, i32* %251
%253 = mul nsw i32 2, %252
%254 = sub nsw i32 %250, %253
%255 = getelementptr inbounds [9 x i32], [9 x i32]* %4, i64 0, i64 1
%256 = load i32, i32* %255
%257 = mul nsw i32 5, %256
%258 = sub nsw i32 %254, %257
store i32 %258, i32* %2
br label %259
259: ; preds = %237, %236, %231
%260 = load i32, i32* %2
ret i32 %260
}

LLVM IR (-O2):
define i32 @ScoreBoard([7 x i32]* nocapture %0) {
%2 = alloca [9 x i32]
%3 = bitcast [9 x i32]* %2 to i8*
br label %4
4: ; preds = %1, %4
%5 = phi i64 [ 0, %1 ], [ %49, %4 ]
%6 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %5, i64 0
%7 = load i32, i32* %6
%8 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %5, i64 1
%9 = load i32, i32* %8
%10 = add nsw i32 %9, %7
%11 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %5, i64 2
%12 = load i32, i32* %11
%13 = add nsw i32 %10, %12
%14 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %5, i64 3
%15 = load i32, i32* %14
%16 = add nsw i32 %15, %13
%17 = add nsw i32 %16, 4
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %18
%20 = load i32, i32* %19
%21 = add nsw i32 %20, 1
store i32 %21, i32* %19
%22 = sub nsw i32 %16, %7
%23 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %5, i64 4
%24 = load i32, i32* %23
%25 = add nsw i32 %24, %22
%26 = add nsw i32 %25, 4
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %27
%29 = load i32, i32* %28
%30 = add nsw i32 %29, 1
store i32 %30, i32* %28
%31 = sub nsw i32 %25, %9
%32 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %5, i64 5
%33 = load i32, i32* %32
%34 = add nsw i32 %33, %31
%35 = add nsw i32 %34, 4
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %36
%38 = load i32, i32* %37
%39 = add nsw i32 %38, 1
store i32 %39, i32* %37
%40 = sub nsw i32 %34, %12
%41 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %5, i64 6
%42 = load i32, i32* %41
%43 = add nsw i32 %42, %40
%44 = add nsw i32 %43, 4
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %45
%47 = load i32, i32* %46
%48 = add nsw i32 %47, 1
store i32 %48, i32* %46
%49 = add nuw nsw i64 %5, 1
%50 = icmp eq i64 %49, 6
br i1 %50, label %51, label %4
51: ; preds = %4, %51
%52 = phi i64 [ %87, %51 ], [ 0, %4 ]
%53 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 0, i64 %52
%54 = load i32, i32* %53
%55 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 1, i64 %52
%56 = load i32, i32* %55
%57 = add nsw i32 %56, %54
%58 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 2, i64 %52
%59 = load i32, i32* %58
%60 = add nsw i32 %57, %59
%61 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 3, i64 %52
%62 = load i32, i32* %61
%63 = add nsw i32 %62, %60
%64 = add nsw i32 %63, 4
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %65
%67 = load i32, i32* %66
%68 = add nsw i32 %67, 1
store i32 %68, i32* %66
%69 = sub nsw i32 %63, %54
%70 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 4, i64 %52
%71 = load i32, i32* %70
%72 = add nsw i32 %71, %69
%73 = add nsw i32 %72, 4
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %74
%76 = load i32, i32* %75
%77 = add nsw i32 %76, 1
store i32 %77, i32* %75
%78 = sub nsw i32 %72, %56
%79 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 5, i64 %52
%80 = load i32, i32* %79
%81 = add nsw i32 %80, %78
%82 = add nsw i32 %81, 4
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %83
%85 = load i32, i32* %84
%86 = add nsw i32 %85, 1
store i32 %86, i32* %84
%87 = add nuw nsw i64 %52, 1
%88 = icmp eq i64 %87, 7
br i1 %88, label %89, label %51
89: ; preds = %51
%90 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 0, i64 1
%91 = load i32, i32* %90
%92 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 0, i64 2
%93 = load i32, i32* %92
%94 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 0, i64 3
%95 = load i32, i32* %94
br label %96
96: ; preds = %89, %96
%97 = phi i32 [ %95, %89 ], [ %135, %96 ]
%98 = phi i32 [ %93, %89 ], [ %121, %96 ]
%99 = phi i32 [ %91, %89 ], [ %105, %96 ]
%100 = phi i64 [ 0, %89 ], [ %103, %96 ]
%101 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %100, i64 0
%102 = load i32, i32* %101
%103 = add nuw nsw i64 %100, 1
%104 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %103, i64 1
%105 = load i32, i32* %104
%106 = add nsw i32 %105, %102
%107 = add nuw nsw i64 %100, 2
%108 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %107, i64 2
%109 = load i32, i32* %108
%110 = add nsw i32 %109, %106
%111 = add nuw nsw i64 %100, 3
%112 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %111, i64 3
%113 = load i32, i32* %112
%114 = add nsw i32 %113, %110
%115 = add nsw i32 %114, 4
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %116
%118 = load i32, i32* %117
%119 = add nsw i32 %118, 1
store i32 %119, i32* %117
%120 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %103, i64 2
%121 = load i32, i32* %120
%122 = add nsw i32 %121, %99
%123 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %107, i64 3
%124 = load i32, i32* %123
%125 = add nsw i32 %124, %122
%126 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %111, i64 4
%127 = load i32, i32* %126
%128 = add nsw i32 %127, %125
%129 = add nsw i32 %128, 4
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %130
%132 = load i32, i32* %131
%133 = add nsw i32 %132, 1
store i32 %133, i32* %131
%134 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %103, i64 3
%135 = load i32, i32* %134
%136 = add nsw i32 %135, %98
%137 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %107, i64 4
%138 = load i32, i32* %137
%139 = add nsw i32 %138, %136
%140 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %111, i64 5
%141 = load i32, i32* %140
%142 = add nsw i32 %141, %139
%143 = add nsw i32 %142, 4
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %144
%146 = load i32, i32* %145
%147 = add nsw i32 %146, 1
store i32 %147, i32* %145
%148 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %103, i64 4
%149 = load i32, i32* %148
%150 = add nsw i32 %149, %97
%151 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %107, i64 5
%152 = load i32, i32* %151
%153 = add nsw i32 %152, %150
%154 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %111, i64 6
%155 = load i32, i32* %154
%156 = add nsw i32 %155, %153
%157 = add nsw i32 %156, 4
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %158
%160 = load i32, i32* %159
%161 = add nsw i32 %160, 1
store i32 %161, i32* %159
%162 = icmp eq i64 %103, 3
br i1 %162, label %163, label %96
163: ; preds = %96, %163
%164 = phi i64 [ %232, %163 ], [ 3, %96 ]
%165 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %164, i64 0
%166 = load i32, i32* %165
%167 = add nsw i64 %164, -1
%168 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %167, i64 1
%169 = load i32, i32* %168
%170 = add nsw i32 %169, %166
%171 = add nsw i64 %164, -2
%172 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %171, i64 2
%173 = load i32, i32* %172
%174 = add nsw i32 %173, %170
%175 = add nsw i64 %164, -3
%176 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %175, i64 3
%177 = load i32, i32* %176
%178 = add nsw i32 %177, %174
%179 = add nsw i32 %178, 4
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %180
%182 = load i32, i32* %181
%183 = add nsw i32 %182, 1
store i32 %183, i32* %181
%184 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %164, i64 1
%185 = load i32, i32* %184
%186 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %167, i64 2
%187 = load i32, i32* %186
%188 = add nsw i32 %187, %185
%189 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %171, i64 3
%190 = load i32, i32* %189
%191 = add nsw i32 %190, %188
%192 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %175, i64 4
%193 = load i32, i32* %192
%194 = add nsw i32 %193, %191
%195 = add nsw i32 %194, 4
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %196
%198 = load i32, i32* %197
%199 = add nsw i32 %198, 1
store i32 %199, i32* %197
%200 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %164, i64 2
%201 = load i32, i32* %200
%202 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %167, i64 3
%203 = load i32, i32* %202
%204 = add nsw i32 %203, %201
%205 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %171, i64 4
%206 = load i32, i32* %205
%207 = add nsw i32 %206, %204
%208 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %175, i64 5
%209 = load i32, i32* %208
%210 = add nsw i32 %209, %207
%211 = add nsw i32 %210, 4
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %212
%214 = load i32, i32* %213
%215 = add nsw i32 %214, 1
store i32 %215, i32* %213
%216 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %164, i64 3
%217 = load i32, i32* %216
%218 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %167, i64 4
%219 = load i32, i32* %218
%220 = add nsw i32 %219, %217
%221 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %171, i64 5
%222 = load i32, i32* %221
%223 = add nsw i32 %222, %220
%224 = getelementptr inbounds [7 x i32], [7 x i32]* %0, i64 %175, i64 6
%225 = load i32, i32* %224
%226 = add nsw i32 %225, %223
%227 = add nsw i32 %226, 4
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 %228
%230 = load i32, i32* %229
%231 = add nsw i32 %230, 1
store i32 %231, i32* %229
%232 = add nuw nsw i64 %164, 1
%233 = icmp eq i64 %232, 6
br i1 %233, label %234, label %163
234: ; preds = %163
%235 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 0
%236 = load i32, i32* %235
%237 = icmp eq i32 %236, 0
br i1 %237, label %238, label %262
238: ; preds = %234
%239 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 8
%240 = load i32, i32* %239
%241 = icmp eq i32 %240, 0
br i1 %241, label %242, label %262
242: ; preds = %238
%243 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 5
%244 = load i32, i32* %243
%245 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 6
%246 = load i32, i32* %245
%247 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 7
%248 = load i32, i32* %247
%249 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 3
%250 = load i32, i32* %249
%251 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 2
%252 = load i32, i32* %251
%253 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 1
%254 = load i32, i32* %253
%255 = sub i32 %248, %254
%256 = mul i32 %255, 5
%257 = sub i32 %246, %252
%258 = shl i32 %257, 1
%259 = sub i32 %244, %250
%260 = add i32 %259, %258
%261 = add i32 %260, %256
br label %262
262: ; preds = %238, %234, %242
%263 = phi i32 [ %261, %242 ], [ -1000000, %234 ], [ 1000000, %238 ]
ret i32 %263
}