#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 */
int /*<<< orphan*/ var_check_1(int *, int *, int /*<<< orphan*/, int);
int next_combo_b(int length, int basis[100][250], int num_basis,
                 int constraints[250], int combo[100], int sum[250],
                 int start_flag) {
  int go, pos, i, success;
  if (start_flag) {
    for (i = 0; i < length; i++)
      sum[i] = 0;
    for (i = 0; i < num_basis; i++)
      combo[i] = 0;
    pos = -1;
  } else {
    pos = num_basis - 1;
    while (pos >= 0 && !combo[pos])
      pos--;
    combo[pos] = 0;
    {
      int j, *p;
      for (j = 0, p = basis[pos]; j < length; j++)
        sum[j] -= p[j];
    };
  }
  success = 0;
  go = 1;
  while (go && !success) {
    if (pos == num_basis - 1) {
      success = 1;
      for (i = 0; i < length && success; i++)
        if (sum[i] == 0)
          success = 0;
      if (!success) {
        while (pos >= 0 && !combo[pos])
          pos--;
        if (pos < 0)
          go = 0;
        else {
          combo[pos] = 0;
          {
            int j, *p;
            for (j = 0, p = basis[pos]; j < length; j++)
              sum[j] -= p[j];
          };
        }
      }
    } else {
      pos++;
      combo[pos] = 1;
      {
        int j, *p;
        for (j = 0, p = basis[pos]; j < length; j++)
          sum[j] += p[j];
      };
      if (!var_check_1(constraints, sum, 0, length - 1)) {
        combo[pos] = 0;
        {
          int j, *p;
          for (j = 0, p = basis[pos]; j < length; j++)
            sum[j] -= p[j];
        };
      }
    }
  }
  return success;
}


x86 assembly (clang, -O0):
<next_combo_b>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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     11aa <next_combo_b+0x9a>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    116e <next_combo_b+0x5e>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1145 <next_combo_b+0x35>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    119e <next_combo_b+0x8e>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1175 <next_combo_b+0x65>
movl   $0xffffffff,-0x38(%rbp)
jmp    1263 <next_combo_b+0x153>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x38(%rbp)
mov    %al,-0x81(%rbp)
jl     11dc <next_combo_b+0xcc>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
xor    $0xff,%al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    11ef <next_combo_b+0xdf>
jmp    11fd <next_combo_b+0xed>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    11b3 <next_combo_b+0xa3>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%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    125e <next_combo_b+0x14e>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1229 <next_combo_b+0x119>
jmp    1263 <next_combo_b+0x153>
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x34(%rbp)
mov    %al,-0x82(%rbp)
je     1292 <next_combo_b+0x182>
cmpl   $0x0,-0x40(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x82(%rbp)
mov    -0x82(%rbp),%al
test   $0x1,%al
jne    12a5 <next_combo_b+0x195>
jmp    14f9 <next_combo_b+0x3e9>
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1403 <next_combo_b+0x2f3>
movl   $0x1,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x4(%rbp),%ecx
mov    %al,-0x83(%rbp)
jge    12e5 <next_combo_b+0x1d5>
cmpl   $0x0,-0x40(%rbp)
setne  %al
mov    %al,-0x83(%rbp)
mov    -0x83(%rbp),%al
test   $0x1,%al
jne    12f8 <next_combo_b+0x1e8>
jmp    1324 <next_combo_b+0x214>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1311 <next_combo_b+0x201>
movl   $0x0,-0x40(%rbp)
jmp    1316 <next_combo_b+0x206>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12c4 <next_combo_b+0x1b4>
cmpl   $0x0,-0x40(%rbp)
jne    13fe <next_combo_b+0x2ee>
jmp    1333 <next_combo_b+0x223>
xor    %eax,%eax
cmpl   $0x0,-0x38(%rbp)
mov    %al,-0x84(%rbp)
jl     135c <next_combo_b+0x24c>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
xor    $0xff,%al
mov    %al,-0x84(%rbp)
mov    -0x84(%rbp),%al
test   $0x1,%al
jne    136f <next_combo_b+0x25f>
jmp    137d <next_combo_b+0x26d>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1333 <next_combo_b+0x223>
cmpl   $0x0,-0x38(%rbp)
jge    1393 <next_combo_b+0x283>
movl   $0x0,-0x34(%rbp)
jmp    13f9 <next_combo_b+0x2e9>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f4 <next_combo_b+0x2e4>
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    13bf <next_combo_b+0x2af>
jmp    13f9 <next_combo_b+0x2e9>
jmp    13fe <next_combo_b+0x2ee>
jmp    14f4 <next_combo_b+0x3e4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
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    146b <next_combo_b+0x35b>
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    1438 <next_combo_b+0x328>
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,%eax
jne    14ef <next_combo_b+0x3df>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14ea <next_combo_b+0x3da>
mov    -0x80(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x30(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    14b5 <next_combo_b+0x3a5>
jmp    14ef <next_combo_b+0x3df>
jmp    14f4 <next_combo_b+0x3e4>
jmp    1271 <next_combo_b+0x161>
mov    -0x40(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<next_combo_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,%rbx
mov    %r8,%r14
mov    %rcx,0x78(%rsp)
mov    %edx,%r9d
mov    %rsi,0x10(%rsp)
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
mov    %rax,0x30(%rsp)
cmpl   $0x0,0xd0(%rsp)
mov    %edi,%r13d
mov    %r9,0x8(%rsp)
mov    %rdi,0x20(%rsp)
je     11b9 <next_combo_b+0x99>
test   %edi,%edi
jle    118a <next_combo_b+0x6a>
lea    0x0(,%r13,4),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x20(%rsp),%rdi
mov    0x8(%rsp),%r9
mov    $0xffffffff,%r12d
test   %r9d,%r9d
jle    1359 <next_combo_b+0x239>
mov    %r9d,%edx
shl    $0x2,%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x20(%rsp),%rdi
mov    0x8(%rsp),%r9
jmp    1359 <next_combo_b+0x239>
mov    %r9d,%eax
xor    %r12d,%r12d
test   %r9d,%r9d
cmovs  %r9d,%r12d
add    $0xffffffff,%r12d
nopw   0x0(%rax,%rax,1)
test   %eax,%eax
jle    11e4 <next_combo_b+0xc4>
add    $0xffffffffffffffff,%rax
mov    %eax,%ecx
cmpl   $0x0,(%r14,%rcx,4)
je     11d0 <next_combo_b+0xb0>
mov    %eax,%r12d
movslq %r12d,%rax
movl   $0x0,(%r14,%rax,4)
test   %edi,%edi
jle    1359 <next_combo_b+0x239>
cmp    $0x8,%edi
jb     121e <next_combo_b+0xfe>
imul   $0x3e8,%rax,%rdx
mov    0x10(%rsp),%rcx
lea    (%rcx,%rdx,1),%r8
lea    (%r8,%r13,4),%rcx
cmp    %rbx,%rcx
jbe    127c <next_combo_b+0x15c>
lea    (%rbx,%r13,4),%rcx
cmp    %rcx,%r8
jae    127c <next_combo_b+0x15c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r13b
je     1242 <next_combo_b+0x122>
imul   $0x3e8,%rax,%rsi
add    0x10(%rsp),%rsi
mov    (%rsi,%rcx,4),%esi
sub    %esi,(%rbx,%rcx,4)
or     $0x1,%rcx
add    %r13,%rdx
je     1359 <next_combo_b+0x239>
imul   $0x3e8,%rax,%rax
mov    0x10(%rsp),%rdx
add    %rdx,%rax
add    $0x4,%rax
xchg   %ax,%ax
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,%r13
jne    1260 <next_combo_b+0x140>
jmp    1359 <next_combo_b+0x239>
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rsi,%rsi
je     1967 <next_combo_b+0x847>
mov    %r10,%rbp
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
and    %rsi,%rbp
mov    0x10(%rsp),%rsi
add    %rsi,%rdx
add    $0x30,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rdx,%rsi,4),%xmm0
movdqu -0x20(%rdx,%rsi,4),%xmm1
movdqu (%rbx,%rsi,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm0
psubd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rsi,4),%xmm1
movdqu 0x30(%rbx,%rsi,4),%xmm3
movdqu %xmm2,(%rbx,%rsi,4)
movdqu %xmm0,0x10(%rbx,%rsi,4)
movdqu -0x10(%rdx,%rsi,4),%xmm0
psubd  %xmm0,%xmm1
movdqu (%rdx,%rsi,4),%xmm0
psubd  %xmm0,%xmm3
movdqu %xmm1,0x20(%rbx,%rsi,4)
movdqu %xmm3,0x30(%rbx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbp
jne    12c0 <next_combo_b+0x1a0>
test   $0x1,%r10b
je     1350 <next_combo_b+0x230>
movdqu (%r8,%rsi,4),%xmm0
movdqu 0x10(%r8,%rsi,4),%xmm1
movdqu (%rbx,%rsi,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rsi,4)
movdqu %xmm0,0x10(%rbx,%rsi,4)
cmp    %r13,%rcx
jne    1220 <next_combo_b+0x100>
lea    -0x1(%r9),%r10d
lea    -0x1(%rdi),%eax
mov    %eax,0x2c(%rsp)
movslq %edi,%rbp
lea    (%rbx,%r13,4),%rax
mov    %rax,0x50(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%r13,4),%rcx
mov    %rcx,0x70(%rsp)
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x48(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x40(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rdx
mov    %rcx,0x38(%rsp)
and    %rcx,0x30(%rsp)
mov    %r13,%rcx
neg    %rcx
mov    %rcx,0x58(%rsp)
lea    0x30(%rax),%rcx
mov    %rcx,0x60(%rsp)
lea    0x4(%rax),%rcx
mov    %rcx,0x68(%rsp)
imul   $0x3e8,%r10,%rcx
add    %rax,%rcx
mov    %rcx,0x90(%rsp)
lea    0x0(,%r13,4),%rax
mov    %rax,0x80(%rsp)
lea    (%r14,%r10,4),%rax
mov    %rax,0x88(%rsp)
mov    %r10,0x18(%rsp)
cmp    %r10d,%r12d
jne    1480 <next_combo_b+0x360>
test   %edi,%edi
jle    1947 <next_combo_b+0x827>
mov    $0x1,%ecx
nopl   (%rax)
mov    -0x4(%rbx,%rcx,4),%esi
test   %esi,%esi
je     1424 <next_combo_b+0x304>
lea    0x1(%rcx),%rdx
cmp    %rbp,%rcx
mov    %rdx,%rcx
jl     1410 <next_combo_b+0x2f0>
xor    %eax,%eax
test   %esi,%esi
setne  %cl
jne    194e <next_combo_b+0x82e>
test   %r9d,%r9d
jle    194e <next_combo_b+0x82e>
mov    %cl,%al
mov    0x88(%rsp),%rcx
mov    0x90(%rsp),%rsi
mov    %r9d,%edx
nop
lea    -0x1(%rdx),%r12d
cmpl   $0x0,(%r14,%r12,4)
jne    1530 <next_combo_b+0x410>
add    $0xfffffffffffffc18,%rsi
add    $0xfffffffffffffffc,%rcx
add    $0xffffffff,%edx
jg     1450 <next_combo_b+0x330>
jmp    1955 <next_combo_b+0x835>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %r12d,%rax
add    $0x1,%r12d
lea    0x1(%rax),%r15
movl   $0x1,0x4(%r14,%rax,4)
test   %edi,%edi
jle    15ac <next_combo_b+0x48c>
cmp    $0x8,%edi
jb     14cc <next_combo_b+0x3ac>
imul   $0x3e8,%r15,%rdx
mov    0x10(%rsp),%rax
add    %rdx,%rax
mov    0x70(%rsp),%rcx
add    %rdx,%rcx
cmp    %rbx,%rcx
jbe    15d4 <next_combo_b+0x4b4>
cmp    0x50(%rsp),%rax
jae    15d4 <next_combo_b+0x4b4>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r13b
je     14f0 <next_combo_b+0x3d0>
imul   $0x3e8,%r15,%rax
add    0x10(%rsp),%rax
mov    (%rax,%rcx,4),%eax
add    %eax,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x58(%rsp),%rcx
je     1690 <next_combo_b+0x570>
imul   $0x3e8,%r15,%rcx
add    0x68(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
mov    -0x4(%rcx,%rax,4),%edx
add    %edx,(%rbx,%rax,4)
mov    (%rcx,%rax,4),%edx
add    %edx,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r13
jne    1510 <next_combo_b+0x3f0>
jmp    1690 <next_combo_b+0x570>
nopl   0x0(%rax)
movl   $0x0,(%rcx)
test   %edi,%edi
jle    16b8 <next_combo_b+0x598>
cmp    $0x8,%edi
jb     1562 <next_combo_b+0x442>
mov    0x80(%rsp),%rcx
add    %rsi,%rcx
cmp    %rbx,%rcx
jbe    1786 <next_combo_b+0x666>
cmp    0x50(%rsp),%rsi
jae    1786 <next_combo_b+0x666>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r13b
je     157a <next_combo_b+0x45a>
mov    (%rsi,%rdx,4),%ecx
sub    %ecx,(%rbx,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x58(%rsp),%rdx
je     16b8 <next_combo_b+0x598>
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,4),%edx
sub    %edx,(%rbx,%rcx,4)
mov    0x4(%rsi,%rcx,4),%edx
sub    %edx,0x4(%rbx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1590 <next_combo_b+0x470>
jmp    16b8 <next_combo_b+0x598>
mov    0x78(%rsp),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
mov    0x2c(%rsp),%ecx
call   1040 <var_check_1@plt>
test   %eax,%eax
jne    16a7 <next_combo_b+0x587>
movl   $0x0,(%r14,%r15,4)
jmp    16a7 <next_combo_b+0x587>
cmpq   $0x0,0x40(%rsp)
je     1845 <next_combo_b+0x725>
add    0x60(%rsp),%rdx
mov    0x30(%rsp),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movdqu -0x30(%rdx,%rcx,4),%xmm0
movdqu -0x20(%rdx,%rcx,4),%xmm1
movdqu (%rbx,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm3
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
movdqu -0x10(%rdx,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu (%rdx,%rcx,4),%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,0x20(%rbx,%rcx,4)
movdqu %xmm1,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15f0 <next_combo_b+0x4d0>
testb  $0x1,0x38(%rsp)
je     167f <next_combo_b+0x55f>
movdqu (%rax,%rcx,4),%xmm0
movdqu 0x10(%rax,%rcx,4),%xmm1
movdqu (%rbx,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
mov    0x48(%rsp),%rax
mov    %rax,%rcx
cmp    %r13,%rax
jne    14ce <next_combo_b+0x3ae>
mov    0x78(%rsp),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
mov    0x2c(%rsp),%ecx
call   1040 <var_check_1@plt>
test   %eax,%eax
je     16c5 <next_combo_b+0x5a5>
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%r10
xor    %eax,%eax
test   %eax,%eax
je     13f7 <next_combo_b+0x2d7>
jmp    1955 <next_combo_b+0x835>
movl   $0x0,(%r14,%r15,4)
mov    0x20(%rsp),%rdi
test   %edi,%edi
jle    177c <next_combo_b+0x65c>
cmp    $0x8,%edi
jb     170a <next_combo_b+0x5ea>
imul   $0x3e8,%r15,%rdx
mov    0x10(%rsp),%rax
add    %rdx,%rax
mov    0x70(%rsp),%rcx
add    %rdx,%rcx
cmp    %rbx,%rcx
jbe    1857 <next_combo_b+0x737>
cmp    0x50(%rsp),%rax
jae    1857 <next_combo_b+0x737>
xor    %ecx,%ecx
mov    0x8(%rsp),%r9
mov    0x18(%rsp),%r10
mov    %rcx,%rax
test   $0x1,%r13b
je     1738 <next_combo_b+0x618>
imul   $0x3e8,%r15,%rax
add    0x10(%rsp),%rax
mov    (%rax,%rcx,4),%eax
sub    %eax,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x58(%rsp),%rcx
je     16b6 <next_combo_b+0x596>
imul   $0x3e8,%r15,%rcx
add    0x68(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x4(%rcx,%rax,4),%edx
sub    %edx,(%rbx,%rax,4)
mov    (%rcx,%rax,4),%edx
sub    %edx,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r13
jne    1760 <next_combo_b+0x640>
jmp    16b6 <next_combo_b+0x596>
mov    0x8(%rsp),%r9
jmp    16b1 <next_combo_b+0x591>
cmpq   $0x0,0x40(%rsp)
je     192a <next_combo_b+0x80a>
mov    0x30(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movdqu (%rsi,%rcx,4),%xmm0
movdqu 0x10(%rsi,%rcx,4),%xmm1
movdqu (%rbx,%rcx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm3
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
movdqu 0x20(%rsi,%rcx,4),%xmm0
psubd  %xmm0,%xmm1
movdqu 0x30(%rsi,%rcx,4),%xmm0
psubd  %xmm0,%xmm3
movdqu %xmm1,0x20(%rbx,%rcx,4)
movdqu %xmm3,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    17a0 <next_combo_b+0x680>
testb  $0x1,0x38(%rsp)
je     182f <next_combo_b+0x70f>
movdqu (%rsi,%rcx,4),%xmm0
movdqu 0x10(%rsi,%rcx,4),%xmm1
movdqu (%rbx,%rcx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
mov    0x48(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r13,%rcx
je     16b8 <next_combo_b+0x598>
jmp    1564 <next_combo_b+0x444>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    1656 <next_combo_b+0x536>
jmp    167f <next_combo_b+0x55f>
cmpq   $0x0,0x40(%rsp)
mov    0x8(%rsp),%r9
je     193c <next_combo_b+0x81c>
add    0x60(%rsp),%rdx
mov    0x30(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x30(%rdx,%rcx,4),%xmm0
movdqu -0x20(%rdx,%rcx,4),%xmm1
movdqu (%rbx,%rcx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm3
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
movdqu -0x10(%rdx,%rcx,4),%xmm0
psubd  %xmm0,%xmm1
movdqu (%rdx,%rcx,4),%xmm0
psubd  %xmm0,%xmm3
movdqu %xmm1,0x20(%rbx,%rcx,4)
movdqu %xmm3,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1880 <next_combo_b+0x760>
testb  $0x1,0x38(%rsp)
je     190f <next_combo_b+0x7ef>
movdqu (%rax,%rcx,4),%xmm0
movdqu 0x10(%rax,%rcx,4),%xmm1
movdqu (%rbx,%rcx,4),%xmm2
psubd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
psubd  %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
mov    0x48(%rsp),%rax
mov    %rax,%rcx
cmp    %r13,%rax
mov    0x18(%rsp),%r10
je     16b6 <next_combo_b+0x596>
jmp    1716 <next_combo_b+0x5f6>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    1806 <next_combo_b+0x6e6>
jmp    182f <next_combo_b+0x70f>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    18e6 <next_combo_b+0x7c6>
jmp    190f <next_combo_b+0x7ef>
mov    $0x1,%eax
jmp    1955 <next_combo_b+0x835>
xor    %eax,%eax
test   %esi,%esi
setne  %al
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%r10b
jne    1325 <next_combo_b+0x205>
jmp    1350 <next_combo_b+0x230>

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

LLVM IR (-O2):
define i32 @next_combo_b(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 = bitcast i32* %4 to i8*
%10 = icmp eq i32 %6, 0
br i1 %10, label %11, label %15
11: ; preds = %7
%12 = zext i32 %2 to i64
%13 = call i32 @llvm.smin.i32(i32 %2, i32 0)
%14 = add i32 %13, -1
br label %25
15: ; preds = %7
%16 = icmp sgt i32 %0, 0
br i1 %16, label %17, label %20
17: ; preds = %15
%18 = zext i32 %0 to i64
%19 = shl nuw nsw i64 %18, 2
br label %20
20: ; preds = %17, %15
%21 = icmp sgt i32 %2, 0
br i1 %21, label %22, label %153
22: ; preds = %20
%23 = zext i32 %2 to i64
%24 = shl nuw nsw i64 %23, 2
br label %153
25: ; preds = %11, %30
%26 = phi i64 [ %12, %11 ], [ %27, %30 ]
%27 = add nsw i64 %26, -1
%28 = trunc i64 %26 to i32
%29 = icmp sgt i32 %28, 0
br i1 %29, label %30, label %37
30: ; preds = %25
%31 = and i64 %27, 4294967295
%32 = getelementptr inbounds i32, i32* %4, i64 %31
%33 = load i32, i32* %32
%34 = icmp eq i32 %33, 0
br i1 %34, label %25, label %35
35: ; preds = %30
%36 = trunc i64 %27 to i32
br label %37
37: ; preds = %25, %35
%38 = phi i32 [ %36, %35 ], [ %14, %25 ]
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %4, i64 %39
store i32 0, i32* %40
%41 = icmp sgt i32 %0, 0
br i1 %41, label %42, label %153
42: ; preds = %37
%43 = zext i32 %0 to i64
%44 = icmp ult i32 %0, 8
br i1 %44, label %122, label %45
45: ; preds = %42
%46 = getelementptr i32, i32* %5, i64 %43
%47 = getelementptr [250 x i32], [250 x i32]* %1, i64 %39, i64 0
%48 = getelementptr [250 x i32], [250 x i32]* %1, i64 %39, i64 %43
%49 = icmp ugt i32* %48, %5
%50 = icmp ult i32* %47, %46
%51 = and i1 %49, %50
br i1 %51, label %122, label %52
52: ; preds = %45
%53 = and i64 %43, 4294967288
%54 = add nsw i64 %53, -8
%55 = lshr exact i64 %54, 3
%56 = add nuw nsw i64 %55, 1
%57 = and i64 %56, 1
%58 = icmp eq i64 %54, 0
br i1 %58, label %100, label %59
59: ; preds = %52
%60 = and i64 %56, 4611686018427387902
br label %61
61: ; preds = %61, %59
%62 = phi i64 [ 0, %59 ], [ %97, %61 ]
%63 = phi i64 [ 0, %59 ], [ %98, %61 ]
%64 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %62
%65 = bitcast i32* %64 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = getelementptr inbounds i32, i32* %64, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
%69 = load <4 x i32>, <4 x i32>* %68
%70 = getelementptr inbounds i32, i32* %5, i64 %62
%71 = bitcast i32* %70 to <4 x i32>*
%72 = load <4 x i32>, <4 x i32>* %71
%73 = getelementptr inbounds i32, i32* %70, i64 4
%74 = bitcast i32* %73 to <4 x i32>*
%75 = load <4 x i32>, <4 x i32>* %74
%76 = sub nsw <4 x i32> %72, %66
%77 = sub nsw <4 x i32> %75, %69
%78 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> %76, <4 x i32>* %78
%79 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> %77, <4 x i32>* %79
%80 = or i64 %62, 8
%81 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %80
%82 = bitcast i32* %81 to <4 x i32>*
%83 = load <4 x i32>, <4 x i32>* %82
%84 = getelementptr inbounds i32, i32* %81, i64 4
%85 = bitcast i32* %84 to <4 x i32>*
%86 = load <4 x i32>, <4 x i32>* %85
%87 = getelementptr inbounds i32, i32* %5, i64 %80
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = getelementptr inbounds i32, i32* %87, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = sub nsw <4 x i32> %89, %83
%94 = sub nsw <4 x i32> %92, %86
%95 = bitcast i32* %87 to <4 x i32>*
store <4 x i32> %93, <4 x i32>* %95
%96 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> %94, <4 x i32>* %96
%97 = add nuw i64 %62, 16
%98 = add i64 %63, 2
%99 = icmp eq i64 %98, %60
br i1 %99, label %100, label %61
100: ; preds = %61, %52
%101 = phi i64 [ 0, %52 ], [ %97, %61 ]
%102 = icmp eq i64 %57, 0
br i1 %102, label %120, label %103
103: ; preds = %100
%104 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %101
%105 = bitcast i32* %104 to <4 x i32>*
%106 = load <4 x i32>, <4 x i32>* %105
%107 = getelementptr inbounds i32, i32* %104, i64 4
%108 = bitcast i32* %107 to <4 x i32>*
%109 = load <4 x i32>, <4 x i32>* %108
%110 = getelementptr inbounds i32, i32* %5, i64 %101
%111 = bitcast i32* %110 to <4 x i32>*
%112 = load <4 x i32>, <4 x i32>* %111
%113 = getelementptr inbounds i32, i32* %110, i64 4
%114 = bitcast i32* %113 to <4 x i32>*
%115 = load <4 x i32>, <4 x i32>* %114
%116 = sub nsw <4 x i32> %112, %106
%117 = sub nsw <4 x i32> %115, %109
%118 = bitcast i32* %110 to <4 x i32>*
store <4 x i32> %116, <4 x i32>* %118
%119 = bitcast i32* %113 to <4 x i32>*
store <4 x i32> %117, <4 x i32>* %119
br label %120
120: ; preds = %100, %103
%121 = icmp eq i64 %53, %43
br i1 %121, label %153, label %122
122: ; preds = %45, %42, %120
%123 = phi i64 [ 0, %45 ], [ 0, %42 ], [ %53, %120 ]
%124 = xor i64 %123, -1
%125 = and i64 %43, 1
%126 = icmp eq i64 %125, 0
br i1 %126, label %134, label %127
127: ; preds = %122
%128 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %123
%129 = load i32, i32* %128
%130 = getelementptr inbounds i32, i32* %5, i64 %123
%131 = load i32, i32* %130
%132 = sub nsw i32 %131, %129
store i32 %132, i32* %130
%133 = or i64 %123, 1
br label %134
134: ; preds = %127, %122
%135 = phi i64 [ %123, %122 ], [ %133, %127 ]
%136 = sub nsw i64 0, %43
%137 = icmp eq i64 %124, %136
br i1 %137, label %153, label %138
138: ; preds = %134, %138
%139 = phi i64 [ %151, %138 ], [ %135, %134 ]
%140 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %139
%141 = load i32, i32* %140
%142 = getelementptr inbounds i32, i32* %5, i64 %139
%143 = load i32, i32* %142
%144 = sub nsw i32 %143, %141
store i32 %144, i32* %142
%145 = add nuw nsw i64 %139, 1
%146 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %39, i64 %145
%147 = load i32, i32* %146
%148 = getelementptr inbounds i32, i32* %5, i64 %145
%149 = load i32, i32* %148
%150 = sub nsw i32 %149, %147
store i32 %150, i32* %148
%151 = add nuw nsw i64 %139, 2
%152 = icmp eq i64 %151, %43
br i1 %152, label %153, label %138
153: ; preds = %134, %138, %120, %22, %20, %37
%154 = phi i32 [ %38, %37 ], [ -1, %20 ], [ -1, %22 ], [ %38, %120 ], [ %38, %138 ], [ %38, %134 ]
%155 = add nsw i32 %2, -1
%156 = icmp sgt i32 %0, 0
%157 = add nsw i32 %0, -1
%158 = sext i32 %0 to i64
%159 = zext i32 %0 to i64
%160 = zext i32 %0 to i64
%161 = icmp slt i32 %2, 1
%162 = zext i32 %0 to i64
%163 = getelementptr i32, i32* %5, i64 %159
%164 = getelementptr [250 x i32], [250 x i32]* %1, i64 0, i64 %159
%165 = getelementptr i32, i32* %5, i64 %159
%166 = getelementptr [250 x i32], [250 x i32]* %1, i64 0, i64 %159
%167 = getelementptr i32, i32* %5, i64 %159
%168 = getelementptr [250 x i32], [250 x i32]* %1, i64 0, i64 %159
%169 = and i64 %159, 4294967288
%170 = add nsw i64 %169, -8
%171 = lshr exact i64 %170, 3
%172 = add nuw nsw i64 %171, 1
%173 = icmp ult i32 %0, 8
%174 = and i64 %159, 4294967288
%175 = and i64 %172, 1
%176 = icmp eq i64 %170, 0
%177 = and i64 %172, 4611686018427387902
%178 = icmp eq i64 %175, 0
%179 = icmp eq i64 %174, %159
%180 = and i64 %159, 1
%181 = icmp eq i64 %180, 0
%182 = sub nsw i64 0, %159
%183 = icmp ult i32 %0, 8
%184 = and i64 %159, 4294967288
%185 = and i64 %172, 1
%186 = icmp eq i64 %170, 0
%187 = and i64 %172, 4611686018427387902
%188 = icmp eq i64 %185, 0
%189 = icmp eq i64 %184, %159
%190 = and i64 %159, 1
%191 = icmp eq i64 %190, 0
%192 = sub nsw i64 0, %159
%193 = icmp ult i32 %0, 8
%194 = and i64 %159, 4294967288
%195 = and i64 %172, 1
%196 = icmp eq i64 %170, 0
%197 = and i64 %172, 4611686018427387902
%198 = icmp eq i64 %195, 0
%199 = icmp eq i64 %194, %159
%200 = and i64 %159, 1
%201 = icmp eq i64 %200, 0
%202 = sub nsw i64 0, %159
br label %203
203: ; preds = %153, %530
%204 = phi i32 [ %154, %153 ], [ %532, %530 ]
%205 = icmp eq i32 %204, %155
br i1 %205, label %206, label %326
206: ; preds = %203
br i1 %156, label %207, label %536
207: ; preds = %206, %207
%208 = phi i64 [ %212, %207 ], [ 0, %206 ]
%209 = getelementptr inbounds i32, i32* %5, i64 %208
%210 = load i32, i32* %209
%211 = icmp ne i32 %210, 0
%212 = add nuw nsw i64 %208, 1
%213 = icmp slt i64 %212, %158
%214 = and i1 %211, %213
br i1 %214, label %207, label %215
215: ; preds = %207
%216 = zext i1 %211 to i32
%217 = or i1 %211, %161
br i1 %217, label %534, label %218
218: ; preds = %215, %224
%219 = phi i32 [ %225, %224 ], [ %155, %215 ]
%220 = zext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %4, i64 %220
%222 = load i32, i32* %221
%223 = icmp eq i32 %222, 0
br i1 %223, label %224, label %227
224: ; preds = %218
%225 = add nsw i32 %219, -1
%226 = icmp sgt i32 %219, 0
br i1 %226, label %218, label %536
227: ; preds = %218
%228 = zext i32 %219 to i64
%229 = getelementptr inbounds i32, i32* %4, i64 %228
store i32 0, i32* %229
br i1 %156, label %230, label %530
230: ; preds = %227
br i1 %193, label %298, label %231
231: ; preds = %230
%232 = getelementptr [250 x i32], [250 x i32]* %1, i64 %228, i64 0
%233 = mul nuw nsw i64 %228, 250
%234 = getelementptr i32, i32* %164, i64 %233
%235 = icmp ugt i32* %234, %5
%236 = icmp ult i32* %232, %163
%237 = and i1 %235, %236
br i1 %237, label %298, label %238
238: ; preds = %231
br i1 %196, 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, %197
br i1 %277, label %278, label %239
278: ; preds = %239, %238
%279 = phi i64 [ 0, %238 ], [ %275, %239 ]
br i1 %198, 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 %199, label %530, label %298
298: ; preds = %231, %230, %297
%299 = phi i64 [ 0, %231 ], [ 0, %230 ], [ %194, %297 ]
%300 = xor i64 %299, -1
br i1 %201, 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, %202
br i1 %310, label %530, 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, %162
br i1 %325, label %530, label %311
326: ; preds = %203
%327 = add nsw i32 %204, 1
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %4, i64 %328
store i32 1, i32* %329
br i1 %156, label %330, label %429
330: ; preds = %326
br i1 %173, label %398, label %331
331: ; preds = %330
%332 = getelementptr [250 x i32], [250 x i32]* %1, i64 %328, i64 0
%333 = mul nsw i64 %328, 250
%334 = getelementptr i32, i32* %168, i64 %333
%335 = icmp ugt i32* %334, %5
%336 = icmp ult i32* %332, %167
%337 = and i1 %335, %336
br i1 %337, label %398, label %338
338: ; preds = %331
br i1 %176, label %378, label %339
339: ; preds = %338, %339
%340 = phi i64 [ %375, %339 ], [ 0, %338 ]
%341 = phi i64 [ %376, %339 ], [ 0, %338 ]
%342 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %340
%343 = bitcast i32* %342 to <4 x i32>*
%344 = load <4 x i32>, <4 x i32>* %343
%345 = getelementptr inbounds i32, i32* %342, i64 4
%346 = bitcast i32* %345 to <4 x i32>*
%347 = load <4 x i32>, <4 x i32>* %346
%348 = getelementptr inbounds i32, i32* %5, i64 %340
%349 = bitcast i32* %348 to <4 x i32>*
%350 = load <4 x i32>, <4 x i32>* %349
%351 = getelementptr inbounds i32, i32* %348, i64 4
%352 = bitcast i32* %351 to <4 x i32>*
%353 = load <4 x i32>, <4 x i32>* %352
%354 = add nsw <4 x i32> %350, %344
%355 = add nsw <4 x i32> %353, %347
%356 = bitcast i32* %348 to <4 x i32>*
store <4 x i32> %354, <4 x i32>* %356
%357 = bitcast i32* %351 to <4 x i32>*
store <4 x i32> %355, <4 x i32>* %357
%358 = or i64 %340, 8
%359 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %358
%360 = bitcast i32* %359 to <4 x i32>*
%361 = load <4 x i32>, <4 x i32>* %360
%362 = getelementptr inbounds i32, i32* %359, i64 4
%363 = bitcast i32* %362 to <4 x i32>*
%364 = load <4 x i32>, <4 x i32>* %363
%365 = getelementptr inbounds i32, i32* %5, i64 %358
%366 = bitcast i32* %365 to <4 x i32>*
%367 = load <4 x i32>, <4 x i32>* %366
%368 = getelementptr inbounds i32, i32* %365, i64 4
%369 = bitcast i32* %368 to <4 x i32>*
%370 = load <4 x i32>, <4 x i32>* %369
%371 = add nsw <4 x i32> %367, %361
%372 = add nsw <4 x i32> %370, %364
%373 = bitcast i32* %365 to <4 x i32>*
store <4 x i32> %371, <4 x i32>* %373
%374 = bitcast i32* %368 to <4 x i32>*
store <4 x i32> %372, <4 x i32>* %374
%375 = add nuw i64 %340, 16
%376 = add i64 %341, 2
%377 = icmp eq i64 %376, %177
br i1 %377, label %378, label %339
378: ; preds = %339, %338
%379 = phi i64 [ 0, %338 ], [ %375, %339 ]
br i1 %178, label %397, label %380
380: ; preds = %378
%381 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %379
%382 = bitcast i32* %381 to <4 x i32>*
%383 = load <4 x i32>, <4 x i32>* %382
%384 = getelementptr inbounds i32, i32* %381, i64 4
%385 = bitcast i32* %384 to <4 x i32>*
%386 = load <4 x i32>, <4 x i32>* %385
%387 = getelementptr inbounds i32, i32* %5, i64 %379
%388 = bitcast i32* %387 to <4 x i32>*
%389 = load <4 x i32>, <4 x i32>* %388
%390 = getelementptr inbounds i32, i32* %387, i64 4
%391 = bitcast i32* %390 to <4 x i32>*
%392 = load <4 x i32>, <4 x i32>* %391
%393 = add nsw <4 x i32> %389, %383
%394 = add nsw <4 x i32> %392, %386
%395 = bitcast i32* %387 to <4 x i32>*
store <4 x i32> %393, <4 x i32>* %395
%396 = bitcast i32* %390 to <4 x i32>*
store <4 x i32> %394, <4 x i32>* %396
br label %397
397: ; preds = %378, %380
br i1 %179, label %426, label %398
398: ; preds = %331, %330, %397
%399 = phi i64 [ 0, %331 ], [ 0, %330 ], [ %174, %397 ]
%400 = xor i64 %399, -1
br i1 %181, label %408, label %401
401: ; preds = %398
%402 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %399
%403 = load i32, i32* %402
%404 = getelementptr inbounds i32, i32* %5, i64 %399
%405 = load i32, i32* %404
%406 = add nsw i32 %405, %403
store i32 %406, i32* %404
%407 = or i64 %399, 1
br label %408
408: ; preds = %401, %398
%409 = phi i64 [ %399, %398 ], [ %407, %401 ]
%410 = icmp eq i64 %400, %182
br i1 %410, label %426, label %411
411: ; preds = %408, %411
%412 = phi i64 [ %424, %411 ], [ %409, %408 ]
%413 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %412
%414 = load i32, i32* %413
%415 = getelementptr inbounds i32, i32* %5, i64 %412
%416 = load i32, i32* %415
%417 = add nsw i32 %416, %414
store i32 %417, i32* %415
%418 = add nuw nsw i64 %412, 1
%419 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %418
%420 = load i32, i32* %419
%421 = getelementptr inbounds i32, i32* %5, i64 %418
%422 = load i32, i32* %421
%423 = add nsw i32 %422, %420
store i32 %423, i32* %421
%424 = add nuw nsw i64 %412, 2
%425 = icmp eq i64 %424, %159
br i1 %425, label %426, label %411
426: ; preds = %408, %411, %397
%427 = tail call i32 @var_check_1(i32* %3, i32* %5, i32 0, i32 %157)
%428 = icmp eq i32 %427, 0
br i1 %428, label %433, label %530
429: ; preds = %326
%430 = tail call i32 @var_check_1(i32* %3, i32* %5, i32 0, i32 %157)
%431 = icmp eq i32 %430, 0
br i1 %431, label %432, label %530
432: ; preds = %429
store i32 0, i32* %329
br label %530
433: ; preds = %426
store i32 0, i32* %329
br i1 %156, label %434, label %530
434: ; preds = %433
br i1 %183, label %502, label %435
435: ; preds = %434
%436 = getelementptr [250 x i32], [250 x i32]* %1, i64 %328, i64 0
%437 = mul nsw i64 %328, 250
%438 = getelementptr i32, i32* %166, i64 %437
%439 = icmp ugt i32* %438, %5
%440 = icmp ult i32* %436, %165
%441 = and i1 %439, %440
br i1 %441, label %502, label %442
442: ; preds = %435
br i1 %186, label %482, label %443
443: ; preds = %442, %443
%444 = phi i64 [ %479, %443 ], [ 0, %442 ]
%445 = phi i64 [ %480, %443 ], [ 0, %442 ]
%446 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %444
%447 = bitcast i32* %446 to <4 x i32>*
%448 = load <4 x i32>, <4 x i32>* %447
%449 = getelementptr inbounds i32, i32* %446, i64 4
%450 = bitcast i32* %449 to <4 x i32>*
%451 = load <4 x i32>, <4 x i32>* %450
%452 = getelementptr inbounds i32, i32* %5, i64 %444
%453 = bitcast i32* %452 to <4 x i32>*
%454 = load <4 x i32>, <4 x i32>* %453
%455 = getelementptr inbounds i32, i32* %452, i64 4
%456 = bitcast i32* %455 to <4 x i32>*
%457 = load <4 x i32>, <4 x i32>* %456
%458 = sub nsw <4 x i32> %454, %448
%459 = sub nsw <4 x i32> %457, %451
%460 = bitcast i32* %452 to <4 x i32>*
store <4 x i32> %458, <4 x i32>* %460
%461 = bitcast i32* %455 to <4 x i32>*
store <4 x i32> %459, <4 x i32>* %461
%462 = or i64 %444, 8
%463 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %462
%464 = bitcast i32* %463 to <4 x i32>*
%465 = load <4 x i32>, <4 x i32>* %464
%466 = getelementptr inbounds i32, i32* %463, i64 4
%467 = bitcast i32* %466 to <4 x i32>*
%468 = load <4 x i32>, <4 x i32>* %467
%469 = getelementptr inbounds i32, i32* %5, i64 %462
%470 = bitcast i32* %469 to <4 x i32>*
%471 = load <4 x i32>, <4 x i32>* %470
%472 = getelementptr inbounds i32, i32* %469, i64 4
%473 = bitcast i32* %472 to <4 x i32>*
%474 = load <4 x i32>, <4 x i32>* %473
%475 = sub nsw <4 x i32> %471, %465
%476 = sub nsw <4 x i32> %474, %468
%477 = bitcast i32* %469 to <4 x i32>*
store <4 x i32> %475, <4 x i32>* %477
%478 = bitcast i32* %472 to <4 x i32>*
store <4 x i32> %476, <4 x i32>* %478
%479 = add nuw i64 %444, 16
%480 = add i64 %445, 2
%481 = icmp eq i64 %480, %187
br i1 %481, label %482, label %443
482: ; preds = %443, %442
%483 = phi i64 [ 0, %442 ], [ %479, %443 ]
br i1 %188, label %501, label %484
484: ; preds = %482
%485 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %483
%486 = bitcast i32* %485 to <4 x i32>*
%487 = load <4 x i32>, <4 x i32>* %486
%488 = getelementptr inbounds i32, i32* %485, i64 4
%489 = bitcast i32* %488 to <4 x i32>*
%490 = load <4 x i32>, <4 x i32>* %489
%491 = getelementptr inbounds i32, i32* %5, i64 %483
%492 = bitcast i32* %491 to <4 x i32>*
%493 = load <4 x i32>, <4 x i32>* %492
%494 = getelementptr inbounds i32, i32* %491, i64 4
%495 = bitcast i32* %494 to <4 x i32>*
%496 = load <4 x i32>, <4 x i32>* %495
%497 = sub nsw <4 x i32> %493, %487
%498 = sub nsw <4 x i32> %496, %490
%499 = bitcast i32* %491 to <4 x i32>*
store <4 x i32> %497, <4 x i32>* %499
%500 = bitcast i32* %494 to <4 x i32>*
store <4 x i32> %498, <4 x i32>* %500
br label %501
501: ; preds = %482, %484
br i1 %189, label %530, label %502
502: ; preds = %435, %434, %501
%503 = phi i64 [ 0, %435 ], [ 0, %434 ], [ %184, %501 ]
%504 = xor i64 %503, -1
br i1 %191, label %512, label %505
505: ; preds = %502
%506 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %503
%507 = load i32, i32* %506
%508 = getelementptr inbounds i32, i32* %5, i64 %503
%509 = load i32, i32* %508
%510 = sub nsw i32 %509, %507
store i32 %510, i32* %508
%511 = or i64 %503, 1
br label %512
512: ; preds = %505, %502
%513 = phi i64 [ %503, %502 ], [ %511, %505 ]
%514 = icmp eq i64 %504, %192
br i1 %514, label %530, label %515
515: ; preds = %512, %515
%516 = phi i64 [ %528, %515 ], [ %513, %512 ]
%517 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %516
%518 = load i32, i32* %517
%519 = getelementptr inbounds i32, i32* %5, i64 %516
%520 = load i32, i32* %519
%521 = sub nsw i32 %520, %518
store i32 %521, i32* %519
%522 = add nuw nsw i64 %516, 1
%523 = getelementptr inbounds [250 x i32], [250 x i32]* %1, i64 %328, i64 %522
%524 = load i32, i32* %523
%525 = getelementptr inbounds i32, i32* %5, i64 %522
%526 = load i32, i32* %525
%527 = sub nsw i32 %526, %524
store i32 %527, i32* %525
%528 = add nuw nsw i64 %516, 2
%529 = icmp eq i64 %528, %160
br i1 %529, label %530, label %515
530: ; preds = %512, %515, %308, %311, %501, %297, %432, %429, %433, %227, %426
%531 = phi i32 [ 0, %426 ], [ %216, %227 ], [ 0, %433 ], [ 0, %429 ], [ 0, %432 ], [ %216, %297 ], [ 0, %501 ], [ %216, %311 ], [ %216, %308 ], [ 0, %515 ], [ 0, %512 ]
%532 = phi i32 [ %327, %426 ], [ %219, %227 ], [ %327, %433 ], [ %327, %429 ], [ %327, %432 ], [ %219, %297 ], [ %327, %501 ], [ %219, %311 ], [ %219, %308 ], [ %327, %515 ], [ %327, %512 ]
%533 = icmp eq i32 %531, 0
br i1 %533, label %203, label %536
534: ; preds = %215
%535 = zext i1 %211 to i32
br label %536
536: ; preds = %534, %530, %206, %224
%537 = phi i32 [ %216, %224 ], [ %535, %534 ], [ %531, %530 ], [ 1, %206 ]
ret i32 %537
}