#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ var_check_1(int *, int *, int /*<<< orphan*/, int);
int next_combo_c(int length, int basis[100][250], int num_basis,
                 int constraints[250], int combo[100], int sum[250],
                 int start_flag) {
  int pos, i, status, ok;
  if (start_flag) {
    for (i = 0; i < length; i++)
      sum[i] = 0;
    for (i = 0; i < num_basis; i++) {
      combo[i] = 1;
      {
        int j, *p;
        for (j = 0, p = basis[i]; j < length; j++)
          sum[j] += p[j];
      };
    }
    pos = -1;
    for (i = 0, ok = 1; i < length && ok; i++)
      if (sum[i] == 0)
        ok = 0;
    status = (ok ? 1 : 5);
  } else {
    pos = num_basis - 1;
    status = 3;
  }
  while (status != 4 && status != 5) {
    if (status == 1) {
      if (pos == -1 || combo[pos] == 0) {
        pos++;
        combo[pos] = 0;
        {
          int j, *p;
          for (j = 0, p = basis[pos]; j < length; j++)
            sum[j] -= p[j];
        };
      } else {
        pos++;
        for (i = pos + 1; i < num_basis; i++) {
          combo[i] = 1;
          {
            int j, *p;
            for (j = 0, p = basis[i]; j < length; j++)
              sum[j] += p[j];
          };
        }
      }
      for (i = 0, ok = 1; i < length && ok; i++)
        if (sum[i] == 0)
          ok = 0;
      if (ok)
        status = (pos == num_basis - 1) ? 4 : 1;
      else
        status = 2;
    } else if (status == 2) {
      combo[pos] = 1;
      {
        int j, *p;
        for (j = 0, p = basis[pos]; j < length; j++)
          sum[j] += p[j];
      };
      for (i = pos + 1; i < num_basis; i++) {
        if (combo[i]) {
          combo[i] = 0;
          {
            int j, *p;
            for (j = 0, p = basis[i]; j < length; j++)
              sum[j] -= p[j];
          };
        }
      }
      if (var_check_1(constraints, sum, 0, length - 1))
        status = (pos == num_basis - 1) ? 4 : 1;
      else
        status = 3;
    } else if (status == 3) {
      while (pos >= 0 && combo[pos])
        pos--;
      status = (pos < 0 ? 5 : 2);
    }
  }
  return status == 4 ? 1 : 0;
}


x86 assembly (clang, -O0):
<next_combo_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
cmpl   $0x0,0x10(%rbp)
je     1283 <next_combo_c+0x173>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    116e <next_combo_c+0x5e>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1145 <next_combo_c+0x35>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11f3 <next_combo_c+0xe3>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movl   $0x0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11e0 <next_combo_c+0xd0>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11ad <next_combo_c+0x9d>
jmp    11e5 <next_combo_c+0xd5>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1175 <next_combo_c+0x65>
movl   $0xffffffff,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x38(%rbp),%ecx
xor    %eax,%eax
cmp    -0x4(%rbp),%ecx
mov    %al,-0x91(%rbp)
jge    1229 <next_combo_c+0x119>
cmpl   $0x0,-0x40(%rbp)
setne  %al
mov    %al,-0x91(%rbp)
mov    -0x91(%rbp),%al
test   $0x1,%al
jne    123c <next_combo_c+0x12c>
jmp    1268 <next_combo_c+0x158>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1255 <next_combo_c+0x145>
movl   $0x0,-0x40(%rbp)
jmp    125a <next_combo_c+0x14a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1208 <next_combo_c+0xf8>
mov    -0x40(%rbp),%edx
mov    $0x5,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x3c(%rbp)
jmp    1293 <next_combo_c+0x183>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x3,-0x3c(%rbp)
jmp    1298 <next_combo_c+0x188>
xor    %eax,%eax
cmpl   $0x4,-0x3c(%rbp)
mov    %al,-0x92(%rbp)
je     12b7 <next_combo_c+0x1a7>
cmpl   $0x5,-0x3c(%rbp)
setne  %al
mov    %al,-0x92(%rbp)
mov    -0x92(%rbp),%al
test   $0x1,%al
jne    12ca <next_combo_c+0x1ba>
jmp    1680 <next_combo_c+0x570>
cmpl   $0x1,-0x3c(%rbp)
jne    1498 <next_combo_c+0x388>
cmpl   $0xffffffff,-0x34(%rbp)
je     12f0 <next_combo_c+0x1e0>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    135f <next_combo_c+0x24f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    135a <next_combo_c+0x24a>
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1325 <next_combo_c+0x215>
jmp    13f4 <next_combo_c+0x2e4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13ef <next_combo_c+0x2df>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movl   $0x0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13dc <next_combo_c+0x2cc>
mov    -0x70(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13a9 <next_combo_c+0x299>
jmp    13e1 <next_combo_c+0x2d1>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1371 <next_combo_c+0x261>
jmp    13f4 <next_combo_c+0x2e4>
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x38(%rbp),%ecx
xor    %eax,%eax
cmp    -0x4(%rbp),%ecx
mov    %al,-0x93(%rbp)
jge    1423 <next_combo_c+0x313>
cmpl   $0x0,-0x40(%rbp)
setne  %al
mov    %al,-0x93(%rbp)
mov    -0x93(%rbp),%al
test   $0x1,%al
jne    1436 <next_combo_c+0x326>
jmp    1462 <next_combo_c+0x352>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    144f <next_combo_c+0x33f>
movl   $0x0,-0x40(%rbp)
jmp    1454 <next_combo_c+0x344>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1402 <next_combo_c+0x2f2>
cmpl   $0x0,-0x40(%rbp)
je     148c <next_combo_c+0x37c>
mov    -0x34(%rbp),%edx
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    $0x1,%eax
mov    $0x4,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
mov    %eax,-0x3c(%rbp)
jmp    1493 <next_combo_c+0x383>
movl   $0x2,-0x3c(%rbp)
jmp    167b <next_combo_c+0x56b>
cmpl   $0x2,-0x3c(%rbp)
jne    1604 <next_combo_c+0x4f4>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movl   $0x0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1501 <next_combo_c+0x3f1>
mov    -0x80(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x74(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    14ce <next_combo_c+0x3be>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15b9 <next_combo_c+0x4a9>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     15a6 <next_combo_c+0x496>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a1 <next_combo_c+0x491>
mov    -0x90(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x30(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    155a <next_combo_c+0x44a>
jmp    15a6 <next_combo_c+0x496>
jmp    15ab <next_combo_c+0x49b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    150a <next_combo_c+0x3fa>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
xor    %edx,%edx
call   1030 <var_check_1@plt>
cmp    $0x0,%rax
je     15f8 <next_combo_c+0x4e8>
mov    -0x34(%rbp),%edx
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    $0x1,%eax
mov    $0x4,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
mov    %eax,-0x3c(%rbp)
jmp    15ff <next_combo_c+0x4ef>
movl   $0x3,-0x3c(%rbp)
jmp    1676 <next_combo_c+0x566>
cmpl   $0x3,-0x3c(%rbp)
jne    1671 <next_combo_c+0x561>
jmp    1613 <next_combo_c+0x503>
xor    %eax,%eax
cmpl   $0x0,-0x34(%rbp)
mov    %al,-0x94(%rbp)
jl     163a <next_combo_c+0x52a>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x94(%rbp)
mov    -0x94(%rbp),%al
test   $0x1,%al
jne    164d <next_combo_c+0x53d>
jmp    165b <next_combo_c+0x54b>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1613 <next_combo_c+0x503>
mov    -0x34(%rbp),%edx
mov    $0x2,%eax
mov    $0x5,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x3c(%rbp)
jmp    1676 <next_combo_c+0x566>
jmp    167b <next_combo_c+0x56b>
jmp    1298 <next_combo_c+0x188>
mov    -0x3c(%rbp),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x4,%edx
cmove  %ecx,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<next_combo_c>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%rbx
mov    %r8,%r14
mov    %rcx,0x70(%rsp)
mov    %edx,%r9d
mov    %rsi,%r10
mov    %edi,%r12d
movabs $0x3ffffffffffffffe,%r11
ff ff 3f
cmpl   $0x0,0xb0(%rsp)
mov    %edi,%r15d
mov    %r9,0x8(%rsp)
mov    %rsi,0x50(%rsp)
je     13ae <next_combo_c+0x28e>
test   %r12d,%r12d
jle    1188 <next_combo_c+0x68>
lea    0x0(,%r15,4),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x50(%rsp),%r10
mov    0x8(%rsp),%r9
test   %r9d,%r9d
jle    1353 <next_combo_c+0x233>
mov    0x8(%rsp),%eax
lea    (%rbx,%r15,4),%rcx
mov    %rcx,0x28(%rsp)
mov    %r15d,%r13d
and    $0xfffffff8,%r13d
lea    -0x8(%r13),%rcx
mov    %rcx,0x20(%rsp)
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x18(%rsp)
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%rdx
mov    %rdx,0x10(%rsp)
mov    %r15,%r11
neg    %r11
lea    0x30(%r10),%rcx
lea    0x4(%r10),%rdi
xor    %edx,%edx
jmp    120b <next_combo_c+0xeb>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
add    $0x3e8,%rcx
add    $0x3e8,%rdi
cmp    %rax,%rdx
je     1353 <next_combo_c+0x233>
movl   $0x1,(%r14,%rdx,4)
test   %r12d,%r12d
jle    11f0 <next_combo_c+0xd0>
imul   $0x3e8,%rdx,%r8
add    %r10,%r8
cmp    $0x8,%r12d
jb     1238 <next_combo_c+0x118>
lea    (%r8,%r15,4),%rsi
cmp    %rbx,%rsi
jbe    127c <next_combo_c+0x15c>
cmp    0x28(%rsp),%r8
jae    127c <next_combo_c+0x15c>
xor    %esi,%esi
mov    %rsi,%rbp
test   $0x1,%r15b
je     1251 <next_combo_c+0x131>
mov    (%r8,%rsi,4),%ebp
add    %ebp,(%rbx,%rsi,4)
mov    %rsi,%rbp
or     $0x1,%rbp
not    %rsi
cmp    %r11,%rsi
je     11f0 <next_combo_c+0xd0>
nopl   0x0(%rax)
mov    -0x4(%rdi,%rbp,4),%esi
add    %esi,(%rbx,%rbp,4)
mov    (%rdi,%rbp,4),%esi
add    %esi,0x4(%rbx,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%r15
jne    1260 <next_combo_c+0x140>
jmp    11f0 <next_combo_c+0xd0>
cmpq   $0x0,0x20(%rsp)
je     1347 <next_combo_c+0x227>
mov    0x10(%rsp),%r10
xor    %r9d,%r9d
movdqu -0x30(%rcx,%r9,4),%xmm0
movdqu -0x20(%rcx,%r9,4),%xmm1
movdqu (%rbx,%r9,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%r9,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%r9,4),%xmm1
movdqu 0x30(%rbx,%r9,4),%xmm3
movdqu %xmm2,(%rbx,%r9,4)
movdqu %xmm0,0x10(%rbx,%r9,4)
movdqu -0x10(%rcx,%r9,4),%xmm0
paddd  %xmm1,%xmm0
movdqu (%rcx,%r9,4),%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,0x20(%rbx,%r9,4)
movdqu %xmm1,0x30(%rbx,%r9,4)
add    $0x10,%r9
add    $0xfffffffffffffffe,%r10
jne    1290 <next_combo_c+0x170>
testb  $0x1,0x18(%rsp)
je     1331 <next_combo_c+0x211>
movdqu (%r8,%r9,4),%xmm0
movdqu 0x10(%r8,%r9,4),%xmm1
movdqu (%rbx,%r9,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%r9,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%r9,4)
movdqu %xmm0,0x10(%rbx,%r9,4)
mov    %r13,%rsi
cmp    %r15,%r13
mov    0x50(%rsp),%r10
je     11f0 <next_combo_c+0xd0>
jmp    123a <next_combo_c+0x11a>
xor    %r9d,%r9d
testb  $0x1,0x18(%rsp)
jne    1302 <next_combo_c+0x1e2>
jmp    1331 <next_combo_c+0x211>
mov    $0xffffffff,%r13d
test   %r12d,%r12d
jle    13ba <next_combo_c+0x29a>
mov    $0x1,%eax
mov    0x8(%rsp),%r9
movabs $0x3ffffffffffffffe,%r11
ff ff 3f
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x4(%rbx,%rax,4),%ecx
test   %ecx,%ecx
je     1394 <next_combo_c+0x274>
lea    0x1(%rax),%rdx
cmp    %r15,%rax
mov    %rdx,%rax
jb     1380 <next_combo_c+0x260>
xor    %eax,%eax
test   %ecx,%ecx
sete   %al
lea    0x1(,%rax,4),%r8d
test   $0x4,%r8b
je     13cf <next_combo_c+0x2af>
jmp    1b68 <next_combo_c+0xa48>
lea    -0x1(%r9),%r13d
mov    $0x3,%r8d
jmp    13cf <next_combo_c+0x2af>
mov    $0x1,%r8d
mov    0x8(%rsp),%r9
movabs $0x3ffffffffffffffe,%r11
ff ff 3f
lea    -0x1(%r12),%eax
mov    %eax,0x64(%rsp)
lea    -0x1(%r9),%eax
mov    %eax,0x34(%rsp)
movslq %r12d,%rbp
lea    (%rbx,%r15,4),%rax
mov    %rax,0x58(%rsp)
lea    (%r10,%r15,4),%rax
mov    %rax,0x68(%rsp)
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,%rcx
mov    %rax,0x10(%rsp)
and    %rax,%r11
mov    %r15,%rax
neg    %rax
mov    %rax,0x28(%rsp)
lea    0x30(%r10),%rax
mov    %rax,0x38(%rsp)
lea    0x4(%r10),%rax
mov    %rax,0x40(%rsp)
mov    %r8d,%eax
mov    %rbp,0x48(%rsp)
jmp    146e <next_combo_c+0x34e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
cmp    0x34(%rsp),%r13d
sete   %al
lea    (%rax,%rax,2),%eax
add    $0x1,%eax
mov    %eax,%ecx
and    $0x6,%ecx
cmp    $0x4,%ecx
je     1b68 <next_combo_c+0xa48>
mov    $0x4,%r8d
cmp    $0x1,%eax
je     14c0 <next_combo_c+0x3a0>
cmp    $0x2,%eax
je     1660 <next_combo_c+0x540>
cmp    $0x3,%eax
jne    1b68 <next_combo_c+0xa48>
test   %r13d,%r13d
js     1b62 <next_combo_c+0xa42>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13d,%eax
cmpl   $0x0,(%r14,%rax,4)
je     17ec <next_combo_c+0x6cc>
lea    -0x1(%r13),%eax
test   %r13d,%r13d
mov    %eax,%r13d
jg     14a0 <next_combo_c+0x380>
jmp    1b62 <next_combo_c+0xa42>
nop
cmp    $0xffffffff,%r13d
je     1700 <next_combo_c+0x5e0>
movslq %r13d,%rax
cmpl   $0x0,(%r14,%rax,4)
je     1700 <next_combo_c+0x5e0>
lea    0x1(%r13),%eax
add    $0x2,%r13d
cmp    %r9d,%r13d
jge    17a9 <next_combo_c+0x689>
mov    %eax,0x60(%rsp)
movslq %r13d,%rcx
imul   $0x3e8,%rcx,%rdx
mov    0x38(%rsp),%rax
lea    (%rax,%rdx,1),%rsi
add    0x40(%rsp),%rdx
mov    0x58(%rsp),%r8
jmp    152b <next_combo_c+0x40b>
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x3e8,%rsi
add    $0x3e8,%rdx
cmp    %r9d,%ecx
je     17ae <next_combo_c+0x68e>
movl   $0x1,(%r14,%rcx,4)
test   %r12d,%r12d
jle    1510 <next_combo_c+0x3f0>
imul   $0x3e8,%rcx,%rdi
add    %r10,%rdi
cmp    $0x8,%r12d
jb     1556 <next_combo_c+0x436>
lea    (%rdi,%r15,4),%rax
cmp    %rbx,%rax
jbe    159c <next_combo_c+0x47c>
cmp    %r8,%rdi
jae    159c <next_combo_c+0x47c>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%r15b
je     156e <next_combo_c+0x44e>
mov    (%rdi,%rbp,4),%eax
add    %eax,(%rbx,%rbp,4)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0x28(%rsp),%rbp
je     1510 <next_combo_c+0x3f0>
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rdx,%rax,4),%edi
add    %edi,(%rbx,%rax,4)
mov    (%rdx,%rax,4),%edi
add    %edi,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r15
jne    1580 <next_combo_c+0x460>
jmp    1510 <next_combo_c+0x3f0>
cmpq   $0x0,0x18(%rsp)
je     1655 <next_combo_c+0x535>
mov    %r11,%rbp
xor    %eax,%eax
nopl   (%rax)
movdqu -0x30(%rsi,%rax,4),%xmm0
movdqu -0x20(%rsi,%rax,4),%xmm1
movdqu (%rbx,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rax,4),%xmm1
movdqu 0x30(%rbx,%rax,4),%xmm3
movdqu %xmm2,(%rbx,%rax,4)
movdqu %xmm0,0x10(%rbx,%rax,4)
movdqu -0x10(%rsi,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu (%rsi,%rax,4),%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,0x20(%rbx,%rax,4)
movdqu %xmm1,0x30(%rbx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbp
jne    15b0 <next_combo_c+0x490>
testb  $0x1,0x10(%rsp)
je     163f <next_combo_c+0x51f>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
movdqu (%rbx,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rax,4)
movdqu %xmm0,0x10(%rbx,%rax,4)
mov    0x20(%rsp),%rax
mov    %rax,%rbp
cmp    %r15,%rax
je     1510 <next_combo_c+0x3f0>
jmp    1558 <next_combo_c+0x438>
xor    %eax,%eax
testb  $0x1,0x10(%rsp)
jne    1616 <next_combo_c+0x4f6>
jmp    163f <next_combo_c+0x51f>
movslq %r13d,%rax
movl   $0x1,(%r14,%rax,4)
test   %r12d,%r12d
mov    0x58(%rsp),%r8
jle    18b0 <next_combo_c+0x790>
cmp    $0x8,%r12d
jb     16a4 <next_combo_c+0x584>
imul   $0x3e8,%rax,%rsi
lea    (%r10,%rsi,1),%rcx
mov    0x68(%rsp),%rdx
add    %rsi,%rdx
cmp    %rbx,%rdx
jbe    17f6 <next_combo_c+0x6d6>
cmp    %r8,%rcx
jae    17f6 <next_combo_c+0x6d6>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r15b
je     16c6 <next_combo_c+0x5a6>
imul   $0x3e8,%rax,%rcx
add    %r10,%rcx
mov    (%rcx,%rdx,4),%ecx
add    %ecx,(%rbx,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x28(%rsp),%rdx
je     18b0 <next_combo_c+0x790>
imul   $0x3e8,%rax,%rax
add    0x40(%rsp),%rax
mov    -0x4(%rax,%rcx,4),%edx
add    %edx,(%rbx,%rcx,4)
mov    (%rax,%rcx,4),%edx
add    %edx,0x4(%rbx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    16e0 <next_combo_c+0x5c0>
jmp    18b0 <next_combo_c+0x790>
nopl   0x0(%rax)
movslq %r13d,%rax
add    $0x1,%r13d
movl   $0x0,0x4(%r14,%rax,4)
test   %r12d,%r12d
jle    1450 <next_combo_c+0x330>
add    $0x1,%rax
cmp    $0x8,%r12d
jb     174a <next_combo_c+0x62a>
imul   $0x3e8,%rax,%rsi
lea    (%r10,%rsi,1),%rcx
mov    0x68(%rsp),%rdx
add    %rsi,%rdx
cmp    %rbx,%rdx
jbe    1a7f <next_combo_c+0x95f>
cmp    0x58(%rsp),%rcx
jae    1a7f <next_combo_c+0x95f>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r15b
je     176c <next_combo_c+0x64c>
imul   $0x3e8,%rax,%rcx
add    %r10,%rcx
mov    (%rcx,%rdx,4),%ecx
sub    %ecx,(%rbx,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x28(%rsp),%rdx
je     17c0 <next_combo_c+0x6a0>
imul   $0x3e8,%rax,%rax
add    0x40(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x4(%rax,%rcx,4),%edx
sub    %edx,(%rbx,%rcx,4)
mov    (%rax,%rcx,4),%edx
sub    %edx,0x4(%rbx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    1790 <next_combo_c+0x670>
jmp    17c0 <next_combo_c+0x6a0>
mov    %eax,%r13d
jmp    17bb <next_combo_c+0x69b>
mov    0x60(%rsp),%eax
mov    %eax,%r13d
mov    $0x4,%r8d
mov    0x48(%rsp),%rbp
test   %r12d,%r12d
jle    1450 <next_combo_c+0x330>
mov    $0x1,%eax
xchg   %ax,%ax
mov    -0x4(%rbx,%rax,4),%ecx
test   %ecx,%ecx
je     17e4 <next_combo_c+0x6c4>
lea    0x1(%rax),%rdx
cmp    %rbp,%rax
mov    %rdx,%rax
jl     17d0 <next_combo_c+0x6b0>
test   %ecx,%ecx
jne    1450 <next_combo_c+0x330>
mov    $0x2,%eax
jmp    1460 <next_combo_c+0x340>
cmpq   $0x0,0x18(%rsp)
je     1b45 <next_combo_c+0xa25>
add    0x38(%rsp),%rsi
mov    %r11,%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movdqu -0x30(%rsi,%rdx,4),%xmm0
movdqu -0x20(%rsi,%rdx,4),%xmm1
movdqu (%rbx,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rdx,4),%xmm1
movdqu 0x30(%rbx,%rdx,4),%xmm3
movdqu %xmm2,(%rbx,%rdx,4)
movdqu %xmm0,0x10(%rbx,%rdx,4)
movdqu -0x10(%rsi,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu (%rsi,%rdx,4),%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,0x20(%rbx,%rdx,4)
movdqu %xmm1,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1810 <next_combo_c+0x6f0>
testb  $0x1,0x10(%rsp)
je     189f <next_combo_c+0x77f>
movdqu (%rcx,%rdx,4),%xmm0
movdqu 0x10(%rcx,%rdx,4),%xmm1
movdqu (%rbx,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rdx,4)
movdqu %xmm0,0x10(%rbx,%rdx,4)
mov    0x20(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
jne    16a6 <next_combo_c+0x586>
lea    0x1(%r13),%eax
cmp    %r9d,%eax
jge    1a30 <next_combo_c+0x910>
cltq
imul   $0x3e8,%rax,%rcx
mov    0x38(%rsp),%rdx
add    %rcx,%rdx
add    0x40(%rsp),%rcx
jmp    18fb <next_combo_c+0x7db>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
add    $0x3e8,%rdx
add    $0x3e8,%rcx
cmp    %r9d,%eax
je     1a30 <next_combo_c+0x910>
cmpl   $0x0,(%r14,%rax,4)
je     18e0 <next_combo_c+0x7c0>
movl   $0x0,(%r14,%rax,4)
test   %r12d,%r12d
jle    18e0 <next_combo_c+0x7c0>
imul   $0x3e8,%rax,%rsi
add    %r10,%rsi
cmp    $0x8,%r12d
jb     192d <next_combo_c+0x80d>
lea    (%rsi,%r15,4),%rdi
cmp    %rbx,%rdi
jbe    196c <next_combo_c+0x84c>
cmp    %r8,%rsi
jae    196c <next_combo_c+0x84c>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%r15b
je     1945 <next_combo_c+0x825>
mov    (%rsi,%rbp,4),%esi
sub    %esi,(%rbx,%rbp,4)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    0x28(%rsp),%rbp
je     18e0 <next_combo_c+0x7c0>
nop
mov    -0x4(%rcx,%rdi,4),%esi
sub    %esi,(%rbx,%rdi,4)
mov    (%rcx,%rdi,4),%esi
sub    %esi,0x4(%rbx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r15
jne    1950 <next_combo_c+0x830>
jmp    18e0 <next_combo_c+0x7c0>
cmpq   $0x0,0x18(%rsp)
je     1a25 <next_combo_c+0x905>
mov    %r11,%rbp
xor    %edi,%edi
nopl   (%rax)
movdqu -0x30(%rdx,%rdi,4),%xmm0
movdqu -0x20(%rdx,%rdi,4),%xmm1
movdqu (%rbx,%rdi,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rdi,4),%xmm0
psubd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rdi,4),%xmm1
movdqu 0x30(%rbx,%rdi,4),%xmm3
movdqu %xmm2,(%rbx,%rdi,4)
movdqu %xmm0,0x10(%rbx,%rdi,4)
movdqu -0x10(%rdx,%rdi,4),%xmm0
psubd  %xmm0,%xmm1
movdqu (%rdx,%rdi,4),%xmm0
psubd  %xmm0,%xmm3
movdqu %xmm1,0x20(%rbx,%rdi,4)
movdqu %xmm3,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1980 <next_combo_c+0x860>
testb  $0x1,0x10(%rsp)
je     1a0f <next_combo_c+0x8ef>
movdqu (%rsi,%rdi,4),%xmm0
movdqu 0x10(%rsi,%rdi,4),%xmm1
movdqu (%rbx,%rdi,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rdi,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rdi,4)
movdqu %xmm0,0x10(%rbx,%rdi,4)
mov    0x20(%rsp),%rdi
mov    %rdi,%rbp
cmp    %r15,%rdi
je     18e0 <next_combo_c+0x7c0>
jmp    192f <next_combo_c+0x80f>
xor    %edi,%edi
testb  $0x1,0x10(%rsp)
jne    19e6 <next_combo_c+0x8c6>
jmp    1a0f <next_combo_c+0x8ef>
mov    %r11,%rbp
mov    0x70(%rsp),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
mov    0x64(%rsp),%ecx
call   1040 <var_check_1@plt>
test   %rax,%rax
je     1a5d <next_combo_c+0x93d>
xor    %eax,%eax
cmp    0x34(%rsp),%r13d
sete   %al
lea    (%rax,%rax,2),%eax
add    $0x1,%eax
jmp    1a62 <next_combo_c+0x942>
mov    $0x3,%eax
mov    0x8(%rsp),%r9
mov    0x50(%rsp),%r10
mov    %rbp,%r11
mov    $0x4,%r8d
mov    0x48(%rsp),%rbp
jmp    1460 <next_combo_c+0x340>
cmpq   $0x0,0x18(%rsp)
je     1b57 <next_combo_c+0xa37>
add    0x38(%rsp),%rsi
mov    %r11,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x30(%rsi,%rdx,4),%xmm0
movdqu -0x20(%rsi,%rdx,4),%xmm1
movdqu (%rbx,%rdx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rdx,4),%xmm1
movdqu 0x30(%rbx,%rdx,4),%xmm3
movdqu %xmm2,(%rbx,%rdx,4)
movdqu %xmm0,0x10(%rbx,%rdx,4)
movdqu -0x10(%rsi,%rdx,4),%xmm0
psubd  %xmm0,%xmm1
movdqu (%rsi,%rdx,4),%xmm0
psubd  %xmm0,%xmm3
movdqu %xmm1,0x20(%rbx,%rdx,4)
movdqu %xmm3,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1aa0 <next_combo_c+0x980>
testb  $0x1,0x10(%rsp)
je     1b2f <next_combo_c+0xa0f>
movdqu (%rcx,%rdx,4),%xmm0
movdqu 0x10(%rcx,%rdx,4),%xmm1
movdqu (%rbx,%rdx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rdx,4)
movdqu %xmm0,0x10(%rbx,%rdx,4)
mov    0x20(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
je     17c0 <next_combo_c+0x6a0>
jmp    174c <next_combo_c+0x62c>
xor    %edx,%edx
testb  $0x1,0x10(%rsp)
jne    1876 <next_combo_c+0x756>
jmp    189f <next_combo_c+0x77f>
xor    %edx,%edx
testb  $0x1,0x10(%rsp)
jne    1b06 <next_combo_c+0x9e6>
jmp    1b2f <next_combo_c+0xa0f>
mov    $0x5,%r8d
xor    %eax,%eax
cmp    $0x4,%r8d
sete   %al
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @next_combo_c(i32 %0, [250 x i32]* %1, i32 %2, i32* %3, i32* %4, i32* %5, i32 %6) {
%8 = alloca i32
%9 = alloca [250 x i32]*
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32*
%21 = alloca i32
%22 = alloca i32*
%23 = alloca i32
%24 = alloca i32*
%25 = alloca i32
%26 = alloca i32*
%27 = alloca i32
%28 = alloca i32*
store i32 %0, i32* %8
store [250 x i32]* %1, [250 x i32]** %9
store i32 %2, i32* %10
store i32* %3, i32** %11
store i32* %4, i32** %12
store i32* %5, i32** %13
store i32 %6, i32* %14
%29 = load i32, i32* %14
%30 = icmp ne i32 %29, 0
br i1 %30, label %31, label %109
31: ; preds = %7
store i32 0, i32* %16
br label %32
32: ; preds = %41, %31
%33 = load i32, i32* %16
%34 = load i32, i32* %8
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %44
36: ; preds = %32
%37 = load i32*, i32** %13
%38 = load i32, i32* %16
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %37, i64 %39
store i32 0, i32* %40
br label %41
41: ; preds = %36
%42 = load i32, i32* %16
%43 = add nsw i32 %42, 1
store i32 %43, i32* %16
br label %32
44: ; preds = %32
store i32 0, i32* %16
br label %45
45: ; preds = %79, %44
%46 = load i32, i32* %16
%47 = load i32, i32* %10
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %82
49: ; preds = %45
%50 = load i32*, i32** %12
%51 = load i32, i32* %16
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i32, i32* %50, i64 %52
store i32 1, i32* %53
store i32 0, i32* %19
%54 = load [250 x i32]*, [250 x i32]** %9
%55 = load i32, i32* %16
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [250 x i32], [250 x i32]* %54, i64 %56
%58 = getelementptr inbounds [250 x i32], [250 x i32]* %57, i64 0, i64 0
store i32* %58, i32** %20
br label %59
59: ; preds = %75, %49
%60 = load i32, i32* %19
%61 = load i32, i32* %8
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %78
63: ; preds = %59
%64 = load i32*, i32** %20
%65 = load i32, i32* %19
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %64, i64 %66
%68 = load i32, i32* %67
%69 = load i32*, i32** %13
%70 = load i32, i32* %19
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %69, i64 %71
%73 = load i32, i32* %72
%74 = add nsw i32 %73, %68
store i32 %74, i32* %72
br label %75
75: ; preds = %63
%76 = load i32, i32* %19
%77 = add nsw i32 %76, 1
store i32 %77, i32* %19
br label %59
78: ; preds = %59
br label %79
79: ; preds = %78
%80 = load i32, i32* %16
%81 = add nsw i32 %80, 1
store i32 %81, i32* %16
br label %45
82: ; preds = %45
store i32 -1, i32* %15
store i32 0, i32* %16
store i32 1, i32* %18
br label %83
83: ; preds = %101, %82
%84 = load i32, i32* %16
%85 = load i32, i32* %8
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %90
87: ; preds = %83
%88 = load i32, i32* %18
%89 = icmp ne i32 %88, 0
br label %90
90: ; preds = %87, %83
%91 = phi i1 [ false, %83 ], [ %89, %87 ]
br i1 %91, label %92, label %104
92: ; preds = %90
%93 = load i32*, i32** %13
%94 = load i32, i32* %16
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
%98 = icmp eq i32 %97, 0
br i1 %98, label %99, label %100
99: ; preds = %92
store i32 0, i32* %18
br label %100
100: ; preds = %99, %92
br label %101
101: ; preds = %100
%102 = load i32, i32* %16
%103 = add nsw i32 %102, 1
store i32 %103, i32* %16
br label %83
104: ; preds = %90
%105 = load i32, i32* %18
%106 = icmp ne i32 %105, 0
%107 = zext i1 %106 to i64
%108 = select i1 %106, i32 1, i32 5
store i32 %108, i32* %17
br label %112
109: ; preds = %7
%110 = load i32, i32* %10
%111 = sub nsw i32 %110, 1
store i32 %111, i32* %15
store i32 3, i32* %17
br label %112
112: ; preds = %109, %104
br label %113
113: ; preds = %365, %112
%114 = load i32, i32* %17
%115 = icmp ne i32 %114, 4
br i1 %115, label %116, label %119
116: ; preds = %113
%117 = load i32, i32* %17
%118 = icmp ne i32 %117, 5
br label %119
119: ; preds = %116, %113
%120 = phi i1 [ false, %113 ], [ %118, %116 ]
br i1 %120, label %121, label %366
121: ; preds = %119
%122 = load i32, i32* %17
%123 = icmp eq i32 %122, 1
br i1 %123, label %124, label %243
124: ; preds = %121
%125 = load i32, i32* %15
%126 = icmp eq i32 %125, -1
br i1 %126, label %134, label %127
127: ; preds = %124
%128 = load i32*, i32** %12
%129 = load i32, i32* %15
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i32, i32* %128, i64 %130
%132 = load i32, i32* %131
%133 = icmp eq i32 %132, 0
br i1 %133, label %134, label %166
134: ; preds = %127, %124
%135 = load i32, i32* %15
%136 = add nsw i32 %135, 1
store i32 %136, i32* %15
%137 = load i32*, i32** %12
%138 = load i32, i32* %15
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %137, i64 %139
store i32 0, i32* %140
store i32 0, i32* %21
%141 = load [250 x i32]*, [250 x i32]** %9
%142 = load i32, i32* %15
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [250 x i32], [250 x i32]* %141, i64 %143
%145 = getelementptr inbounds [250 x i32], [250 x i32]* %144, i64 0, i64 0
store i32* %145, i32** %22
br label %146
146: ; preds = %162, %134
%147 = load i32, i32* %21
%148 = load i32, i32* %8
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %165
150: ; preds = %146
%151 = load i32*, i32** %22
%152 = load i32, i32* %21
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i32, i32* %151, i64 %153
%155 = load i32, i32* %154
%156 = load i32*, i32** %13
%157 = load i32, i32* %21
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %156, i64 %158
%160 = load i32, i32* %159
%161 = sub nsw i32 %160, %155
store i32 %161, i32* %159
br label %162
162: ; preds = %150
%163 = load i32, i32* %21
%164 = add nsw i32 %163, 1
store i32 %164, i32* %21
br label %146
165: ; preds = %146
br label %209
166: ; preds = %127
%167 = load i32, i32* %15
%168 = add nsw i32 %167, 1
store i32 %168, i32* %15
%169 = load i32, i32* %15
%170 = add nsw i32 %169, 1
store i32 %170, i32* %16
br label %171
171: ; preds = %205, %166
%172 = load i32, i32* %16
%173 = load i32, i32* %10
%174 = icmp slt i32 %172, %173
br i1 %174, label %175, label %208
175: ; preds = %171
%176 = load i32*, i32** %12
%177 = load i32, i32* %16
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i32, i32* %176, i64 %178
store i32 1, i32* %179
store i32 0, i32* %23
%180 = load [250 x i32]*, [250 x i32]** %9
%181 = load i32, i32* %16
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [250 x i32], [250 x i32]* %180, i64 %182
%184 = getelementptr inbounds [250 x i32], [250 x i32]* %183, i64 0, i64 0
store i32* %184, i32** %24
br label %185
185: ; preds = %201, %175
%186 = load i32, i32* %23
%187 = load i32, i32* %8
%188 = icmp slt i32 %186, %187
br i1 %188, label %189, label %204
189: ; preds = %185
%190 = load i32*, i32** %24
%191 = load i32, i32* %23
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i32, i32* %190, i64 %192
%194 = load i32, i32* %193
%195 = load i32*, i32** %13
%196 = load i32, i32* %23
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
%199 = load i32, i32* %198
%200 = add nsw i32 %199, %194
store i32 %200, i32* %198
br label %201
201: ; preds = %189
%202 = load i32, i32* %23
%203 = add nsw i32 %202, 1
store i32 %203, i32* %23
br label %185
204: ; preds = %185
br label %205
205: ; preds = %204
%206 = load i32, i32* %16
%207 = add nsw i32 %206, 1
store i32 %207, i32* %16
br label %171
208: ; preds = %171
br label %209
209: ; preds = %208, %165
store i32 0, i32* %16
store i32 1, i32* %18
br label %210
210: ; preds = %228, %209
%211 = load i32, i32* %16
%212 = load i32, i32* %8
%213 = icmp slt i32 %211, %212
br i1 %213, label %214, label %217
214: ; preds = %210
%215 = load i32, i32* %18
%216 = icmp ne i32 %215, 0
br label %217
217: ; preds = %214, %210
%218 = phi i1 [ false, %210 ], [ %216, %214 ]
br i1 %218, label %219, label %231
219: ; preds = %217
%220 = load i32*, i32** %13
%221 = load i32, i32* %16
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i32, i32* %220, i64 %222
%224 = load i32, i32* %223
%225 = icmp eq i32 %224, 0
br i1 %225, label %226, label %227
226: ; preds = %219
store i32 0, i32* %18
br label %227
227: ; preds = %226, %219
br label %228
228: ; preds = %227
%229 = load i32, i32* %16
%230 = add nsw i32 %229, 1
store i32 %230, i32* %16
br label %210
231: ; preds = %217
%232 = load i32, i32* %18
%233 = icmp ne i32 %232, 0
br i1 %233, label %234, label %241
234: ; preds = %231
%235 = load i32, i32* %15
%236 = load i32, i32* %10
%237 = sub nsw i32 %236, 1
%238 = icmp eq i32 %235, %237
%239 = zext i1 %238 to i64
%240 = select i1 %238, i32 4, i32 1
store i32 %240, i32* %17
br label %242
241: ; preds = %231
store i32 2, i32* %17
br label %242
242: ; preds = %241, %234
br label %365
243: ; preds = %121
%244 = load i32, i32* %17
%245 = icmp eq i32 %244, 2
br i1 %245, label %246, label %339
246: ; preds = %243
%247 = load i32*, i32** %12
%248 = load i32, i32* %15
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %247, i64 %249
store i32 1, i32* %250
store i32 0, i32* %25
%251 = load [250 x i32]*, [250 x i32]** %9
%252 = load i32, i32* %15
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [250 x i32], [250 x i32]* %251, i64 %253
%255 = getelementptr inbounds [250 x i32], [250 x i32]* %254, i64 0, i64 0
store i32* %255, i32** %26
br label %256
256: ; preds = %272, %246
%257 = load i32, i32* %25
%258 = load i32, i32* %8
%259 = icmp slt i32 %257, %258
br i1 %259, label %260, label %275
260: ; preds = %256
%261 = load i32*, i32** %26
%262 = load i32, i32* %25
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %261, i64 %263
%265 = load i32, i32* %264
%266 = load i32*, i32** %13
%267 = load i32, i32* %25
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i32, i32* %266, i64 %268
%270 = load i32, i32* %269
%271 = add nsw i32 %270, %265
store i32 %271, i32* %269
br label %272
272: ; preds = %260
%273 = load i32, i32* %25
%274 = add nsw i32 %273, 1
store i32 %274, i32* %25
br label %256
275: ; preds = %256
%276 = load i32, i32* %15
%277 = add nsw i32 %276, 1
store i32 %277, i32* %16
br label %278
278: ; preds = %320, %275
%279 = load i32, i32* %16
%280 = load i32, i32* %10
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %323
282: ; preds = %278
%283 = load i32*, i32** %12
%284 = load i32, i32* %16
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %283, i64 %285
%287 = load i32, i32* %286
%288 = icmp ne i32 %287, 0
br i1 %288, label %289, label %319
289: ; preds = %282
%290 = load i32*, i32** %12
%291 = load i32, i32* %16
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %290, i64 %292
store i32 0, i32* %293
store i32 0, i32* %27
%294 = load [250 x i32]*, [250 x i32]** %9
%295 = load i32, i32* %16
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [250 x i32], [250 x i32]* %294, i64 %296
%298 = getelementptr inbounds [250 x i32], [250 x i32]* %297, i64 0, i64 0
store i32* %298, i32** %28
br label %299
299: ; preds = %315, %289
%300 = load i32, i32* %27
%301 = load i32, i32* %8
%302 = icmp slt i32 %300, %301
br i1 %302, label %303, label %318
303: ; preds = %299
%304 = load i32*, i32** %28
%305 = load i32, i32* %27
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds i32, i32* %304, i64 %306
%308 = load i32, i32* %307
%309 = load i32*, i32** %13
%310 = load i32, i32* %27
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i32, i32* %309, i64 %311
%313 = load i32, i32* %312
%314 = sub nsw i32 %313, %308
store i32 %314, i32* %312
br label %315
315: ; preds = %303
%316 = load i32, i32* %27
%317 = add nsw i32 %316, 1
store i32 %317, i32* %27
br label %299
318: ; preds = %299
br label %319
319: ; preds = %318, %282
br label %320
320: ; preds = %319
%321 = load i32, i32* %16
%322 = add nsw i32 %321, 1
store i32 %322, i32* %16
br label %278
323: ; preds = %278
%324 = load i32*, i32** %11
%325 = load i32*, i32** %13
%326 = load i32, i32* %8
%327 = sub nsw i32 %326, 1
%328 = call i64 @var_check_1(i32* %324, i32* %325, i32 0, i32 %327)
%329 = icmp ne i64 %328, 0
br i1 %329, label %330, label %337
330: ; preds = %323
%331 = load i32, i32* %15
%332 = load i32, i32* %10
%333 = sub nsw i32 %332, 1
%334 = icmp eq i32 %331, %333
%335 = zext i1 %334 to i64
%336 = select i1 %334, i32 4, i32 1
store i32 %336, i32* %17
br label %338
337: ; preds = %323
store i32 3, i32* %17
br label %338
338: ; preds = %337, %330
br label %364
339: ; preds = %243
%340 = load i32, i32* %17
%341 = icmp eq i32 %340, 3
br i1 %341, label %342, label %363
342: ; preds = %339
br label %343
343: ; preds = %355, %342
%344 = load i32, i32* %15
%345 = icmp sge i32 %344, 0
br i1 %345, label %346, label %353
346: ; preds = %343
%347 = load i32*, i32** %12
%348 = load i32, i32* %15
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i32, i32* %347, i64 %349
%351 = load i32, i32* %350
%352 = icmp ne i32 %351, 0
br label %353
353: ; preds = %346, %343
%354 = phi i1 [ false, %343 ], [ %352, %346 ]
br i1 %354, label %355, label %358
355: ; preds = %353
%356 = load i32, i32* %15
%357 = add nsw i32 %356, -1
store i32 %357, i32* %15
br label %343
358: ; preds = %353
%359 = load i32, i32* %15
%360 = icmp slt i32 %359, 0
%361 = zext i1 %360 to i64
%362 = select i1 %360, i32 5, i32 2
store i32 %362, i32* %17
br label %363
363: ; preds = %358, %339
br label %364
364: ; preds = %363, %338
br label %365
365: ; preds = %364, %242
br label %113
366: ; preds = %119
%367 = load i32, i32* %17
%368 = icmp eq i32 %367, 4
%369 = zext i1 %368 to i64
%370 = select i1 %368, i32 1, i32 0
ret i32 %370
}

LLVM IR (-O2):
define i32 @next_combo_c(i32 %0, [250 x i32]* nocapture %1, i32 %2, i32* %3, i32* nocapture %4, i32* %5, i32 %6) {
%8 = bitcast i32* %5 to i8*
%9 = icmp eq i32 %6, 0
br i1 %9, label %147, label %10
10: ; preds = %7
%11 = icmp sgt i32 %0, 0
br i1 %11, label %12, label %15
12: ; preds = %10
%13 = zext i32 %0 to i64
%14 = shl nuw nsw i64 %13, 2
br label %15
15: ; preds = %12, %10
%16 = icmp sgt i32 %2, 0
br i1 %16, label %17, label %35
17: ; preds = %15
%18 = zext i32 %2 to i64
%19 = zext i32 %0 to i64
%20 = getelementptr i32, i32* %5, i64 %19
%21 = and i64 %19, 4294967288
%22 = add nsw i64 %21, -8
%23 = lshr exact i64 %22, 3
%24 = add nuw nsw i64 %23, 1
%25 = icmp ult i32 %0, 8
%26 = and i64 %19, 4294967288
%27 = and i64 %24, 1
%28 = icmp eq i64 %22, 0
%29 = and i64 %24, 4611686018427387902
%30 = icmp eq i64 %27, 0
%31 = icmp eq i64 %26, %19
%32 = and i64 %19, 1
%33 = icmp eq i64 %32, 0
%34 = sub nsw i64 0, %19
br label %38
35: ; preds = %136, %15
br i1 %11, label %36, label %153
36: ; preds = %35
%37 = zext i32 %0 to i64
br label %139
38: ; preds = %17, %136
%39 = phi i64 [ 0, %17 ], [ %137, %136 ]
%40 = getelementptr [250 x i32], [250 x i32]* %1, i64 %39, i64 0
%41 = getelementptr [250 x i32], [250 x i32]* %1, i64 %39, i64 %19
%42 = getelementptr inbounds i32, i32* %4, i64 %39
store i32 1, i32* %42
br i1 %11, label %43, label %136
43: ; preds = %38
br i1 %25, label %108, label %44
44: ; preds = %43
%45 = icmp ugt i32* %41, %5
%46 = icmp ult i32* %40, %20
%47 = and i1 %45, %46
br i1 %47, label %108, label %48
48: ; preds = %44
br i1 %28, label %88, label %49
49: ; preds = %48, %49
%50 = phi i64 [ %85, %49 ], [ 0, %48 ]
%51 = phi i64 [ %86, %49 ], [ 0, %48 ]
%52 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %50
%53 = bitcast i32* %52 to <4 x i32>*
%54 = load <4 x i32>, <4 x i32>* %53
%55 = getelementptr inbounds i32, i32* %52, i64 4
%56 = bitcast i32* %55 to <4 x i32>*
%57 = load <4 x i32>, <4 x i32>* %56
%58 = getelementptr inbounds i32, i32* %5, i64 %50
%59 = bitcast i32* %58 to <4 x i32>*
%60 = load <4 x i32>, <4 x i32>* %59
%61 = getelementptr inbounds i32, i32* %58, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
%63 = load <4 x i32>, <4 x i32>* %62
%64 = add nsw <4 x i32> %60, %54
%65 = add nsw <4 x i32> %63, %57
%66 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %66
%67 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %67
%68 = or i64 %50, 8
%69 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = getelementptr inbounds i32, i32* %69, i64 4
%73 = bitcast i32* %72 to <4 x i32>*
%74 = load <4 x i32>, <4 x i32>* %73
%75 = getelementptr inbounds i32, i32* %5, i64 %68
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = getelementptr inbounds i32, i32* %75, i64 4
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = add nsw <4 x i32> %77, %71
%82 = add nsw <4 x i32> %80, %74
%83 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %83
%84 = bitcast i32* %78 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %84
%85 = add nuw i64 %50, 16
%86 = add i64 %51, 2
%87 = icmp eq i64 %86, %29
br i1 %87, label %88, label %49
88: ; preds = %49, %48
%89 = phi i64 [ 0, %48 ], [ %85, %49 ]
br i1 %30, label %107, label %90
90: ; preds = %88
%91 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %89
%92 = bitcast i32* %91 to <4 x i32>*
%93 = load <4 x i32>, <4 x i32>* %92
%94 = getelementptr inbounds i32, i32* %91, i64 4
%95 = bitcast i32* %94 to <4 x i32>*
%96 = load <4 x i32>, <4 x i32>* %95
%97 = getelementptr inbounds i32, i32* %5, i64 %89
%98 = bitcast i32* %97 to <4 x i32>*
%99 = load <4 x i32>, <4 x i32>* %98
%100 = getelementptr inbounds i32, i32* %97, i64 4
%101 = bitcast i32* %100 to <4 x i32>*
%102 = load <4 x i32>, <4 x i32>* %101
%103 = add nsw <4 x i32> %99, %93
%104 = add nsw <4 x i32> %102, %96
%105 = bitcast i32* %97 to <4 x i32>*
store <4 x i32> %103, <4 x i32>* %105
%106 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> %104, <4 x i32>* %106
br label %107
107: ; preds = %88, %90
br i1 %31, label %136, label %108
108: ; preds = %44, %43, %107
%109 = phi i64 [ 0, %44 ], [ 0, %43 ], [ %26, %107 ]
%110 = xor i64 %109, -1
br i1 %33, label %118, label %111
111: ; preds = %108
%112 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %109
%113 = load i32, i32* %112
%114 = getelementptr inbounds i32, i32* %5, i64 %109
%115 = load i32, i32* %114
%116 = add nsw i32 %115, %113
store i32 %116, i32* %114
%117 = or i64 %109, 1
br label %118
118: ; preds = %111, %108
%119 = phi i64 [ %109, %108 ], [ %117, %111 ]
%120 = icmp eq i64 %110, %34
br i1 %120, label %136, label %121
121: ; preds = %118, %121
%122 = phi i64 [ %134, %121 ], [ %119, %118 ]
%123 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %122
%124 = load i32, i32* %123
%125 = getelementptr inbounds i32, i32* %5, i64 %122
%126 = load i32, i32* %125
%127 = add nsw i32 %126, %124
store i32 %127, i32* %125
%128 = add nuw nsw i64 %122, 1
%129 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %128
%130 = load i32, i32* %129
%131 = getelementptr inbounds i32, i32* %5, i64 %128
%132 = load i32, i32* %131
%133 = add nsw i32 %132, %130
store i32 %133, i32* %131
%134 = add nuw nsw i64 %122, 2
%135 = icmp eq i64 %134, %19
br i1 %135, label %136, label %121
136: ; preds = %118, %121, %107, %38
%137 = add nuw nsw i64 %39, 1
%138 = icmp eq i64 %137, %18
br i1 %138, label %35, label %38
139: ; preds = %36, %139
%140 = phi i64 [ 0, %36 ], [ %144, %139 ]
%141 = getelementptr inbounds i32, i32* %5, i64 %140
%142 = load i32, i32* %141
%143 = icmp ne i32 %142, 0
%144 = add nuw nsw i64 %140, 1
%145 = icmp ult i64 %144, %37
%146 = and i1 %143, %145
br i1 %146, label %139, label %149
147: ; preds = %7
%148 = add nsw i32 %2, -1
br label %153
149: ; preds = %139
%150 = select i1 %143, i32 1, i32 5
%151 = and i32 %150, 4
%152 = icmp eq i32 %151, 0
br i1 %152, label %153, label %678
153: ; preds = %35, %147, %149
%154 = phi i32 [ -1, %149 ], [ -1, %35 ], [ %148, %147 ]
%155 = phi i32 [ %150, %149 ], [ 1, %35 ], [ 3, %147 ]
%156 = icmp sgt i32 %0, 0
%157 = add nsw i32 %0, -1
%158 = add nsw i32 %2, -1
%159 = sext i32 %0 to i64
%160 = zext i32 %0 to i64
%161 = zext i32 %0 to i64
%162 = zext i32 %0 to i64
%163 = zext i32 %0 to i64
%164 = getelementptr i32, i32* %5, i64 %160
%165 = getelementptr [250 x i32], [250 x i32]* %1, i64 0, i64 %160
%166 = getelementptr i32, i32* %5, i64 %160
%167 = getelementptr i32, i32* %5, i64 %160
%168 = getelementptr i32, i32* %5, i64 %160
%169 = getelementptr [250 x i32], [250 x i32]* %1, i64 0, i64 %160
%170 = and i64 %160, 4294967288
%171 = add nsw i64 %170, -8
%172 = lshr exact i64 %171, 3
%173 = add nuw nsw i64 %172, 1
%174 = icmp ult i32 %0, 8
%175 = and i64 %160, 4294967288
%176 = and i64 %173, 1
%177 = icmp eq i64 %171, 0
%178 = and i64 %173, 4611686018427387902
%179 = icmp eq i64 %176, 0
%180 = icmp eq i64 %175, %160
%181 = and i64 %160, 1
%182 = icmp eq i64 %181, 0
%183 = sub nsw i64 0, %160
%184 = icmp ult i32 %0, 8
%185 = and i64 %160, 4294967288
%186 = and i64 %173, 1
%187 = icmp eq i64 %171, 0
%188 = and i64 %173, 4611686018427387902
%189 = icmp eq i64 %186, 0
%190 = icmp eq i64 %185, %160
%191 = and i64 %160, 1
%192 = icmp eq i64 %191, 0
%193 = sub nsw i64 0, %160
%194 = icmp ult i32 %0, 8
%195 = and i64 %160, 4294967288
%196 = and i64 %173, 1
%197 = icmp eq i64 %171, 0
%198 = and i64 %173, 4611686018427387902
%199 = icmp eq i64 %196, 0
%200 = icmp eq i64 %195, %160
%201 = and i64 %160, 1
%202 = icmp eq i64 %201, 0
%203 = sub nsw i64 0, %160
%204 = icmp ult i32 %0, 8
%205 = and i64 %160, 4294967288
%206 = and i64 %173, 1
%207 = icmp eq i64 %171, 0
%208 = and i64 %173, 4611686018427387902
%209 = icmp eq i64 %206, 0
%210 = icmp eq i64 %205, %160
%211 = and i64 %160, 1
%212 = icmp eq i64 %211, 0
%213 = sub nsw i64 0, %160
br label %214
214: ; preds = %153, %673
%215 = phi i32 [ %154, %153 ], [ %675, %673 ]
%216 = phi i32 [ %155, %153 ], [ %674, %673 ]
switch i32 %216, label %678 [
i32 1, label %219
i32 2, label %449
i32 3, label %217
]
217: ; preds = %214
%218 = icmp sgt i32 %215, -1
br i1 %218, label %664, label %678
219: ; preds = %214
%220 = icmp eq i32 %215, -1
br i1 %220, label %226, label %221
221: ; preds = %219
%222 = sext i32 %215 to i64
%223 = getelementptr inbounds i32, i32* %4, i64 %222
%224 = load i32, i32* %223
%225 = icmp eq i32 %224, 0
br i1 %225, label %226, label %326
226: ; preds = %221, %219
%227 = add nsw i32 %215, 1
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %4, i64 %228
store i32 0, i32* %229
br i1 %156, label %230, label %445
230: ; preds = %226
br i1 %204, label %298, label %231
231: ; preds = %230
%232 = getelementptr [250 x i32], [250 x i32]* %1, i64 %228, i64 0
%233 = mul nsw i64 %228, 250
%234 = getelementptr i32, i32* %165, i64 %233
%235 = icmp ugt i32* %234, %5
%236 = icmp ult i32* %232, %164
%237 = and i1 %235, %236
br i1 %237, label %298, label %238
238: ; preds = %231
br i1 %207, label %278, label %239
239: ; preds = %238, %239
%240 = phi i64 [ %275, %239 ], [ 0, %238 ]
%241 = phi i64 [ %276, %239 ], [ 0, %238 ]
%242 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %228, i64 %240
%243 = bitcast i32* %242 to <4 x i32>*
%244 = load <4 x i32>, <4 x i32>* %243
%245 = getelementptr inbounds i32, i32* %242, i64 4
%246 = bitcast i32* %245 to <4 x i32>*
%247 = load <4 x i32>, <4 x i32>* %246
%248 = getelementptr inbounds i32, i32* %5, i64 %240
%249 = bitcast i32* %248 to <4 x i32>*
%250 = load <4 x i32>, <4 x i32>* %249
%251 = getelementptr inbounds i32, i32* %248, i64 4
%252 = bitcast i32* %251 to <4 x i32>*
%253 = load <4 x i32>, <4 x i32>* %252
%254 = sub nsw <4 x i32> %250, %244
%255 = sub nsw <4 x i32> %253, %247
%256 = bitcast i32* %248 to <4 x i32>*
store <4 x i32> %254, <4 x i32>* %256
%257 = bitcast i32* %251 to <4 x i32>*
store <4 x i32> %255, <4 x i32>* %257
%258 = or i64 %240, 8
%259 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %228, i64 %258
%260 = bitcast i32* %259 to <4 x i32>*
%261 = load <4 x i32>, <4 x i32>* %260
%262 = getelementptr inbounds i32, i32* %259, i64 4
%263 = bitcast i32* %262 to <4 x i32>*
%264 = load <4 x i32>, <4 x i32>* %263
%265 = getelementptr inbounds i32, i32* %5, i64 %258
%266 = bitcast i32* %265 to <4 x i32>*
%267 = load <4 x i32>, <4 x i32>* %266
%268 = getelementptr inbounds i32, i32* %265, i64 4
%269 = bitcast i32* %268 to <4 x i32>*
%270 = load <4 x i32>, <4 x i32>* %269
%271 = sub nsw <4 x i32> %267, %261
%272 = sub nsw <4 x i32> %270, %264
%273 = bitcast i32* %265 to <4 x i32>*
store <4 x i32> %271, <4 x i32>* %273
%274 = bitcast i32* %268 to <4 x i32>*
store <4 x i32> %272, <4 x i32>* %274
%275 = add nuw i64 %240, 16
%276 = add i64 %241, 2
%277 = icmp eq i64 %276, %208
br i1 %277, label %278, label %239
278: ; preds = %239, %238
%279 = phi i64 [ 0, %238 ], [ %275, %239 ]
br i1 %209, label %297, label %280
280: ; preds = %278
%281 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %228, i64 %279
%282 = bitcast i32* %281 to <4 x i32>*
%283 = load <4 x i32>, <4 x i32>* %282
%284 = getelementptr inbounds i32, i32* %281, i64 4
%285 = bitcast i32* %284 to <4 x i32>*
%286 = load <4 x i32>, <4 x i32>* %285
%287 = getelementptr inbounds i32, i32* %5, i64 %279
%288 = bitcast i32* %287 to <4 x i32>*
%289 = load <4 x i32>, <4 x i32>* %288
%290 = getelementptr inbounds i32, i32* %287, i64 4
%291 = bitcast i32* %290 to <4 x i32>*
%292 = load <4 x i32>, <4 x i32>* %291
%293 = sub nsw <4 x i32> %289, %283
%294 = sub nsw <4 x i32> %292, %286
%295 = bitcast i32* %287 to <4 x i32>*
store <4 x i32> %293, <4 x i32>* %295
%296 = bitcast i32* %290 to <4 x i32>*
store <4 x i32> %294, <4 x i32>* %296
br label %297
297: ; preds = %278, %280
br i1 %210, label %434, label %298
298: ; preds = %231, %230, %297
%299 = phi i64 [ 0, %231 ], [ 0, %230 ], [ %205, %297 ]
%300 = xor i64 %299, -1
br i1 %212, label %308, label %301
301: ; preds = %298
%302 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %228, i64 %299
%303 = load i32, i32* %302
%304 = getelementptr inbounds i32, i32* %5, i64 %299
%305 = load i32, i32* %304
%306 = sub nsw i32 %305, %303
store i32 %306, i32* %304
%307 = or i64 %299, 1
br label %308
308: ; preds = %301, %298
%309 = phi i64 [ %299, %298 ], [ %307, %301 ]
%310 = icmp eq i64 %300, %213
br i1 %310, label %434, label %311
311: ; preds = %308, %311
%312 = phi i64 [ %324, %311 ], [ %309, %308 ]
%313 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %228, i64 %312
%314 = load i32, i32* %313
%315 = getelementptr inbounds i32, i32* %5, i64 %312
%316 = load i32, i32* %315
%317 = sub nsw i32 %316, %314
store i32 %317, i32* %315
%318 = add nuw nsw i64 %312, 1
%319 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %228, i64 %318
%320 = load i32, i32* %319
%321 = getelementptr inbounds i32, i32* %5, i64 %318
%322 = load i32, i32* %321
%323 = sub nsw i32 %322, %320
store i32 %323, i32* %321
%324 = add nuw nsw i64 %312, 2
%325 = icmp eq i64 %324, %163
br i1 %325, label %434, label %311
326: ; preds = %221
%327 = add nuw nsw i32 %215, 1
%328 = add i32 %215, 2
%329 = icmp slt i32 %328, %2
br i1 %329, label %330, label %434
330: ; preds = %326
%331 = sext i32 %328 to i64
br label %332
332: ; preds = %330, %430
%333 = phi i64 [ %331, %330 ], [ %431, %430 ]
%334 = getelementptr [250 x i32], [250 x i32]* %1, i64 %333, i64 0
%335 = getelementptr [250 x i32], [250 x i32]* %1, i64 %333, i64 %160
%336 = getelementptr inbounds i32, i32* %4, i64 %333
store i32 1, i32* %336
br i1 %156, label %337, label %430
337: ; preds = %332
br i1 %194, label %402, label %338
338: ; preds = %337
%339 = icmp ugt i32* %335, %5
%340 = icmp ult i32* %334, %166
%341 = and i1 %339, %340
br i1 %341, label %402, label %342
342: ; preds = %338
br i1 %197, label %382, label %343
343: ; preds = %342, %343
%344 = phi i64 [ %379, %343 ], [ 0, %342 ]
%345 = phi i64 [ %380, %343 ], [ 0, %342 ]
%346 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %333, i64 %344
%347 = bitcast i32* %346 to <4 x i32>*
%348 = load <4 x i32>, <4 x i32>* %347
%349 = getelementptr inbounds i32, i32* %346, i64 4
%350 = bitcast i32* %349 to <4 x i32>*
%351 = load <4 x i32>, <4 x i32>* %350
%352 = getelementptr inbounds i32, i32* %5, i64 %344
%353 = bitcast i32* %352 to <4 x i32>*
%354 = load <4 x i32>, <4 x i32>* %353
%355 = getelementptr inbounds i32, i32* %352, i64 4
%356 = bitcast i32* %355 to <4 x i32>*
%357 = load <4 x i32>, <4 x i32>* %356
%358 = add nsw <4 x i32> %354, %348
%359 = add nsw <4 x i32> %357, %351
%360 = bitcast i32* %352 to <4 x i32>*
store <4 x i32> %358, <4 x i32>* %360
%361 = bitcast i32* %355 to <4 x i32>*
store <4 x i32> %359, <4 x i32>* %361
%362 = or i64 %344, 8
%363 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %333, i64 %362
%364 = bitcast i32* %363 to <4 x i32>*
%365 = load <4 x i32>, <4 x i32>* %364
%366 = getelementptr inbounds i32, i32* %363, i64 4
%367 = bitcast i32* %366 to <4 x i32>*
%368 = load <4 x i32>, <4 x i32>* %367
%369 = getelementptr inbounds i32, i32* %5, i64 %362
%370 = bitcast i32* %369 to <4 x i32>*
%371 = load <4 x i32>, <4 x i32>* %370
%372 = getelementptr inbounds i32, i32* %369, i64 4
%373 = bitcast i32* %372 to <4 x i32>*
%374 = load <4 x i32>, <4 x i32>* %373
%375 = add nsw <4 x i32> %371, %365
%376 = add nsw <4 x i32> %374, %368
%377 = bitcast i32* %369 to <4 x i32>*
store <4 x i32> %375, <4 x i32>* %377
%378 = bitcast i32* %372 to <4 x i32>*
store <4 x i32> %376, <4 x i32>* %378
%379 = add nuw i64 %344, 16
%380 = add i64 %345, 2
%381 = icmp eq i64 %380, %198
br i1 %381, label %382, label %343
382: ; preds = %343, %342
%383 = phi i64 [ 0, %342 ], [ %379, %343 ]
br i1 %199, label %401, label %384
384: ; preds = %382
%385 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %333, i64 %383
%386 = bitcast i32* %385 to <4 x i32>*
%387 = load <4 x i32>, <4 x i32>* %386
%388 = getelementptr inbounds i32, i32* %385, i64 4
%389 = bitcast i32* %388 to <4 x i32>*
%390 = load <4 x i32>, <4 x i32>* %389
%391 = getelementptr inbounds i32, i32* %5, i64 %383
%392 = bitcast i32* %391 to <4 x i32>*
%393 = load <4 x i32>, <4 x i32>* %392
%394 = getelementptr inbounds i32, i32* %391, i64 4
%395 = bitcast i32* %394 to <4 x i32>*
%396 = load <4 x i32>, <4 x i32>* %395
%397 = add nsw <4 x i32> %393, %387
%398 = add nsw <4 x i32> %396, %390
%399 = bitcast i32* %391 to <4 x i32>*
store <4 x i32> %397, <4 x i32>* %399
%400 = bitcast i32* %394 to <4 x i32>*
store <4 x i32> %398, <4 x i32>* %400
br label %401
401: ; preds = %382, %384
br i1 %200, label %430, label %402
402: ; preds = %338, %337, %401
%403 = phi i64 [ 0, %338 ], [ 0, %337 ], [ %195, %401 ]
%404 = xor i64 %403, -1
br i1 %202, label %412, label %405
405: ; preds = %402
%406 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %333, i64 %403
%407 = load i32, i32* %406
%408 = getelementptr inbounds i32, i32* %5, i64 %403
%409 = load i32, i32* %408
%410 = add nsw i32 %409, %407
store i32 %410, i32* %408
%411 = or i64 %403, 1
br label %412
412: ; preds = %405, %402
%413 = phi i64 [ %403, %402 ], [ %411, %405 ]
%414 = icmp eq i64 %404, %203
br i1 %414, label %430, label %415
415: ; preds = %412, %415
%416 = phi i64 [ %428, %415 ], [ %413, %412 ]
%417 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %333, i64 %416
%418 = load i32, i32* %417
%419 = getelementptr inbounds i32, i32* %5, i64 %416
%420 = load i32, i32* %419
%421 = add nsw i32 %420, %418
store i32 %421, i32* %419
%422 = add nuw nsw i64 %416, 1
%423 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %333, i64 %422
%424 = load i32, i32* %423
%425 = getelementptr inbounds i32, i32* %5, i64 %422
%426 = load i32, i32* %425
%427 = add nsw i32 %426, %424
store i32 %427, i32* %425
%428 = add nuw nsw i64 %416, 2
%429 = icmp eq i64 %428, %162
br i1 %429, label %430, label %415
430: ; preds = %412, %415, %401, %332
%431 = add nsw i64 %333, 1
%432 = trunc i64 %431 to i32
%433 = icmp eq i32 %432, %2
br i1 %433, label %434, label %332
434: ; preds = %430, %308, %311, %297, %326
%435 = phi i32 [ %327, %326 ], [ %227, %297 ], [ %227, %311 ], [ %227, %308 ], [ %327, %430 ]
br i1 %156, label %436, label %445
436: ; preds = %434, %436
%437 = phi i64 [ %441, %436 ], [ 0, %434 ]
%438 = getelementptr inbounds i32, i32* %5, i64 %437
%439 = load i32, i32* %438
%440 = icmp ne i32 %439, 0
%441 = add nuw nsw i64 %437, 1
%442 = icmp slt i64 %441, %159
%443 = and i1 %440, %442
br i1 %443, label %436, label %444
444: ; preds = %436
br i1 %440, label %445, label %673
445: ; preds = %226, %434, %444
%446 = phi i32 [ %435, %434 ], [ %435, %444 ], [ %227, %226 ]
%447 = icmp eq i32 %446, %158
%448 = select i1 %447, i32 4, i32 1
br label %673
449: ; preds = %214
%450 = sext i32 %215 to i64
%451 = getelementptr inbounds i32, i32* %4, i64 %450
store i32 1, i32* %451
br i1 %156, label %452, label %533
452: ; preds = %449
br i1 %174, label %520, label %453
453: ; preds = %452
%454 = getelementptr [250 x i32], [250 x i32]* %1, i64 %450, i64 0
%455 = mul nsw i64 %450, 250
%456 = getelementptr i32, i32* %169, i64 %455
%457 = icmp ugt i32* %456, %5
%458 = icmp ult i32* %454, %168
%459 = and i1 %457, %458
br i1 %459, label %520, label %460
460: ; preds = %453
br i1 %177, label %500, label %461
461: ; preds = %460, %461
%462 = phi i64 [ %497, %461 ], [ 0, %460 ]
%463 = phi i64 [ %498, %461 ], [ 0, %460 ]
%464 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %450, i64 %462
%465 = bitcast i32* %464 to <4 x i32>*
%466 = load <4 x i32>, <4 x i32>* %465
%467 = getelementptr inbounds i32, i32* %464, i64 4
%468 = bitcast i32* %467 to <4 x i32>*
%469 = load <4 x i32>, <4 x i32>* %468
%470 = getelementptr inbounds i32, i32* %5, i64 %462
%471 = bitcast i32* %470 to <4 x i32>*
%472 = load <4 x i32>, <4 x i32>* %471
%473 = getelementptr inbounds i32, i32* %470, i64 4
%474 = bitcast i32* %473 to <4 x i32>*
%475 = load <4 x i32>, <4 x i32>* %474
%476 = add nsw <4 x i32> %472, %466
%477 = add nsw <4 x i32> %475, %469
%478 = bitcast i32* %470 to <4 x i32>*
store <4 x i32> %476, <4 x i32>* %478
%479 = bitcast i32* %473 to <4 x i32>*
store <4 x i32> %477, <4 x i32>* %479
%480 = or i64 %462, 8
%481 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %450, i64 %480
%482 = bitcast i32* %481 to <4 x i32>*
%483 = load <4 x i32>, <4 x i32>* %482
%484 = getelementptr inbounds i32, i32* %481, i64 4
%485 = bitcast i32* %484 to <4 x i32>*
%486 = load <4 x i32>, <4 x i32>* %485
%487 = getelementptr inbounds i32, i32* %5, i64 %480
%488 = bitcast i32* %487 to <4 x i32>*
%489 = load <4 x i32>, <4 x i32>* %488
%490 = getelementptr inbounds i32, i32* %487, i64 4
%491 = bitcast i32* %490 to <4 x i32>*
%492 = load <4 x i32>, <4 x i32>* %491
%493 = add nsw <4 x i32> %489, %483
%494 = add nsw <4 x i32> %492, %486
%495 = bitcast i32* %487 to <4 x i32>*
store <4 x i32> %493, <4 x i32>* %495
%496 = bitcast i32* %490 to <4 x i32>*
store <4 x i32> %494, <4 x i32>* %496
%497 = add nuw i64 %462, 16
%498 = add i64 %463, 2
%499 = icmp eq i64 %498, %178
br i1 %499, label %500, label %461
500: ; preds = %461, %460
%501 = phi i64 [ 0, %460 ], [ %497, %461 ]
br i1 %179, label %519, label %502
502: ; preds = %500
%503 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %450, i64 %501
%504 = bitcast i32* %503 to <4 x i32>*
%505 = load <4 x i32>, <4 x i32>* %504
%506 = getelementptr inbounds i32, i32* %503, i64 4
%507 = bitcast i32* %506 to <4 x i32>*
%508 = load <4 x i32>, <4 x i32>* %507
%509 = getelementptr inbounds i32, i32* %5, i64 %501
%510 = bitcast i32* %509 to <4 x i32>*
%511 = load <4 x i32>, <4 x i32>* %510
%512 = getelementptr inbounds i32, i32* %509, i64 4
%513 = bitcast i32* %512 to <4 x i32>*
%514 = load <4 x i32>, <4 x i32>* %513
%515 = add nsw <4 x i32> %511, %505
%516 = add nsw <4 x i32> %514, %508
%517 = bitcast i32* %509 to <4 x i32>*
store <4 x i32> %515, <4 x i32>* %517
%518 = bitcast i32* %512 to <4 x i32>*
store <4 x i32> %516, <4 x i32>* %518
br label %519
519: ; preds = %500, %502
br i1 %180, label %533, label %520
520: ; preds = %453, %452, %519
%521 = phi i64 [ 0, %453 ], [ 0, %452 ], [ %175, %519 ]
%522 = xor i64 %521, -1
br i1 %182, label %530, label %523
523: ; preds = %520
%524 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %450, i64 %521
%525 = load i32, i32* %524
%526 = getelementptr inbounds i32, i32* %5, i64 %521
%527 = load i32, i32* %526
%528 = add nsw i32 %527, %525
store i32 %528, i32* %526
%529 = or i64 %521, 1
br label %530
530: ; preds = %523, %520
%531 = phi i64 [ %521, %520 ], [ %529, %523 ]
%532 = icmp eq i64 %522, %183
br i1 %532, label %533, label %538
533: ; preds = %530, %538, %519, %449
%534 = add i32 %215, 1
%535 = icmp slt i32 %534, %2
br i1 %535, label %536, label %658
536: ; preds = %533
%537 = sext i32 %534 to i64
br label %553
538: ; preds = %530, %538
%539 = phi i64 [ %551, %538 ], [ %531, %530 ]
%540 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %450, i64 %539
%541 = load i32, i32* %540
%542 = getelementptr inbounds i32, i32* %5, i64 %539
%543 = load i32, i32* %542
%544 = add nsw i32 %543, %541
store i32 %544, i32* %542
%545 = add nuw nsw i64 %539, 1
%546 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %450, i64 %545
%547 = load i32, i32* %546
%548 = getelementptr inbounds i32, i32* %5, i64 %545
%549 = load i32, i32* %548
%550 = add nsw i32 %549, %547
store i32 %550, i32* %548
%551 = add nuw nsw i64 %539, 2
%552 = icmp eq i64 %551, %160
br i1 %552, label %533, label %538
553: ; preds = %536, %654
%554 = phi i64 [ %537, %536 ], [ %655, %654 ]
%555 = getelementptr [250 x i32], [250 x i32]* %1, i64 %554, i64 0
%556 = getelementptr [250 x i32], [250 x i32]* %1, i64 %554, i64 %160
%557 = getelementptr inbounds i32, i32* %4, i64 %554
%558 = load i32, i32* %557
%559 = icmp eq i32 %558, 0
br i1 %559, label %654, label %560
560: ; preds = %553
store i32 0, i32* %557
br i1 %156, label %561, label %654
561: ; preds = %560
br i1 %184, label %626, label %562
562: ; preds = %561
%563 = icmp ugt i32* %556, %5
%564 = icmp ult i32* %555, %167
%565 = and i1 %563, %564
br i1 %565, label %626, label %566
566: ; preds = %562
br i1 %187, label %606, label %567
567: ; preds = %566, %567
%568 = phi i64 [ %603, %567 ], [ 0, %566 ]
%569 = phi i64 [ %604, %567 ], [ 0, %566 ]
%570 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %554, i64 %568
%571 = bitcast i32* %570 to <4 x i32>*
%572 = load <4 x i32>, <4 x i32>* %571
%573 = getelementptr inbounds i32, i32* %570, i64 4
%574 = bitcast i32* %573 to <4 x i32>*
%575 = load <4 x i32>, <4 x i32>* %574
%576 = getelementptr inbounds i32, i32* %5, i64 %568
%577 = bitcast i32* %576 to <4 x i32>*
%578 = load <4 x i32>, <4 x i32>* %577
%579 = getelementptr inbounds i32, i32* %576, i64 4
%580 = bitcast i32* %579 to <4 x i32>*
%581 = load <4 x i32>, <4 x i32>* %580
%582 = sub nsw <4 x i32> %578, %572
%583 = sub nsw <4 x i32> %581, %575
%584 = bitcast i32* %576 to <4 x i32>*
store <4 x i32> %582, <4 x i32>* %584
%585 = bitcast i32* %579 to <4 x i32>*
store <4 x i32> %583, <4 x i32>* %585
%586 = or i64 %568, 8
%587 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %554, i64 %586
%588 = bitcast i32* %587 to <4 x i32>*
%589 = load <4 x i32>, <4 x i32>* %588
%590 = getelementptr inbounds i32, i32* %587, i64 4
%591 = bitcast i32* %590 to <4 x i32>*
%592 = load <4 x i32>, <4 x i32>* %591
%593 = getelementptr inbounds i32, i32* %5, i64 %586
%594 = bitcast i32* %593 to <4 x i32>*
%595 = load <4 x i32>, <4 x i32>* %594
%596 = getelementptr inbounds i32, i32* %593, i64 4
%597 = bitcast i32* %596 to <4 x i32>*
%598 = load <4 x i32>, <4 x i32>* %597
%599 = sub nsw <4 x i32> %595, %589
%600 = sub nsw <4 x i32> %598, %592
%601 = bitcast i32* %593 to <4 x i32>*
store <4 x i32> %599, <4 x i32>* %601
%602 = bitcast i32* %596 to <4 x i32>*
store <4 x i32> %600, <4 x i32>* %602
%603 = add nuw i64 %568, 16
%604 = add i64 %569, 2
%605 = icmp eq i64 %604, %188
br i1 %605, label %606, label %567
606: ; preds = %567, %566
%607 = phi i64 [ 0, %566 ], [ %603, %567 ]
br i1 %189, label %625, label %608
608: ; preds = %606
%609 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %554, i64 %607
%610 = bitcast i32* %609 to <4 x i32>*
%611 = load <4 x i32>, <4 x i32>* %610
%612 = getelementptr inbounds i32, i32* %609, i64 4
%613 = bitcast i32* %612 to <4 x i32>*
%614 = load <4 x i32>, <4 x i32>* %613
%615 = getelementptr inbounds i32, i32* %5, i64 %607
%616 = bitcast i32* %615 to <4 x i32>*
%617 = load <4 x i32>, <4 x i32>* %616
%618 = getelementptr inbounds i32, i32* %615, i64 4
%619 = bitcast i32* %618 to <4 x i32>*
%620 = load <4 x i32>, <4 x i32>* %619
%621 = sub nsw <4 x i32> %617, %611
%622 = sub nsw <4 x i32> %620, %614
%623 = bitcast i32* %615 to <4 x i32>*
store <4 x i32> %621, <4 x i32>* %623
%624 = bitcast i32* %618 to <4 x i32>*
store <4 x i32> %622, <4 x i32>* %624
br label %625
625: ; preds = %606, %608
br i1 %190, label %654, label %626
626: ; preds = %562, %561, %625
%627 = phi i64 [ 0, %562 ], [ 0, %561 ], [ %185, %625 ]
%628 = xor i64 %627, -1
br i1 %192, label %636, label %629
629: ; preds = %626
%630 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %554, i64 %627
%631 = load i32, i32* %630
%632 = getelementptr inbounds i32, i32* %5, i64 %627
%633 = load i32, i32* %632
%634 = sub nsw i32 %633, %631
store i32 %634, i32* %632
%635 = or i64 %627, 1
br label %636
636: ; preds = %629, %626
%637 = phi i64 [ %627, %626 ], [ %635, %629 ]
%638 = icmp eq i64 %628, %193
br i1 %638, label %654, label %639
639: ; preds = %636, %639
%640 = phi i64 [ %652, %639 ], [ %637, %636 ]
%641 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %554, i64 %640
%642 = load i32, i32* %641
%643 = getelementptr inbounds i32, i32* %5, i64 %640
%644 = load i32, i32* %643
%645 = sub nsw i32 %644, %642
store i32 %645, i32* %643
%646 = add nuw nsw i64 %640, 1
%647 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %554, i64 %646
%648 = load i32, i32* %647
%649 = getelementptr inbounds i32, i32* %5, i64 %646
%650 = load i32, i32* %649
%651 = sub nsw i32 %650, %648
store i32 %651, i32* %649
%652 = add nuw nsw i64 %640, 2
%653 = icmp eq i64 %652, %161
br i1 %653, label %654, label %639
654: ; preds = %636, %639, %625, %560, %553
%655 = add nsw i64 %554, 1
%656 = trunc i64 %655 to i32
%657 = icmp eq i32 %656, %2
br i1 %657, label %658, label %553
658: ; preds = %654, %533
%659 = tail call i64 @var_check_1(i32* %3, i32* %5, i32 0, i32 %157)
%660 = icmp eq i64 %659, 0
br i1 %660, label %673, label %661
661: ; preds = %658
%662 = icmp eq i32 %215, %158
%663 = select i1 %662, i32 4, i32 1
br label %673
664: ; preds = %217, %670
%665 = phi i32 [ %671, %670 ], [ %215, %217 ]
%666 = zext i32 %665 to i64
%667 = getelementptr inbounds i32, i32* %4, i64 %666
%668 = load i32, i32* %667
%669 = icmp eq i32 %668, 0
br i1 %669, label %673, label %670
670: ; preds = %664
%671 = add nsw i32 %665, -1
%672 = icmp sgt i32 %665, 0
br i1 %672, label %664, label %678
673: ; preds = %664, %658, %444, %661, %445
%674 = phi i32 [ %448, %445 ], [ %663, %661 ], [ 2, %444 ], [ 3, %658 ], [ 2, %664 ]
%675 = phi i32 [ %446, %445 ], [ %215, %661 ], [ %435, %444 ], [ %215, %658 ], [ %665, %664 ]
%676 = and i32 %674, 6
%677 = icmp eq i32 %676, 4
br i1 %677, label %678, label %214
678: ; preds = %217, %214, %673, %670, %149
%679 = phi i32 [ %150, %149 ], [ 5, %670 ], [ 4, %214 ], [ 5, %217 ], [ 4, %673 ]
%680 = icmp eq i32 %679, 4
%681 = zext i1 %680 to i32
ret i32 %681
}