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