double dlevmar_L2nrmxmy(double *e, double *x, double *y, int n) {
  const int blocksize = 8, bpwr = 3;
  register int i;
  int j1, j2, j3, j4, j5, j6, j7;
  int blockn;
  register double 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):
<dlevmar_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
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
sar    $0x3,%eax
shl    $0x3,%eax
mov    %eax,-0x48(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1714 <dlevmar_L2nrmxmy+0x614>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1450 <dlevmar_L2nrmxmy+0x350>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    1161 <dlevmar_L2nrmxmy+0x61>
mov    -0x48(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    170f <dlevmar_L2nrmxmy+0x60f>
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%eax
not    %eax
add    %ecx,%eax
mov    %eax,%ecx
mov    %rcx,-0x70(%rbp)
sub    $0x6,%eax
ja     170a <dlevmar_L2nrmxmy+0x60a>
mov    -0x70(%rbp),%rax
lea    0xb96(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    170f <dlevmar_L2nrmxmy+0x60f>
jmp    1d66 <dlevmar_L2nrmxmy+0xc66>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1a5c <dlevmar_L2nrmxmy+0x95c>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    171d <dlevmar_L2nrmxmy+0x61d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1d61 <dlevmar_L2nrmxmy+0xc61>
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%eax
not    %eax
add    %ecx,%eax
mov    %eax,%ecx
mov    %rcx,-0x78(%rbp)
sub    $0x6,%eax
ja     1d5c <dlevmar_L2nrmxmy+0xc5c>
mov    -0x78(%rbp),%rax
lea    0x56e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1d61 <dlevmar_L2nrmxmy+0xc61>
jmp    1d66 <dlevmar_L2nrmxmy+0xc66>
movsd  -0x50(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<dlevmar_L2nrmxmy>:
mov    %ecx,%r8d
and    $0xfffffff8,%r8d
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
test   %rsi,%rsi
je     134c <dlevmar_L2nrmxmy+0x24c>
cmp    $0x2,%r8d
jl     121e <dlevmar_L2nrmxmy+0x11e>
lea    -0x8(%r8),%eax
or     $0x7,%eax
cltq
add    $0x8,%rax
xorpd  %xmm5,%xmm5
xorpd  %xmm4,%xmm4
nopw   0x0(%rax,%rax,1)
movsd  -0x40(%rsi,%rax,8),%xmm0
subsd  -0x40(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x40(%rdi,%rax,8)
movsd  -0x48(%rsi,%rax,8),%xmm2
subsd  -0x48(%rdx,%rax,8),%xmm2
movsd  %xmm2,-0x48(%rdi,%rax,8)
movsd  -0x50(%rsi,%rax,8),%xmm1
subsd  -0x50(%rdx,%rax,8),%xmm1
movsd  %xmm1,-0x50(%rdi,%rax,8)
movsd  -0x58(%rsi,%rax,8),%xmm3
subsd  -0x58(%rdx,%rax,8),%xmm3
movsd  %xmm3,-0x58(%rdi,%rax,8)
unpcklpd %xmm1,%xmm2
unpcklpd %xmm0,%xmm3
mulpd  %xmm3,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm2
addpd  %xmm4,%xmm2
movsd  -0x60(%rsi,%rax,8),%xmm4
subsd  -0x60(%rdx,%rax,8),%xmm4
movsd  %xmm4,-0x60(%rdi,%rax,8)
movsd  -0x68(%rsi,%rax,8),%xmm0
subsd  -0x68(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x68(%rdi,%rax,8)
movsd  -0x70(%rsi,%rax,8),%xmm5
subsd  -0x70(%rdx,%rax,8),%xmm5
movsd  %xmm5,-0x70(%rdi,%rax,8)
movsd  -0x78(%rsi,%rax,8),%xmm1
subsd  -0x78(%rdx,%rax,8),%xmm1
movsd  %xmm1,-0x78(%rdi,%rax,8)
unpcklpd %xmm4,%xmm1
unpcklpd %xmm5,%xmm0
mulpd  %xmm0,%xmm0
movapd %xmm0,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm1
movapd %xmm1,%xmm5
addpd  %xmm3,%xmm5
add    $0xfffffffffffffff8,%rax
cmp    $0x8,%rax
jg     1140 <dlevmar_L2nrmxmy+0x40>
addpd  %xmm3,%xmm1
addpd  %xmm2,%xmm0
cmp    %ecx,%r8d
jge    15cf <dlevmar_L2nrmxmy+0x4cf>
and    $0x7,%ecx
add    $0xffffffff,%ecx
cmp    $0x6,%ecx
ja     15cf <dlevmar_L2nrmxmy+0x4cf>
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
lea    0xdcb(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
movapd %xmm0,%xmm3
jmp    *%rcx
movslq %r8d,%rax
movsd  (%rsi,%rax,8),%xmm3
subsd  (%rdx,%rax,8),%xmm3
movsd  %xmm3,(%rdi,%rax,8)
mulsd  %xmm3,%xmm3
addsd  %xmm3,%xmm2
or     $0x1,%r8d
movslq %r8d,%r8
movsd  (%rsi,%r8,8),%xmm3
subsd  (%rdx,%r8,8),%xmm3
movsd  %xmm3,(%rdi,%r8,8)
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
add    $0x1,%r8d
unpckhpd %xmm0,%xmm0
movslq %r8d,%r8
movsd  (%rsi,%r8,8),%xmm4
subsd  (%rdx,%r8,8),%xmm4
movsd  %xmm4,(%rdi,%r8,8)
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
unpcklpd %xmm4,%xmm3
add    $0x1,%r8d
movapd %xmm3,%xmm0
movslq %r8d,%r8
movsd  (%rsi,%r8,8),%xmm3
subsd  (%rdx,%r8,8),%xmm3
movsd  %xmm3,(%rdi,%r8,8)
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
unpcklpd %xmm2,%xmm3
add    $0x1,%r8d
movapd %xmm3,%xmm1
movslq %r8d,%r8
movsd  (%rsi,%r8,8),%xmm2
subsd  (%rdx,%r8,8),%xmm2
movsd  %xmm2,(%rdi,%r8,8)
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
add    $0x1,%r8d
unpcklpd %xmm2,%xmm1
movslq %r8d,%r8
movsd  (%rsi,%r8,8),%xmm2
subsd  (%rdx,%r8,8),%xmm2
movsd  %xmm2,(%rdi,%r8,8)
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%r8d
movslq %r8d,%rax
movsd  (%rsi,%rax,8),%xmm2
subsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdi,%rax,8)
jmp    15bb <dlevmar_L2nrmxmy+0x4bb>
cmp    $0x2,%r8d
jl     1466 <dlevmar_L2nrmxmy+0x366>
lea    -0x8(%r8),%eax
or     $0x7,%eax
movslq %eax,%rsi
add    $0x8,%rsi
xorpd  %xmm6,%xmm6
movapd 0xc90(%rip),%xmm2
xorpd  %xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x40(%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm2,%xmm1
movlpd %xmm1,-0x40(%rdi,%rsi,8)
movsd  -0x48(%rdx,%rsi,8),%xmm3
movapd %xmm3,%xmm1
xorpd  %xmm2,%xmm1
movlpd %xmm1,-0x48(%rdi,%rsi,8)
movsd  -0x50(%rdx,%rsi,8),%xmm1
unpcklpd %xmm1,%xmm3
xorpd  %xmm2,%xmm1
movlpd %xmm1,-0x50(%rdi,%rsi,8)
movsd  -0x58(%rdx,%rsi,8),%xmm4
movapd %xmm4,%xmm1
xorpd  %xmm2,%xmm1
movlpd %xmm1,-0x58(%rdi,%rsi,8)
unpcklpd %xmm0,%xmm4
mulpd  %xmm4,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm3,%xmm3
addpd  %xmm5,%xmm3
movsd  -0x60(%rdx,%rsi,8),%xmm5
movapd %xmm5,%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,-0x60(%rdi,%rsi,8)
movsd  -0x68(%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm2,%xmm1
movlpd %xmm1,-0x68(%rdi,%rsi,8)
movsd  -0x70(%rdx,%rsi,8),%xmm1
unpcklpd %xmm1,%xmm0
xorpd  %xmm2,%xmm1
movlpd %xmm1,-0x70(%rdi,%rsi,8)
movsd  -0x78(%rdx,%rsi,8),%xmm1
movapd %xmm1,%xmm6
xorpd  %xmm2,%xmm6
movlpd %xmm6,-0x78(%rdi,%rsi,8)
unpcklpd %xmm5,%xmm1
mulpd  %xmm0,%xmm0
movapd %xmm0,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm1
movapd %xmm1,%xmm6
addpd  %xmm4,%xmm6
add    $0xfffffffffffffff8,%rsi
cmp    $0x8,%rsi
jg     1380 <dlevmar_L2nrmxmy+0x280>
addpd  %xmm4,%xmm1
addpd  %xmm3,%xmm0
cmp    %ecx,%r8d
jge    15cf <dlevmar_L2nrmxmy+0x4cf>
and    $0x7,%ecx
add    $0xffffffff,%ecx
cmp    $0x6,%ecx
ja     15cf <dlevmar_L2nrmxmy+0x4cf>
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
lea    0xb9f(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
movapd %xmm0,%xmm3
jmp    *%rcx
movslq %r8d,%rax
movsd  (%rdx,%rax,8),%xmm3
movapd 0xb56(%rip),%xmm4
xorpd  %xmm3,%xmm4
movlpd %xmm4,(%rdi,%rax,8)
mulsd  %xmm3,%xmm3
addsd  %xmm3,%xmm2
or     $0x1,%r8d
movslq %r8d,%r8
movsd  (%rdx,%r8,8),%xmm3
movapd 0xb30(%rip),%xmm4
xorpd  %xmm3,%xmm4
movlpd %xmm4,(%rdi,%r8,8)
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
add    $0x1,%r8d
unpckhpd %xmm0,%xmm0
movslq %r8d,%r8
movsd  (%rdx,%r8,8),%xmm4
movapd 0xb05(%rip),%xmm5
xorpd  %xmm4,%xmm5
movlpd %xmm5,(%rdi,%r8,8)
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
unpcklpd %xmm4,%xmm3
add    $0x1,%r8d
movapd %xmm3,%xmm0
movslq %r8d,%r8
movsd  (%rdx,%r8,8),%xmm3
movapd 0xad6(%rip),%xmm4
xorpd  %xmm3,%xmm4
movlpd %xmm4,(%rdi,%r8,8)
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
unpcklpd %xmm2,%xmm3
add    $0x1,%r8d
movapd %xmm3,%xmm1
movslq %r8d,%r8
movsd  (%rdx,%r8,8),%xmm2
movapd 0xaa7(%rip),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdi,%r8,8)
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
add    $0x1,%r8d
unpcklpd %xmm2,%xmm1
movslq %r8d,%r8
movsd  (%rdx,%r8,8),%xmm2
movapd 0xa74(%rip),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdi,%r8,8)
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%r8d
movslq %r8d,%rax
movsd  (%rdx,%rax,8),%xmm2
movapd 0xa4e(%rip),%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rdi,%rax,8)
movapd %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
unpcklpd %xmm2,%xmm0
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm0,%xmm2
unpckhpd %xmm0,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ret

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

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