void tred2(a, n, d, e) float **a, *d, *e;
int n;
{
  int l, k, j, i;
  float scale, hh, h, g, f;
  for (i = n; i >= 2; i--) {
    l = i - 1;
    h = scale = 0.0;
    if (l > 1) {
      for (k = 1; k <= l; k++)
        scale += fabs(a[i][k]);
      if (scale == 0.0)
        e[i] = a[i][l];
      else {
        for (k = 1; k <= l; k++) {
          a[i][k] /= scale;
          h += a[i][k] * a[i][k];
        }
        f = a[i][l];
        g = f > 0 ? -sqrt(h) : sqrt(h);
        e[i] = scale * g;
        h -= f * g;
        a[i][l] = f - g;
        f = 0.0;
        for (j = 1; j <= l; j++) {
          a[j][i] = a[i][j] / h;
          g = 0.0;
          for (k = 1; k <= j; k++)
            g += a[j][k] * a[i][k];
          for (k = j + 1; k <= l; k++)
            g += a[k][j] * a[i][k];
          e[j] = g / h;
          f += e[j] * a[i][j];
        }
        hh = f / (h + h);
        for (j = 1; j <= l; j++) {
          f = a[i][j];
          e[j] = g = e[j] - hh * f;
          for (k = 1; k <= j; k++)
            a[j][k] -= (f * e[k] + g * a[i][k]);
        }
      }
    } else
      e[i] = a[i][l];
    d[i] = h;
  }
  d[1] = 0.0;
  e[1] = 0.0;
  for (i = 1; i <= n; i++) {
    l = i - 1;
    if (d[i]) {
      for (j = 1; j <= l; j++) {
        g = 0.0;
        for (k = 1; k <= l; k++)
          g += a[i][k] * a[k][j];
        for (k = 1; k <= l; k++)
          a[k][j] -= g * a[k][i];
      }
    }
    d[i] = a[i][i];
    a[i][i] = 1.0;
    for (j = 1; j <= l; j++)
      a[j][i] = a[i][j] = 0.0;
  }
}


x86 assembly (clang, -O0):
<tred2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jl     160e <tred2+0x4fe>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
cmpl   $0x1,-0x24(%rbp)
jle    15cc <tred2+0x4bc>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11b5 <tred2+0xa5>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xe83(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1161 <tred2+0x51>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f8 <tred2+0xe8>
jp     11f8 <tred2+0xe8>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    15c7 <tred2+0x4b7>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1278 <tred2+0x168>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ff <tred2+0xef>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    12d2 <tred2+0x1c2>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    12e5 <tred2+0x1d5>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14b9 <tred2+0x3a9>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1401 <tred2+0x2f1>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13ab <tred2+0x29b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1460 <tred2+0x350>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    140a <tred2+0x2fa>
movss  -0x40(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1361 <tred2+0x251>
movss  -0x44(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
addss  -0x3c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     15c2 <tred2+0x4b2>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     15af <tred2+0x49f>
movss  -0x44(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1543 <tred2+0x433>
jmp    15b4 <tred2+0x4a4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d8 <tred2+0x3c8>
jmp    15c7 <tred2+0x4b7>
jmp    15ee <tred2+0x4de>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    112d <tred2+0x1d>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1804 <tred2+0x6f4>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1666 <tred2+0x556>
jp     1666 <tred2+0x556>
jmp    1761 <tred2+0x651>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     175c <tred2+0x64c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     16de <tred2+0x5ce>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1688 <tred2+0x578>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1749 <tred2+0x639>
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%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
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16e5 <tred2+0x5d5>
jmp    174e <tred2+0x63e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    166d <tred2+0x55d>
jmp    1761 <tred2+0x651>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  0x865(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     17f1 <tred2+0x6e1>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17a7 <tred2+0x697>
jmp    17f6 <tred2+0x6e6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    162d <tred2+0x51d>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tred2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r12
mov    %rdx,0x8(%rsp)
mov    %rdi,%r15
mov    %rsi,0x20(%rsp)
cmp    $0x2,%esi
jl     1636 <tred2+0x526>
movabs $0x100000000,%rbx
mov    0x20(%rsp),%r13d
lea    0x4(%r12),%rax
mov    %rax,0x30(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x28(%rsp)
movaps 0xe9f(%rip),%xmm9
xorps  %xmm10,%xmm10
xorpd  %xmm11,%xmm11
movaps 0xeae(%rip),%xmm12
jmp    11a7 <tred2+0x97>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%r12,%r13,4)
xorps  %xmm13,%xmm13
mov    0x8(%rsp),%rax
movss  %xmm13,(%rax,%r13,4)
cmp    $0x2,%r13
mov    %rbp,%r13
jle    1636 <tred2+0x526>
cmp    $0x2,%r13
je     1619 <tred2+0x509>
lea    -0x1(%r13),%rbp
mov    (%r15,%r13,8),%rax
xorps  %xmm1,%xmm1
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
andps  %xmm9,%xmm0
addss  %xmm0,%xmm1
add    $0x1,%rcx
cmp    %rcx,%r13
jne    11d0 <tred2+0xc0>
ucomiss %xmm10,%xmm1
mov    (%r15,%r13,8),%rax
jne    11f2 <tred2+0xe2>
jnp    1180 <tred2+0x70>
xorps  %xmm13,%xmm13
mov    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mulss  %xmm0,%xmm0
addss  %xmm0,%xmm13
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1200 <tred2+0xf0>
movss  (%rax,%rbp,4),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm13,%xmm0
ucomisd %xmm11,%xmm0
jb     123a <tred2+0x12a>
sqrtsd %xmm0,%xmm0
jmp    127c <tred2+0x16c>
movss  %xmm13,0x10(%rsp)
movss  %xmm1,(%rsp)
movss  %xmm3,0x1c(%rsp)
call   1030 <sqrt@plt>
movss  0x1c(%rsp),%xmm3
movss  (%rsp),%xmm1
movss  0x10(%rsp),%xmm13
movaps 0xdb5(%rip),%xmm12
xorpd  %xmm11,%xmm11
xorps  %xmm10,%xmm10
movaps 0xd84(%rip),%xmm9
xorps  %xmm8,%xmm8
ucomiss %xmm8,%xmm3
jbe    128d <tred2+0x17d>
xorps  0xd83(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  %xmm0,%xmm1
movss  %xmm1,(%r12,%r13,4)
movaps %xmm3,%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm13
subss  %xmm0,%xmm3
mov    (%r15,%r13,8),%rax
mov    %rbp,(%rsp)
movss  %xmm3,(%rax,%rbp,4)
lea    0x8(%rax),%r10
mov    $0x1,%ecx
movabs $0x300000000,%r9
mov    0x28(%rsp),%r11
xor    %r8d,%r8d
jmp    130c <tred2+0x1fc>
cs nopw 0x0(%rax,%rax,1)
nop
divss  %xmm13,%xmm0
movss  %xmm0,(%r12,%rcx,4)
mulss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm8
add    $0x4,%r10
add    $0x8,%r11
add    %rbx,%r9
mov    %rdx,%rcx
cmp    %r13,%rdx
je     1420 <tred2+0x310>
mov    %r8,%rsi
add    $0x1,%r8
movss  (%rax,%rcx,4),%xmm0
divss  %xmm13,%xmm0
mov    (%r15,%rcx,8),%rbp
movss  %xmm0,0x0(%rbp,%r13,4)
xorps  %xmm0,%xmm0
mov    $0x1,%edx
cmp    $0x3,%rsi
jb     139d <tred2+0x28d>
mov    %rcx,%rdi
and    $0xfffffffffffffffc,%rdi
xorps  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x4(%rbp,%rdx,4),%xmm2
movss  0x8(%rbp,%rdx,4),%xmm3
mulss  0x4(%rax,%rdx,4),%xmm2
mulss  0x8(%rax,%rdx,4),%xmm3
addss  %xmm0,%xmm2
movss  0xc(%rbp,%rdx,4),%xmm4
mulss  0xc(%rax,%rdx,4),%xmm4
addss  %xmm2,%xmm3
movss  0x10(%rbp,%rdx,4),%xmm0
mulss  0x10(%rax,%rdx,4),%xmm0
addss  %xmm3,%xmm4
addss  %xmm4,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rdi
jne    1350 <tred2+0x240>
add    $0x1,%rdx
test   $0x3,%r8b
je     13d7 <tred2+0x2c7>
mov    %ecx,%edi
and    $0x3,%edi
lea    (%rax,%rdx,4),%rsi
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  (%rdx,%rbp,4),%xmm2
mulss  (%rsi,%rbp,4),%xmm2
addss  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    13c0 <tred2+0x2b0>
lea    0x1(%rcx),%rdx
cmp    %r13,%rdx
jge    12e0 <tred2+0x1d0>
mov    %r9,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%r11,%rbp,2),%rsi
movss  (%rsi,%rcx,4),%xmm2
mulss  (%r10,%rbp,1),%xmm2
addss  %xmm2,%xmm0
mov    %rdi,%rsi
sar    $0x20,%rsi
add    $0x4,%rbp
add    %rbx,%rdi
cmp    %r13,%rsi
jl     13f0 <tred2+0x2e0>
jmp    12e0 <tred2+0x1d0>
nopl   0x0(%rax,%rax,1)
movaps %xmm13,%xmm0
addss  %xmm13,%xmm0
xorps  %xmm12,%xmm8
divss  %xmm0,%xmm8
lea    0x4(%rax),%rcx
mov    %rcx,0x10(%rsp)
mov    $0x2,%edx
mov    $0x1,%r10d
xor    %r9d,%r9d
jmp    1461 <tred2+0x351>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x1,%rdx
cmp    %r13,%r10
je     1610 <tred2+0x500>
mov    %r9,%rsi
add    $0x1,%r9
movss  (%rax,%r10,4),%xmm0
movaps %xmm8,%xmm2
mulss  %xmm0,%xmm2
addss  (%r12,%r10,4),%xmm2
movss  %xmm2,(%r12,%r10,4)
mov    (%r15,%r10,8),%rcx
mov    $0x1,%edi
cmp    $0x8,%r9
jb     1570 <tred2+0x460>
add    $0x2,%rsi
lea    (%rax,%rsi,4),%r11
lea    (%r12,%rsi,4),%rbp
lea    0x4(%rcx),%rdi
lea    (%rcx,%rsi,4),%r14
cmp    %rbp,%rdi
setb   %bpl
cmp    %r14,0x30(%rsp)
setb   %r8b
cmp    %r11,%rdi
setb   %sil
cmp    %r14,0x10(%rsp)
setb   %r11b
mov    $0x1,%edi
test   %r8b,%bpl
jne    1570 <tred2+0x460>
mov    $0x1,%edi
and    %r11b,%sil
jne    1570 <tred2+0x460>
mov    %r10,%rsi
and    $0xfffffffffffffff8,%rsi
mov    %r9,%r11
and    $0xfffffffffffffff8,%r11
lea    0x1(%r11),%rdi
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
movaps %xmm0,%xmm4
shufps $0x0,%xmm0,%xmm4
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups 0x4(%r12,%rbp,4),%xmm5
movups 0x14(%r12,%rbp,4),%xmm6
movups 0x4(%rax,%rbp,4),%xmm7
movups 0x14(%rax,%rbp,4),%xmm1
mulps  %xmm3,%xmm7
mulps  %xmm3,%xmm1
mulps  %xmm4,%xmm5
addps  %xmm7,%xmm5
mulps  %xmm4,%xmm6
addps  %xmm1,%xmm6
movups 0x4(%rcx,%rbp,4),%xmm1
subps  %xmm5,%xmm1
movups 0x14(%rcx,%rbp,4),%xmm5
subps  %xmm6,%xmm5
movups %xmm1,0x4(%rcx,%rbp,4)
movups %xmm5,0x14(%rcx,%rbp,4)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1510 <tred2+0x400>
cmp    %r11,%r9
je     1450 <tred2+0x340>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdi,%rbp
test   $0x1,%dl
jne    15a1 <tred2+0x491>
movss  (%rax,%rdi,4),%xmm1
mulss  %xmm2,%xmm1
movss  (%r12,%rdi,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
movss  (%rcx,%rdi,4),%xmm1
subss  %xmm3,%xmm1
movss  %xmm1,(%rcx,%rdi,4)
lea    0x1(%rdi),%rbp
cmp    %rdi,%r9
je     1450 <tred2+0x340>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rbp,4),%xmm1
mulss  %xmm2,%xmm1
movss  (%r12,%rbp,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
movss  (%rcx,%rbp,4),%xmm1
subss  %xmm3,%xmm1
movss  0x4(%rcx,%rbp,4),%xmm3
movss  %xmm1,(%rcx,%rbp,4)
movss  0x4(%rax,%rbp,4),%xmm1
mulss  %xmm2,%xmm1
movss  0x4(%r12,%rbp,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,0x4(%rcx,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    15b0 <tred2+0x4a0>
jmp    1450 <tred2+0x340>
nopl   0x0(%rax)
mov    (%rsp),%rbp
jmp    118f <tred2+0x7f>
mov    0x10(%r15),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,0x8(%r12)
mov    0x8(%rsp),%rax
movl   $0x0,(%rax,%r13,4)
mov    0x8(%rsp),%r13
movl   $0x0,0x4(%r13)
movl   $0x0,0x4(%r12)
mov    0x20(%rsp),%r12
test   %r12d,%r12d
jle    18e0 <tred2+0x7d0>
add    $0x1,%r12d
mov    $0x1,%eax
xor    %r9d,%r9d
xorps  %xmm0,%xmm0
movaps 0x9b0(%rip),%xmm1
jmp    1691 <tred2+0x581>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x1,%r9
cmp    %r12,%rax
je     18e0 <tred2+0x7d0>
mov    %r9d,%r11d
and    $0x3,%r11d
mov    %r9,%r10
and    $0xfffffffffffffffc,%r10
lea    -0x1(%r9),%r8
movss  0x0(%r13,%rax,4),%xmm2
ucomiss %xmm0,%xmm2
jne    16b5 <tred2+0x5a5>
jnp    1810 <tred2+0x700>
cmp    $0x2,%rax
jb     1810 <tred2+0x700>
mov    %r9,%r14
and    $0xfffffffffffffffe,%r14
neg    %r14
mov    (%r15,%rax,8),%rdi
mov    $0x1,%ebp
jmp    16ed <tred2+0x5dd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %rax,%rbp
je     1810 <tred2+0x700>
xorps  %xmm2,%xmm2
mov    $0x1,%esi
cmp    $0x3,%r8
jb     175d <tred2+0x64d>
xorps  %xmm2,%xmm2
xor    %esi,%esi
movss  0x4(%rdi,%rsi,4),%xmm3
movss  0x8(%rdi,%rsi,4),%xmm4
mov    0x8(%r15,%rsi,8),%rcx
mov    0x10(%r15,%rsi,8),%rdx
mulss  (%rcx,%rbp,4),%xmm3
addss  %xmm2,%xmm3
mulss  (%rdx,%rbp,4),%xmm4
addss  %xmm3,%xmm4
movss  0xc(%rdi,%rsi,4),%xmm3
mov    0x18(%r15,%rsi,8),%rcx
mulss  (%rcx,%rbp,4),%xmm3
movss  0x10(%rdi,%rsi,4),%xmm2
mov    0x20(%r15,%rsi,8),%rcx
mulss  (%rcx,%rbp,4),%xmm2
addss  %xmm4,%xmm3
addss  %xmm3,%xmm2
add    $0x4,%rsi
cmp    %rsi,%r10
jne    1700 <tred2+0x5f0>
add    $0x1,%rsi
test   $0x3,%r9b
je     178b <tred2+0x67b>
lea    (%r15,%rsi,8),%rdx
lea    (%rdi,%rsi,4),%rsi
xor    %ecx,%ecx
nopl   (%rax)
movss  (%rsi,%rcx,4),%xmm3
mov    (%rdx,%rcx,8),%rbx
mulss  (%rbx,%rbp,4),%xmm3
addss  %xmm3,%xmm2
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1770 <tred2+0x660>
xorps  %xmm1,%xmm2
mov    $0x1,%esi
cmp    $0x1,%r9
je     17e1 <tred2+0x6d1>
mov    $0x1,%esi
xchg   %ax,%ax
mov    (%r15,%rsi,8),%rcx
movss  (%rcx,%rax,4),%xmm3
mulss  %xmm2,%xmm3
addss  (%rcx,%rbp,4),%xmm3
movss  %xmm3,(%rcx,%rbp,4)
mov    0x8(%r15,%rsi,8),%rcx
movss  (%rcx,%rax,4),%xmm3
mulss  %xmm2,%xmm3
addss  (%rcx,%rbp,4),%xmm3
movss  %xmm3,(%rcx,%rbp,4)
lea    (%r14,%rsi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rsi
cmp    $0x1,%rcx
jne    17a0 <tred2+0x690>
test   $0x1,%r9b
je     16e0 <tred2+0x5d0>
mov    (%r15,%rsi,8),%rcx
mulss  (%rcx,%rax,4),%xmm2
addss  (%rcx,%rbp,4),%xmm2
movss  %xmm2,(%rcx,%rbp,4)
jmp    16e0 <tred2+0x5d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rax,8),%rcx
movss  (%rcx,%rax,4),%xmm2
movss  %xmm2,0x0(%r13,%rax,4)
movl   $0x3f800000,(%rcx,%rax,4)
cmp    $0x2,%rax
jb     1680 <tred2+0x570>
mov    $0x1,%esi
cmp    $0x3,%r8
jb     189d <tred2+0x78d>
xor    %esi,%esi
xchg   %ax,%ax
movl   $0x0,0x4(%rcx,%rsi,4)
mov    0x8(%r15,%rsi,8),%rdx
movl   $0x0,(%rdx,%rax,4)
movl   $0x0,0x8(%rcx,%rsi,4)
mov    0x10(%r15,%rsi,8),%rdx
movl   $0x0,(%rdx,%rax,4)
movl   $0x0,0xc(%rcx,%rsi,4)
mov    0x18(%r15,%rsi,8),%rdx
movl   $0x0,(%rdx,%rax,4)
movl   $0x0,0x10(%rcx,%rsi,4)
mov    0x20(%r15,%rsi,8),%rdx
movl   $0x0,(%rdx,%rax,4)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    1840 <tred2+0x730>
add    $0x1,%rsi
test   $0x3,%r9b
je     1680 <tred2+0x570>
lea    (%r15,%rsi,8),%rdx
lea    (%rcx,%rsi,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rcx,%rsi,4)
mov    (%rdx,%rsi,8),%rdi
movl   $0x0,(%rdi,%rax,4)
add    $0x1,%rsi
cmp    %rsi,%r11
jne    18c0 <tred2+0x7b0>
jmp    1680 <tred2+0x570>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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