void optimalBST(float *p, float *q, int n, float e[][n + 1],
                int root[][n + 1]) {
  int i, l, j, r, indice_menor;
  float menor, t, w[n + 1][n + 1];
  for (i = 0; i <= n; i++) {
    w[i][i] = q[i];
    e[i][i] = q[i];
    root[i][i] = 0;
    for (j = i + 1; j <= n; j++)
      w[i][j] = w[i][j - 1] + p[j] + q[j];
  }
  for (i = 0; i <= (n - 1); i++) {
    j = i + 1;
    e[i][j] = e[i][i] + e[j][j] + w[i][j];
    root[i][j] = j;
  }
  for (l = 2; l <= n; l++) {
    for (i = 0; i <= (n - l); i++) {
      j = i + l;
      indice_menor = root[i][j - 1];
      menor = e[i][indice_menor - 1] + e[indice_menor][j];
      for (r = indice_menor + 1; r <= root[i + 1][j]; r++) {
        t = e[i][r - 1] + e[r][j];
        if (t < menor) {
          menor = t;
          indice_menor = r;
        }
      }
      e[i][j] = w[i][j] + menor;
      root[i][j] = indice_menor;
    }
  }
}


x86 assembly (clang, -O0):
<optimalBST>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %rax,-0x80(%rbp)
mov    %rax,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rax,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rax,%rcx
mov    %rsp,%rdx
mov    %rdx,-0x50(%rbp)
mov    %rax,%rdx
imul   %rdx,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x68(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x58(%rbp)
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1288 <optimalBST+0x188>
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rsi
mov    -0x68(%rbp),%rax
mov    -0x80(%rbp),%rdi
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%r8
movss  (%rcx,%r8,4),%xmm0
movslq -0x2c(%rbp),%rcx
imul   %rdi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1275 <optimalBST+0x175>
mov    -0x68(%rbp),%rax
mov    -0x80(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movss  (%rcx,%rsi,4),%xmm0
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rsi
addss  (%rcx,%rsi,4),%xmm0
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rsi
addss  (%rcx,%rsi,4),%xmm0
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1201 <optimalBST+0x101>
jmp    127a <optimalBST+0x17a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116f <optimalBST+0x6f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1352 <optimalBST+0x252>
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x68(%rbp),%rax
mov    -0x80(%rbp),%rdi
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x34(%rbp)
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%r8
imul   %rdx,%r8
shl    $0x2,%r8
add    %r8,%rcx
movslq -0x2c(%rbp),%r8
movss  (%rcx,%r8,4),%xmm0
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%r8
imul   %rdx,%r8
shl    $0x2,%r8
add    %r8,%rcx
movslq -0x34(%rbp),%r8
addss  (%rcx,%r8,4),%xmm0
movslq -0x2c(%rbp),%rcx
imul   %rdi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    128f <optimalBST+0x18f>
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     152a <optimalBST+0x42a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jg     1517 <optimalBST+0x417>
mov    -0x78(%rbp),%rdx
mov    -0x70(%rbp),%rsi
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x70(%rbp),%rsi
mov    -0x38(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     14a3 <optimalBST+0x3a3>
mov    -0x78(%rbp),%rdx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1490 <optimalBST+0x390>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1495 <optimalBST+0x395>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13fb <optimalBST+0x2fb>
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x68(%rbp),%rax
mov    -0x80(%rbp),%rdi
movslq -0x2c(%rbp),%rcx
imul   %rdi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    136c <optimalBST+0x26c>
jmp    151c <optimalBST+0x41c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1359 <optimalBST+0x259>
mov    -0x50(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<optimalBST>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
lea    0x1(%rdx),%r13d
mov    %r13,%rax
imul   %r13,%rax
mov    %rsp,%r9
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r9
mov    %r9,%rsp
mov    %rdx,-0x30(%rbp)
test   %edx,%edx
js     14a4 <optimalBST+0x3a4>
mov    %rcx,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
lea    0x4(%r9),%rcx
mov    %rcx,-0x48(%rbp)
lea    0x0(,%r13,4),%rcx
mov    %rcx,-0x78(%rbp)
lea    0x4(,%r13,4),%rcx
mov    %rcx,-0x60(%rbp)
lea    0x8(%r9),%rcx
mov    %rcx,-0x58(%rbp)
lea    -0x1(%rax),%r12d
lea    0xc(%r9),%r11
mov    $0x1,%r15d
xor    %eax,%eax
mov    %r9,-0x68(%rbp)
mov    %r12d,-0x80(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r13,-0x40(%rbp)
jmp    11c2 <optimalBST+0xc2>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15d
add    $0xffffffff,%r12d
mov    -0x78(%rbp),%rax
add    %rax,%r11
add    %rax,%r9
mov    -0x88(%rbp),%rax
cmp    %r13,%rax
je     13a4 <optimalBST+0x2a4>
mov    %rax,%rbx
imul   %r13,%rax
mov    -0x68(%rbp),%rcx
lea    (%rcx,%rax,4),%r10
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rbx,4)
mov    -0x70(%rbp),%rcx
lea    (%rcx,%rax,4),%rdx
movss  %xmm0,(%rdx,%rbx,4)
lea    (%r8,%rax,4),%rax
movl   $0x0,(%rax,%rbx,4)
lea    0x1(%rbx),%rax
mov    %rax,-0x88(%rbp)
cmp    -0x50(%rbp),%rbx
jae    11a0 <optimalBST+0xa0>
movslq %r15d,%rax
mov    -0x80(%rbp),%ecx
mov    %ecx,%r14d
sub    %ebx,%r14d
cmp    $0x7,%r14d
jb     130e <optimalBST+0x20e>
mov    $0xfffffffe,%r8d
sub    %ebx,%r8d
mov    %ebx,%edx
not    %edx
add    -0x30(%rbp),%edx
cmp    %edx,%r8d
jb     130a <optimalBST+0x20a>
mov    -0x60(%rbp),%rdx
imul   %rbx,%rdx
mov    -0x48(%rbp),%rcx
lea    (%rcx,%rdx,1),%r8
shl    $0x20,%rbx
movabs $0x100000000,%rcx
add    %rcx,%rbx
mov    %rbx,%rcx
sar    $0x20,%rcx
add    %r14,%rcx
lea    (%r10,%rcx,4),%rcx
cmp    %rcx,%r8
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r13
jae    128d <optimalBST+0x18d>
add    -0x58(%rbp),%rdx
lea    (%rdx,%r14,4),%rcx
sar    $0x1e,%rbx
lea    (%rbx,%r10,1),%rdx
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%rcx
ja     1312 <optimalBST+0x212>
mov    %r12d,%ecx
add    $0x1,%rcx
and    $0xfffffffffffffff8,%rcx
add    $0x1,%r14
mov    %r14,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r8,%rax,1),%rdx
nopw   0x0(%rax,%rax,1)
movups -0x10(%r11,%rax,4),%xmm0
movups (%r11,%rax,4),%xmm1
mov    %eax,%ebx
shl    $0x2,%rbx
movups (%rdi,%rbx,1),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdi,%rbx,1),%xmm0
addps  %xmm1,%xmm0
movups (%rsi,%rbx,1),%xmm1
addps  %xmm2,%xmm1
movups 0x10(%rsi,%rbx,1),%xmm2
addps  %xmm0,%xmm2
movups %xmm1,(%r10,%rbx,1)
movups %xmm2,0x10(%r10,%rbx,1)
add    $0x8,%rax
add    $0xfffffffffffffff8,%rcx
jne    12b0 <optimalBST+0x1b0>
mov    %rdx,%rax
cmp    %r8,%r14
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r13
je     11a0 <optimalBST+0xa0>
jmp    1312 <optimalBST+0x212>
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r13
mov    %r13d,%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    1330 <optimalBST+0x230>
mov    %rax,%rcx
jmp    1350 <optimalBST+0x250>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r10,%rax,4),%xmm0
mov    %eax,%ecx
addss  (%rdi,%rcx,4),%xmm0
addss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%r10,%rcx,4)
mov    %rax,%rcx
add    $0x1,%rcx
cmp    -0x30(%rbp),%eax
mov    -0x40(%rbp),%r13
je     11a0 <optimalBST+0xa0>
nopl   (%rax)
movss  -0x4(%r9,%rcx,4),%xmm0
mov    %ecx,%eax
shl    $0x2,%rax
addss  (%rdi,%rax,1),%xmm0
addss  (%rsi,%rax,1),%xmm0
movss  %xmm0,(%r10,%rax,1)
lea    0x1(%rcx),%eax
movss  (%r9,%rcx,4),%xmm0
addss  (%rdi,%rax,4),%xmm0
addss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
add    $0x2,%rcx
cmp    %ecx,%r13d
jne    1360 <optimalBST+0x260>
jmp    11a0 <optimalBST+0xa0>
cmpl   $0x0,-0x30(%rbp)
mov    -0x70(%rbp),%r12
mov    -0x68(%rbp),%r11
jle    14a4 <optimalBST+0x3a4>
cmpl   $0x1,-0x30(%rbp)
jne    13c7 <optimalBST+0x2c7>
xor    %ecx,%ecx
mov    -0x38(%rbp),%r10
jmp    1458 <optimalBST+0x358>
mov    -0x50(%rbp),%r8
and    $0xfffffffe,%r8d
xor    %edx,%edx
mov    -0x38(%rbp),%r10
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdx,%rsi
or     $0x1,%rsi
mov    %rdx,%rcx
imul   %r13,%rcx
lea    (%r12,%rcx,4),%r9
movss  (%r9,%rdx,4),%xmm0
mov    %rsi,%rbx
imul   %r13,%rbx
lea    (%r12,%rbx,4),%rax
addss  (%rax,%rsi,4),%xmm0
lea    (%r11,%rcx,4),%rdi
addss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%r9,%rsi,4)
lea    (%r10,%rcx,4),%rcx
mov    %esi,(%rcx,%rsi,4)
lea    0x2(%rdx),%rcx
movss  (%rax,%rsi,4),%xmm0
mov    %rcx,%rsi
imul   %r13,%rsi
lea    (%r12,%rsi,4),%rsi
addss  0x8(%rsi,%rdx,4),%xmm0
lea    (%r11,%rbx,4),%rsi
addss  0x8(%rsi,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax,%rdx,4)
lea    (%r10,%rbx,4),%rax
mov    %ecx,0x8(%rax,%rdx,4)
mov    %rcx,%rdx
cmp    %r8,%rcx
jne    13e0 <optimalBST+0x2e0>
testb  $0x1,-0x50(%rbp)
mov    %r10,%r8
je     149e <optimalBST+0x39e>
lea    0x1(%rcx),%rbx
mov    %rcx,%rdx
imul   %r13,%rdx
lea    (%r12,%rdx,4),%rsi
movss  (%rsi,%rcx,4),%xmm0
mov    %rbx,%rdi
imul   %r13,%rdi
lea    (%r12,%rdi,4),%rdi
addss  0x4(%rdi,%rcx,4),%xmm0
lea    (%r11,%rdx,4),%rdi
addss  0x4(%rdi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
lea    (%r8,%rdx,4),%rdx
mov    %ebx,0x4(%rdx,%rcx,4)
cmpl   $0x2,-0x30(%rbp)
jge    14b3 <optimalBST+0x3b3>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x8(%r12),%rcx
mov    %rcx,-0x90(%rbp)
lea    0x0(,%r13,8),%r10
lea    0x4(%r12),%rcx
mov    %rcx,-0x98(%rbp)
mov    $0x2,%edx
jmp    14f1 <optimalBST+0x3f1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
addq   $0x4,-0x90(%rbp)
04
cmp    %r13,%rdx
je     14a4 <optimalBST+0x3a4>
mov    -0x30(%rbp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,-0x30(%rbp)
cmp    -0x50(%rbp),%rdx
ja     14e0 <optimalBST+0x3e0>
mov    -0x30(%rbp),%ecx
mov    %rcx,-0x58(%rbp)
mov    -0x98(%rbp),%rsi
mov    -0x90(%rbp),%r14
xor    %eax,%eax
mov    %rdx,-0x60(%rbp)
jmp    156a <optimalBST+0x46a>
nop
movaps %xmm0,%xmm1
mov    -0x48(%rbp),%rdi
mov    -0x68(%rbp),%rax
lea    (%rax,%r9,4),%rax
addss  (%rax,%rdx,4),%xmm1
movss  %xmm1,(%rdi,%rdx,4)
mov    -0x88(%rbp),%rax
mov    %r11d,(%rax,%rdx,4)
add    $0x4,%r14
add    -0x78(%rbp),%rsi
mov    -0x80(%rbp),%rax
cmp    -0x58(%rbp),%rax
mov    -0x38(%rbp),%r8
mov    -0x70(%rbp),%r12
mov    -0x40(%rbp),%r13
mov    -0x60(%rbp),%rdx
je     14e0 <optimalBST+0x3e0>
add    %rax,%rdx
mov    %rax,%r9
imul   %r13,%r9
lea    (%r8,%r9,4),%rdi
mov    -0x4(%rdi,%rdx,4),%r11d
movslq %r11d,%rbx
lea    (%r12,%r9,4),%rcx
mov    %rcx,-0x48(%rbp)
movss  -0x4(%rcx,%rbx,4),%xmm0
mov    %rbx,%rcx
imul   %r13,%rcx
lea    (%r12,%rcx,4),%rcx
addss  (%rcx,%rdx,4),%xmm0
add    $0x1,%rax
mov    %rax,%rcx
imul   %r13,%rcx
lea    (%r8,%rcx,4),%rcx
movslq (%rcx,%rdx,4),%r15
cmp    %r15d,%ebx
mov    %rdi,-0x88(%rbp)
mov    %rax,-0x80(%rbp)
jge    1520 <optimalBST+0x420>
mov    %r15d,%ecx
sub    %r11d,%ecx
test   $0x1,%cl
jne    15e0 <optimalBST+0x4e0>
mov    %rbx,%r8
mov    -0x48(%rbp),%rdi
jmp    160c <optimalBST+0x50c>
nopl   0x0(%rax)
lea    (%r12,%rdx,4),%r12
lea    0x1(%rbx),%r8
mov    -0x48(%rbp),%rdi
movss  (%rdi,%rbx,4),%xmm1
mov    %r8,%rcx
imul   %r13,%rcx
addss  (%r12,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
cmova  %r8d,%r11d
minss  %xmm0,%xmm1
movaps %xmm1,%xmm0
not    %rbx
add    %r15,%rbx
je     1527 <optimalBST+0x427>
lea    0x2(%r8),%rcx
mov    -0x78(%rbp),%rax
imul   %rax,%rcx
lea    0x1(%r8),%r12
imul   %rax,%r12
mov    %r14,%rbx
nop
movss  -0x4(%rsi,%r8,4),%xmm2
addss  (%rbx,%r12,1),%xmm2
ucomiss %xmm2,%xmm0
lea    0x1(%r8),%r13d
cmovbe %r11d,%r13d
movss  (%rsi,%r8,4),%xmm1
minss  %xmm0,%xmm2
add    $0x2,%r8
addss  (%rbx,%rcx,1),%xmm1
ucomiss %xmm1,%xmm2
mov    %r8d,%r11d
cmovbe %r13d,%r11d
minss  %xmm2,%xmm1
add    %r10,%rbx
movaps %xmm1,%xmm0
cmp    %r8,%r15
jne    1630 <optimalBST+0x530>
jmp    1527 <optimalBST+0x427>

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

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