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


x86 assembly (clang, -O0):
<next_combo_a>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%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     11a0 <next_combo_a+0x90>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    116b <next_combo_a+0x5b>
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    1142 <next_combo_a+0x32>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    119b <next_combo_a+0x8b>
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    1172 <next_combo_a+0x62>
jmp    11a0 <next_combo_a+0x90>
movl   $0x0,-0x40(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x34(%rbp)
mov    %al,-0x61(%rbp)
je     11da <next_combo_a+0xca>
cmpl   $0x0,-0x40(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    11ea <next_combo_a+0xda>
jmp    1388 <next_combo_a+0x278>
movl   $0x1,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    12f2 <next_combo_a+0x1e2>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movl   $0x0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1262 <next_combo_a+0x152>
mov    -0x50(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    122f <next_combo_a+0x11f>
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     12ed <next_combo_a+0x1dd>
movl   $0x1,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x4(%rbp),%ecx
mov    %al,-0x62(%rbp)
jge    12aa <next_combo_a+0x19a>
cmpl   $0x0,-0x40(%rbp)
setne  %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
test   $0x1,%al
jne    12ba <next_combo_a+0x1aa>
jmp    12e6 <next_combo_a+0x1d6>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    12d3 <next_combo_a+0x1c3>
movl   $0x0,-0x40(%rbp)
jmp    12d8 <next_combo_a+0x1c8>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    128f <next_combo_a+0x17f>
movl   $0x0,-0x44(%rbp)
jmp    12f2 <next_combo_a+0x1e2>
cmpl   $0x0,-0x44(%rbp)
je     137a <next_combo_a+0x26a>
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    135d <next_combo_a+0x24d>
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    1328 <next_combo_a+0x218>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x34(%rbp)
jmp    1383 <next_combo_a+0x273>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11bf <next_combo_a+0xaf>
mov    -0x40(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<next_combo_a>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%rbx
mov    %r8,%r14
mov    %rcx,0x68(%rsp)
mov    %edx,%ebp
mov    %rsi,0x8(%rsp)
cmpl   $0x0,0xb0(%rsp)
mov    %edi,%r15d
mov    %rdi,0x18(%rsp)
je     1187 <next_combo_a+0x67>
test   %edi,%edi
jle    1168 <next_combo_a+0x48>
lea    0x0(,%r15,4),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
test   %ebp,%ebp
jle    15aa <next_combo_a+0x48a>
mov    %ebp,%edx
shl    $0x2,%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x18(%rsp),%rdi
jmp    118f <next_combo_a+0x6f>
test   %ebp,%ebp
jle    15aa <next_combo_a+0x48a>
add    $0xffffffff,%ebp
lea    -0x1(%rdi),%eax
mov    %eax,0x14(%rsp)
movslq %edi,%r12
lea    (%rbx,%r15,4),%rax
mov    %rax,0x50(%rsp)
mov    0x8(%rsp),%rax
lea    (%rax,%r15,4),%rcx
mov    %rcx,0x60(%rsp)
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x48(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x40(%rsp)
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x38(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x30(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x70(%rsp)
lea    0x30(%rax),%rcx
mov    %rcx,0x28(%rsp)
add    $0x4,%rax
mov    %rax,0x58(%rsp)
mov    %ebp,0x24(%rsp)
mov    %ebp,%r13d
nopw   0x0(%rax,%rax,1)
movslq %r13d,%rbp
cmpl   $0x0,(%r14,%rbp,4)
je     12c0 <next_combo_a+0x1a0>
movl   $0x0,(%r14,%rbp,4)
test   %edi,%edi
jle    1450 <next_combo_a+0x330>
cmp    $0x8,%edi
jb     125e <next_combo_a+0x13e>
imul   $0x3e8,%rbp,%rdx
mov    0x8(%rsp),%rax
add    %rdx,%rax
mov    0x60(%rsp),%rcx
add    %rdx,%rcx
cmp    %rbx,%rcx
jbe    138a <next_combo_a+0x26a>
cmp    0x50(%rsp),%rax
jae    138a <next_combo_a+0x26a>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r15b
je     1282 <next_combo_a+0x162>
imul   $0x3e8,%rbp,%rax
add    0x8(%rsp),%rax
mov    (%rax,%rcx,4),%eax
sub    %eax,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x70(%rsp),%rcx
je     1450 <next_combo_a+0x330>
imul   $0x3e8,%rbp,%rcx
add    0x58(%rsp),%rcx
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,%r15
jne    12a0 <next_combo_a+0x180>
jmp    1450 <next_combo_a+0x330>
nopl   0x0(%rax)
movl   $0x1,(%r14,%rbp,4)
test   %edi,%edi
jle    135c <next_combo_a+0x23c>
cmp    $0x8,%edi
jb     1300 <next_combo_a+0x1e0>
imul   $0x3e8,%rbp,%rdx
mov    0x8(%rsp),%rax
add    %rdx,%rax
mov    0x60(%rsp),%rcx
add    %rdx,%rcx
cmp    %rbx,%rcx
jbe    1476 <next_combo_a+0x356>
cmp    0x50(%rsp),%rax
jae    1476 <next_combo_a+0x356>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r15b
je     1324 <next_combo_a+0x204>
imul   $0x3e8,%rbp,%rax
add    0x8(%rsp),%rax
mov    (%rax,%rcx,4),%eax
add    %eax,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x70(%rsp),%rcx
je     1530 <next_combo_a+0x410>
imul   $0x3e8,%rbp,%rcx
add    0x58(%rsp),%rcx
xchg   %ax,%ax
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,%r15
jne    1340 <next_combo_a+0x220>
jmp    1530 <next_combo_a+0x410>
mov    0x68(%rsp),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
mov    0x14(%rsp),%ecx
call   1040 <var_check_1@plt>
test   %rax,%rax
jne    15ae <next_combo_a+0x48e>
movl   $0x0,(%r14,%rbp,4)
mov    0x18(%rsp),%rdi
jmp    1450 <next_combo_a+0x330>
cmpq   $0x0,0x40(%rsp)
je     1586 <next_combo_a+0x466>
add    0x28(%rsp),%rdx
mov    0x30(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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    13b0 <next_combo_a+0x290>
testb  $0x1,0x38(%rsp)
je     143f <next_combo_a+0x31f>
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    %r15,%rax
jne    1260 <next_combo_a+0x140>
xor    %ecx,%ecx
test   %r13d,%r13d
lea    -0x1(%r13),%edx
setg   %cl
xor    %eax,%eax
mov    %edx,%r13d
test   %ecx,%ecx
je     15b3 <next_combo_a+0x493>
test   %eax,%eax
je     1210 <next_combo_a+0xf0>
jmp    15b3 <next_combo_a+0x493>
cmpq   $0x0,0x40(%rsp)
je     1598 <next_combo_a+0x478>
add    0x28(%rsp),%rdx
mov    0x30(%rsp),%rsi
xor    %ecx,%ecx
xchg   %ax,%ax
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    1490 <next_combo_a+0x370>
testb  $0x1,0x38(%rsp)
je     151f <next_combo_a+0x3ff>
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    %r15,%rax
jne    1302 <next_combo_a+0x1e2>
mov    0x68(%rsp),%rdi
mov    %rbx,%rsi
xor    %edx,%edx
mov    0x14(%rsp),%ecx
call   1040 <var_check_1@plt>
test   %rax,%rax
mov    0x18(%rsp),%rdi
je     121e <next_combo_a+0xfe>
test   %edi,%edi
jle    15ae <next_combo_a+0x48e>
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
mov    -0x4(%rbx,%rax,4),%ecx
cmp    %r12,%rax
jge    1571 <next_combo_a+0x451>
add    $0x1,%rax
test   %ecx,%ecx
jne    1560 <next_combo_a+0x440>
xor    %eax,%eax
test   %ecx,%ecx
setne  %al
mov    $0x1,%ecx
mov    0x24(%rsp),%edx
jmp    145e <next_combo_a+0x33e>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    1416 <next_combo_a+0x2f6>
jmp    143f <next_combo_a+0x31f>
xor    %ecx,%ecx
testb  $0x1,0x38(%rsp)
jne    14f6 <next_combo_a+0x3d6>
jmp    151f <next_combo_a+0x3ff>
xor    %eax,%eax
jmp    15b3 <next_combo_a+0x493>
mov    $0x1,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @next_combo_a(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*
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
%24 = load i32, i32* %14
%25 = icmp ne i32 %24, 0
br i1 %25, label %26, label %53
26: ; preds = %7
store i32 0, i32* %17
br label %27
27: ; preds = %36, %26
%28 = load i32, i32* %17
%29 = load i32, i32* %8
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %39
31: ; preds = %27
%32 = load i32*, i32** %13
%33 = load i32, i32* %17
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
store i32 0, i32* %35
br label %36
36: ; preds = %31
%37 = load i32, i32* %17
%38 = add nsw i32 %37, 1
store i32 %38, i32* %17
br label %27
39: ; preds = %27
store i32 0, i32* %17
br label %40
40: ; preds = %49, %39
%41 = load i32, i32* %17
%42 = load i32, i32* %10
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %52
44: ; preds = %40
%45 = load i32*, i32** %12
%46 = load i32, i32* %17
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
store i32 0, i32* %48
br label %49
49: ; preds = %44
%50 = load i32, i32* %17
%51 = add nsw i32 %50, 1
store i32 %51, i32* %17
br label %40
52: ; preds = %40
br label %53
53: ; preds = %52, %7
store i32 0, i32* %18
%54 = load i32, i32* %10
%55 = sub nsw i32 %54, 1
store i32 %55, i32* %16
%56 = load i32, i32* %16
%57 = icmp sge i32 %56, 0
%58 = zext i1 %57 to i32
store i32 %58, i32* %15
br label %59
59: ; preds = %176, %53
%60 = load i32, i32* %15
%61 = icmp ne i32 %60, 0
br i1 %61, label %62, label %66
62: ; preds = %59
%63 = load i32, i32* %18
%64 = icmp ne i32 %63, 0
%65 = xor i1 %64, true
br label %66
66: ; preds = %62, %59
%67 = phi i1 [ false, %59 ], [ %65, %62 ]
br i1 %67, label %68, label %177
68: ; preds = %66
store i32 1, i32* %19
%69 = load i32*, i32** %12
%70 = load i32, i32* %16
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %69, i64 %71
%73 = load i32, i32* %72
%74 = icmp ne i32 %73, 0
br i1 %74, label %135, label %75
75: ; preds = %68
%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 1, i32* %79
store i32 0, i32* %20
%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** %21
br label %85
85: ; preds = %101, %75
%86 = load i32, i32* %20
%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** %21
%91 = load i32, i32* %20
%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* %20
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %95, i64 %97
%99 = load i32, i32* %98
%100 = add nsw i32 %99, %94
store i32 %100, i32* %98
br label %101
101: ; preds = %89
%102 = load i32, i32* %20
%103 = add nsw i32 %102, 1
store i32 %103, i32* %20
br label %85
104: ; preds = %85
%105 = load i32*, i32** %11
%106 = load i32*, i32** %13
%107 = load i32, i32* %8
%108 = sub nsw i32 %107, 1
%109 = call i64 @var_check_1(i32* %105, i32* %106, i32 0, i32 %108)
%110 = icmp ne i64 %109, 0
br i1 %110, label %111, label %134
111: ; preds = %104
store i32 1, i32* %18
store i32 0, i32* %17
br label %112
112: ; preds = %130, %111
%113 = load i32, i32* %17
%114 = load i32, i32* %8
%115 = icmp slt i32 %113, %114
br i1 %115, label %116, label %119
116: ; preds = %112
%117 = load i32, i32* %18
%118 = icmp ne i32 %117, 0
br label %119
119: ; preds = %116, %112
%120 = phi i1 [ false, %112 ], [ %118, %116 ]
br i1 %120, label %121, label %133
121: ; preds = %119
%122 = load i32*, i32** %13
%123 = load i32, i32* %17
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %122, i64 %124
%126 = load i32, i32* %125
%127 = icmp eq i32 %126, 0
br i1 %127, label %128, label %129
128: ; preds = %121
store i32 0, i32* %18
br label %129
129: ; preds = %128, %121
br label %130
130: ; preds = %129
%131 = load i32, i32* %17
%132 = add nsw i32 %131, 1
store i32 %132, i32* %17
br label %112
133: ; preds = %119
store i32 0, i32* %19
br label %134
134: ; preds = %133, %104
br label %135
135: ; preds = %134, %68
%136 = load i32, i32* %19
%137 = icmp ne i32 %136, 0
br i1 %137, label %138, label %173
138: ; preds = %135
%139 = load i32*, i32** %12
%140 = load i32, i32* %16
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
store i32 0, i32* %142
store i32 0, i32* %22
%143 = load [250 x i32]*, [250 x i32]** %9
%144 = load i32, i32* %16
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [250 x i32], [250 x i32]* %143, i64 %145
%147 = getelementptr inbounds [250 x i32], [250 x i32]* %146, i64 0, i64 0
store i32* %147, i32** %23
br label %148
148: ; preds = %164, %138
%149 = load i32, i32* %22
%150 = load i32, i32* %8
%151 = icmp slt i32 %149, %150
br i1 %151, label %152, label %167
152: ; preds = %148
%153 = load i32*, i32** %23
%154 = load i32, i32* %22
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
%157 = load i32, i32* %156
%158 = load i32*, i32** %13
%159 = load i32, i32* %22
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %158, i64 %160
%162 = load i32, i32* %161
%163 = sub nsw i32 %162, %157
store i32 %163, i32* %161
br label %164
164: ; preds = %152
%165 = load i32, i32* %22
%166 = add nsw i32 %165, 1
store i32 %166, i32* %22
br label %148
167: ; preds = %148
%168 = load i32, i32* %16
%169 = add nsw i32 %168, -1
store i32 %169, i32* %16
%170 = load i32, i32* %16
%171 = icmp sge i32 %170, 0
%172 = zext i1 %171 to i32
store i32 %172, i32* %15
br label %176
173: ; preds = %135
%174 = load i32, i32* %10
%175 = sub nsw i32 %174, 1
store i32 %175, i32* %16
br label %176
176: ; preds = %173, %167
br label %59
177: ; preds = %66
%178 = load i32, i32* %18
ret i32 %178
}

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