long long pseudoknot(long long n, int *inp) {
  if (n == 0)
    return 0;
  long long i, j, k, l, a, b, c;
  long long cur, new, newL, newM, newR;
  long long *t = calloc(n * n, sizeof(long long));
  long long *u = calloc(n * n * n * n, sizeof(long long));
  long long *v = calloc(n * n * n * n, sizeof(long long));
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      t[((i)*n + (j))] = 0;
      for (k = 0; k < n; k++)
        for (l = 0; l < n; l++) {
          u[((i)*n * n * n + (j)*n * n + (k)*n + (l))] = -999999;
          v[((i)*n * n * n + (j)*n * n + (k)*n + (l))] = -999999;
        }
    }
  for (i = n - 1; i >= 0; i--)
    for (j = i; j < n; j++) {
      cur = 0;
      if (j > 0) {
        new = t[((i)*n + (j - 1))];
        cur = (((cur) > (new)) ? (cur) : (new));
      };
      for (a = i; a <= j; a++) {
        new = -999999;
        newL = a <= i ? 0 : t[((i)*n + (a - 1))];
        newR = a + 1 >= j - 1 ? 0 : t[((a + 1) * n + (j - 1))];
        if (pairs(inp[a], inp[j])) {
          new = newL + newR + 1;
          cur = (((cur) > (new)) ? (cur) : (new));
        }
      };
      for (a = i; a <= j; a++)
        for (b = a + 1; b <= j; b++)
          for (c = b + 1; c < j; c++) {
            if (1) {
              newL = u[((i)*n * n * n + (a)*n * n + (b + 1) * n + (c))];
              newR = v[((a + 1) * n * n * n + (b)*n * n + (c + 1) * n + (j))];
              new = newL + newR;
              cur = (((cur) > (new)) ? (cur) : (new));
            }
          };
      t[i * n + j] = cur;
      filluv('U', inp, t, u, n, i, j);
      filluv('V', inp, t, v, n, i, j);
    }
  cur = t[((0) * n + (n - 1))];
  free(t);
  free(u);
  free(v);
  return cur;
}


x86 assembly (clang, -O0):
<pseudoknot>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    116b <pseudoknot+0x2b>
movq   $0x0,-0x8(%rbp)
jmp    171d <pseudoknot+0x5dd>
mov    -0x10(%rbp),%rdi
imul   -0x10(%rbp),%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x10(%rbp),%rdi
imul   -0x10(%rbp),%rdi
imul   -0x10(%rbp),%rdi
imul   -0x10(%rbp),%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x10(%rbp),%rdi
imul   -0x10(%rbp),%rdi
imul   -0x10(%rbp),%rdi
imul   -0x10(%rbp),%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1314 <pseudoknot+0x1d4>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    12fe <pseudoknot+0x1be>
mov    -0x80(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x28(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    12e8 <pseudoknot+0x1a8>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    12d2 <pseudoknot+0x192>
mov    -0x88(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x10(%rbp),%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
mov    -0x30(%rbp),%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
add    -0x38(%rbp),%rcx
movq   $0xfffffffffff0bdc1,(%rax,%rcx,8)
ff
mov    -0x90(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x10(%rbp),%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
mov    -0x30(%rbp),%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
add    -0x38(%rbp),%rcx
movq   $0xfffffffffff0bdc1,(%rax,%rcx,8)
ff
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    122d <pseudoknot+0xed>
jmp    12d7 <pseudoknot+0x197>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1217 <pseudoknot+0xd7>
jmp    12ed <pseudoknot+0x1ad>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11e8 <pseudoknot+0xa8>
jmp    1303 <pseudoknot+0x1c3>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11d2 <pseudoknot+0x92>
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jl     16d8 <pseudoknot+0x598>
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    16c2 <pseudoknot+0x582>
movq   $0x0,-0x58(%rbp)
cmpq   $0x0,-0x28(%rbp)
jle    13a8 <pseudoknot+0x268>
mov    -0x80(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
sub    $0x1,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jle    1392 <pseudoknot+0x252>
mov    -0x58(%rbp),%rax
mov    %rax,-0x98(%rbp)
jmp    139d <pseudoknot+0x25d>
mov    -0x60(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     14e9 <pseudoknot+0x3a9>
movq   $0xfffffffffff0bdc1,-0x60(%rbp)
ff
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
jg     13e2 <pseudoknot+0x2a2>
xor    %eax,%eax
mov    %rax,-0xa0(%rbp)
jmp    1405 <pseudoknot+0x2c5>
mov    -0x80(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x10(%rbp),%rcx
mov    -0x40(%rbp),%rdx
sub    $0x1,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jl     1437 <pseudoknot+0x2f7>
xor    %eax,%eax
mov    %rax,-0xa8(%rbp)
jmp    145e <pseudoknot+0x31e>
mov    -0x80(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    $0x1,%rcx
imul   -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
sub    $0x1,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1040 <pairs@plt>
cmp    $0x0,%eax
je     14d3 <pseudoknot+0x393>
mov    -0x68(%rbp),%rax
add    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jle    14bd <pseudoknot+0x37d>
mov    -0x58(%rbp),%rax
mov    %rax,-0xb0(%rbp)
jmp    14c8 <pseudoknot+0x388>
mov    -0x60(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    14d8 <pseudoknot+0x398>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    13b0 <pseudoknot+0x270>
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     1642 <pseudoknot+0x502>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x28(%rbp),%rax
jg     162c <pseudoknot+0x4ec>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1616 <pseudoknot+0x4d6>
mov    -0x88(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
mov    -0x40(%rbp),%rdx
imul   -0x10(%rbp),%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
mov    -0x48(%rbp),%rdx
add    $0x1,%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
add    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    $0x1,%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
imul   -0x10(%rbp),%rcx
mov    -0x48(%rbp),%rdx
imul   -0x10(%rbp),%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
mov    -0x50(%rbp),%rdx
add    $0x1,%rdx
imul   -0x10(%rbp),%rdx
add    %rdx,%rcx
add    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x78(%rbp)
mov    -0x68(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jle    15ef <pseudoknot+0x4af>
mov    -0x58(%rbp),%rax
mov    %rax,-0xb8(%rbp)
jmp    15fa <pseudoknot+0x4ba>
mov    -0x60(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1525 <pseudoknot+0x3e5>
jmp    161b <pseudoknot+0x4db>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    150b <pseudoknot+0x3cb>
jmp    1631 <pseudoknot+0x4f1>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    14f1 <pseudoknot+0x3b1>
mov    -0x58(%rbp),%rdx
mov    -0x80(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x20(%rbp),%r9
mov    -0x28(%rbp),%rax
mov    $0x55,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1060 <filluv@plt>
mov    -0x18(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    -0x90(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x20(%rbp),%r9
mov    -0x28(%rbp),%rax
mov    $0x56,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1060 <filluv@plt>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1333 <pseudoknot+0x1f3>
jmp    16c7 <pseudoknot+0x587>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    1320 <pseudoknot+0x1e0>
mov    -0x80(%rbp),%rax
imul   $0x0,-0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
sub    $0x1,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pseudoknot>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %rsi,0xb8(%rsp)
test   %rdi,%rdi
je     1bf2 <pseudoknot+0xab2>
mov    %rdi,%rbx
mov    %rdi,%r15
imul   %rbx,%r15
mov    $0x8,%esi
mov    %r15,%rdi
call   1050 <calloc@plt>
mov    %rax,0x58(%rsp)
mov    %r15,%rbp
imul   %r15,%rbp
mov    $0x8,%esi
mov    %rbp,%rdi
call   1050 <calloc@plt>
mov    %rax,%r14
mov    $0x8,%esi
mov    %rbp,%rdi
call   1050 <calloc@plt>
mov    %rax,%rbp
test   %rbx,%rbx
jle    1c0a <pseudoknot+0xaca>
lea    -0x4(%rbx),%rax
mov    %rax,0x28(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %eax,%edi
and    $0x3,%edi
and    $0xfffffffffffffffc,%rax
mov    %rax,0xd0(%rsp)
lea    0x70(%rbp),%r8
mov    %rbx,%rax
imul   %r15,%rax
mov    %rax,0x88(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x60(%rsp)
mov    %r15,0x48(%rsp)
lea    0x0(,%r15,8),%rax
mov    %rax,0x30(%rsp)
lea    0x0(,%rbx,8),%r12
lea    0x70(%r14),%r13
lea    0x10(%rbp),%r10
lea    0x10(%r14),%r15
mov    %rdi,0x8(%rsp)
shl    $0x5,%rdi
xor    %esi,%esi
movdqa 0xdd0(%rip),%xmm0
mov    %r14,0x50(%rsp)
mov    %rbp,0x40(%rsp)
mov    %rbp,%rax
jmp    1296 <pseudoknot+0x156>
nop
mov    0x98(%rsp),%rsi
add    $0x1,%rsi
mov    0x70(%rsp),%r8
mov    0x60(%rsp),%rbp
add    %rbp,%r8
mov    0xb0(%rsp),%r13
add    %rbp,%r13
mov    0xa8(%rsp),%r10
add    %rbp,%r10
mov    0xa0(%rsp),%r15
add    %rbp,%r15
mov    0x68(%rsp),%rax
add    %rbp,%rax
mov    0x90(%rsp),%r14
add    %rbp,%r14
cmp    %rbx,%rsi
je     149e <pseudoknot+0x35e>
mov    %rsi,0x98(%rsp)
mov    %r14,0x90(%rsp)
mov    %rax,0x68(%rsp)
mov    %rax,%rsi
mov    %r15,0xa0(%rsp)
mov    %r10,0xa8(%rsp)
mov    %r13,0xb0(%rsp)
mov    %r8,0x70(%rsp)
mov    %r8,%rax
xor    %ebp,%ebp
jmp    1330 <pseudoknot+0x1f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x38(%rsp),%rbp
add    $0x1,%rbp
mov    0x30(%rsp),%rax
mov    0xc0(%rsp),%rdx
add    %rax,%rdx
mov    0x18(%rsp),%r13
add    %rax,%r13
mov    0x78(%rsp),%r10
add    %rax,%r10
mov    0xc8(%rsp),%r15
add    %rax,%r15
mov    0x20(%rsp),%rsi
add    %rax,%rsi
mov    0x10(%rsp),%r14
add    %rax,%r14
mov    %rdx,%rax
cmp    %rbx,%rbp
je     1240 <pseudoknot+0x100>
mov    %rbp,0x38(%rsp)
mov    %r14,0x10(%rsp)
mov    %r14,%r8
mov    %rsi,0x20(%rsp)
mov    %rsi,%r9
mov    %r15,0xc8(%rsp)
mov    %r10,0x78(%rsp)
mov    %r10,%r14
mov    %r13,0x18(%rsp)
mov    %rax,0xc0(%rsp)
mov    %rax,%r10
xor    %eax,%eax
jmp    138f <pseudoknot+0x24f>
nopl   0x0(%rax)
add    $0x1,%rax
add    %r12,%r10
add    %r12,%r13
add    %r12,%r14
add    %r12,%r15
add    %r12,%r9
add    %r12,%r8
cmp    %rbx,%rax
je     12e0 <pseudoknot+0x1a0>
cmp    $0x4,%rbx
jae    13a0 <pseudoknot+0x260>
xor    %esi,%esi
jmp    1480 <pseudoknot+0x340>
nopl   0x0(%rax)
cmpq   $0xc,0x28(%rsp)
jae    13b0 <pseudoknot+0x270>
xor    %r11d,%r11d
jmp    1439 <pseudoknot+0x2f9>
mov    0xd0(%rsp),%rbp
xor    %r11d,%r11d
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x70(%r13,%r11,8)
movdqu %xmm0,-0x60(%r13,%r11,8)
movdqu %xmm0,-0x70(%r10,%r11,8)
movdqu %xmm0,-0x60(%r10,%r11,8)
movdqu %xmm0,-0x50(%r13,%r11,8)
movdqu %xmm0,-0x40(%r13,%r11,8)
movdqu %xmm0,-0x50(%r10,%r11,8)
movdqu %xmm0,-0x40(%r10,%r11,8)
movdqu %xmm0,-0x30(%r13,%r11,8)
movdqu %xmm0,-0x20(%r13,%r11,8)
movdqu %xmm0,-0x30(%r10,%r11,8)
movdqu %xmm0,-0x20(%r10,%r11,8)
movdqu %xmm0,-0x10(%r13,%r11,8)
movdqu %xmm0,0x0(%r13,%r11,8)
movdqu %xmm0,-0x10(%r10,%r11,8)
movdqu %xmm0,(%r10,%r11,8)
add    $0x10,%r11
add    $0xfffffffffffffffc,%rbp
jne    13c0 <pseudoknot+0x280>
cmpq   $0x0,0x8(%rsp)
je     1470 <pseudoknot+0x330>
lea    (%r14,%r11,8),%rsi
lea    (%r15,%r11,8),%rbp
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rbp,%rdx,1)
movdqu %xmm0,0x0(%rbp,%rdx,1)
movdqu %xmm0,-0x10(%rsi,%rdx,1)
movdqu %xmm0,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1450 <pseudoknot+0x310>
mov    %rcx,%rsi
cmp    %rbx,%rcx
je     1370 <pseudoknot+0x230>
nopl   0x0(%rax)
movq   $0xfffffffffff0bdc1,(%r8,%rsi,8)
ff
movq   $0xfffffffffff0bdc1,(%r9,%rsi,8)
ff
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1480 <pseudoknot+0x340>
jmp    1370 <pseudoknot+0x230>
lea    -0x1(%rbx),%r13
test   %rbx,%rbx
jle    1c13 <pseudoknot+0xad3>
lea    0x1(%rbx),%r8
mov    %rbx,%rdi
imul   %r8,%rdi
lea    0x0(,%rdi,8),%rcx
mov    %rcx,0x78(%rsp)
mov    0x58(%rsp),%rcx
lea    (%rcx,%rdi,8),%rdx
add    $0xfffffffffffffff0,%rdx
mov    %rdx,0xe0(%rsp)
mov    %r12,%rdx
xor    $0xfffffffffffffff8,%rdx
mov    %rdx,0x128(%rsp)
mov    0xb8(%rsp),%rdx
lea    (%rdx,%r13,4),%rdx
mov    %rdx,0x70(%rsp)
mov    0x48(%rsp),%rsi
lea    -0x10(%rcx,%rsi,8),%rcx
mov    %rcx,0x60(%rsp)
mov    0x88(%rsp),%rbp
lea    0x2(%rbp),%rcx
imul   %rbx,%rcx
mov    0x50(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
add    $0x18,%rcx
mov    %rcx,0xe8(%rsp)
mov    %rbx,%rcx
not    %rcx
imul   %rbx,%rcx
mov    %rcx,0x120(%rsp)
add    $0xffffffffffffffff,%rcx
imul   %rbx,%rcx
lea    -0x8(,%rcx,8),%rax
ff
mov    %rax,0x110(%rsp)
shl    $0x3,%rcx
mov    %rcx,0x118(%rsp)
lea    0x8(,%rdi,8),%rax
mov    %rax,0x140(%rsp)
mov    %rdi,0x148(%rsp)
lea    0x1(%rdi),%rax
imul   %rbx,%rax
lea    0x3(%rax),%rcx
imul   %rbx,%rcx
mov    0x40(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
add    $0x8,%rcx
mov    %rcx,0xd8(%rsp)
shl    $0x3,%rax
mov    %rax,0x138(%rsp)
imul   %r8,%rsi
mov    %rbx,%rax
shl    $0x5,%rax
mov    %rax,0xc0(%rsp)
add    $0x1,%rsi
mov    %rsi,0x48(%rsp)
add    $0x1,%rbp
imul   %rbx,%rbp
lea    (%rdx,%rbp,8),%rax
mov    %rax,0x80(%rsp)
lea    0x8(,%rbx,8),%rax
mov    %rax,0xd0(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r13,0x108(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r12,0x150(%rsp)
jmp    167e <pseudoknot+0x53e>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%r13),%rax
addq   $0xffffffffffffffff,0x18(%rsp)
mov    0x128(%rsp),%rcx
add    %rcx,0xe0(%rsp)
addq   $0xfffffffffffffffc,0x70(%rsp)
add    %rcx,0x60(%rsp)
mov    0x110(%rsp),%rcx
add    %rcx,0xe8(%rsp)
add    %rcx,0xd8(%rsp)
mov    0x120(%rsp),%rcx
add    %rcx,0x48(%rsp)
mov    0x80(%rsp),%rcx
add    0x118(%rsp),%rcx
mov    %rcx,0x80(%rsp)
test   %r13,%r13
mov    %rax,%r13
jle    1bf6 <pseudoknot+0xab6>
cmp    %rbx,%r13
jge    1610 <pseudoknot+0x4d0>
mov    %r13,%rax
imul   %rbx,%rax
mov    %rax,0x100(%rsp)
movq   $0xfffffffffffffffe,0xf8(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0xe0(%rsp),%rdx
xor    %esi,%esi
mov    0x18(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    %r13,%rbp
mov    %r13,0x38(%rsp)
jmp    1770 <pseudoknot+0x630>
nop
mov    0x100(%rsp),%rax
add    %rbp,%rax
mov    0x58(%rsp),%r15
mov    %r14,(%r15,%rax,8)
mov    %rbp,(%rsp)
mov    $0x55,%edi
mov    0xb8(%rsp),%r14
mov    %r14,%rsi
mov    %r15,%rdx
mov    0x50(%rsp),%rcx
mov    %rbx,%r8
mov    0x38(%rsp),%r13
mov    %r13,%r9
xor    %eax,%eax
call   1060 <filluv@plt>
mov    %rbp,(%rsp)
mov    $0x56,%edi
mov    %r14,%rsi
mov    %r15,%rdx
mov    0x40(%rsp),%rcx
mov    %rbx,%r8
mov    %r13,%r9
xor    %eax,%eax
call   1060 <filluv@plt>
add    $0x1,%rbp
addq   $0x1,0x68(%rsp)
mov    0x130(%rsp),%rsi
add    $0x1,%rsi
mov    0x88(%rsp),%rdx
add    $0x8,%rdx
addq   $0x1,0xf8(%rsp)
addq   $0x8,0xf0(%rsp)
cmp    %rbx,%rbp
je     1610 <pseudoknot+0x4d0>
test   %rbp,%rbp
jle    17a0 <pseudoknot+0x660>
mov    0x100(%rsp),%rax
add    %rbp,%rax
mov    0x58(%rsp),%rcx
mov    -0x8(%rcx,%rax,8),%r14
test   %r14,%r14
mov    $0x0,%eax
cmovs  %rax,%r14
jmp    17a3 <pseudoknot+0x663>
nopl   0x0(%rax,%rax,1)
xor    %r14d,%r14d
cmp    %rbp,%r13
mov    %rdx,0x88(%rsp)
mov    %rsi,0x130(%rsp)
jg     16d0 <pseudoknot+0x590>
lea    -0x2(%rsi),%rax
mov    %rax,0xc8(%rsp)
lea    -0x1(%rbp),%rax
mov    %rax,0x20(%rsp)
lea    0x1(%rsi),%rax
mov    %rax,0x30(%rsp)
mov    %rdx,%r15
xor    %r13d,%r13d
jmp    184d <pseudoknot+0x70d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15),%rax
mov    %rax,0x10(%rsp)
mov    0x70(%rsp),%rax
mov    (%rax,%r13,4),%edi
mov    0xb8(%rsp),%rax
mov    (%rax,%rbp,4),%esi
xor    %eax,%eax
call   1040 <pairs@plt>
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%rdx
add    %rdx,%rcx
add    $0x1,%rcx
cmp    %rcx,%r14
cmovg  %r14,%rcx
test   %eax,%eax
cmovne %rcx,%r14
add    $0x1,%r13
add    %r12,%r15
cmp    %r13,0x30(%rsp)
mov    0x78(%rsp),%r10
movdqa 0x7c5(%rip),%xmm8
je     18a0 <pseudoknot+0x760>
mov    0x18(%rsp),%rax
add    %r13,%rax
add    $0xffffffffffffffff,%rax
cmp    0x38(%rsp),%rax
jle    1870 <pseudoknot+0x730>
mov    0x60(%rsp),%rax
mov    (%rax,%r13,8),%rax
jmp    1872 <pseudoknot+0x732>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x18(%rsp),%rax
add    %r13,%rax
cmp    0x20(%rsp),%rax
jl     17f0 <pseudoknot+0x6b0>
xor    %eax,%eax
jmp    17f3 <pseudoknot+0x6b3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
cmp    %rbp,%rax
jg     16d0 <pseudoknot+0x590>
mov    0x80(%rsp),%rcx
mov    0x48(%rsp),%r15
mov    0xf0(%rsp),%r11
mov    0xe8(%rsp),%rsi
mov    0xf8(%rsp),%r13
xor    %edx,%edx
mov    %rdx,0x20(%rsp)
jmp    1942 <pseudoknot+0x802>
nopl   0x0(%rax)
addq   $0x1,0x20(%rsp)
mov    0x98(%rsp),%r13
add    $0xffffffffffffffff,%r13
mov    0xa0(%rsp),%rsi
add    0x140(%rsp),%rsi
mov    0xa8(%rsp),%r11
add    0x138(%rsp),%r11
mov    0xb0(%rsp),%r15
add    0x148(%rsp),%r15
mov    0x30(%rsp),%rcx
add    %r10,%rcx
mov    0x90(%rsp),%rax
cmp    0x68(%rsp),%rax
mov    0x28(%rsp),%rbx
je     16d0 <pseudoknot+0x590>
lea    0x1(%rax),%rdx
cmp    %rbp,%rax
mov    %rcx,0x30(%rsp)
mov    %r15,0xb0(%rsp)
mov    %r11,0xa8(%rsp)
mov    %rsi,0xa0(%rsp)
mov    %r13,0x98(%rsp)
mov    %rdx,0x90(%rsp)
jge    18e0 <pseudoknot+0x7a0>
xor    %r9d,%r9d
mov    %rdx,%rbx
jmp    19b4 <pseudoknot+0x874>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r9
add    $0xffffffffffffffff,%r13
add    0xd0(%rsp),%rsi
add    %r10,%r11
add    0x28(%rsp),%r15
add    %r12,%rcx
cmp    %rbp,%rdi
jge    18e0 <pseudoknot+0x7a0>
mov    %rbx,%rdi
add    $0x1,%rbx
cmp    %rbp,%rbx
jge    1990 <pseudoknot+0x850>
mov    %r10,%rdx
mov    %rdi,0x10(%rsp)
mov    %rbx,0x8(%rsp)
mov    0x20(%rsp),%rax
add    %r9,%rax
mov    0xc8(%rsp),%r10
sub    %rax,%r10
cmp    $0x4,%r10
jb     1ba0 <pseudoknot+0xa60>
cmpq   $0x1,0x28(%rsp)
jne    1ba0 <pseudoknot+0xa60>
mov    %r13,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %r10,%r12
and    $0xfffffffffffffffc,%r12
mov    0x8(%rsp),%rax
lea    (%rax,%r12,1),%r8
movq   %r14,%xmm0
pshufd $0x44,%xmm0,%xmm0
mov    %r11,%rax
xor    %edx,%edx
movdqa %xmm0,%xmm1
mov    0xc0(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rdx,8),%xmm2
movdqu (%rsi,%rdx,8),%xmm3
movdqu -0x10(%rax),%xmm4
paddq  %xmm2,%xmm4
movdqu (%rax),%xmm2
paddq  %xmm3,%xmm2
movdqa %xmm0,%xmm3
pxor   %xmm8,%xmm0
movdqa %xmm4,%xmm5
pxor   %xmm8,%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm5,%xmm6
pshufd $0xa0,%xmm6,%xmm7
pcmpeqd %xmm0,%xmm5
pshufd $0xf5,%xmm5,%xmm0
pand   %xmm7,%xmm0
pshufd $0xf5,%xmm6,%xmm5
por    %xmm0,%xmm5
pand   %xmm5,%xmm3
pandn  %xmm4,%xmm5
movdqa %xmm5,%xmm0
por    %xmm3,%xmm0
movdqa %xmm1,%xmm3
pxor   %xmm8,%xmm1
movdqa %xmm2,%xmm4
pxor   %xmm8,%xmm4
movdqa %xmm1,%xmm5
pcmpgtd %xmm4,%xmm5
pshufd $0xa0,%xmm5,%xmm6
pcmpeqd %xmm1,%xmm4
pshufd $0xf5,%xmm4,%xmm1
pand   %xmm6,%xmm1
pshufd $0xf5,%xmm5,%xmm4
por    %xmm1,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm2,%xmm4
movdqa %xmm4,%xmm1
por    %xmm3,%xmm1
add    $0x4,%rdx
add    %rbx,%rax
cmp    %rdx,%rdi
jne    1a30 <pseudoknot+0x8f0>
movdqa %xmm1,%xmm2
pxor   %xmm8,%xmm2
movdqa %xmm0,%xmm3
pxor   %xmm8,%xmm3
movdqa %xmm3,%xmm4
pcmpgtd %xmm2,%xmm4
pshufd $0xa0,%xmm4,%xmm5
pcmpeqd %xmm2,%xmm3
pshufd $0xf5,%xmm3,%xmm2
pand   %xmm5,%xmm2
pshufd $0xf5,%xmm4,%xmm3
por    %xmm2,%xmm3
pand   %xmm3,%xmm0
pandn  %xmm1,%xmm3
por    %xmm0,%xmm3
pshufd $0xee,%xmm3,%xmm0
movdqa %xmm3,%xmm1
pxor   %xmm8,%xmm1
movdqa %xmm0,%xmm2
pxor   %xmm8,%xmm2
movdqa %xmm1,%xmm4
pcmpgtd %xmm2,%xmm4
pshufd $0xa0,%xmm4,%xmm5
pcmpeqd %xmm1,%xmm2
pshufd $0xf5,%xmm2,%xmm1
pand   %xmm5,%xmm1
pshufd $0xf5,%xmm4,%xmm2
por    %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movq   %xmm2,%r14
cmp    %r12,%r10
mov    0x78(%rsp),%r10
mov    0x150(%rsp),%r12
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%rdi
je     1990 <pseudoknot+0x850>
jmp    1bb0 <pseudoknot+0xa70>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%rbx
mov    %rbx,%r8
mov    0x10(%rsp),%rdi
mov    %rdx,%r10
lea    (%r8,%r15,1),%rax
imul   0x28(%rsp),%rax
add    %rbp,%rax
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %r14,%rdx
nopl   0x0(%rax)
mov    (%rax),%r14
add    (%rcx,%r8,8),%r14
add    $0x1,%r8
cmp    %r14,%rdx
cmovg  %rdx,%r14
add    %r12,%rax
mov    %r14,%rdx
cmp    %rbp,%r8
jl     1bd0 <pseudoknot+0xa90>
jmp    1990 <pseudoknot+0x850>
xor    %ebx,%ebx
jmp    1c3b <pseudoknot+0xafb>
mov    0x50(%rsp),%r14
mov    0x40(%rsp),%rbp
mov    0x108(%rsp),%r13
jmp    1c1d <pseudoknot+0xadd>
add    $0xffffffffffffffff,%rbx
mov    %rbx,%r13
jmp    1c1d <pseudoknot+0xadd>
mov    0x50(%rsp),%r14
mov    0x40(%rsp),%rbp
mov    0x58(%rsp),%rdi
mov    (%rdi,%r13,8),%rbx
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %rbx,%rax
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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