int prove(char **lhs, int llen, char **rhs, int rlen) {
  int i;
  char **formula, op, *old, **nlhs, **nrhs;
  while (hasSolven(lhs, llen, rhs, rlen) == -1) {
    for (i = 0; i < llen; i++) {
      formula = parseFormula(lhs[i], &op);
      if (op == '-')
        move(i, &lhs, &llen, &rhs, &rlen), i--;
      else if (op == '&') {
        free(lhs[i]);
        lhs[i] = formula[0];
        lhs = (char **)realloc(lhs, sizeof(char *) * (llen + 1));
        lhs[llen++] = formula[1];
        i--;
      } else if (op == '>') {
        old = lhs[i];
        lhs[i] = (char *)malloc(sizeof(char) * (strlen(lhs[i]) + 3));
        free(old);
        strcpy(lhs[i], "-");
        strcat(lhs[i], formula[0]);
        strcat(lhs[i], "|");
        strcat(lhs[i], formula[1]);
        free(formula[0]);
        free(formula[1]);
        i--;
      }
      free(formula);
    }
    for (i = 0; i < rlen; i++) {
      formula = parseFormula(rhs[i], &op);
      if (op == '-')
        move(i, &rhs, &rlen, &lhs, &llen), i--;
      else if (op == '|') {
        free(rhs[i]);
        rhs[i] = formula[0];
        rhs = (char **)realloc(rhs, sizeof(char *) * (rlen + 1));
        rhs[rlen++] = formula[1];
        i--;
      } else if (op == '>') {
        old = rhs[i];
        rhs[i] = (char *)malloc(sizeof(char) * (strlen(rhs[i]) + 3));
        free(old);
        strcpy(rhs[i], "-");
        strcat(rhs[i], formula[0]);
        strcat(rhs[i], "|");
        strcat(rhs[i], formula[1]);
        free(formula[0]);
        free(formula[1]);
        i--;
      }
      free(formula);
    }
    for (i = 0; i < llen; i++) {
      formula = parseFormula(lhs[i], &op);
      if (op == '|') {
        nlhs = copy(lhs, llen);
        free(nlhs[i]);
        nlhs[i] = formula[0];
        nrhs = copy(rhs, rlen);
        op = prove(nlhs, llen, nrhs, rlen);
        if (op == 1) {
          nlhs = copy(lhs, llen);
          free(nlhs[i]);
          nlhs[i] = formula[1];
          nrhs = copy(rhs, rlen);
          op = prove(nlhs, llen, nrhs, rlen);
        }
        freeF(lhs, llen);
        freeF(rhs, rlen);
        return op;
      }
    }
    for (i = 0; i < rlen; i++) {
      formula = parseFormula(rhs[i], &op);
      if (op == '&') {
        nlhs = copy(lhs, llen);
        nrhs = copy(rhs, rlen);
        free(nrhs[i]);
        nrhs[i] = formula[0];
        op = prove(nlhs, llen, nrhs, rlen);
        if (op == 1) {
          nlhs = copy(lhs, llen);
          nrhs = copy(rhs, rlen);
          free(nrhs[i]);
          nrhs[i] = formula[1];
          op = prove(nlhs, llen, nrhs, rlen);
        }
        freeF(lhs, llen);
        freeF(rhs, rlen);
        return op;
      }
    }
  }
  i = hasSolven(lhs, llen, rhs, rlen);
  freeF(lhs, llen);
  freeF(rhs, rlen);
  return i;
}


x86 assembly (clang, -O0):
<prove>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    $0x0,%al
call   10a0 <hasSolven@plt>
cmp    $0xffffffff,%eax
jne    1839 <prove+0x679>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13ca <prove+0x20a>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x31(%rbp),%rsi
mov    $0x0,%al
call   1080 <parseFormula@plt>
cltq
mov    %rax,-0x30(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x2d,%eax
jne    1259 <prove+0x99>
mov    -0x28(%rbp),%edi
lea    -0x10(%rbp),%rsi
lea    -0x14(%rbp),%rdx
lea    -0x20(%rbp),%rcx
lea    -0x24(%rbp),%r8
mov    $0x0,%al
call   10e0 <move@plt>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    13b3 <prove+0x1f3>
movsbl -0x31(%rbp),%eax
cmp    $0x26,%eax
jne    12d0 <prove+0x110>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rsi
shl    $0x3,%rsi
call   10b0 <realloc@plt>
mov    %rax,-0x10(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    13ae <prove+0x1ee>
movsbl -0x31(%rbp),%eax
cmp    $0x3e,%eax
jne    13a9 <prove+0x1e9>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <strlen@plt>
mov    %rax,%rdi
add    $0x3,%rdi
shl    $0x0,%rdi
call   1090 <malloc@plt>
mov    %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xcc7(%rip),%rsi
call   1040 <strcpy@plt>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x30(%rbp),%rax
mov    (%rax),%rsi
call   10c0 <strcat@plt>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc99(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rsi
call   10c0 <strcat@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    13ae <prove+0x1ee>
jmp    13b3 <prove+0x1f3>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11fb <prove+0x3b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15a0 <prove+0x3e0>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x31(%rbp),%rsi
mov    $0x0,%al
call   1080 <parseFormula@plt>
cltq
mov    %rax,-0x30(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x2d,%eax
jne    142f <prove+0x26f>
mov    -0x28(%rbp),%edi
lea    -0x20(%rbp),%rsi
lea    -0x24(%rbp),%rdx
lea    -0x10(%rbp),%rcx
lea    -0x14(%rbp),%r8
mov    $0x0,%al
call   10e0 <move@plt>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1589 <prove+0x3c9>
movsbl -0x31(%rbp),%eax
cmp    $0x7c,%eax
jne    14a6 <prove+0x2e6>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rsi
shl    $0x3,%rsi
call   10b0 <realloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1584 <prove+0x3c4>
movsbl -0x31(%rbp),%eax
cmp    $0x3e,%eax
jne    157f <prove+0x3bf>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <strlen@plt>
mov    %rax,%rdi
add    $0x3,%rdi
shl    $0x0,%rdi
call   1090 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xaf1(%rip),%rsi
call   1040 <strcpy@plt>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x30(%rbp),%rax
mov    (%rax),%rsi
call   10c0 <strcat@plt>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xac3(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rsi
call   10c0 <strcat@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1584 <prove+0x3c4>
jmp    1589 <prove+0x3c9>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13d1 <prove+0x211>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16ea <prove+0x52a>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x31(%rbp),%rsi
mov    $0x0,%al
call   1080 <parseFormula@plt>
cltq
mov    %rax,-0x30(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x7c,%eax
jne    16d7 <prove+0x517>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdx
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   10d0 <prove@plt>
mov    %al,-0x31(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x1,%eax
jne    16af <prove+0x4ef>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdx
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   10d0 <prove@plt>
mov    %al,-0x31(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1070 <freeF@plt>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1070 <freeF@plt>
movsbl -0x31(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1873 <prove+0x6b3>
jmp    16dc <prove+0x51c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15a7 <prove+0x3e7>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1834 <prove+0x674>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x31(%rbp),%rsi
mov    $0x0,%al
call   1080 <parseFormula@plt>
cltq
mov    %rax,-0x30(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x26,%eax
jne    1821 <prove+0x661>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdx
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   10d0 <prove@plt>
mov    %al,-0x31(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x1,%eax
jne    17f9 <prove+0x639>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1060 <copy@plt>
cltq
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdx
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   10d0 <prove@plt>
mov    %al,-0x31(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1070 <freeF@plt>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1070 <freeF@plt>
movsbl -0x31(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1873 <prove+0x6b3>
jmp    1826 <prove+0x666>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16f1 <prove+0x531>
jmp    11d6 <prove+0x16>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    $0x0,%al
call   10a0 <hasSolven@plt>
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1070 <freeF@plt>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1070 <freeF@plt>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prove>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,0x20(%rsp)
mov    %esi,0x10(%rsp)
mov    %rdx,0x18(%rsp)
mov    %ecx,0x14(%rsp)
xor    %eax,%eax
call   1090 <hasSolven@plt>
cmp    $0xffffffff,%eax
je     121c <prove+0x6c>
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%esi
mov    0x18(%rsp),%rdx
mov    0x14(%rsp),%ecx
xor    %eax,%eax
call   1090 <hasSolven@plt>
mov    %eax,%ebx
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1060 <freeF@plt>
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%esi
xor    %eax,%eax
call   1060 <freeF@plt>
jmp    16f6 <prove+0x546>
lea    0xf(%rsp),%r15
lea    0x14(%rsp),%r13
mov    0x10(%rsp),%esi
test   %esi,%esi
jle    1390 <prove+0x1e0>
xor    %r14d,%r14d
jmp    12e1 <prove+0x131>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rbx
mov    (%rbx,%r12,8),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
lea    0x3(%rax),%rdi
call   1080 <malloc@plt>
mov    %rax,(%rbx,%r12,8)
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%rax
movw   $0x2d,(%rax)
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%rdi
mov    0x0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0x7c,(%rbx,%rax,1)
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%rdi
mov    0x8(%rbp),%rsi
call   10b0 <strcat@plt>
mov    0x0(%rbp),%rdi
call   1030 <free@plt>
mov    0x8(%rbp),%rdi
call   1030 <free@plt>
add    $0xffffffff,%r12d
mov    %r12d,%r14d
mov    %rbp,%rdi
call   1030 <free@plt>
add    $0x1,%r14d
mov    0x10(%rsp),%esi
cmp    %esi,%r14d
jge    1390 <prove+0x1e0>
mov    0x20(%rsp),%rax
movslq %r14d,%r12
mov    (%rax,%r12,8),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <parseFormula@plt>
movslq %eax,%rbp
movzbl 0xf(%rsp),%eax
cmp    $0x26,%al
je     1340 <prove+0x190>
cmp    $0x3e,%al
je     1240 <prove+0x90>
cmp    $0x2d,%al
jne    12c8 <prove+0x118>
mov    %r14d,%edi
lea    0x20(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x18(%rsp),%rcx
mov    %r13,%r8
xor    %eax,%eax
call   10d0 <move@plt>
add    $0xffffffff,%r14d
jmp    12c8 <prove+0x118>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%rdi
call   1030 <free@plt>
mov    0x0(%rbp),%rax
mov    0x20(%rsp),%rcx
mov    %rax,(%rcx,%r12,8)
mov    0x20(%rsp),%rdi
movslq 0x10(%rsp),%rax
lea    0x8(,%rax,8),%rsi
call   10a0 <realloc@plt>
mov    %rax,0x20(%rsp)
mov    0x8(%rbp),%rcx
movslq 0x10(%rsp),%rdx
lea    0x1(%rdx),%esi
mov    %esi,0x10(%rsp)
mov    %rcx,(%rax,%rdx,8)
jmp    12c1 <prove+0x111>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
jle    14f4 <prove+0x344>
xor    %ebx,%ebx
jmp    144b <prove+0x29b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x18(%rsp),%rbx
mov    (%rbx,%rbp,8),%r12
mov    %r12,%rdi
call   1040 <strlen@plt>
lea    0x3(%rax),%rdi
call   1080 <malloc@plt>
mov    %rax,(%rbx,%rbp,8)
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rax
movw   $0x2d,(%rax)
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
mov    (%r14),%rsi
call   10b0 <strcat@plt>
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0x7c,(%rbx,%rax,1)
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
mov    0x8(%r14),%rsi
call   10b0 <strcat@plt>
mov    (%r14),%rdi
call   1030 <free@plt>
mov    0x8(%r14),%rdi
call   1030 <free@plt>
add    $0xffffffff,%ebp
mov    %ebp,%ebx
mov    %r14,%rdi
call   1030 <free@plt>
add    $0x1,%ebx
mov    0x14(%rsp),%ecx
cmp    %ecx,%ebx
jge    14f0 <prove+0x340>
mov    0x18(%rsp),%rax
movslq %ebx,%rbp
mov    (%rax,%rbp,8),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <parseFormula@plt>
movslq %eax,%r14
movzbl 0xf(%rsp),%eax
cmp    $0x7c,%al
je     14a0 <prove+0x2f0>
cmp    $0x3e,%al
je     13b0 <prove+0x200>
cmp    $0x2d,%al
jne    1434 <prove+0x284>
mov    %ebx,%edi
lea    0x18(%rsp),%rsi
mov    %r13,%rdx
lea    0x20(%rsp),%rcx
lea    0x10(%rsp),%r8
xor    %eax,%eax
call   10d0 <move@plt>
add    $0xffffffff,%ebx
jmp    1434 <prove+0x284>
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
call   1030 <free@plt>
mov    (%r14),%rax
mov    0x18(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
mov    0x18(%rsp),%rdi
movslq 0x14(%rsp),%rax
lea    0x8(,%rax,8),%rsi
call   10a0 <realloc@plt>
mov    %rax,0x18(%rsp)
mov    0x8(%r14),%rcx
movslq 0x14(%rsp),%rdx
lea    0x1(%rdx),%esi
mov    %esi,0x14(%rsp)
mov    %rcx,(%rax,%rdx,8)
jmp    142f <prove+0x27f>
nop
mov    0x10(%rsp),%esi
test   %esi,%esi
jle    152c <prove+0x37c>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <parseFormula@plt>
cmpb   $0x7c,0xf(%rsp)
je     158f <prove+0x3df>
add    $0x1,%rbp
movslq 0x10(%rsp),%rsi
cmp    %rsi,%rbp
jl     1500 <prove+0x350>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
jle    1570 <prove+0x3c0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,8),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <parseFormula@plt>
cmpb   $0x26,0xf(%rsp)
je     162b <prove+0x47b>
add    $0x1,%rbx
movslq 0x14(%rsp),%rcx
cmp    %rcx,%rbx
jl     1540 <prove+0x390>
mov    0x10(%rsp),%esi
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rdx
xor    %eax,%eax
call   1090 <hasSolven@plt>
cmp    $0xffffffff,%eax
je     1226 <prove+0x76>
jmp    11dc <prove+0x2c>
movslq %eax,%r14
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%rbx
mov    (%rbx,%rbp,8),%rdi
call   1030 <free@plt>
mov    (%r14),%rax
mov    %rax,(%rbx,%rbp,8)
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%rdx
mov    0x10(%rsp),%esi
mov    0x14(%rsp),%ecx
mov    %rbx,%rdi
call   10c0 <prove@plt>
mov    %al,0xf(%rsp)
cmp    $0x1,%al
jne    16d1 <prove+0x521>
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%rbx
mov    (%rbx,%rbp,8),%rdi
call   1030 <free@plt>
mov    0x8(%r14),%rax
mov    %rax,(%rbx,%rbp,8)
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%rdx
mov    0x10(%rsp),%esi
mov    0x14(%rsp),%ecx
mov    %rbx,%rdi
jmp    16c8 <prove+0x518>
movslq %eax,%r15
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%r14
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%rbp
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r15),%rax
mov    %rax,0x0(%rbp,%rbx,8)
mov    0x10(%rsp),%esi
mov    0x14(%rsp),%ecx
mov    %r14,%rdi
mov    %rbp,%rdx
call   10c0 <prove@plt>
mov    %al,0xf(%rsp)
cmp    $0x1,%al
jne    16d1 <prove+0x521>
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%r14
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%esi
xor    %eax,%eax
call   1050 <copy@plt>
movslq %eax,%rbp
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
mov    0x8(%r15),%rax
mov    %rax,0x0(%rbp,%rbx,8)
mov    0x10(%rsp),%esi
mov    0x14(%rsp),%ecx
mov    %r14,%rdi
mov    %rbp,%rdx
call   10c0 <prove@plt>
mov    %al,0xf(%rsp)
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1060 <freeF@plt>
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%esi
xor    %eax,%eax
call   1060 <freeF@plt>
movsbl 0xf(%rsp),%ebx
mov    %ebx,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [2 x i8] c"-\00"
@.str.1 = [2 x i8] c"|\00"
define i32 @prove(i8** %0, i32 %1, i8** %2, i32 %3) {
%5 = alloca i32
%6 = alloca i8**
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8**
%12 = alloca i8
%13 = alloca i8*
%14 = alloca i8**
%15 = alloca i8**
store i8** %0, i8*** %6
store i32 %1, i32* %7
store i8** %2, i8*** %8
store i32 %3, i32* %9
br label %16
16: ; preds = %459, %4
%17 = load i8**, i8*** %6
%18 = load i32, i32* %7
%19 = load i8**, i8*** %8
%20 = load i32, i32* %9
%21 = call i32 (i8**, i32, i8**, i32, ...) bitcast (i32 (...)* @hasSolven to i32 (i8**, i32, i8**, i32, ...)*)(i8** %17, i32 %18, i8** %19, i32 %20)
%22 = icmp eq i32 %21, -1
br i1 %22, label %23, label %460
23: ; preds = %16
store i32 0, i32* %10
br label %24
24: ; preds = %147, %23
%25 = load i32, i32* %10
%26 = load i32, i32* %7
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %150
28: ; preds = %24
%29 = load i8**, i8*** %6
%30 = load i32, i32* %10
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8*, i8** %29, i64 %31
%33 = load i8*, i8** %32
%34 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @parseFormula to i32 (i8*, i8*, ...)*)(i8* %33, i8* %12)
%35 = sext i32 %34 to i64
%36 = inttoptr i64 %35 to i8**
store i8** %36, i8*** %11
%37 = load i8, i8* %12
%38 = sext i8 %37 to i32
%39 = icmp eq i32 %38, 45
br i1 %39, label %40, label %45
40: ; preds = %28
%41 = load i32, i32* %10
%42 = call i32 (i32, i8***, i32*, i8***, i32*, ...) bitcast (i32 (...)* @move to i32 (i32, i8***, i32*, i8***, i32*, ...)*)(i32 %41, i8*** %6, i32* %7, i8*** %8, i32* %9)
%43 = load i32, i32* %10
%44 = add nsw i32 %43, -1
store i32 %44, i32* %10
br label %144
45: ; preds = %28
%46 = load i8, i8* %12
%47 = sext i8 %46 to i32
%48 = icmp eq i32 %47, 38
br i1 %48, label %49, label %80
49: ; preds = %45
%50 = load i8**, i8*** %6
%51 = load i32, i32* %10
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8*, i8** %50, i64 %52
%54 = load i8*, i8** %53
%55 = load i8**, i8*** %11
%56 = getelementptr inbounds i8*, i8** %55, i64 0
%57 = load i8*, i8** %56
%58 = load i8**, i8*** %6
%59 = load i32, i32* %10
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8*, i8** %58, i64 %60
store i8* %57, i8** %61
%62 = load i8**, i8*** %6
%63 = bitcast i8** %62 to i8*
%64 = load i32, i32* %7
%65 = add nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = mul i64 8, %66
%68 = call i8* @realloc(i8* %63, i64 %67)
%69 = bitcast i8* %68 to i8**
store i8** %69, i8*** %6
%70 = load i8**, i8*** %11
%71 = getelementptr inbounds i8*, i8** %70, i64 1
%72 = load i8*, i8** %71
%73 = load i8**, i8*** %6
%74 = load i32, i32* %7
%75 = add nsw i32 %74, 1
store i32 %75, i32* %7
%76 = sext i32 %74 to i64
%77 = getelementptr inbounds i8*, i8** %73, i64 %76
store i8* %72, i8** %77
%78 = load i32, i32* %10
%79 = add nsw i32 %78, -1
store i32 %79, i32* %10
br label %143
80: ; preds = %45
%81 = load i8, i8* %12
%82 = sext i8 %81 to i32
%83 = icmp eq i32 %82, 62
br i1 %83, label %84, label %142
84: ; preds = %80
%85 = load i8**, i8*** %6
%86 = load i32, i32* %10
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8*, i8** %85, i64 %87
%89 = load i8*, i8** %88
store i8* %89, i8** %13
%90 = load i8**, i8*** %6
%91 = load i32, i32* %10
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8*, i8** %90, i64 %92
%94 = load i8*, i8** %93
%95 = call i64 @strlen(i8* %94)
%96 = add i64 %95, 3
%97 = mul i64 1, %96
%98 = call i8* @malloc(i64 %97)
%99 = load i8**, i8*** %6
%100 = load i32, i32* %10
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8*, i8** %99, i64 %101
store i8* %98, i8** %102
%103 = load i8*, i8** %13
%104 = load i8**, i8*** %6
%105 = load i32, i32* %10
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8*, i8** %104, i64 %106
%108 = load i8*, i8** %107
%109 = call i8* @strcpy(i8* %108, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%110 = load i8**, i8*** %6
%111 = load i32, i32* %10
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8*, i8** %110, i64 %112
%114 = load i8*, i8** %113
%115 = load i8**, i8*** %11
%116 = getelementptr inbounds i8*, i8** %115, i64 0
%117 = load i8*, i8** %116
%118 = call i8* @strcat(i8* %114, i8* %117)
%119 = load i8**, i8*** %6
%120 = load i32, i32* %10
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8*, i8** %119, i64 %121
%123 = load i8*, i8** %122
%124 = call i8* @strcat(i8* %123, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%125 = load i8**, i8*** %6
%126 = load i32, i32* %10
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8*, i8** %125, i64 %127
%129 = load i8*, i8** %128
%130 = load i8**, i8*** %11
%131 = getelementptr inbounds i8*, i8** %130, i64 1
%132 = load i8*, i8** %131
%133 = call i8* @strcat(i8* %129, i8* %132)
%134 = load i8**, i8*** %11
%135 = getelementptr inbounds i8*, i8** %134, i64 0
%136 = load i8*, i8** %135
%137 = load i8**, i8*** %11
%138 = getelementptr inbounds i8*, i8** %137, i64 1
%139 = load i8*, i8** %138
%140 = load i32, i32* %10
%141 = add nsw i32 %140, -1
store i32 %141, i32* %10
br label %142
142: ; preds = %84, %80
br label %143
143: ; preds = %142, %49
br label %144
144: ; preds = %143, %40
%145 = load i8**, i8*** %11
%146 = bitcast i8** %145 to i8*
br label %147
147: ; preds = %144
%148 = load i32, i32* %10
%149 = add nsw i32 %148, 1
store i32 %149, i32* %10
br label %24
150: ; preds = %24
store i32 0, i32* %10
br label %151
151: ; preds = %274, %150
%152 = load i32, i32* %10
%153 = load i32, i32* %9
%154 = icmp slt i32 %152, %153
br i1 %154, label %155, label %277
155: ; preds = %151
%156 = load i8**, i8*** %8
%157 = load i32, i32* %10
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i8*, i8** %156, i64 %158
%160 = load i8*, i8** %159
%161 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @parseFormula to i32 (i8*, i8*, ...)*)(i8* %160, i8* %12)
%162 = sext i32 %161 to i64
%163 = inttoptr i64 %162 to i8**
store i8** %163, i8*** %11
%164 = load i8, i8* %12
%165 = sext i8 %164 to i32
%166 = icmp eq i32 %165, 45
br i1 %166, label %167, label %172
167: ; preds = %155
%168 = load i32, i32* %10
%169 = call i32 (i32, i8***, i32*, i8***, i32*, ...) bitcast (i32 (...)* @move to i32 (i32, i8***, i32*, i8***, i32*, ...)*)(i32 %168, i8*** %8, i32* %9, i8*** %6, i32* %7)
%170 = load i32, i32* %10
%171 = add nsw i32 %170, -1
store i32 %171, i32* %10
br label %271
172: ; preds = %155
%173 = load i8, i8* %12
%174 = sext i8 %173 to i32
%175 = icmp eq i32 %174, 124
br i1 %175, label %176, label %207
176: ; preds = %172
%177 = load i8**, i8*** %8
%178 = load i32, i32* %10
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8*, i8** %177, i64 %179
%181 = load i8*, i8** %180
%182 = load i8**, i8*** %11
%183 = getelementptr inbounds i8*, i8** %182, i64 0
%184 = load i8*, i8** %183
%185 = load i8**, i8*** %8
%186 = load i32, i32* %10
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8*, i8** %185, i64 %187
store i8* %184, i8** %188
%189 = load i8**, i8*** %8
%190 = bitcast i8** %189 to i8*
%191 = load i32, i32* %9
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = mul i64 8, %193
%195 = call i8* @realloc(i8* %190, i64 %194)
%196 = bitcast i8* %195 to i8**
store i8** %196, i8*** %8
%197 = load i8**, i8*** %11
%198 = getelementptr inbounds i8*, i8** %197, i64 1
%199 = load i8*, i8** %198
%200 = load i8**, i8*** %8
%201 = load i32, i32* %9
%202 = add nsw i32 %201, 1
store i32 %202, i32* %9
%203 = sext i32 %201 to i64
%204 = getelementptr inbounds i8*, i8** %200, i64 %203
store i8* %199, i8** %204
%205 = load i32, i32* %10
%206 = add nsw i32 %205, -1
store i32 %206, i32* %10
br label %270
207: ; preds = %172
%208 = load i8, i8* %12
%209 = sext i8 %208 to i32
%210 = icmp eq i32 %209, 62
br i1 %210, label %211, label %269
211: ; preds = %207
%212 = load i8**, i8*** %8
%213 = load i32, i32* %10
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i8*, i8** %212, i64 %214
%216 = load i8*, i8** %215
store i8* %216, i8** %13
%217 = load i8**, i8*** %8
%218 = load i32, i32* %10
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i8*, i8** %217, i64 %219
%221 = load i8*, i8** %220
%222 = call i64 @strlen(i8* %221)
%223 = add i64 %222, 3
%224 = mul i64 1, %223
%225 = call i8* @malloc(i64 %224)
%226 = load i8**, i8*** %8
%227 = load i32, i32* %10
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i8*, i8** %226, i64 %228
store i8* %225, i8** %229
%230 = load i8*, i8** %13
%231 = load i8**, i8*** %8
%232 = load i32, i32* %10
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i8*, i8** %231, i64 %233
%235 = load i8*, i8** %234
%236 = call i8* @strcpy(i8* %235, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%237 = load i8**, i8*** %8
%238 = load i32, i32* %10
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i8*, i8** %237, i64 %239
%241 = load i8*, i8** %240
%242 = load i8**, i8*** %11
%243 = getelementptr inbounds i8*, i8** %242, i64 0
%244 = load i8*, i8** %243
%245 = call i8* @strcat(i8* %241, i8* %244)
%246 = load i8**, i8*** %8
%247 = load i32, i32* %10
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i8*, i8** %246, i64 %248
%250 = load i8*, i8** %249
%251 = call i8* @strcat(i8* %250, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%252 = load i8**, i8*** %8
%253 = load i32, i32* %10
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i8*, i8** %252, i64 %254
%256 = load i8*, i8** %255
%257 = load i8**, i8*** %11
%258 = getelementptr inbounds i8*, i8** %257, i64 1
%259 = load i8*, i8** %258
%260 = call i8* @strcat(i8* %256, i8* %259)
%261 = load i8**, i8*** %11
%262 = getelementptr inbounds i8*, i8** %261, i64 0
%263 = load i8*, i8** %262
%264 = load i8**, i8*** %11
%265 = getelementptr inbounds i8*, i8** %264, i64 1
%266 = load i8*, i8** %265
%267 = load i32, i32* %10
%268 = add nsw i32 %267, -1
store i32 %268, i32* %10
br label %269
269: ; preds = %211, %207
br label %270
270: ; preds = %269, %176
br label %271
271: ; preds = %270, %167
%272 = load i8**, i8*** %11
%273 = bitcast i8** %272 to i8*
br label %274
274: ; preds = %271
%275 = load i32, i32* %10
%276 = add nsw i32 %275, 1
store i32 %276, i32* %10
br label %151
277: ; preds = %151
store i32 0, i32* %10
br label %278
278: ; preds = %365, %277
%279 = load i32, i32* %10
%280 = load i32, i32* %7
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %368
282: ; preds = %278
%283 = load i8**, i8*** %6
%284 = load i32, i32* %10
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i8*, i8** %283, i64 %285
%287 = load i8*, i8** %286
%288 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @parseFormula to i32 (i8*, i8*, ...)*)(i8* %287, i8* %12)
%289 = sext i32 %288 to i64
%290 = inttoptr i64 %289 to i8**
store i8** %290, i8*** %11
%291 = load i8, i8* %12
%292 = sext i8 %291 to i32
%293 = icmp eq i32 %292, 124
br i1 %293, label %294, label %364
294: ; preds = %282
%295 = load i8**, i8*** %6
%296 = load i32, i32* %7
%297 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %295, i32 %296)
%298 = sext i32 %297 to i64
%299 = inttoptr i64 %298 to i8**
store i8** %299, i8*** %14
%300 = load i8**, i8*** %14
%301 = load i32, i32* %10
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i8*, i8** %300, i64 %302
%304 = load i8*, i8** %303
%305 = load i8**, i8*** %11
%306 = getelementptr inbounds i8*, i8** %305, i64 0
%307 = load i8*, i8** %306
%308 = load i8**, i8*** %14
%309 = load i32, i32* %10
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i8*, i8** %308, i64 %310
store i8* %307, i8** %311
%312 = load i8**, i8*** %8
%313 = load i32, i32* %9
%314 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %312, i32 %313)
%315 = sext i32 %314 to i64
%316 = inttoptr i64 %315 to i8**
store i8** %316, i8*** %15
%317 = load i8**, i8*** %14
%318 = load i32, i32* %7
%319 = load i8**, i8*** %15
%320 = load i32, i32* %9
%321 = call i32 @prove(i8** %317, i32 %318, i8** %319, i32 %320)
%322 = trunc i32 %321 to i8
store i8 %322, i8* %12
%323 = load i8, i8* %12
%324 = sext i8 %323 to i32
%325 = icmp eq i32 %324, 1
br i1 %325, label %326, label %355
326: ; preds = %294
%327 = load i8**, i8*** %6
%328 = load i32, i32* %7
%329 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %327, i32 %328)
%330 = sext i32 %329 to i64
%331 = inttoptr i64 %330 to i8**
store i8** %331, i8*** %14
%332 = load i8**, i8*** %14
%333 = load i32, i32* %10
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i8*, i8** %332, i64 %334
%336 = load i8*, i8** %335
%337 = load i8**, i8*** %11
%338 = getelementptr inbounds i8*, i8** %337, i64 1
%339 = load i8*, i8** %338
%340 = load i8**, i8*** %14
%341 = load i32, i32* %10
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i8*, i8** %340, i64 %342
store i8* %339, i8** %343
%344 = load i8**, i8*** %8
%345 = load i32, i32* %9
%346 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %344, i32 %345)
%347 = sext i32 %346 to i64
%348 = inttoptr i64 %347 to i8**
store i8** %348, i8*** %15
%349 = load i8**, i8*** %14
%350 = load i32, i32* %7
%351 = load i8**, i8*** %15
%352 = load i32, i32* %9
%353 = call i32 @prove(i8** %349, i32 %350, i8** %351, i32 %352)
%354 = trunc i32 %353 to i8
store i8 %354, i8* %12
br label %355
355: ; preds = %326, %294
%356 = load i8**, i8*** %6
%357 = load i32, i32* %7
%358 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @freeF to i32 (i8**, i32, ...)*)(i8** %356, i32 %357)
%359 = load i8**, i8*** %8
%360 = load i32, i32* %9
%361 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @freeF to i32 (i8**, i32, ...)*)(i8** %359, i32 %360)
%362 = load i8, i8* %12
%363 = sext i8 %362 to i32
store i32 %363, i32* %5
br label %473
364: ; preds = %282
br label %365
365: ; preds = %364
%366 = load i32, i32* %10
%367 = add nsw i32 %366, 1
store i32 %367, i32* %10
br label %278
368: ; preds = %278
store i32 0, i32* %10
br label %369
369: ; preds = %456, %368
%370 = load i32, i32* %10
%371 = load i32, i32* %9
%372 = icmp slt i32 %370, %371
br i1 %372, label %373, label %459
373: ; preds = %369
%374 = load i8**, i8*** %8
%375 = load i32, i32* %10
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i8*, i8** %374, i64 %376
%378 = load i8*, i8** %377
%379 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @parseFormula to i32 (i8*, i8*, ...)*)(i8* %378, i8* %12)
%380 = sext i32 %379 to i64
%381 = inttoptr i64 %380 to i8**
store i8** %381, i8*** %11
%382 = load i8, i8* %12
%383 = sext i8 %382 to i32
%384 = icmp eq i32 %383, 38
br i1 %384, label %385, label %455
385: ; preds = %373
%386 = load i8**, i8*** %6
%387 = load i32, i32* %7
%388 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %386, i32 %387)
%389 = sext i32 %388 to i64
%390 = inttoptr i64 %389 to i8**
store i8** %390, i8*** %14
%391 = load i8**, i8*** %8
%392 = load i32, i32* %9
%393 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %391, i32 %392)
%394 = sext i32 %393 to i64
%395 = inttoptr i64 %394 to i8**
store i8** %395, i8*** %15
%396 = load i8**, i8*** %15
%397 = load i32, i32* %10
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds i8*, i8** %396, i64 %398
%400 = load i8*, i8** %399
%401 = load i8**, i8*** %11
%402 = getelementptr inbounds i8*, i8** %401, i64 0
%403 = load i8*, i8** %402
%404 = load i8**, i8*** %15
%405 = load i32, i32* %10
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds i8*, i8** %404, i64 %406
store i8* %403, i8** %407
%408 = load i8**, i8*** %14
%409 = load i32, i32* %7
%410 = load i8**, i8*** %15
%411 = load i32, i32* %9
%412 = call i32 @prove(i8** %408, i32 %409, i8** %410, i32 %411)
%413 = trunc i32 %412 to i8
store i8 %413, i8* %12
%414 = load i8, i8* %12
%415 = sext i8 %414 to i32
%416 = icmp eq i32 %415, 1
br i1 %416, label %417, label %446
417: ; preds = %385
%418 = load i8**, i8*** %6
%419 = load i32, i32* %7
%420 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %418, i32 %419)
%421 = sext i32 %420 to i64
%422 = inttoptr i64 %421 to i8**
store i8** %422, i8*** %14
%423 = load i8**, i8*** %8
%424 = load i32, i32* %9
%425 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @copy to i32 (i8**, i32, ...)*)(i8** %423, i32 %424)
%426 = sext i32 %425 to i64
%427 = inttoptr i64 %426 to i8**
store i8** %427, i8*** %15
%428 = load i8**, i8*** %15
%429 = load i32, i32* %10
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds i8*, i8** %428, i64 %430
%432 = load i8*, i8** %431
%433 = load i8**, i8*** %11
%434 = getelementptr inbounds i8*, i8** %433, i64 1
%435 = load i8*, i8** %434
%436 = load i8**, i8*** %15
%437 = load i32, i32* %10
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds i8*, i8** %436, i64 %438
store i8* %435, i8** %439
%440 = load i8**, i8*** %14
%441 = load i32, i32* %7
%442 = load i8**, i8*** %15
%443 = load i32, i32* %9
%444 = call i32 @prove(i8** %440, i32 %441, i8** %442, i32 %443)
%445 = trunc i32 %444 to i8
store i8 %445, i8* %12
br label %446
446: ; preds = %417, %385
%447 = load i8**, i8*** %6
%448 = load i32, i32* %7
%449 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @freeF to i32 (i8**, i32, ...)*)(i8** %447, i32 %448)
%450 = load i8**, i8*** %8
%451 = load i32, i32* %9
%452 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @freeF to i32 (i8**, i32, ...)*)(i8** %450, i32 %451)
%453 = load i8, i8* %12
%454 = sext i8 %453 to i32
store i32 %454, i32* %5
br label %473
455: ; preds = %373
br label %456
456: ; preds = %455
%457 = load i32, i32* %10
%458 = add nsw i32 %457, 1
store i32 %458, i32* %10
br label %369
459: ; preds = %369
br label %16
460: ; preds = %16
%461 = load i8**, i8*** %6
%462 = load i32, i32* %7
%463 = load i8**, i8*** %8
%464 = load i32, i32* %9
%465 = call i32 (i8**, i32, i8**, i32, ...) bitcast (i32 (...)* @hasSolven to i32 (i8**, i32, i8**, i32, ...)*)(i8** %461, i32 %462, i8** %463, i32 %464)
store i32 %465, i32* %10
%466 = load i8**, i8*** %6
%467 = load i32, i32* %7
%468 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @freeF to i32 (i8**, i32, ...)*)(i8** %466, i32 %467)
%469 = load i8**, i8*** %8
%470 = load i32, i32* %9
%471 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @freeF to i32 (i8**, i32, ...)*)(i8** %469, i32 %470)
%472 = load i32, i32* %10
store i32 %472, i32* %5
br label %473
473: ; preds = %460, %446, %355
%474 = load i32, i32* %5
ret i32 %474
}

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