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