#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double denorm(int, double *);
double sqrt(double);
int ddoglg(int n, double r[], double diag[], double qtb[], double delta,
           double x[], double wa1[], double wa2[]) {
  int i, j, k, l;
  int jj;
  int jp1;
  int nm1 = n - 1;
  double temp;
  double alpha, gnorm, qnorm;
  double epsmch;
  double sgnorm;
  double sum;
  epsmch = 2.22e-15;
  jj = n * (n + 1) / 2;
  for (k = 0; k < n; ++k) {
    j = nm1 - k;
    jp1 = j + 1;
    jj -= (k + 1);
    l = jj + 1;
    sum = 0.0;
    if (n >= (jp1 + 1)) {
      for (i = jp1; i < n; ++i) {
        sum += r[l] * x[i];
        ++l;
      }
    }
    temp = r[jj];
    if (temp == 0.0) {
      l = j;
      for (i = 0; i <= j; ++i) {
        double dt;
        dt = ((r[l]) >= 0.0 ? (r[l]) : -(r[l]));
        temp = ((temp) >= (dt) ? (temp) : (dt));
        l += nm1 - i;
      }
      temp = epsmch * temp;
      if (temp == 0.0) {
        temp = epsmch;
      }
    }
    x[j] = (qtb[j] - sum) / temp;
  }
  for (j = 0; j < n; ++j) {
    wa1[j] = 0.0;
    wa2[j] = diag[j] * x[j];
  }
  qnorm = denorm(n, &wa2[0]);
  if (qnorm <= delta) {
    return 0;
  }
  l = 0;
  for (j = 0; j < n; ++j) {
    temp = qtb[j];
    for (i = j; i < n; ++i) {
      wa1[i] += r[l] * temp;
      ++l;
    }
    wa1[j] /= diag[j];
  }
  gnorm = denorm(n, &wa1[0]);
  sgnorm = 0.0;
  alpha = delta / qnorm;
  if (gnorm != 0.0) {
    for (j = 0; j < n; ++j)
      wa1[j] = wa1[j] / gnorm / diag[j];
    l = 0;
    for (j = 0; j < n; ++j) {
      sum = 0.0;
      for (i = j; i < n; ++i) {
        sum += r[l] * wa1[i];
        ++l;
      }
      wa2[j] = sum;
    }
    temp = denorm(n, &wa2[0]);
    sgnorm = gnorm / temp / temp;
    alpha = 0.0;
    if (sgnorm < delta) {
      double d0, d1, d2, d3, d4, bnorm = denorm(n, &qtb[0]);
      d0 = bnorm / gnorm * (bnorm / qnorm) * (sgnorm / delta);
      d1 = sgnorm / delta;
      d2 = d0 - delta / qnorm;
      d3 = delta / qnorm;
      d4 = sgnorm / delta;
      d0 = d0 - delta / qnorm * (d1 * d1) +
           sqrt(d2 * d2 + (1.0 - d3 * d3) * (1.0 - d4 * d4));
      d1 = sgnorm / delta;
      alpha = delta / qnorm * (1.0 - d1 * d1) / d0;
    }
  }
  temp = (1.0 - alpha) * ((sgnorm) <= (delta) ? (sgnorm) : (delta));
  for (j = 0; j < n; ++j)
    x[j] = temp * wa1[j] + alpha * x[j];
  return 0;
}


x86 assembly (clang, -O0):
<ddoglg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
movsd  0xea4(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13aa <ddoglg+0x28a>
mov    -0x54(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%eax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1230 <ddoglg+0x110>
mov    -0x50(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    122b <ddoglg+0x10b>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d6 <ddoglg+0xb6>
jmp    1230 <ddoglg+0x110>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1375 <ddoglg+0x255>
jp     1375 <ddoglg+0x255>
mov    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     133f <ddoglg+0x21f>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12a7 <ddoglg+0x187>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    12d3 <ddoglg+0x1b3>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jb     1308 <ddoglg+0x1e8>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1318 <ddoglg+0x1f8>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x3c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1267 <ddoglg+0x147>
movsd  -0x80(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1370 <ddoglg+0x250>
jp     1370 <ddoglg+0x250>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1375 <ddoglg+0x255>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
divsd  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    117f <ddoglg+0x5f>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1402 <ddoglg+0x2e2>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13b1 <ddoglg+0x291>
mov    -0x8(%rbp),%edi
mov    0x10(%rbp),%rsi
call   1040 <denorm@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1433 <ddoglg+0x313>
movl   $0x0,-0x4(%rbp)
jmp    192c <ddoglg+0x80c>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14e5 <ddoglg+0x3c5>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14b4 <ddoglg+0x394>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1465 <ddoglg+0x345>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1441 <ddoglg+0x321>
mov    -0x8(%rbp),%edi
mov    -0x38(%rbp),%rsi
call   1040 <denorm@plt>
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
movsd  -0x28(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    152d <ddoglg+0x40d>
jp     152d <ddoglg+0x40d>
jmp    1864 <ddoglg+0x744>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    157a <ddoglg+0x45a>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1534 <ddoglg+0x414>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    161d <ddoglg+0x4fd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15fa <ddoglg+0x4da>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15a5 <ddoglg+0x485>
movsd  -0x90(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1588 <ddoglg+0x468>
mov    -0x8(%rbp),%edi
mov    0x10(%rbp),%rsi
call   1040 <denorm@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    185f <ddoglg+0x73f>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%rsi
call   1040 <denorm@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
divsd  -0x70(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm1
ff
divsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
divsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x28(%rbp),%xmm1
divsd  -0x78(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
mulsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
movsd  0x873(%rip),%xmm3
addsd  %xmm3,%xmm1
movsd  -0xc0(%rbp),%xmm3
ff
movsd  -0xc0(%rbp),%xmm4
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
movsd  0x83c(%rip),%xmm4
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
movsd  0x7be(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
jmp    1864 <ddoglg+0x744>
movsd  0x79c(%rip),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     18a5 <ddoglg+0x785>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    18b2 <ddoglg+0x792>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1925 <ddoglg+0x805>
movsd  -0x60(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    18d2 <ddoglg+0x7b2>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ddoglg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,%r15
movapd %xmm0,0x40(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,%r12
mov    0xc0(%rsp),%rsi
mov    %edi,%r14d
test   %edi,%edi
mov    %r8,0x20(%rsp)
mov    %r14,0x10(%rsp)
mov    %rdi,(%rsp)
jle    16cd <ddoglg+0x5ad>
mov    %r15,0x70(%rsp)
lea    -0x1(%rdi),%eax
lea    0x1(%rdi),%ecx
imul   %edi,%ecx
mov    %ecx,%r11d
shr    $0x1f,%r11d
add    %ecx,%r11d
sar    %r11d
lea    -0x1(%r11),%r15d
mov    %eax,%ecx
mov    %rcx,0x28(%rsp)
lea    0x18(%r8),%rcx
mov    %rcx,0x80(%rsp)
lea    0x20(%r12),%rcx
mov    %rcx,0x78(%rsp)
mov    $0xfffffffe,%r9d
xor    %r10d,%r10d
xorpd  %xmm0,%xmm0
movsd  0xe67(%rip),%xmm1
movapd 0xe3e(%rip),%xmm8
movapd 0xe36(%rip),%xmm3
mov    %edi,%ebx
jmp    1200 <ddoglg+0xe0>
xchg   %ax,%ax
mov    0x10(%rsp),%r14
mov    0x60(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm2
subsd  %xmm4,%xmm2
divsd  %xmm5,%xmm2
movsd  %xmm2,(%r8,%rcx,8)
add    %r9d,%r15d
add    $0xffffffff,%ebx
add    $0xffffffff,%r9d
cmp    %r14,%r10
je     1475 <ddoglg+0x355>
mov    %r10,%rbp
mov    %ebx,%ecx
mov    %rcx,0x30(%rsp)
mov    0x28(%rsp),%rcx
sub    %r10,%rcx
add    $0x1,%r10
sub    %r10d,%r11d
lea    0x2(%rcx),%rdx
xorpd  %xmm4,%xmm4
cmp    %r14,%rdx
jg     1326 <ddoglg+0x206>
lea    0x1(%rcx),%rdx
xorpd  %xmm4,%xmm4
cmp    0x10(%rsp),%rdx
jge    1326 <ddoglg+0x206>
movslq %r15d,%r14
lea    -0x1(%rbp),%edx
test   $0x3,%bpl
je     12a9 <ddoglg+0x189>
mov    %edx,0x50(%rsp)
mov    %r8,%rdx
mov    %r11,%r8
movslq %ebx,%r13
lea    (%rdx,%r13,8),%rdx
lea    (%r12,%r14,8),%rdi
and    $0x3,%ebp
neg    %ebp
xorpd  %xmm4,%xmm4
mov    $0x8,%r11d
xor    %esi,%esi
nop
movsd  (%rdi,%r11,1),%xmm5
mulsd  -0x8(%rdx,%r11,1),%xmm5
addsd  %xmm5,%xmm4
add    $0xffffffffffffffff,%rsi
add    $0x8,%r11
cmp    %esi,%ebp
jne    1270 <ddoglg+0x150>
sub    %rsi,%r13
sub    %rsi,%r14
mov    0x20(%rsp),%rdx
mov    %r8,%r11
mov    %rdx,%r8
mov    0x50(%rsp),%edx
cmp    $0x3,%edx
jae    12b7 <ddoglg+0x197>
jmp    1326 <ddoglg+0x206>
movslq 0x30(%rsp),%r13
xorpd  %xmm4,%xmm4
cmp    $0x3,%edx
jb     1326 <ddoglg+0x206>
mov    (%rsp),%rbp
sub    %r13d,%ebp
mov    0x80(%rsp),%rdx
lea    (%rdx,%r13,8),%rsi
mov    0x78(%rsp),%rdx
lea    (%rdx,%r14,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%rdx,%rdi,8),%xmm5
movsd  -0x10(%rdx,%rdi,8),%xmm6
mulsd  -0x18(%rsi,%rdi,8),%xmm5
mulsd  -0x10(%rsi,%rdi,8),%xmm6
addsd  %xmm4,%xmm5
movsd  -0x8(%rdx,%rdi,8),%xmm7
mulsd  -0x8(%rsi,%rdi,8),%xmm7
addsd  %xmm5,%xmm6
movsd  (%rdx,%rdi,8),%xmm4
mulsd  (%rsi,%rdi,8),%xmm4
addsd  %xmm6,%xmm7
addsd  %xmm7,%xmm4
add    $0x4,%rdi
cmp    %edi,%ebp
jne    12e0 <ddoglg+0x1c0>
movslq %r11d,%rdx
movsd  (%r12,%rdx,8),%xmm5
ucomisd %xmm0,%xmm5
jne    11d0 <ddoglg+0xb0>
jp     11d0 <ddoglg+0xb0>
test   %rcx,%rcx
js     1453 <ddoglg+0x333>
cmp    $0x1,%ebx
jne    1359 <ddoglg+0x239>
mov    %ecx,%esi
mov    0x30(%rsp),%rbp
jmp    1409 <ddoglg+0x2e9>
mov    0x30(%rsp),%rbp
mov    %ebp,%edi
and    $0xfffffffe,%edi
mov    $0xffffffff,%r13d
xor    %r14d,%r14d
mov    %ecx,%esi
xchg   %ax,%ax
movslq %esi,%rdx
movsd  (%r12,%rdx,8),%xmm6
movapd %xmm6,%xmm7
xorpd  %xmm3,%xmm7
xorpd  %xmm2,%xmm2
cmpnlesd %xmm6,%xmm2
andpd  %xmm2,%xmm7
andnpd %xmm6,%xmm2
orpd   %xmm7,%xmm2
movapd %xmm2,%xmm6
cmplesd %xmm5,%xmm6
movapd %xmm6,%xmm7
andnpd %xmm2,%xmm7
andpd  %xmm5,%xmm6
orpd   %xmm7,%xmm6
add    %eax,%edx
sub    %r14d,%edx
movslq %edx,%rsi
movsd  (%r12,%rsi,8),%xmm2
movapd %xmm2,%xmm5
xorpd  %xmm3,%xmm5
xorpd  %xmm7,%xmm7
cmpnlesd %xmm2,%xmm7
andpd  %xmm7,%xmm5
andnpd %xmm2,%xmm7
orpd   %xmm5,%xmm7
movapd %xmm7,%xmm5
cmplesd %xmm6,%xmm5
movapd %xmm5,%xmm2
andpd  %xmm6,%xmm2
andnpd %xmm7,%xmm5
orpd   %xmm2,%xmm5
add    %eax,%esi
add    %r13d,%esi
add    $0x2,%r14
add    $0xfffffffe,%r13d
cmp    %r14,%rdi
jne    1370 <ddoglg+0x250>
test   $0x1,%bpl
je     1453 <ddoglg+0x333>
movslq %esi,%rdx
movsd  (%r12,%rdx,8),%xmm2
movapd %xmm2,%xmm6
xorpd  %xmm8,%xmm6
xorpd  %xmm7,%xmm7
cmpnlesd %xmm2,%xmm7
andpd  %xmm7,%xmm6
andnpd %xmm2,%xmm7
orpd   %xmm6,%xmm7
movapd %xmm7,%xmm2
cmplesd %xmm5,%xmm2
movapd %xmm2,%xmm6
andnpd %xmm7,%xmm6
andpd  %xmm5,%xmm2
orpd   %xmm6,%xmm2
movapd %xmm2,%xmm5
mulsd  %xmm1,%xmm5
ucomisd %xmm0,%xmm5
mov    0x10(%rsp),%r14
jne    11d5 <ddoglg+0xb5>
jp     11d5 <ddoglg+0xb5>
movapd %xmm1,%xmm5
jmp    11d5 <ddoglg+0xb5>
mov    (%rsp),%rdi
test   %edi,%edi
mov    0x70(%rsp),%r15
mov    0xc0(%rsp),%rsi
mov    0x8(%rsp),%rbx
jle    16cd <ddoglg+0x5ad>
cmp    $0x4,%edi
jae    149f <ddoglg+0x37f>
xor    %eax,%eax
jmp    165f <ddoglg+0x53f>
lea    (%rsi,%r14,8),%rax
cmp    %r15,%rax
seta   %r11b
lea    (%r15,%r14,8),%rcx
cmp    %rsi,%rcx
seta   %bpl
lea    (%rbx,%r14,8),%rdx
cmp    %r15,%rdx
seta   %r10b
cmp    %rbx,%rcx
mov    %r14,%rdi
seta   %r14b
lea    (%r8,%rdi,8),%rdi
cmp    %r15,%rdi
seta   %r9b
cmp    %r8,%rcx
seta   %r13b
cmp    %rsi,%rdx
seta   %cl
cmp    %rbx,%rax
seta   %dl
cmp    %rsi,%rdi
seta   %sil
cmp    %r8,%rax
seta   %bl
xor    %eax,%eax
test   %bpl,%r11b
jne    1644 <ddoglg+0x524>
and    %r14b,%r10b
mov    0x20(%rsp),%r8
jne    1649 <ddoglg+0x529>
and    %r13b,%r9b
jne    1649 <ddoglg+0x529>
and    %dl,%cl
mov    0x10(%rsp),%r14
jne    164e <ddoglg+0x52e>
and    %bl,%sil
mov    (%rsp),%rdi
mov    0xc0(%rsp),%rsi
mov    0x8(%rsp),%rbx
jne    165f <ddoglg+0x53f>
mov    %r14d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     163a <ddoglg+0x51a>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
nopl   0x0(%rax)
movupd %xmm0,(%r15,%rcx,8)
movupd %xmm0,0x10(%r15,%rcx,8)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd (%r8,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
movupd 0x10(%r8,%rcx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd %xmm3,(%rsi,%rcx,8)
movupd %xmm1,0x10(%rsi,%rcx,8)
movupd %xmm0,0x20(%r15,%rcx,8)
movupd %xmm0,0x30(%r15,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movupd 0x20(%r8,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
movupd 0x30(%r8,%rcx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd %xmm3,0x20(%rsi,%rcx,8)
movupd %xmm1,0x30(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1570 <ddoglg+0x450>
test   $0x1,%bpl
je     1630 <ddoglg+0x510>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%r15,%rcx,8)
movupd %xmm0,0x10(%r15,%rcx,8)
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%r8,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r8,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rsi,%rcx,8)
movupd %xmm0,0x10(%rsi,%rcx,8)
cmp    %r14,%rax
jne    165f <ddoglg+0x53f>
jmp    16cd <ddoglg+0x5ad>
xor    %ecx,%ecx
test   $0x1,%bpl
jne    15f4 <ddoglg+0x4d4>
jmp    1630 <ddoglg+0x510>
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%r14
mov    (%rsp),%rdi
mov    0xc0(%rsp),%rsi
mov    0x8(%rsp),%rbx
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
je     1687 <ddoglg+0x567>
movq   $0x0,(%r15,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
or     $0x1,%rax
add    %r14,%rcx
je     16cd <ddoglg+0x5ad>
nopl   0x0(%rax)
movq   $0x0,(%r15,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movq   $0x0,0x8(%r15,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  0x8(%r8,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1690 <ddoglg+0x570>
call   1040 <denorm@plt>
mov    (%rsp),%rdi
movapd %xmm0,%xmm1
movapd 0x40(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jae    1e90 <ddoglg+0xd70>
test   %edi,%edi
movsd  %xmm1,0x28(%rsp)
jle    19a1 <ddoglg+0x881>
lea    (%r15,%r14,8),%rax
mov    %rax,0x30(%rsp)
mov    %r14,%r11
neg    %r11
lea    0x30(%r12),%r8
lea    0x30(%r15),%rdx
lea    -0x4(%r14),%r13
lea    0x8(%r12),%r9
lea    0x8(%r15),%r10
xor    %eax,%eax
xor    %edi,%edi
jmp    175b <ddoglg+0x63b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
mov    0x8(%rsp),%rcx
divsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
add    $0x8,%rdx
add    $0xffffffffffffffff,%r13
cmp    %r14,%rax
je     1944 <ddoglg+0x824>
mov    %r14,%rcx
sub    %rax,%rcx
mov    0x60(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
movslq %edi,%rdi
cmp    $0x4,%rcx
jb     1798 <ddoglg+0x678>
lea    (%r12,%rcx,8),%rsi
lea    (%r15,%rax,8),%rbx
lea    (%rsi,%rdi,8),%rsi
cmp    %rsi,%rbx
jae    1830 <ddoglg+0x710>
lea    (%r12,%rdi,8),%rsi
cmp    0x30(%rsp),%rsi
jae    1830 <ddoglg+0x710>
mov    %rax,%rbx
mov    %r14d,%ecx
sub    %ebx,%ecx
test   $0x1,%cl
jne    17b0 <ddoglg+0x690>
mov    %rbx,%rbp
jmp    17ce <ddoglg+0x6ae>
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r15,%rbx,8),%xmm1
movsd  %xmm1,(%r15,%rbx,8)
add    $0x1,%rdi
lea    0x1(%rbx),%rbp
not    %rbx
cmp    %r11,%rbx
je     1730 <ddoglg+0x610>
lea    (%r9,%rdi,8),%rcx
mov    %r14,%rsi
sub    %rbp,%rsi
lea    (%r10,%rbp,8),%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbp,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rbx,8)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rbx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rsi
jne    17f0 <ddoglg+0x6d0>
add    %rbx,%rdi
jmp    1730 <ddoglg+0x610>
nopl   0x0(%rax)
lea    -0x4(%rcx),%rsi
mov    %rsi,%r14
shr    $0x2,%r14
add    $0x1,%r14
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x4,%rsi
jae    1854 <ddoglg+0x734>
xor    %esi,%esi
jmp    18e0 <ddoglg+0x7c0>
mov    %r13,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r8,%rdi,8),%rbp
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x30(%rbp,%rsi,8),%xmm2
movupd -0x20(%rbp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rdx,%rsi,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rdx,%rsi,8),%xmm2
movupd -0x10(%rdx,%rsi,8),%xmm5
movupd (%rdx,%rsi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rdx,%rsi,8)
movupd %xmm3,-0x20(%rdx,%rsi,8)
movupd -0x10(%rbp,%rsi,8),%xmm2
movupd 0x0(%rbp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rdx,%rsi,8)
movupd %xmm3,(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1870 <ddoglg+0x750>
mov    %rcx,%rbx
and    $0xfffffffffffffffc,%rbx
test   $0x1,%r14b
je     192b <ddoglg+0x80b>
lea    (%rdi,%rsi,1),%rbp
add    %rax,%rsi
movupd (%r12,%rbp,8),%xmm2
movupd 0x10(%r12,%rbp,8),%xmm3
movupd (%r15,%rsi,8),%xmm4
movupd 0x10(%r15,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r15,%rsi,8)
movupd %xmm3,0x10(%r15,%rsi,8)
add    %rbx,%rdi
cmp    %rbx,%rcx
mov    0x10(%rsp),%r14
je     1730 <ddoglg+0x610>
add    %rax,%rbx
jmp    179b <ddoglg+0x67b>
mov    (%rsp),%rbx
mov    %ebx,%edi
mov    %r15,%rsi
call   1040 <denorm@plt>
movapd 0x40(%rsp),%xmm4
movapd %xmm4,%xmm9
divsd  0x28(%rsp),%xmm9
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
jne    1974 <ddoglg+0x854>
jnp    1c4b <ddoglg+0xb2b>
test   %ebx,%ebx
mov    %rbx,%rdi
movapd %xmm9,0x50(%rsp)
movapd %xmm0,0x10(%rsp)
jle    19dd <ddoglg+0x8bd>
cmp    $0x1,%edi
mov    0xc0(%rsp),%rsi
jne    19ea <ddoglg+0x8ca>
xor    %eax,%eax
mov    0x8(%rsp),%rbx
jmp    1a97 <ddoglg+0x977>
mov    %r15,%rsi
call   1040 <denorm@plt>
movsd  0x28(%rsp),%xmm2
movapd 0x40(%rsp),%xmm1
mov    (%rsp),%rdi
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
jne    19c9 <ddoglg+0x8a9>
jnp    1e90 <ddoglg+0xd70>
movapd %xmm0,0x10(%rsp)
movapd %xmm1,%xmm0
divsd  %xmm2,%xmm0
movapd %xmm0,0x50(%rsp)
mov    0xc0(%rsp),%rsi
jmp    1b62 <ddoglg+0xa42>
mov    0x8(%rsp),%rbx
lea    (%rbx,%r14,8),%rax
cmp    %r15,%rax
jbe    1a06 <ddoglg+0x8e6>
cmp    %rbx,0x30(%rsp)
jbe    1a06 <ddoglg+0x8e6>
xor    %eax,%eax
jmp    1a97 <ddoglg+0x977>
mov    %r14d,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
lea    -0x2(%rax),%rdx
mov    %rdx,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     1a71 <ddoglg+0x951>
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edx,%edx
movupd (%r15,%rdx,8),%xmm1
movupd 0x10(%r15,%rdx,8),%xmm2
divpd  %xmm5,%xmm1
movupd (%rbx,%rdx,8),%xmm3
divpd  %xmm3,%xmm1
movupd %xmm1,(%r15,%rdx,8)
divpd  %xmm5,%xmm2
movupd 0x10(%rbx,%rdx,8),%xmm1
divpd  %xmm1,%xmm2
movupd %xmm2,0x10(%r15,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1a30 <ddoglg+0x910>
jmp    1a73 <ddoglg+0x953>
xor    %edx,%edx
test   $0x1,%bpl
je     1a92 <ddoglg+0x972>
movupd (%r15,%rdx,8),%xmm1
divpd  %xmm5,%xmm1
movupd (%rbx,%rdx,8),%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,(%r15,%rdx,8)
cmp    %r14,%rax
je     1b06 <ddoglg+0x9e6>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
je     1abc <ddoglg+0x99c>
movsd  (%r15,%rax,8),%xmm1
divsd  %xmm0,%xmm1
divsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
or     $0x1,%rax
add    %r14,%rcx
je     1b06 <ddoglg+0x9e6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm2
movsd  0x8(%r15,%rax,8),%xmm1
divsd  %xmm0,%xmm2
divsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,(%r15,%rax,8)
divsd  %xmm0,%xmm1
divsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1ad0 <ddoglg+0x9b0>
test   %edi,%edi
jle    1b62 <ddoglg+0xa42>
xor    %r8d,%r8d
mov    %r14,%rcx
mov    %r15,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
cltq
lea    (%r12,%rax,8),%rbp
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  (%rdx,%rbx,8),%xmm1
addsd  %xmm1,%xmm2
add    $0x1,%rbx
cmp    %rbx,%rcx
jne    1b30 <ddoglg+0xa10>
movsd  %xmm2,(%rsi,%r8,8)
add    $0x1,%r8
add    %rbx,%rax
add    $0x8,%rdx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%r8
jne    1b20 <ddoglg+0xa00>
mov    %rdi,%rbx
call   1040 <denorm@plt>
movapd 0x10(%rsp),%xmm1
movapd %xmm1,%xmm3
divsd  %xmm0,%xmm3
divsd  %xmm0,%xmm3
movapd 0x40(%rsp),%xmm4
ucomisd %xmm3,%xmm4
jbe    1c46 <ddoglg+0xb26>
mov    %ebx,%edi
mov    0x60(%rsp),%rsi
movapd %xmm1,0x10(%rsp)
movapd %xmm3,0x30(%rsp)
call   1040 <denorm@plt>
movapd 0x30(%rsp),%xmm3
movapd 0x40(%rsp),%xmm4
movapd %xmm0,%xmm1
movapd %xmm3,%xmm2
unpcklpd %xmm0,%xmm2
divsd  0x28(%rsp),%xmm1
movapd %xmm4,%xmm0
unpcklpd 0x10(%rsp),%xmm0
divpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
movapd 0x50(%rsp),%xmm9
movapd %xmm9,%xmm1
unpcklpd %xmm2,%xmm1
mulsd  %xmm2,%xmm2
movapd 0x404(%rip),%xmm5
xorpd  %xmm9,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm0,%xmm5
subsd  %xmm9,%xmm0
mulpd  %xmm1,%xmm1
movapd 0x3f6(%rip),%xmm2
subpd  %xmm1,%xmm2
movapd %xmm2,%xmm6
unpckhpd %xmm2,%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c59 <ddoglg+0xb39>
sqrtsd %xmm0,%xmm0
jmp    1c89 <ddoglg+0xb69>
xorpd  %xmm9,%xmm9
mov    0x20(%rsp),%rdi
test   %ebx,%ebx
jg     1ca8 <ddoglg+0xb88>
jmp    1e90 <ddoglg+0xd70>
movapd %xmm5,0x10(%rsp)
movapd %xmm6,0x60(%rsp)
call   1030 <sqrt@plt>
movapd 0x60(%rsp),%xmm6
movapd 0x10(%rsp),%xmm5
movapd 0x30(%rsp),%xmm3
movapd 0x50(%rsp),%xmm9
movapd 0x40(%rsp),%xmm4
mov    0x20(%rsp),%rdi
addsd  %xmm5,%xmm0
mulsd  %xmm6,%xmm9
divsd  %xmm0,%xmm9
mov    (%rsp),%rbx
test   %ebx,%ebx
jle    1e90 <ddoglg+0xd70>
movsd  0x378(%rip),%xmm1
subsd  %xmm9,%xmm1
movapd %xmm3,%xmm8
cmplesd %xmm4,%xmm8
andpd  %xmm8,%xmm3
andnpd %xmm4,%xmm8
orpd   %xmm3,%xmm8
mulsd  %xmm1,%xmm8
cmp    $0x4,%ebx
jb     1cf3 <ddoglg+0xbd3>
lea    (%r15,%r14,8),%rax
cmp    %rdi,%rax
jbe    1d7d <ddoglg+0xc5d>
lea    (%rdi,%r14,8),%rax
cmp    %r15,%rax
jbe    1d7d <ddoglg+0xc5d>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
je     1d23 <ddoglg+0xc03>
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
or     $0x1,%rax
add    %r14,%rcx
je     1e90 <ddoglg+0xd70>
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1d30 <ddoglg+0xc10>
jmp    1e90 <ddoglg+0xd70>
mov    %r14d,%eax
and    $0xfffffffc,%eax
movapd %xmm9,%xmm2
unpcklpd %xmm9,%xmm2
movapd %xmm8,%xmm1
unpcklpd %xmm8,%xmm1
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1ea4 <ddoglg+0xd84>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
movupd (%rdi,%rcx,8),%xmm5
movupd 0x10(%rdi,%rcx,8),%xmm6
movupd 0x20(%rdi,%rcx,8),%xmm7
movupd 0x30(%rdi,%rcx,8),%xmm0
mulpd  %xmm2,%xmm5
mulpd  %xmm2,%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm1,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rdi,%rcx,8)
movupd %xmm4,0x10(%rdi,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm3
movupd 0x30(%r15,%rcx,8),%xmm4
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm0
mulpd  %xmm1,%xmm3
addpd  %xmm7,%xmm3
mulpd  %xmm1,%xmm4
addpd  %xmm0,%xmm4
movupd %xmm3,0x20(%rdi,%rcx,8)
movupd %xmm4,0x30(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1dc0 <ddoglg+0xca0>
test   $0x1,%dl
je     1e87 <ddoglg+0xd67>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm3
movupd (%rdi,%rcx,8),%xmm4
movupd 0x10(%rdi,%rcx,8),%xmm5
mulpd  %xmm2,%xmm4
mulpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm0
addpd  %xmm4,%xmm0
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm3,0x10(%rdi,%rcx,8)
cmp    %r14,%rax
jne    1cf5 <ddoglg+0xbd5>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    1e4c <ddoglg+0xd2c>
jmp    1e87 <ddoglg+0xd67>

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

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