mom_solve(matrix, vector, irow, ilead) int irow, ilead;
float (*matrix)[];
float (*vector)[];
{
  float quotient;
  int i, j, k;
  int mpi, mpj, mpk;
  mpi = 0;
  for (i = 0; i < irow - 1; i++) {
    j = i;
    mpj = mpi;
    while ((*matrix)[mpi + i] == 0) {
      if (j == irow) {
        return (-1);
      }
      j++;
      mpj += ilead;
      (*vector)[i] += (*vector)[j];
      for (k = i; k < irow; k++) {
        (*matrix)[mpi + k] += (*matrix)[mpj + k];
      }
    }
    mpj = mpi + ilead;
    for (j = i + 1; j < irow; j++) {
      if ((*matrix)[mpj + i] != 0) {
        quotient = (*matrix)[mpj + i] / (*matrix)[mpi + i];
        (*vector)[j] -= (*vector)[i] * quotient;
        for (k = i; k < irow; k++) {
          (*matrix)[mpj + k] -= (*matrix)[mpi + k] * quotient;
        }
      }
      mpj += ilead;
    }
    mpi += ilead;
  }
  mpi = 0;
  for (i = 0; i < irow - 1; i++) {
    k = irow - i - 1;
    mpj = 0;
    mpk = k * ilead;
    for (j = 0; j < k; j++) {
      (*vector)[j] -= (*matrix)[mpj + k] / (*matrix)[mpk + k] * (*vector)[k];
      mpj += ilead;
    }
  }
  mpi = 0;
  for (i = 0; i < irow; i++) {
    (*vector)[i] /= (*matrix)[mpi + i];
    mpi += ilead;
  }
  return (0);
}


x86 assembly (clang, -O0):
<mom_solve>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1339 <mom_solve+0x239>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11f8 <mom_solve+0xf8>
jp     11f8 <mom_solve+0xf8>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1179 <mom_solve+0x79>
movl   $0xffffffff,-0x4(%rbp)
jmp    146b <mom_solve+0x36b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11f3 <mom_solve+0xf3>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11b0 <mom_solve+0xb0>
jmp    113d <mom_solve+0x3d>
mov    -0x34(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1322 <mom_solve+0x222>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    123f <mom_solve+0x13f>
jp     123f <mom_solve+0x13f>
jmp    130b <mom_solve+0x20b>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1306 <mom_solve+0x206>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12a8 <mom_solve+0x1a8>
jmp    130b <mom_solve+0x20b>
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120a <mom_solve+0x10a>
mov    -0x20(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1120 <mom_solve+0x20>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    140b <mom_solve+0x30b>
mov    -0x1c(%rbp),%eax
sub    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13f8 <mom_solve+0x2f8>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    137c <mom_solve+0x27c>
jmp    13fd <mom_solve+0x2fd>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1347 <mom_solve+0x247>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1464 <mom_solve+0x364>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1419 <mom_solve+0x319>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<mom_solve>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdi,%r15
cmp    $0x2,%edx
jl     178b <mom_solve+0x68b>
lea    -0x1(%rdx),%eax
movslq %ecx,%rbp
mov    %rdx,0x58(%rsp)
mov    %edx,%r10d
mov    %rax,0x50(%rsp)
mov    %eax,%eax
mov    %rax,-0x18(%rsp)
lea    0x0(,%rbp,4),%rdi
lea    0x4(,%rbp,4),%r9
lea    (%r10,%rbp,1),%rdx
mov    %rdx,0x68(%rsp)
mov    %r10,%rdx
neg    %rdx
mov    %rdx,0x40(%rsp)
lea    0x30(%r15),%rbx
lea    (%r15,%rbp,4),%rdx
add    $0x30,%rdx
mov    %rdx,0x18(%rsp)
lea    -0x8(%r10),%rdx
mov    %rdx,0x10(%rsp)
lea    0x4(%r15),%r13
mov    %rbp,-0x70(%rsp)
lea    (%r15,%rbp,4),%rdx
mov    %rdx,0x8(%rsp)
lea    0x10(%r15),%rdx
mov    $0x1,%ebp
mov    %rbp,-0x8(%rsp)
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
mov    %r15,%r8
mov    %rdx,(%rsp)
mov    %r10,-0x10(%rsp)
mov    %r13,0x60(%rsp)
mov    %ecx,-0x54(%rsp)
xor    %eax,%eax
mov    %rdi,-0x28(%rsp)
mov    %rsi,0x38(%rsp)
mov    %r15,-0x60(%rsp)
mov    %ecx,-0x1c(%rsp)
mov    %r9,0x70(%rsp)
jmp    122e <mom_solve+0x12e>
nopl   0x0(%rax,%rax,1)
mov    -0x68(%rsp),%rbp
add    -0x70(%rsp),%rbp
mov    -0x1c(%rsp),%ecx
add    %ecx,-0x54(%rsp)
addq   $0x1,-0x8(%rsp)
mov    0x70(%rsp),%r9
add    %r9,%rbx
add    %r9,0x18(%rsp)
addq   $0xffffffffffffffff,0x10(%rsp)
add    %rdi,%r13
add    %rdi,0x8(%rsp)
addq   $0xffffffffffffffff,-0x10(%rsp)
mov    0x20(%rsp),%rdx
add    %r9,%rdx
addq   $0x4,(%rsp)
add    %rdi,%r8
mov    -0x50(%rsp),%rax
cmp    -0x18(%rsp),%rax
mov    0x38(%rsp),%rsi
je     1711 <mom_solve+0x611>
mov    %rdx,0x20(%rsp)
mov    %rax,%rdx
mov    %r10,%rcx
sub    %rax,%rcx
mov    %rcx,-0x78(%rsp)
imul   %rax,%r9
mov    %r9,-0x38(%rsp)
lea    (%r15,%r9,1),%rax
mov    %rax,0x28(%rsp)
lea    (%r10,%rbp,1),%rcx
lea    (%r15,%rcx,4),%rax
mov    %rax,0x30(%rsp)
mov    %rbp,%rax
mov    %rbp,-0x68(%rsp)
mov    %rdx,-0x80(%rsp)
lea    (%rdx,%rbp,1),%rax
mov    %rax,0x48(%rsp)
movss  (%r15,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jne    14e0 <mom_solve+0x3e0>
jp     14e0 <mom_solve+0x3e0>
mov    0x10(%rsp),%rax
shr    $0x3,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x78(%rsp)
mov    -0x78(%rsp),%rcx
lea    -0x8(%rcx),%rax
mov    %rax,-0x40(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,-0x48(%rsp)
mov    0x68(%rsp),%rax
mov    -0x68(%rsp),%r14
add    %r14,%rax
mov    %rax,-0x30(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    -0x80(%rsp),%rbp
mov    %rcx,-0x50(%rsp)
lea    (%rcx,%rbp,1),%rax
mov    %rax,0x80(%rsp)
mov    0x8(%rsp),%r12
mov    0x18(%rsp),%r9
xor    %r11d,%r11d
jmp    1328 <mom_solve+0x228>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
mov    0x48(%rsp),%rax
movss  (%r15,%rax,4),%xmm1
add    $0x1,%r11
add    %rdi,%r9
add    %rdi,%r12
ucomiss %xmm0,%xmm1
jne    14e0 <mom_solve+0x3e0>
jp     14e0 <mom_solve+0x3e0>
cmp    %r10,%rbp
je     1707 <mom_solve+0x607>
add    -0x70(%rsp),%r14
movss  0x4(%rsi,%rbp,4),%xmm1
mov    -0x80(%rsp),%rax
addss  (%rsi,%rax,4),%xmm1
movss  %xmm1,(%rsi,%rax,4)
cmp    %r10,%rax
jae    1300 <mom_solve+0x200>
mov    -0x80(%rsp),%rcx
cmpq   $0x8,-0x78(%rsp)
jb     1460 <mom_solve+0x360>
mov    %r11,%rdx
imul   -0x70(%rsp),%rdx
mov    -0x30(%rsp),%rax
add    %rdx,%rax
lea    (%r15,%rax,4),%rax
cmp    %rax,0x28(%rsp)
jae    139b <mom_solve+0x29b>
add    -0x70(%rsp),%rdx
lea    (%r15,%rdx,4),%rax
add    -0x38(%rsp),%rax
mov    -0x80(%rsp),%rcx
cmp    0x30(%rsp),%rax
jb     1460 <mom_solve+0x360>
cmpq   $0x8,-0x40(%rsp)
jae    13a7 <mom_solve+0x2a7>
xor    %edx,%edx
jmp    1403 <mom_solve+0x303>
mov    0x78(%rsp),%rax
xor    %edx,%edx
xchg   %ax,%ax
movups -0x30(%r9,%rdx,4),%xmm1
movups -0x20(%r9,%rdx,4),%xmm2
movups -0x30(%rbx,%rdx,4),%xmm3
addps  %xmm1,%xmm3
movups -0x20(%rbx,%rdx,4),%xmm1
addps  %xmm2,%xmm1
movups -0x10(%rbx,%rdx,4),%xmm2
movups (%rbx,%rdx,4),%xmm4
movups %xmm3,-0x30(%rbx,%rdx,4)
movups %xmm1,-0x20(%rbx,%rdx,4)
movups -0x10(%r9,%rdx,4),%xmm1
addps  %xmm2,%xmm1
movups (%r9,%rdx,4),%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rbx,%rdx,4)
movups %xmm2,(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    13b0 <mom_solve+0x2b0>
testb  $0x1,-0x48(%rsp)
je     143f <mom_solve+0x33f>
add    -0x80(%rsp),%rdx
lea    (%rdx,%r14,1),%rax
movups (%r15,%rax,4),%xmm1
movups 0x10(%r15,%rax,4),%xmm2
add    -0x68(%rsp),%rdx
movups (%r15,%rdx,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%r15,%rdx,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
mov    0x80(%rsp),%rcx
mov    -0x50(%rsp),%rax
cmp    %rax,-0x78(%rsp)
je     1300 <mom_solve+0x200>
nopw   0x0(%rax,%rax,1)
mov    %r10d,%eax
sub    %ecx,%eax
mov    %rcx,%rdx
test   $0x1,%al
je     148e <mom_solve+0x38e>
lea    (%rcx,%r14,1),%rax
movss  (%r15,%rax,4),%xmm1
mov    -0x68(%rsp),%rax
add    %rcx,%rax
addss  (%r15,%rax,4),%xmm1
movss  %xmm1,(%r15,%rax,4)
lea    0x1(%rcx),%rdx
not    %rcx
cmp    0x40(%rsp),%rcx
je     1300 <mom_solve+0x200>
nopl   0x0(%rax)
movss  (%r12,%rdx,4),%xmm1
addss  -0x4(%r13,%rdx,4),%xmm1
movss  %xmm1,-0x4(%r13,%rdx,4)
movss  0x4(%r12,%rdx,4),%xmm1
addss  0x0(%r13,%rdx,4),%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    14a0 <mom_solve+0x3a0>
jmp    1300 <mom_solve+0x200>
nopw   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rsp)
cmp    %r10,%rax
jae    11d0 <mom_solve+0xd0>
movslq -0x54(%rsp),%rcx
mov    0x60(%rsp),%rax
lea    (%rax,%rcx,4),%rbp
mov    (%rsp),%rax
lea    (%rax,%rcx,4),%rdx
mov    -0x10(%rsp),%r9
and    $0xfffffffffffffff8,%r9
mov    -0x80(%rsp),%rax
lea    (%rax,%rcx,1),%rsi
mov    %rsi,-0x30(%rsp)
lea    (%r10,%rcx,1),%rsi
mov    %rsi,-0x38(%rsp)
mov    -0x78(%rsp),%rsi
and    $0xfffffffffffffff8,%rsi
mov    %rsi,-0x40(%rsp)
add    %rsi,%rax
mov    %rax,-0x48(%rsp)
xor    %r12d,%r12d
mov    -0x8(%rsp),%r14
jmp    1571 <mom_solve+0x471>
nopl   (%rax)
add    -0x70(%rsp),%rcx
add    $0x1,%r14
add    $0x1,%r12
add    %rdi,%rdx
add    %rdi,%rbp
cmp    %r10,%r14
mov    -0x60(%rsp),%r15
je     11d0 <mom_solve+0xd0>
mov    -0x80(%rsp),%rax
add    %rcx,%rax
movss  (%r15,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jne    1586 <mom_solve+0x486>
jnp    1550 <mom_solve+0x450>
mov    -0x60(%rsp),%rax
mov    0x48(%rsp),%rsi
divss  (%rax,%rsi,4),%xmm1
mov    0x38(%rsp),%rax
movss  (%rax,%r14,4),%xmm2
mov    -0x80(%rsp),%r11
movss  (%rax,%r11,4),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,(%rax,%r14,4)
cmpq   $0x8,-0x78(%rsp)
jb     1670 <mom_solve+0x570>
mov    %r12,%rsi
imul   -0x70(%rsp),%rsi
mov    -0x30(%rsp),%rax
add    %rsi,%rax
mov    -0x60(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
mov    -0x28(%rsp),%rdi
cmp    0x30(%rsp),%rax
jae    1605 <mom_solve+0x505>
add    -0x38(%rsp),%rsi
mov    -0x60(%rsp),%rax
lea    (%rax,%rsi,4),%rax
mov    -0x80(%rsp),%r11
cmp    %rax,0x28(%rsp)
jb     1670 <mom_solve+0x570>
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
xor    %esi,%esi
mov    0x20(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rax,%rsi,4),%xmm3
movups (%rax,%rsi,4),%xmm4
movups -0x10(%rdx,%rsi,4),%xmm5
movups (%rdx,%rsi,4),%xmm6
mulps  %xmm2,%xmm3
subps  %xmm3,%xmm5
mulps  %xmm2,%xmm4
subps  %xmm4,%xmm6
movups %xmm5,-0x10(%rdx,%rsi,4)
movups %xmm6,(%rdx,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%r9
jne    1620 <mom_solve+0x520>
mov    -0x48(%rsp),%r11
mov    -0x40(%rsp),%rax
cmp    %rax,-0x78(%rsp)
je     1550 <mom_solve+0x450>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r10d,%eax
sub    %r11d,%eax
mov    %r11,%r15
test   $0x1,%al
je     16ae <mom_solve+0x5ae>
mov    -0x68(%rsp),%rax
add    %r11,%rax
lea    (%r11,%rcx,1),%rsi
mov    -0x60(%rsp),%rdi
movss  (%rdi,%rsi,4),%xmm2
movss  (%rdi,%rax,4),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,(%rdi,%rsi,4)
mov    -0x28(%rsp),%rdi
lea    0x1(%r11),%r15
not    %r11
cmp    0x40(%rsp),%r11
je     1550 <mom_solve+0x450>
nopl   0x0(%rax)
movss  (%r8,%r15,4),%xmm2
mulss  %xmm1,%xmm2
movss  -0x4(%rbp,%r15,4),%xmm3
subss  %xmm2,%xmm3
movss  0x0(%rbp,%r15,4),%xmm2
movss  %xmm3,-0x4(%rbp,%r15,4)
movss  0x4(%r8,%r15,4),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%r15,4)
add    $0x2,%r15
cmp    %r15,%r10
jne    16c0 <mom_solve+0x5c0>
jmp    1550 <mom_solve+0x450>
mov    $0xffffffff,%eax
jmp    1853 <mom_solve+0x753>
mov    0x58(%rsp),%rdx
cmp    $0x2,%edx
mov    0x50(%rsp),%r9
jl     178b <mom_solve+0x68b>
xor    %r8d,%r8d
mov    -0x28(%rsp),%r10
jmp    173f <mom_solve+0x63f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0xffffffff,%r9d
cmp    -0x18(%rsp),%r8
je     178b <mom_solve+0x68b>
mov    %r9d,%r9d
mov    %r8d,%ebp
not    %ebp
add    %edx,%ebp
test   %ebp,%ebp
jle    1730 <mom_solve+0x630>
lea    (%r15,%r9,4),%rax
mov    %ebp,%edi
imul   %ecx,%edi
add    %ebp,%edi
movslq %edi,%rbx
mov    %ebp,%ebp
xor    %edi,%edi
nop
movss  (%rax),%xmm0
divss  (%r15,%rbx,4),%xmm0
movss  (%rsi,%rdi,4),%xmm1
mulss  (%rsi,%rbp,4),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
add    $0x1,%rdi
add    %r10,%rax
cmp    %rdi,%r9
jne    1760 <mom_solve+0x660>
jmp    1730 <mom_solve+0x630>
test   %edx,%edx
jle    1851 <mom_solve+0x751>
movslq %ecx,%rcx
mov    %edx,%r8d
cmp    $0x4,%edx
jb     17d9 <mom_solve+0x6d9>
lea    -0x1(%r8),%rax
lea    0x4(,%rcx,4),%rdx
imul   %rax,%rdx
add    %r15,%rdx
cmp    %r15,%rdx
mov    %rdx,%rax
cmova  %r15,%rax
cmovb  %r15,%rdx
add    $0x4,%rdx
cmp    %rsi,%rdx
jbe    1865 <mom_solve+0x765>
lea    (%rsi,%r8,4),%rdx
cmp    %rdx,%rax
jae    1865 <mom_solve+0x765>
xor    %ebx,%ebx
xor    %r10d,%r10d
mov    %rbx,%rdx
not    %rdx
test   $0x1,%r8b
je     1805 <mom_solve+0x705>
lea    (%r10,%rbx,1),%rax
movss  (%rsi,%rbx,4),%xmm0
divss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
add    %rcx,%r10
or     $0x1,%rbx
xor    %eax,%eax
add    %r8,%rdx
je     1853 <mom_solve+0x753>
add    %rbx,%r10
lea    0x8(,%rcx,8),%rdx
add    %r10,%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rbx,4),%xmm0
divss  (%r15,%r10,4),%xmm0
movss  0x4(%rsi,%rbx,4),%xmm1
movss  %xmm0,(%rsi,%rbx,4)
divss  0x4(%r15,%rcx,4),%xmm1
movss  %xmm1,0x4(%rsi,%rbx,4)
add    $0x2,%rbx
add    %rdx,%r15
cmp    %rbx,%r8
jne    1820 <mom_solve+0x720>
jmp    1853 <mom_solve+0x753>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8d,%ebx
and    $0xfffffffc,%ebx
mov    %rbx,%r10
imul   %rcx,%r10
lea    0x0(,%rcx,4),%rax
lea    (%rax,%rax,2),%r9
mov    %rcx,%r11
shl    $0x4,%r11
add    $0x10,%r11
lea    0x0(,%r8,4),%rbp
and    $0xfffffffffffffff0,%rbp
xor    %edx,%edx
mov    %r15,%rax
nopw   0x0(%rax,%rax,1)
movss  0xc(%rax,%r9,1),%xmm0
movss  0x8(%rax,%rcx,8),%xmm1
unpcklps %xmm0,%xmm1
movss  0x4(%rax,%rcx,4),%xmm0
movss  (%rax),%xmm2
unpcklps %xmm0,%xmm2
movlhps %xmm1,%xmm2
movups (%rsi,%rdx,1),%xmm0
divps  %xmm2,%xmm0
movups %xmm0,(%rsi,%rdx,1)
add    %r11,%rax
add    $0x10,%rdx
cmp    %rdx,%rbp
jne    18a0 <mom_solve+0x7a0>
xor    %eax,%eax
cmp    %r8,%rbx
jne    17de <mom_solve+0x6de>
jmp    1853 <mom_solve+0x753>

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

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