float slevmar_L2nrmxmy(float *e, float *x, float *y, int n) {
  const int blocksize = 8, bpwr = 3;
  register int i;
  int j1, j2, j3, j4, j5, j6, j7;
  int blockn;
  register float sum0 = 0.0, sum1 = 0.0, sum2 = 0.0, sum3 = 0.0;
  blockn = (n >> bpwr) << bpwr;
  if (x) {
    for (i = blockn - 1; i > 0; i -= blocksize) {
      e[i] = x[i] - y[i];
      sum0 += e[i] * e[i];
      j1 = i - 1;
      e[j1] = x[j1] - y[j1];
      sum1 += e[j1] * e[j1];
      j2 = i - 2;
      e[j2] = x[j2] - y[j2];
      sum2 += e[j2] * e[j2];
      j3 = i - 3;
      e[j3] = x[j3] - y[j3];
      sum3 += e[j3] * e[j3];
      j4 = i - 4;
      e[j4] = x[j4] - y[j4];
      sum0 += e[j4] * e[j4];
      j5 = i - 5;
      e[j5] = x[j5] - y[j5];
      sum1 += e[j5] * e[j5];
      j6 = i - 6;
      e[j6] = x[j6] - y[j6];
      sum2 += e[j6] * e[j6];
      j7 = i - 7;
      e[j7] = x[j7] - y[j7];
      sum3 += e[j7] * e[j7];
    }
    i = blockn;
    if (i < n) {
      switch (n - i) {
      case 7:
        e[i] = x[i] - y[i];
        sum0 += e[i] * e[i];
        ++i;
      case 6:
        e[i] = x[i] - y[i];
        sum1 += e[i] * e[i];
        ++i;
      case 5:
        e[i] = x[i] - y[i];
        sum2 += e[i] * e[i];
        ++i;
      case 4:
        e[i] = x[i] - y[i];
        sum3 += e[i] * e[i];
        ++i;
      case 3:
        e[i] = x[i] - y[i];
        sum0 += e[i] * e[i];
        ++i;
      case 2:
        e[i] = x[i] - y[i];
        sum1 += e[i] * e[i];
        ++i;
      case 1:
        e[i] = x[i] - y[i];
        sum2 += e[i] * e[i];
      }
    }
  } else {
    for (i = blockn - 1; i > 0; i -= blocksize) {
      e[i] = -y[i];
      sum0 += e[i] * e[i];
      j1 = i - 1;
      e[j1] = -y[j1];
      sum1 += e[j1] * e[j1];
      j2 = i - 2;
      e[j2] = -y[j2];
      sum2 += e[j2] * e[j2];
      j3 = i - 3;
      e[j3] = -y[j3];
      sum3 += e[j3] * e[j3];
      j4 = i - 4;
      e[j4] = -y[j4];
      sum0 += e[j4] * e[j4];
      j5 = i - 5;
      e[j5] = -y[j5];
      sum1 += e[j5] * e[j5];
      j6 = i - 6;
      e[j6] = -y[j6];
      sum2 += e[j6] * e[j6];
      j7 = i - 7;
      e[j7] = -y[j7];
      sum3 += e[j7] * e[j7];
    }
    i = blockn;
    if (i < n) {
      switch (n - i) {
      case 7:
        e[i] = -y[i];
        sum0 += e[i] * e[i];
        ++i;
      case 6:
        e[i] = -y[i];
        sum1 += e[i] * e[i];
        ++i;
      case 5:
        e[i] = -y[i];
        sum2 += e[i] * e[i];
        ++i;
      case 4:
        e[i] = -y[i];
        sum3 += e[i] * e[i];
        ++i;
      case 3:
        e[i] = -y[i];
        sum0 += e[i] * e[i];
        ++i;
      case 2:
        e[i] = -y[i];
        sum1 += e[i] * e[i];
        ++i;
      case 1:
        e[i] = -y[i];
        sum2 += e[i] * e[i];
      }
    }
  }
  return sum0 + sum1 + sum2 + sum3;
}


x86 assembly (clang, -O0):
<slevmar_L2nrmxmy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x8,-0x20(%rbp)
movl   $0x3,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
sar    $0x3,%eax
shl    $0x3,%eax
mov    %eax,-0x48(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1714 <slevmar_L2nrmxmy+0x614>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1450 <slevmar_L2nrmxmy+0x350>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    1161 <slevmar_L2nrmxmy+0x61>
mov    -0x48(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    170f <slevmar_L2nrmxmy+0x60f>
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%eax
not    %eax
add    %ecx,%eax
mov    %eax,%ecx
mov    %rcx,-0x60(%rbp)
sub    $0x6,%eax
ja     170a <slevmar_L2nrmxmy+0x60a>
mov    -0x60(%rbp),%rax
lea    0xb96(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    170f <slevmar_L2nrmxmy+0x60f>
jmp    1cd0 <slevmar_L2nrmxmy+0xbd0>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1a0c <slevmar_L2nrmxmy+0x90c>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    171d <slevmar_L2nrmxmy+0x61d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1ccb <slevmar_L2nrmxmy+0xbcb>
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%eax
not    %eax
add    %ecx,%eax
mov    %eax,%ecx
mov    %rcx,-0x68(%rbp)
sub    $0x6,%eax
ja     1cc6 <slevmar_L2nrmxmy+0xbc6>
mov    -0x68(%rbp),%rax
lea    0x5be(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    1ccb <slevmar_L2nrmxmy+0xbcb>
jmp    1cd0 <slevmar_L2nrmxmy+0xbd0>
movss  -0x4c(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<slevmar_L2nrmxmy>:
mov    %ecx,%r8d
and    $0xfffffff8,%r8d
xorps  %xmm1,%xmm1
test   %rsi,%rsi
je     1344 <slevmar_L2nrmxmy+0x244>
cmp    $0x2,%r8d
jl     11f2 <slevmar_L2nrmxmy+0xf2>
lea    -0x8(%r8),%eax
or     $0x7,%eax
cltq
add    $0x8,%rax
xorps  %xmm2,%xmm2
nopl   (%rax)
movss  -0x20(%rsi,%rax,4),%xmm1
subss  -0x20(%rdx,%rax,4),%xmm1
movss  %xmm1,-0x20(%rdi,%rax,4)
movss  -0x24(%rsi,%rax,4),%xmm3
subss  -0x24(%rdx,%rax,4),%xmm3
movss  %xmm3,-0x24(%rdi,%rax,4)
movss  -0x28(%rsi,%rax,4),%xmm4
subss  -0x28(%rdx,%rax,4),%xmm4
movss  %xmm4,-0x28(%rdi,%rax,4)
movss  -0x2c(%rsi,%rax,4),%xmm0
subss  -0x2c(%rdx,%rax,4),%xmm0
movss  %xmm0,-0x2c(%rdi,%rax,4)
unpcklps %xmm4,%xmm3
unpcklps %xmm1,%xmm0
movlhps %xmm3,%xmm0
mulps  %xmm0,%xmm0
addps  %xmm2,%xmm0
movss  -0x30(%rsi,%rax,4),%xmm2
subss  -0x30(%rdx,%rax,4),%xmm2
movss  %xmm2,-0x30(%rdi,%rax,4)
movss  -0x34(%rsi,%rax,4),%xmm3
subss  -0x34(%rdx,%rax,4),%xmm3
movss  %xmm3,-0x34(%rdi,%rax,4)
movss  -0x38(%rsi,%rax,4),%xmm4
subss  -0x38(%rdx,%rax,4),%xmm4
movss  %xmm4,-0x38(%rdi,%rax,4)
movss  -0x3c(%rsi,%rax,4),%xmm1
subss  -0x3c(%rdx,%rax,4),%xmm1
movss  %xmm1,-0x3c(%rdi,%rax,4)
unpcklps %xmm4,%xmm3
unpcklps %xmm2,%xmm1
movlhps %xmm3,%xmm1
mulps  %xmm1,%xmm1
movaps %xmm1,%xmm2
addps  %xmm0,%xmm2
add    $0xfffffffffffffff8,%rax
cmp    $0x8,%rax
jg     1130 <slevmar_L2nrmxmy+0x30>
addps  %xmm0,%xmm1
cmp    %ecx,%r8d
jge    15ae <slevmar_L2nrmxmy+0x4ae>
and    $0x7,%ecx
add    $0xffffffff,%ecx
cmp    $0x6,%ecx
ja     15ae <slevmar_L2nrmxmy+0x4ae>
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movaps %xmm1,%xmm2
shufps $0xe6,%xmm1,%xmm2
lea    0xdea(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movslq %r8d,%rax
movss  (%rsi,%rax,4),%xmm2
subss  (%rdx,%rax,4),%xmm2
movss  %xmm2,(%rdi,%rax,4)
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm3
or     $0x1,%r8d
movaps %xmm1,%xmm4
unpckhpd %xmm1,%xmm4
movslq %r8d,%r8
movss  (%rsi,%r8,4),%xmm2
subss  (%rdx,%r8,4),%xmm2
movss  %xmm2,(%rdi,%r8,4)
mulss  %xmm2,%xmm2
addss  %xmm4,%xmm2
unpcklps %xmm3,%xmm2
add    $0x1,%r8d
movslq %r8d,%r8
movss  (%rsi,%r8,4),%xmm3
subss  (%rdx,%r8,4),%xmm3
movss  %xmm3,(%rdi,%r8,4)
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm0
add    $0x1,%r8d
movslq %r8d,%r8
movss  (%rsi,%r8,4),%xmm3
subss  (%rdx,%r8,4),%xmm3
movss  %xmm3,(%rdi,%r8,4)
mulss  %xmm3,%xmm3
addss  %xmm1,%xmm3
add    $0x1,%r8d
shufps $0x10,%xmm2,%xmm3
movlhps %xmm2,%xmm0
shufps $0x28,%xmm0,%xmm3
movaps %xmm3,%xmm1
movslq %r8d,%r8
movss  (%rsi,%r8,4),%xmm0
subss  (%rdx,%r8,4),%xmm0
movss  %xmm0,(%rdi,%r8,4)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
add    $0x1,%r8d
movlhps %xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
movaps %xmm0,%xmm1
movslq %r8d,%r8
movss  (%rsi,%r8,4),%xmm0
subss  (%rdx,%r8,4),%xmm0
movss  %xmm0,(%rdi,%r8,4)
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
add    $0x1,%r8d
movaps %xmm1,%xmm2
shufps $0xc7,%xmm0,%xmm2
shufps $0x24,%xmm2,%xmm1
movslq %r8d,%rax
movss  (%rsi,%rax,4),%xmm0
subss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
jmp    1597 <slevmar_L2nrmxmy+0x497>
cmp    $0x2,%r8d
jl     142c <slevmar_L2nrmxmy+0x32c>
lea    -0x8(%r8),%eax
or     $0x7,%eax
movslq %eax,%rsi
add    $0x8,%rsi
xorps  %xmm3,%xmm3
movaps 0xc9a(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movss  -0x20(%rdx,%rsi,4),%xmm1
movaps %xmm1,%xmm2
xorps  %xmm0,%xmm2
movss  %xmm2,-0x20(%rdi,%rsi,4)
movss  -0x24(%rdx,%rsi,4),%xmm4
movaps %xmm4,%xmm2
xorps  %xmm0,%xmm2
movss  %xmm2,-0x24(%rdi,%rsi,4)
movss  -0x28(%rdx,%rsi,4),%xmm2
unpcklps %xmm2,%xmm4
xorps  %xmm0,%xmm2
movss  %xmm2,-0x28(%rdi,%rsi,4)
movss  -0x2c(%rdx,%rsi,4),%xmm2
movaps %xmm2,%xmm5
xorps  %xmm0,%xmm5
movss  %xmm5,-0x2c(%rdi,%rsi,4)
unpcklps %xmm1,%xmm2
movlhps %xmm4,%xmm2
mulps  %xmm2,%xmm2
addps  %xmm3,%xmm2
movss  -0x30(%rdx,%rsi,4),%xmm3
movaps %xmm3,%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x30(%rdi,%rsi,4)
movss  -0x34(%rdx,%rsi,4),%xmm4
movaps %xmm4,%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x34(%rdi,%rsi,4)
movss  -0x38(%rdx,%rsi,4),%xmm1
unpcklps %xmm1,%xmm4
xorps  %xmm0,%xmm1
movss  %xmm1,-0x38(%rdi,%rsi,4)
movss  -0x3c(%rdx,%rsi,4),%xmm1
movaps %xmm1,%xmm5
xorps  %xmm0,%xmm5
movss  %xmm5,-0x3c(%rdi,%rsi,4)
unpcklps %xmm3,%xmm1
movlhps %xmm4,%xmm1
mulps  %xmm1,%xmm1
movaps %xmm1,%xmm3
addps  %xmm2,%xmm3
add    $0xfffffffffffffff8,%rsi
cmp    $0x8,%rsi
jg     1370 <slevmar_L2nrmxmy+0x270>
addps  %xmm2,%xmm1
cmp    %ecx,%r8d
jge    15ae <slevmar_L2nrmxmy+0x4ae>
and    $0x7,%ecx
add    $0xffffffff,%ecx
cmp    $0x6,%ecx
ja     15ae <slevmar_L2nrmxmy+0x4ae>
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movaps %xmm1,%xmm2
shufps $0xe6,%xmm1,%xmm2
lea    0xbcc(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movslq %r8d,%rax
movss  (%rdx,%rax,4),%xmm2
movaps 0xb88(%rip),%xmm4
xorps  %xmm2,%xmm4
movss  %xmm4,(%rdi,%rax,4)
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm3
or     $0x1,%r8d
movaps %xmm1,%xmm4
unpckhpd %xmm1,%xmm4
movslq %r8d,%r8
movss  (%rdx,%r8,4),%xmm2
movaps 0xb5d(%rip),%xmm5
xorps  %xmm2,%xmm5
movss  %xmm5,(%rdi,%r8,4)
mulss  %xmm2,%xmm2
addss  %xmm4,%xmm2
unpcklps %xmm3,%xmm2
add    $0x1,%r8d
movslq %r8d,%r8
movss  (%rdx,%r8,4),%xmm3
movaps 0xb35(%rip),%xmm4
xorps  %xmm3,%xmm4
movss  %xmm4,(%rdi,%r8,4)
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm0
add    $0x1,%r8d
movslq %r8d,%r8
movss  (%rdx,%r8,4),%xmm3
movaps 0xb10(%rip),%xmm4
xorps  %xmm3,%xmm4
movss  %xmm4,(%rdi,%r8,4)
mulss  %xmm3,%xmm3
addss  %xmm1,%xmm3
add    $0x1,%r8d
shufps $0x10,%xmm2,%xmm3
movlhps %xmm2,%xmm0
shufps $0x28,%xmm0,%xmm3
movaps %xmm3,%xmm1
movslq %r8d,%r8
movss  (%rdx,%r8,4),%xmm0
movaps 0xadd(%rip),%xmm2
xorps  %xmm0,%xmm2
movss  %xmm2,(%rdi,%r8,4)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
add    $0x1,%r8d
movlhps %xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
movaps %xmm0,%xmm1
movslq %r8d,%r8
movss  (%rdx,%r8,4),%xmm0
movaps 0xaa7(%rip),%xmm2
xorps  %xmm0,%xmm2
movss  %xmm2,(%rdi,%r8,4)
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
add    $0x1,%r8d
movaps %xmm1,%xmm2
shufps $0xc7,%xmm0,%xmm2
shufps $0x24,%xmm2,%xmm1
movslq %r8d,%rax
movss  (%rdx,%rax,4),%xmm0
movaps 0xa71(%rip),%xmm2
xorps  %xmm0,%xmm2
movss  %xmm2,(%rdi,%rax,4)
movaps %xmm1,%xmm2
shufps $0xff,%xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
shufps $0xe4,%xmm1,%xmm0
shufps $0x24,%xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
addss  %xmm0,%xmm2
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
addss  %xmm2,%xmm0
addss  %xmm1,%xmm0
ret

LLVM IR (-O0):
define float @slevmar_L2nrmxmy(float* %0, float* %1, float* %2, i32 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
store float* %0, float** %5
store float* %1, float** %6
store float* %2, float** %7
store i32 %3, i32* %8
store i32 8, i32* %9
store i32 3, i32* %10
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %23
%24 = load i32, i32* %8
%25 = ashr i32 %24, 3
%26 = shl i32 %25, 3
store i32 %26, i32* %19
%27 = load float*, float** %6
%28 = icmp ne float* %27, null
br i1 %28, label %29, label %488
29: ; preds = %4
%30 = load i32, i32* %19
%31 = sub nsw i32 %30, 1
store i32 %31, i32* %11
br label %32
32: ; preds = %266, %29
%33 = load i32, i32* %11
%34 = icmp sgt i32 %33, 0
br i1 %34, label %35, label %269
35: ; preds = %32
%36 = load float*, float** %6
%37 = load i32, i32* %11
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds float, float* %36, i64 %38
%40 = load float, float* %39
%41 = load float*, float** %7
%42 = load i32, i32* %11
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
%45 = load float, float* %44
%46 = fsub float %40, %45
%47 = load float*, float** %5
%48 = load i32, i32* %11
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %47, i64 %49
store float %46, float* %50
%51 = load float*, float** %5
%52 = load i32, i32* %11
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = load float*, float** %5
%57 = load i32, i32* %11
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
%61 = load float, float* %20
%62 = call float @llvm.fmuladd.f32(float %55, float %60, float %61)
store float %62, float* %20
%63 = load i32, i32* %11
%64 = sub nsw i32 %63, 1
store i32 %64, i32* %12
%65 = load float*, float** %6
%66 = load i32, i32* %12
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
%69 = load float, float* %68
%70 = load float*, float** %7
%71 = load i32, i32* %12
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = fsub float %69, %74
%76 = load float*, float** %5
%77 = load i32, i32* %12
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %76, i64 %78
store float %75, float* %79
%80 = load float*, float** %5
%81 = load i32, i32* %12
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
%84 = load float, float* %83
%85 = load float*, float** %5
%86 = load i32, i32* %12
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %85, i64 %87
%89 = load float, float* %88
%90 = load float, float* %21
%91 = call float @llvm.fmuladd.f32(float %84, float %89, float %90)
store float %91, float* %21
%92 = load i32, i32* %11
%93 = sub nsw i32 %92, 2
store i32 %93, i32* %13
%94 = load float*, float** %6
%95 = load i32, i32* %13
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %94, i64 %96
%98 = load float, float* %97
%99 = load float*, float** %7
%100 = load i32, i32* %13
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %99, i64 %101
%103 = load float, float* %102
%104 = fsub float %98, %103
%105 = load float*, float** %5
%106 = load i32, i32* %13
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %105, i64 %107
store float %104, float* %108
%109 = load float*, float** %5
%110 = load i32, i32* %13
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = load float, float* %112
%114 = load float*, float** %5
%115 = load i32, i32* %13
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %114, i64 %116
%118 = load float, float* %117
%119 = load float, float* %22
%120 = call float @llvm.fmuladd.f32(float %113, float %118, float %119)
store float %120, float* %22
%121 = load i32, i32* %11
%122 = sub nsw i32 %121, 3
store i32 %122, i32* %14
%123 = load float*, float** %6
%124 = load i32, i32* %14
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %123, i64 %125
%127 = load float, float* %126
%128 = load float*, float** %7
%129 = load i32, i32* %14
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float, float* %128, i64 %130
%132 = load float, float* %131
%133 = fsub float %127, %132
%134 = load float*, float** %5
%135 = load i32, i32* %14
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %134, i64 %136
store float %133, float* %137
%138 = load float*, float** %5
%139 = load i32, i32* %14
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %138, i64 %140
%142 = load float, float* %141
%143 = load float*, float** %5
%144 = load i32, i32* %14
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %143, i64 %145
%147 = load float, float* %146
%148 = load float, float* %23
%149 = call float @llvm.fmuladd.f32(float %142, float %147, float %148)
store float %149, float* %23
%150 = load i32, i32* %11
%151 = sub nsw i32 %150, 4
store i32 %151, i32* %15
%152 = load float*, float** %6
%153 = load i32, i32* %15
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = load float*, float** %7
%158 = load i32, i32* %15
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %157, i64 %159
%161 = load float, float* %160
%162 = fsub float %156, %161
%163 = load float*, float** %5
%164 = load i32, i32* %15
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %163, i64 %165
store float %162, float* %166
%167 = load float*, float** %5
%168 = load i32, i32* %15
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %167, i64 %169
%171 = load float, float* %170
%172 = load float*, float** %5
%173 = load i32, i32* %15
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %172, i64 %174
%176 = load float, float* %175
%177 = load float, float* %20
%178 = call float @llvm.fmuladd.f32(float %171, float %176, float %177)
store float %178, float* %20
%179 = load i32, i32* %11
%180 = sub nsw i32 %179, 5
store i32 %180, i32* %16
%181 = load float*, float** %6
%182 = load i32, i32* %16
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds float, float* %181, i64 %183
%185 = load float, float* %184
%186 = load float*, float** %7
%187 = load i32, i32* %16
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float, float* %186, i64 %188
%190 = load float, float* %189
%191 = fsub float %185, %190
%192 = load float*, float** %5
%193 = load i32, i32* %16
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds float, float* %192, i64 %194
store float %191, float* %195
%196 = load float*, float** %5
%197 = load i32, i32* %16
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %196, i64 %198
%200 = load float, float* %199
%201 = load float*, float** %5
%202 = load i32, i32* %16
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %201, i64 %203
%205 = load float, float* %204
%206 = load float, float* %21
%207 = call float @llvm.fmuladd.f32(float %200, float %205, float %206)
store float %207, float* %21
%208 = load i32, i32* %11
%209 = sub nsw i32 %208, 6
store i32 %209, i32* %17
%210 = load float*, float** %6
%211 = load i32, i32* %17
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds float, float* %210, i64 %212
%214 = load float, float* %213
%215 = load float*, float** %7
%216 = load i32, i32* %17
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %215, i64 %217
%219 = load float, float* %218
%220 = fsub float %214, %219
%221 = load float*, float** %5
%222 = load i32, i32* %17
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float, float* %221, i64 %223
store float %220, float* %224
%225 = load float*, float** %5
%226 = load i32, i32* %17
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %225, i64 %227
%229 = load float, float* %228
%230 = load float*, float** %5
%231 = load i32, i32* %17
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %230, i64 %232
%234 = load float, float* %233
%235 = load float, float* %22
%236 = call float @llvm.fmuladd.f32(float %229, float %234, float %235)
store float %236, float* %22
%237 = load i32, i32* %11
%238 = sub nsw i32 %237, 7
store i32 %238, i32* %18
%239 = load float*, float** %6
%240 = load i32, i32* %18
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float, float* %239, i64 %241
%243 = load float, float* %242
%244 = load float*, float** %7
%245 = load i32, i32* %18
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float, float* %244, i64 %246
%248 = load float, float* %247
%249 = fsub float %243, %248
%250 = load float*, float** %5
%251 = load i32, i32* %18
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %250, i64 %252
store float %249, float* %253
%254 = load float*, float** %5
%255 = load i32, i32* %18
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds float, float* %254, i64 %256
%258 = load float, float* %257
%259 = load float*, float** %5
%260 = load i32, i32* %18
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %259, i64 %261
%263 = load float, float* %262
%264 = load float, float* %23
%265 = call float @llvm.fmuladd.f32(float %258, float %263, float %264)
store float %265, float* %23
br label %266
266: ; preds = %35
%267 = load i32, i32* %11
%268 = sub nsw i32 %267, 8
store i32 %268, i32* %11
br label %32
269: ; preds = %32
%270 = load i32, i32* %19
store i32 %270, i32* %11
%271 = load i32, i32* %11
%272 = load i32, i32* %8
%273 = icmp slt i32 %271, %272
br i1 %273, label %274, label %487
274: ; preds = %269
%275 = load i32, i32* %8
%276 = load i32, i32* %11
%277 = sub nsw i32 %275, %276
switch i32 %277, label %486 [
i32 7, label %278
i32 6, label %308
i32 5, label %338
i32 4, label %368
i32 3, label %398
i32 2, label %428
i32 1, label %458
]
278: ; preds = %274
%279 = load float*, float** %6
%280 = load i32, i32* %11
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds float, float* %279, i64 %281
%283 = load float, float* %282
%284 = load float*, float** %7
%285 = load i32, i32* %11
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds float, float* %284, i64 %286
%288 = load float, float* %287
%289 = fsub float %283, %288
%290 = load float*, float** %5
%291 = load i32, i32* %11
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds float, float* %290, i64 %292
store float %289, float* %293
%294 = load float*, float** %5
%295 = load i32, i32* %11
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %294, i64 %296
%298 = load float, float* %297
%299 = load float*, float** %5
%300 = load i32, i32* %11
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %299, i64 %301
%303 = load float, float* %302
%304 = load float, float* %20
%305 = call float @llvm.fmuladd.f32(float %298, float %303, float %304)
store float %305, float* %20
%306 = load i32, i32* %11
%307 = add nsw i32 %306, 1
store i32 %307, i32* %11
br label %308
308: ; preds = %274, %278
%309 = load float*, float** %6
%310 = load i32, i32* %11
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float, float* %309, i64 %311
%313 = load float, float* %312
%314 = load float*, float** %7
%315 = load i32, i32* %11
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %314, i64 %316
%318 = load float, float* %317
%319 = fsub float %313, %318
%320 = load float*, float** %5
%321 = load i32, i32* %11
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds float, float* %320, i64 %322
store float %319, float* %323
%324 = load float*, float** %5
%325 = load i32, i32* %11
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float, float* %324, i64 %326
%328 = load float, float* %327
%329 = load float*, float** %5
%330 = load i32, i32* %11
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %329, i64 %331
%333 = load float, float* %332
%334 = load float, float* %21
%335 = call float @llvm.fmuladd.f32(float %328, float %333, float %334)
store float %335, float* %21
%336 = load i32, i32* %11
%337 = add nsw i32 %336, 1
store i32 %337, i32* %11
br label %338
338: ; preds = %274, %308
%339 = load float*, float** %6
%340 = load i32, i32* %11
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float, float* %339, i64 %341
%343 = load float, float* %342
%344 = load float*, float** %7
%345 = load i32, i32* %11
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %344, i64 %346
%348 = load float, float* %347
%349 = fsub float %343, %348
%350 = load float*, float** %5
%351 = load i32, i32* %11
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds float, float* %350, i64 %352
store float %349, float* %353
%354 = load float*, float** %5
%355 = load i32, i32* %11
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds float, float* %354, i64 %356
%358 = load float, float* %357
%359 = load float*, float** %5
%360 = load i32, i32* %11
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds float, float* %359, i64 %361
%363 = load float, float* %362
%364 = load float, float* %22
%365 = call float @llvm.fmuladd.f32(float %358, float %363, float %364)
store float %365, float* %22
%366 = load i32, i32* %11
%367 = add nsw i32 %366, 1
store i32 %367, i32* %11
br label %368
368: ; preds = %274, %338
%369 = load float*, float** %6
%370 = load i32, i32* %11
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds float, float* %369, i64 %371
%373 = load float, float* %372
%374 = load float*, float** %7
%375 = load i32, i32* %11
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds float, float* %374, i64 %376
%378 = load float, float* %377
%379 = fsub float %373, %378
%380 = load float*, float** %5
%381 = load i32, i32* %11
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds float, float* %380, i64 %382
store float %379, float* %383
%384 = load float*, float** %5
%385 = load i32, i32* %11
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds float, float* %384, i64 %386
%388 = load float, float* %387
%389 = load float*, float** %5
%390 = load i32, i32* %11
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds float, float* %389, i64 %391
%393 = load float, float* %392
%394 = load float, float* %23
%395 = call float @llvm.fmuladd.f32(float %388, float %393, float %394)
store float %395, float* %23
%396 = load i32, i32* %11
%397 = add nsw i32 %396, 1
store i32 %397, i32* %11
br label %398
398: ; preds = %274, %368
%399 = load float*, float** %6
%400 = load i32, i32* %11
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds float, float* %399, i64 %401
%403 = load float, float* %402
%404 = load float*, float** %7
%405 = load i32, i32* %11
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds float, float* %404, i64 %406
%408 = load float, float* %407
%409 = fsub float %403, %408
%410 = load float*, float** %5
%411 = load i32, i32* %11
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds float, float* %410, i64 %412
store float %409, float* %413
%414 = load float*, float** %5
%415 = load i32, i32* %11
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %414, i64 %416
%418 = load float, float* %417
%419 = load float*, float** %5
%420 = load i32, i32* %11
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds float, float* %419, i64 %421
%423 = load float, float* %422
%424 = load float, float* %20
%425 = call float @llvm.fmuladd.f32(float %418, float %423, float %424)
store float %425, float* %20
%426 = load i32, i32* %11
%427 = add nsw i32 %426, 1
store i32 %427, i32* %11
br label %428
428: ; preds = %274, %398
%429 = load float*, float** %6
%430 = load i32, i32* %11
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds float, float* %429, i64 %431
%433 = load float, float* %432
%434 = load float*, float** %7
%435 = load i32, i32* %11
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds float, float* %434, i64 %436
%438 = load float, float* %437
%439 = fsub float %433, %438
%440 = load float*, float** %5
%441 = load i32, i32* %11
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds float, float* %440, i64 %442
store float %439, float* %443
%444 = load float*, float** %5
%445 = load i32, i32* %11
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float, float* %444, i64 %446
%448 = load float, float* %447
%449 = load float*, float** %5
%450 = load i32, i32* %11
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds float, float* %449, i64 %451
%453 = load float, float* %452
%454 = load float, float* %21
%455 = call float @llvm.fmuladd.f32(float %448, float %453, float %454)
store float %455, float* %21
%456 = load i32, i32* %11
%457 = add nsw i32 %456, 1
store i32 %457, i32* %11
br label %458
458: ; preds = %274, %428
%459 = load float*, float** %6
%460 = load i32, i32* %11
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds float, float* %459, i64 %461
%463 = load float, float* %462
%464 = load float*, float** %7
%465 = load i32, i32* %11
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds float, float* %464, i64 %466
%468 = load float, float* %467
%469 = fsub float %463, %468
%470 = load float*, float** %5
%471 = load i32, i32* %11
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds float, float* %470, i64 %472
store float %469, float* %473
%474 = load float*, float** %5
%475 = load i32, i32* %11
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds float, float* %474, i64 %476
%478 = load float, float* %477
%479 = load float*, float** %5
%480 = load i32, i32* %11
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds float, float* %479, i64 %481
%483 = load float, float* %482
%484 = load float, float* %22
%485 = call float @llvm.fmuladd.f32(float %478, float %483, float %484)
store float %485, float* %22
br label %486
486: ; preds = %458, %274
br label %487
487: ; preds = %486, %269
br label %872
488: ; preds = %4
%489 = load i32, i32* %19
%490 = sub nsw i32 %489, 1
store i32 %490, i32* %11
br label %491
491: ; preds = %685, %488
%492 = load i32, i32* %11
%493 = icmp sgt i32 %492, 0
br i1 %493, label %494, label %688
494: ; preds = %491
%495 = load float*, float** %7
%496 = load i32, i32* %11
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds float, float* %495, i64 %497
%499 = load float, float* %498
%500 = fneg float %499
%501 = load float*, float** %5
%502 = load i32, i32* %11
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds float, float* %501, i64 %503
store float %500, float* %504
%505 = load float*, float** %5
%506 = load i32, i32* %11
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds float, float* %505, i64 %507
%509 = load float, float* %508
%510 = load float*, float** %5
%511 = load i32, i32* %11
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds float, float* %510, i64 %512
%514 = load float, float* %513
%515 = load float, float* %20
%516 = call float @llvm.fmuladd.f32(float %509, float %514, float %515)
store float %516, float* %20
%517 = load i32, i32* %11
%518 = sub nsw i32 %517, 1
store i32 %518, i32* %12
%519 = load float*, float** %7
%520 = load i32, i32* %12
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds float, float* %519, i64 %521
%523 = load float, float* %522
%524 = fneg float %523
%525 = load float*, float** %5
%526 = load i32, i32* %12
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds float, float* %525, i64 %527
store float %524, float* %528
%529 = load float*, float** %5
%530 = load i32, i32* %12
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds float, float* %529, i64 %531
%533 = load float, float* %532
%534 = load float*, float** %5
%535 = load i32, i32* %12
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds float, float* %534, i64 %536
%538 = load float, float* %537
%539 = load float, float* %21
%540 = call float @llvm.fmuladd.f32(float %533, float %538, float %539)
store float %540, float* %21
%541 = load i32, i32* %11
%542 = sub nsw i32 %541, 2
store i32 %542, i32* %13
%543 = load float*, float** %7
%544 = load i32, i32* %13
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds float, float* %543, i64 %545
%547 = load float, float* %546
%548 = fneg float %547
%549 = load float*, float** %5
%550 = load i32, i32* %13
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds float, float* %549, i64 %551
store float %548, float* %552
%553 = load float*, float** %5
%554 = load i32, i32* %13
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds float, float* %553, i64 %555
%557 = load float, float* %556
%558 = load float*, float** %5
%559 = load i32, i32* %13
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds float, float* %558, i64 %560
%562 = load float, float* %561
%563 = load float, float* %22
%564 = call float @llvm.fmuladd.f32(float %557, float %562, float %563)
store float %564, float* %22
%565 = load i32, i32* %11
%566 = sub nsw i32 %565, 3
store i32 %566, i32* %14
%567 = load float*, float** %7
%568 = load i32, i32* %14
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds float, float* %567, i64 %569
%571 = load float, float* %570
%572 = fneg float %571
%573 = load float*, float** %5
%574 = load i32, i32* %14
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds float, float* %573, i64 %575
store float %572, float* %576
%577 = load float*, float** %5
%578 = load i32, i32* %14
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds float, float* %577, i64 %579
%581 = load float, float* %580
%582 = load float*, float** %5
%583 = load i32, i32* %14
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds float, float* %582, i64 %584
%586 = load float, float* %585
%587 = load float, float* %23
%588 = call float @llvm.fmuladd.f32(float %581, float %586, float %587)
store float %588, float* %23
%589 = load i32, i32* %11
%590 = sub nsw i32 %589, 4
store i32 %590, i32* %15
%591 = load float*, float** %7
%592 = load i32, i32* %15
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds float, float* %591, i64 %593
%595 = load float, float* %594
%596 = fneg float %595
%597 = load float*, float** %5
%598 = load i32, i32* %15
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds float, float* %597, i64 %599
store float %596, float* %600
%601 = load float*, float** %5
%602 = load i32, i32* %15
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds float, float* %601, i64 %603
%605 = load float, float* %604
%606 = load float*, float** %5
%607 = load i32, i32* %15
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds float, float* %606, i64 %608
%610 = load float, float* %609
%611 = load float, float* %20
%612 = call float @llvm.fmuladd.f32(float %605, float %610, float %611)
store float %612, float* %20
%613 = load i32, i32* %11
%614 = sub nsw i32 %613, 5
store i32 %614, i32* %16
%615 = load float*, float** %7
%616 = load i32, i32* %16
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds float, float* %615, i64 %617
%619 = load float, float* %618
%620 = fneg float %619
%621 = load float*, float** %5
%622 = load i32, i32* %16
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds float, float* %621, i64 %623
store float %620, float* %624
%625 = load float*, float** %5
%626 = load i32, i32* %16
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds float, float* %625, i64 %627
%629 = load float, float* %628
%630 = load float*, float** %5
%631 = load i32, i32* %16
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds float, float* %630, i64 %632
%634 = load float, float* %633
%635 = load float, float* %21
%636 = call float @llvm.fmuladd.f32(float %629, float %634, float %635)
store float %636, float* %21
%637 = load i32, i32* %11
%638 = sub nsw i32 %637, 6
store i32 %638, i32* %17
%639 = load float*, float** %7
%640 = load i32, i32* %17
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds float, float* %639, i64 %641
%643 = load float, float* %642
%644 = fneg float %643
%645 = load float*, float** %5
%646 = load i32, i32* %17
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds float, float* %645, i64 %647
store float %644, float* %648
%649 = load float*, float** %5
%650 = load i32, i32* %17
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds float, float* %649, i64 %651
%653 = load float, float* %652
%654 = load float*, float** %5
%655 = load i32, i32* %17
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds float, float* %654, i64 %656
%658 = load float, float* %657
%659 = load float, float* %22
%660 = call float @llvm.fmuladd.f32(float %653, float %658, float %659)
store float %660, float* %22
%661 = load i32, i32* %11
%662 = sub nsw i32 %661, 7
store i32 %662, i32* %18
%663 = load float*, float** %7
%664 = load i32, i32* %18
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds float, float* %663, i64 %665
%667 = load float, float* %666
%668 = fneg float %667
%669 = load float*, float** %5
%670 = load i32, i32* %18
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds float, float* %669, i64 %671
store float %668, float* %672
%673 = load float*, float** %5
%674 = load i32, i32* %18
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds float, float* %673, i64 %675
%677 = load float, float* %676
%678 = load float*, float** %5
%679 = load i32, i32* %18
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds float, float* %678, i64 %680
%682 = load float, float* %681
%683 = load float, float* %23
%684 = call float @llvm.fmuladd.f32(float %677, float %682, float %683)
store float %684, float* %23
br label %685
685: ; preds = %494
%686 = load i32, i32* %11
%687 = sub nsw i32 %686, 8
store i32 %687, i32* %11
br label %491
688: ; preds = %491
%689 = load i32, i32* %19
store i32 %689, i32* %11
%690 = load i32, i32* %11
%691 = load i32, i32* %8
%692 = icmp slt i32 %690, %691
br i1 %692, label %693, label %871
693: ; preds = %688
%694 = load i32, i32* %8
%695 = load i32, i32* %11
%696 = sub nsw i32 %694, %695
switch i32 %696, label %870 [
i32 7, label %697
i32 6, label %722
i32 5, label %747
i32 4, label %772
i32 3, label %797
i32 2, label %822
i32 1, label %847
]
697: ; preds = %693
%698 = load float*, float** %7
%699 = load i32, i32* %11
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds float, float* %698, i64 %700
%702 = load float, float* %701
%703 = fneg float %702
%704 = load float*, float** %5
%705 = load i32, i32* %11
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds float, float* %704, i64 %706
store float %703, float* %707
%708 = load float*, float** %5
%709 = load i32, i32* %11
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds float, float* %708, i64 %710
%712 = load float, float* %711
%713 = load float*, float** %5
%714 = load i32, i32* %11
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds float, float* %713, i64 %715
%717 = load float, float* %716
%718 = load float, float* %20
%719 = call float @llvm.fmuladd.f32(float %712, float %717, float %718)
store float %719, float* %20
%720 = load i32, i32* %11
%721 = add nsw i32 %720, 1
store i32 %721, i32* %11
br label %722
722: ; preds = %693, %697
%723 = load float*, float** %7
%724 = load i32, i32* %11
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds float, float* %723, i64 %725
%727 = load float, float* %726
%728 = fneg float %727
%729 = load float*, float** %5
%730 = load i32, i32* %11
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds float, float* %729, i64 %731
store float %728, float* %732
%733 = load float*, float** %5
%734 = load i32, i32* %11
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds float, float* %733, i64 %735
%737 = load float, float* %736
%738 = load float*, float** %5
%739 = load i32, i32* %11
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds float, float* %738, i64 %740
%742 = load float, float* %741
%743 = load float, float* %21
%744 = call float @llvm.fmuladd.f32(float %737, float %742, float %743)
store float %744, float* %21
%745 = load i32, i32* %11
%746 = add nsw i32 %745, 1
store i32 %746, i32* %11
br label %747
747: ; preds = %693, %722
%748 = load float*, float** %7
%749 = load i32, i32* %11
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds float, float* %748, i64 %750
%752 = load float, float* %751
%753 = fneg float %752
%754 = load float*, float** %5
%755 = load i32, i32* %11
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds float, float* %754, i64 %756
store float %753, float* %757
%758 = load float*, float** %5
%759 = load i32, i32* %11
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds float, float* %758, i64 %760
%762 = load float, float* %761
%763 = load float*, float** %5
%764 = load i32, i32* %11
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds float, float* %763, i64 %765
%767 = load float, float* %766
%768 = load float, float* %22
%769 = call float @llvm.fmuladd.f32(float %762, float %767, float %768)
store float %769, float* %22
%770 = load i32, i32* %11
%771 = add nsw i32 %770, 1
store i32 %771, i32* %11
br label %772
772: ; preds = %693, %747
%773 = load float*, float** %7
%774 = load i32, i32* %11
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds float, float* %773, i64 %775
%777 = load float, float* %776
%778 = fneg float %777
%779 = load float*, float** %5
%780 = load i32, i32* %11
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds float, float* %779, i64 %781
store float %778, float* %782
%783 = load float*, float** %5
%784 = load i32, i32* %11
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds float, float* %783, i64 %785
%787 = load float, float* %786
%788 = load float*, float** %5
%789 = load i32, i32* %11
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds float, float* %788, i64 %790
%792 = load float, float* %791
%793 = load float, float* %23
%794 = call float @llvm.fmuladd.f32(float %787, float %792, float %793)
store float %794, float* %23
%795 = load i32, i32* %11
%796 = add nsw i32 %795, 1
store i32 %796, i32* %11
br label %797
797: ; preds = %693, %772
%798 = load float*, float** %7
%799 = load i32, i32* %11
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds float, float* %798, i64 %800
%802 = load float, float* %801
%803 = fneg float %802
%804 = load float*, float** %5
%805 = load i32, i32* %11
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds float, float* %804, i64 %806
store float %803, float* %807
%808 = load float*, float** %5
%809 = load i32, i32* %11
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds float, float* %808, i64 %810
%812 = load float, float* %811
%813 = load float*, float** %5
%814 = load i32, i32* %11
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds float, float* %813, i64 %815
%817 = load float, float* %816
%818 = load float, float* %20
%819 = call float @llvm.fmuladd.f32(float %812, float %817, float %818)
store float %819, float* %20
%820 = load i32, i32* %11
%821 = add nsw i32 %820, 1
store i32 %821, i32* %11
br label %822
822: ; preds = %693, %797
%823 = load float*, float** %7
%824 = load i32, i32* %11
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds float, float* %823, i64 %825
%827 = load float, float* %826
%828 = fneg float %827
%829 = load float*, float** %5
%830 = load i32, i32* %11
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds float, float* %829, i64 %831
store float %828, float* %832
%833 = load float*, float** %5
%834 = load i32, i32* %11
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds float, float* %833, i64 %835
%837 = load float, float* %836
%838 = load float*, float** %5
%839 = load i32, i32* %11
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds float, float* %838, i64 %840
%842 = load float, float* %841
%843 = load float, float* %21
%844 = call float @llvm.fmuladd.f32(float %837, float %842, float %843)
store float %844, float* %21
%845 = load i32, i32* %11
%846 = add nsw i32 %845, 1
store i32 %846, i32* %11
br label %847
847: ; preds = %693, %822
%848 = load float*, float** %7
%849 = load i32, i32* %11
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds float, float* %848, i64 %850
%852 = load float, float* %851
%853 = fneg float %852
%854 = load float*, float** %5
%855 = load i32, i32* %11
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds float, float* %854, i64 %856
store float %853, float* %857
%858 = load float*, float** %5
%859 = load i32, i32* %11
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds float, float* %858, i64 %860
%862 = load float, float* %861
%863 = load float*, float** %5
%864 = load i32, i32* %11
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds float, float* %863, i64 %865
%867 = load float, float* %866
%868 = load float, float* %22
%869 = call float @llvm.fmuladd.f32(float %862, float %867, float %868)
store float %869, float* %22
br label %870
870: ; preds = %847, %693
br label %871
871: ; preds = %870, %688
br label %872
872: ; preds = %871, %487
%873 = load float, float* %20
%874 = load float, float* %21
%875 = fadd float %873, %874
%876 = load float, float* %22
%877 = fadd float %875, %876
%878 = load float, float* %23
%879 = fadd float %877, %878
ret float %879
}

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