#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 sqrt(double);
int d1updt(int m, int n, double *s, double *u, double *v, double *w) {
  int i, j, l;
  int jj;
  int nm1 = n - 1;
  int nmj;
  double temp;
  double giant, cotan;
  double tan_;
  double cos_, sin_, tau;
  giant = 1.79e+308;
  jj = n * ((m << 1) - n + 1) / 2 - (m - n) - 1;
  l = jj;
  for (i = nm1; i < m; ++i) {
    w[i] = s[l];
    ++l;
  }
  if (nm1 >= 1) {
    for (nmj = 1; nmj <= nm1; ++nmj) {
      j = n - nmj - 1;
      jj -= m - j;
      w[j] = 0.0;
      if (v[j] == 0.0)
        continue;
      if (((v[nm1]) >= 0.0 ? (v[nm1]) : -(v[nm1])) <
          ((v[j]) >= 0.0 ? (v[j]) : -(v[j]))) {
        cotan = v[nm1] / v[j];
        sin_ = 0.5 / sqrt(0.25 + 0.25 * (cotan * cotan));
        cos_ = sin_ * cotan;
        tau = 1.0;
        if (((cos_) >= 0.0 ? (cos_) : -(cos_)) * giant > 1.0) {
          tau = 1.0 / cos_;
        }
      } else {
        tan_ = v[j] / v[nm1];
        cos_ = 0.5 / sqrt(0.25 + 0.25 * (tan_ * tan_));
        sin_ = cos_ * tan_;
        tau = sin_;
      }
      v[nm1] = sin_ * v[j] + cos_ * v[nm1];
      v[j] = tau;
      l = jj;
      for (i = j; i < m; ++i) {
        temp = cos_ * s[l] - sin_ * w[i];
        w[i] = sin_ * s[l] + cos_ * w[i];
        s[l] = temp;
        ++l;
      }
    }
  }
  for (i = 0; i < m; ++i)
    w[i] += v[nm1] * u[i];
  if (nm1 >= 1) {
    for (j = 0; j < nm1; ++j) {
      if (w[j] != 0.0) {
        if (((s[jj]) >= 0.0 ? (s[jj]) : -(s[jj])) <
            ((w[j]) >= 0.0 ? (w[j]) : -(w[j]))) {
          cotan = s[jj] / w[j];
          sin_ = 0.5 / sqrt(0.25 + 0.25 * (cotan * cotan));
          cos_ = sin_ * cotan;
          tau = 1.0;
          if (((cos_) >= 0.0 ? (cos_) : -(cos_)) * giant > 1.0) {
            tau = 1.0 / cos_;
          }
        } else {
          tan_ = w[j] / s[jj];
          cos_ = 0.5 / sqrt(0.25 + 0.25 * (tan_ * tan_));
          sin_ = cos_ * tan_;
          tau = sin_;
        }
        l = jj;
        for (i = j; i < m; ++i) {
          temp = cos_ * s[l] + sin_ * w[i];
          w[i] = -sin_ * s[l] + cos_ * w[i];
          s[l] = temp;
          ++l;
        }
        w[j] = tau;
      }
      jj += m - j;
    }
  }
  l = jj;
  for (i = nm1; i < m; ++i) {
    s[l] = w[i];
    ++l;
  }
  return 0;
}


x86 assembly (clang, -O0):
<d1updt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movsd  0xebe(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
sub    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11b8 <d1updt+0xa8>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117b <d1updt+0x6b>
cmpl   $0x1,-0x3c(%rbp)
jl     1581 <d1updt+0x471>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     157c <d1updt+0x46c>
mov    -0x8(%rbp),%eax
sub    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1224 <d1updt+0x114>
jp     1224 <d1updt+0x114>
jmp    156e <d1updt+0x45e>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1255 <d1updt+0x145>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    127e <d1updt+0x16e>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12bf <d1updt+0x1af>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    12eb <d1updt+0x1db>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    13f1 <d1updt+0x2e1>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  0xcda(%rip),%xmm1
mulsd  %xmm1,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xcba(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xcaa(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1397 <d1updt+0x287>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    13bb <d1updt+0x2ab>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x50(%rbp),%xmm0
movsd  0xc48(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    13ec <d1updt+0x2dc>
movsd  0xc36(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    145c <d1updt+0x34c>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  0xbee(%rip),%xmm1
mulsd  %xmm1,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xbce(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1569 <d1updt+0x459>
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14b3 <d1updt+0x3a3>
jmp    156e <d1updt+0x45e>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11c9 <d1updt+0xb9>
jmp    1581 <d1updt+0x471>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15d6 <d1updt+0x4c6>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1588 <d1updt+0x478>
cmpl   $0x1,-0x3c(%rbp)
jl     194c <d1updt+0x83c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1947 <d1updt+0x837>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1618 <d1updt+0x508>
jp     1618 <d1updt+0x508>
jmp    192d <d1updt+0x81d>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     164c <d1updt+0x53c>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1678 <d1updt+0x568>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     16bc <d1updt+0x5ac>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    16e8 <d1updt+0x5d8>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    17ee <d1updt+0x6de>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  0x8dd(%rip),%xmm1
mulsd  %xmm1,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x8bd(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x8ad(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1794 <d1updt+0x684>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    17b8 <d1updt+0x6a8>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0x50(%rbp),%xmm0
movsd  0x84b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    17e9 <d1updt+0x6d9>
movsd  0x839(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1859 <d1updt+0x749>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  0x7f1(%rip),%xmm1
mulsd  %xmm1,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x7d1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    191b <d1updt+0x80b>
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1865 <d1updt+0x755>
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
sub    -0x30(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15e7 <d1updt+0x4d7>
jmp    194c <d1updt+0x83c>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1995 <d1updt+0x885>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1958 <d1updt+0x848>
xor    %eax,%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<d1updt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,(%rsp)
mov    %r8,0x20(%rsp)
mov    %rcx,0xa0(%rsp)
mov    %rdx,0x8(%rsp)
lea    -0x1(%rsi),%r14d
lea    (%rdi,%rdi,1),%r9d
mov    %r9d,%eax
sub    %esi,%eax
add    $0x1,%eax
imul   %esi,%eax
mov    %eax,%r12d
shr    $0x1f,%r12d
add    %eax,%r12d
sar    %r12d
mov    %edi,%r10d
not    %r10d
add    %esi,%r10d
add    %r12d,%r10d
mov    %rdi,0x18(%rsp)
mov    %rsi,0x10(%rsp)
sub    %esi,%edi
jl     1316 <d1updt+0x206>
movslq %r14d,%rdx
movslq %r10d,%rsi
cmp    $0x3,%edi
jb     1282 <d1updt+0x172>
mov    (%rsp),%rbp
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
lea    (%rsi,%rdi,1),%rcx
mov    0x8(%rsp),%rbx
lea    (%rbx,%rcx,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%rax
jae    11c5 <d1updt+0xb5>
lea    (%rdx,%rdi,1),%rax
lea    0x8(,%rax,8),%rax
add    %rbp,%rax
lea    (%rbx,%rsi,8),%rcx
cmp    %rax,%rcx
jb     1282 <d1updt+0x172>
mov    %r10d,%r15d
add    $0x1,%rdi
mov    %rdi,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     1ffb <d1updt+0xeeb>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
mov    0x8(%rsp),%rax
lea    (%rax,%rsi,8),%rax
add    $0x30,%rax
mov    (%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
add    $0x30,%rcx
xor    %ebp,%ebp
nopl   (%rax)
movups -0x30(%rax,%rbp,8),%xmm0
movups -0x20(%rax,%rbp,8),%xmm1
movups %xmm0,-0x30(%rcx,%rbp,8)
movups %xmm1,-0x20(%rcx,%rbp,8)
movupd -0x10(%rax,%rbp,8),%xmm0
movupd (%rax,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rcx,%rbp,8)
movupd %xmm1,(%rcx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1210 <d1updt+0x100>
test   $0x1,%r10b
je     1270 <d1updt+0x160>
lea    (%rsi,%rbp,1),%rax
add    %rdx,%rbp
mov    0x8(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
mov    (%rsp),%rax
movupd %xmm0,(%rax,%rbp,8)
movupd %xmm1,0x10(%rax,%rbp,8)
cmp    %r8,%rdi
mov    %r15d,%r10d
je     1316 <d1updt+0x206>
add    %r8,%rsi
add    %r8,%rdx
mov    0x18(%rsp),%rax
mov    %eax,%ebp
sub    %edx,%ebp
mov    %edx,%edi
not    %edi
add    %eax,%edi
and    $0x3,%ebp
je     12b7 <d1updt+0x1a7>
mov    (%rsp),%rax
mov    0x8(%rsp),%rcx
nop
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rsi
add    $0x1,%rdx
add    $0xffffffff,%ebp
jne    12a0 <d1updt+0x190>
cmp    $0x3,%edi
jb     1316 <d1updt+0x206>
mov    0x8(%rsp),%rax
lea    (%rax,%rsi,8),%rax
add    $0x18,%rax
mov    0x18(%rsp),%rcx
sub    %edx,%ecx
mov    (%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
add    $0x18,%rdx
xor    %esi,%esi
xchg   %ax,%ax
movsd  -0x18(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x18(%rdx,%rsi,8)
movsd  -0x10(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%rsi,8)
movsd  -0x8(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rsi,8)
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %esi,%ecx
jne    12e0 <d1updt+0x1d0>
mov    0x10(%rsp),%rdx
cmp    $0x2,%edx
mov    %r14d,0x4c(%rsp)
jl     1879 <d1updt+0x769>
mov    %r14d,%r11d
lea    -0x2(%rdx),%r15d
mov    0x18(%rsp),%rax
movslq %eax,%rcx
lea    (%r12,%rdx,2),%esi
sub    %r9d,%esi
add    $0xfffffffd,%esi
mov    %esi,0x38(%rsp)
mov    %edx,%r14d
sub    %eax,%r14d
add    $0xfffffffd,%r14d
mov    %edx,%esi
mov    %rsi,0x50(%rsp)
mov    (%rsp),%rbp
lea    0x0(,%rcx,8),%rsi
add    %rbp,%rsi
mov    %rsi,0x98(%rsp)
mov    0x8(%rsp),%rsi
add    $0x10,%rsi
mov    %rsi,0x90(%rsp)
lea    0x10(%rbp),%rsi
mov    %rsi,0x88(%rsp)
mov    %rcx,0x30(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x80(%rsp)
mov    $0x1,%r12d
xor    %ecx,%ecx
mov    %rcx,0x40(%rsp)
xorpd  %xmm8,%xmm8
movapd 0x1c49(%rip),%xmm9
movsd  0x1c50(%rip),%xmm10
movsd  0x1c4f(%rip),%xmm11
movapd 0x1c2e(%rip),%xmm12
movsd  0x1c4d(%rip),%xmm13
mov    %r15d,0x6c(%rsp)
mov    0x20(%rsp),%rsi
mov    %r11,0x28(%rsp)
jmp    141f <d1updt+0x30f>
nopl   0x0(%rax)
add    %ebx,%r10d
add    $0x1,%r12
add    $0xffffffff,%r15d
add    %r14d,0x38(%rsp)
add    $0xffffffff,%r14d
mov    0x40(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x40(%rsp)
cmp    0x50(%rsp),%r12
mov    %r8,%rax
je     1887 <d1updt+0x777>
mov    %r12d,%ebx
not    %ebx
add    %edx,%ebx
movslq %ebx,%r13
mov    %rax,%r8
sub    %eax,%ebx
movq   $0x0,0x0(%rbp,%r13,8)
movsd  (%rsi,%r13,8),%xmm14
ucomisd %xmm8,%xmm14
jne    1446 <d1updt+0x336>
jnp    13f0 <d1updt+0x2e0>
movsd  (%rsi,%r11,8),%xmm15
movapd %xmm15,%xmm0
xorpd  %xmm9,%xmm0
xorpd  %xmm1,%xmm1
cmpnlesd %xmm15,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm15,%xmm1
orpd   %xmm0,%xmm1
movapd %xmm14,%xmm0
xorpd  %xmm9,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm14,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm14,%xmm2
orpd   %xmm0,%xmm2
ucomisd %xmm1,%xmm2
jbe    14c0 <d1updt+0x3b0>
divsd  %xmm14,%xmm15
movapd %xmm15,%xmm0
mulsd  %xmm15,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm10,%xmm0
ucomisd %xmm8,%xmm0
jb     14f0 <d1updt+0x3e0>
sqrtsd %xmm0,%xmm0
mov    %r8,%rax
jmp    1553 <d1updt+0x443>
divsd  %xmm15,%xmm14
movapd %xmm14,%xmm0
mulsd  %xmm14,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm10,%xmm0
ucomisd %xmm8,%xmm0
jb     15a2 <d1updt+0x492>
sqrtsd %xmm0,%xmm0
mov    %r8,%rax
jmp    1605 <d1updt+0x4f5>
mov    %r10d,%ebp
movapd %xmm15,0x70(%rsp)
call   1030 <sqrt@plt>
movapd 0x70(%rsp),%xmm15
movsd  0x1b19(%rip),%xmm13
movapd 0x1ae8(%rip),%xmm12
movsd  0x1af7(%rip),%xmm11
movsd  0x1ae6(%rip),%xmm10
movapd 0x1acd(%rip),%xmm9
xorpd  %xmm8,%xmm8
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rsi
mov    %ebp,%r10d
mov    0x10(%rsp),%rdx
mov    (%rsp),%rbp
mov    0x18(%rsp),%rax
movapd %xmm11,%xmm14
divsd  %xmm0,%xmm14
mulsd  %xmm14,%xmm15
movapd %xmm15,%xmm0
xorpd  %xmm12,%xmm0
xorpd  %xmm1,%xmm1
cmplesd %xmm15,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm15,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
mulsd  0x1a91(%rip),%xmm1
movapd %xmm13,%xmm0
ucomisd %xmm13,%xmm1
jbe    1619 <d1updt+0x509>
divsd  %xmm15,%xmm0
jmp    1619 <d1updt+0x509>
mov    %r10d,%ebp
movapd %xmm14,0x70(%rsp)
call   1030 <sqrt@plt>
movapd 0x70(%rsp),%xmm14
movsd  0x1a67(%rip),%xmm13
movapd 0x1a36(%rip),%xmm12
movsd  0x1a45(%rip),%xmm11
movsd  0x1a34(%rip),%xmm10
movapd 0x1a1b(%rip),%xmm9
xorpd  %xmm8,%xmm8
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rsi
mov    %ebp,%r10d
mov    0x10(%rsp),%rdx
mov    (%rsp),%rbp
mov    0x18(%rsp),%rax
movapd %xmm11,%xmm15
divsd  %xmm0,%xmm15
mulsd  %xmm15,%xmm14
movapd %xmm14,%xmm0
movsd  (%rsi,%r11,8),%xmm1
mulsd  %xmm15,%xmm1
movsd  (%rsi,%r13,8),%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%r11,8)
movsd  %xmm0,(%rsi,%r13,8)
mov    %rax,%r8
cmp    %eax,%r13d
mov    0x30(%rsp),%rdi
jge    13f0 <d1updt+0x2e0>
mov    %r10d,%r13d
mov    0x6c(%rsp),%ecx
sub    0x40(%rsp),%ecx
movslq %r15d,%rax
movslq %ecx,%rcx
mov    %rdi,%r10
sub    %rcx,%r10
movslq 0x38(%rsp),%r9
movapd %xmm14,%xmm0
xorpd  %xmm12,%xmm0
cmp    $0x2,%r10
jae    1684 <d1updt+0x574>
mov    %r13d,%r10d
jmp    1816 <d1updt+0x706>
lea    (%rdi,%r9,1),%rdx
sub    %rcx,%rdx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
cmp    %rdx,%rcx
jae    16bf <d1updt+0x5af>
lea    (%rdi,%r9,8),%rcx
cmp    0x98(%rsp),%rcx
jae    16bf <d1updt+0x5af>
mov    0x10(%rsp),%rdx
mov    %r13d,%r10d
jmp    1816 <d1updt+0x706>
lea    -0x2(%r10),%rcx
mov    %rcx,%rbp
shr    %rbp
add    $0x1,%rbp
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm15,%xmm1
unpcklpd %xmm15,%xmm1
movapd %xmm14,%xmm2
unpcklpd %xmm14,%xmm2
cmp    $0x2,%rcx
jae    16f6 <d1updt+0x5e6>
xor    %edi,%edi
jmp    17a6 <d1updt+0x696>
mov    0x80(%rsp),%rsi
sub    %rax,%rsi
shr    %rsi
add    $0x1,%rsi
mov    0x90(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
mov    0x88(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdi,8),%xmm4
movupd -0x10(%rdx,%rdi,8),%xmm5
movapd %xmm5,%xmm6
mulpd  %xmm3,%xmm6
movapd %xmm1,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x10(%rdx,%rdi,8)
movupd %xmm7,-0x10(%rcx,%rdi,8)
movupd (%rcx,%rdi,8),%xmm4
movupd (%rdx,%rdi,8),%xmm5
movapd %xmm5,%xmm6
mulpd  %xmm3,%xmm6
movapd %xmm1,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%rdx,%rdi,8)
movupd %xmm7,(%rcx,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1730 <d1updt+0x620>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
test   $0x1,%bpl
mov    (%rsp),%rbp
mov    0x8(%rsp),%rsi
je     17f5 <d1updt+0x6e5>
lea    (%rdi,%r9,1),%rdx
add    %rax,%rdi
movupd (%rsi,%rdx,8),%xmm4
movupd 0x0(%rbp,%rdi,8),%xmm5
mulpd  %xmm5,%xmm3
movapd %xmm1,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm5,%xmm1
mulpd  %xmm4,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x0(%rbp,%rdi,8)
movupd %xmm6,(%rsi,%rdx,8)
cmp    %rcx,%r10
mov    0x10(%rsp),%rdx
mov    %r13d,%r10d
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%r11
je     13f0 <d1updt+0x2e0>
add    %rcx,%r9
add    %rcx,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
mov    0x30(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx),%xmm1
movsd  0x0(%rbp,%rax,8),%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm15,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm15,%xmm2
mulsd  %xmm14,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  %xmm4,(%rcx)
add    $0x1,%rax
add    $0x8,%rcx
cmp    %rdi,%rax
jl     1830 <d1updt+0x720>
jmp    13f0 <d1updt+0x2e0>
mov    0x18(%rsp),%rax
mov    (%rsp),%rbp
mov    0x20(%rsp),%rsi
mov    %eax,%ebx
mov    %rax,%r8
test   %eax,%eax
mov    0x4c(%rsp),%r9d
mov    0xa0(%rsp),%rdi
mov    0x8(%rsp),%r11
jle    19d4 <d1updt+0x8c4>
movslq %r9d,%rcx
lea    (%rsi,%rcx,8),%rax
cmp    $0x4,%r8d
jae    18ba <d1updt+0x7aa>
xor    %ecx,%ecx
jmp    1966 <d1updt+0x856>
mov    %rsi,%rdx
lea    0x0(,%rbx,8),%rsi
add    %rbp,%rsi
lea    (%rdx,%rcx,8),%rcx
add    $0x8,%rcx
lea    (%rdi,%rbx,8),%rdx
cmp    %rbp,%rcx
seta   %r14b
cmp    %rsi,%rax
setb   %r15b
cmp    %rbp,%rdx
seta   %dl
cmp    %rdi,%rsi
seta   %sil
xor    %ecx,%ecx
test   %r15b,%r14b
jne    1966 <d1updt+0x856>
and    %sil,%dl
jne    1966 <d1updt+0x856>
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
movsd  (%rax),%xmm0
unpcklpd %xmm0,%xmm0
lea    0x0(,%rbx,8),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd (%rdi,%rsi,1),%xmm1
movupd 0x10(%rdi,%rsi,1),%xmm2
movupd 0x0(%rbp,%rsi,1),%xmm3
movupd 0x10(%rbp,%rsi,1),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,0x0(%rbp,%rsi,1)
movupd %xmm2,0x10(%rbp,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1920 <d1updt+0x810>
cmp    %rbx,%rcx
mov    0x10(%rsp),%rdx
je     19d4 <d1updt+0x8c4>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%bl
je     198a <d1updt+0x87a>
movsd  (%rax),%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
addsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
or     $0x1,%rcx
add    %rbx,%rdx
mov    0x10(%rsp),%rdx
je     19d4 <d1updt+0x8c4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax),%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
addsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  (%rax),%xmm0
mulsd  0x8(%rdi,%rcx,8),%xmm0
addsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    19a0 <d1updt+0x890>
cmp    $0x2,%edx
jl     1e2d <d1updt+0xd1d>
movslq %r8d,%rax
mov    %rax,0x40(%rsp)
mov    %r9d,%eax
mov    %r8,%r9
mov    %rax,%r8
lea    0x0(%rbp,%rbx,8),%rax
mov    %rax,0x20(%rsp)
lea    0x10(%r11),%rax
mov    %rax,0x28(%rsp)
lea    0x10(%rbp),%r13
mov    %rbx,0x38(%rsp)
lea    -0x2(%rbx),%r12
xor    %r15d,%r15d
xorpd  %xmm9,%xmm9
movapd 0x15e1(%rip),%xmm10
movsd  0x15e8(%rip),%xmm11
movsd  0x15e7(%rip),%xmm12
movapd 0x15c6(%rip),%xmm13
movsd  0x15e5(%rip),%xmm14
mov    %r9d,%ebx
mov    %r8,0x30(%rsp)
jmp    1a72 <d1updt+0x962>
nopl   (%rax)
movsd  %xmm8,0x0(%rbp,%r15,8)
add    %ebx,%r10d
add    $0x1,%r15
add    $0xffffffff,%ebx
add    $0x8,%r13
add    $0xffffffffffffffff,%r12
cmp    %r8,%r15
je     1e30 <d1updt+0xd20>
movsd  0x0(%rbp,%r15,8),%xmm15
ucomisd %xmm9,%xmm15
jne    1a82 <d1updt+0x972>
jnp    1a57 <d1updt+0x947>
movslq %r10d,%r14
movsd  (%r11,%r14,8),%xmm5
movapd %xmm5,%xmm0
xorpd  %xmm10,%xmm0
xorpd  %xmm1,%xmm1
cmpnlesd %xmm5,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm5,%xmm1
orpd   %xmm0,%xmm1
movapd %xmm15,%xmm0
xorpd  %xmm10,%xmm0
xorpd  %xmm2,%xmm2
cmpnlesd %xmm15,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm15,%xmm2
orpd   %xmm0,%xmm2
ucomisd %xmm1,%xmm2
jbe    1b00 <d1updt+0x9f0>
divsd  %xmm15,%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm11,%xmm0
ucomisd %xmm9,%xmm0
jb     1b2d <d1updt+0xa1d>
sqrtsd %xmm0,%xmm0
jmp    1b89 <d1updt+0xa79>
nopw   0x0(%rax,%rax,1)
divsd  %xmm5,%xmm15
movapd %xmm15,%xmm0
mulsd  %xmm15,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm11,%xmm0
ucomisd %xmm9,%xmm0
jb     1bd5 <d1updt+0xac5>
sqrtsd %xmm0,%xmm0
jmp    1c33 <d1updt+0xb23>
mov    %r10d,%ebp
movapd %xmm5,0x50(%rsp)
call   1030 <sqrt@plt>
movapd 0x50(%rsp),%xmm5
movsd  0x14de(%rip),%xmm14
movapd 0x14ad(%rip),%xmm13
movsd  0x14bc(%rip),%xmm12
movsd  0x14ab(%rip),%xmm11
movapd 0x1492(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x30(%rsp),%r8
mov    %ebp,%r10d
mov    0x8(%rsp),%r11
mov    (%rsp),%rbp
mov    0x18(%rsp),%r9
movapd %xmm12,%xmm15
divsd  %xmm0,%xmm15
mulsd  %xmm15,%xmm5
movapd %xmm5,%xmm0
xorpd  %xmm13,%xmm0
xorpd  %xmm1,%xmm1
cmplesd %xmm5,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm5,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
mulsd  0x145e(%rip),%xmm1
movapd %xmm14,%xmm8
ucomisd %xmm14,%xmm1
jbe    1c46 <d1updt+0xb36>
divsd  %xmm5,%xmm8
jmp    1c46 <d1updt+0xb36>
mov    %r10d,%ebp
movapd %xmm15,0x50(%rsp)
call   1030 <sqrt@plt>
movapd 0x50(%rsp),%xmm15
movsd  0x1434(%rip),%xmm14
movapd 0x1403(%rip),%xmm13
movsd  0x1412(%rip),%xmm12
movsd  0x1401(%rip),%xmm11
movapd 0x13e8(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x30(%rsp),%r8
mov    %ebp,%r10d
mov    0x8(%rsp),%r11
mov    (%rsp),%rbp
mov    0x18(%rsp),%r9
movapd %xmm12,%xmm5
divsd  %xmm0,%xmm5
mulsd  %xmm5,%xmm15
movapd %xmm15,%xmm8
cmp    0x40(%rsp),%r15
jge    1a50 <d1updt+0x940>
mov    0x38(%rsp),%rax
sub    %r15,%rax
movapd %xmm15,%xmm1
xorpd  %xmm13,%xmm1
cmp    $0x2,%rax
jb     1c8c <d1updt+0xb7c>
lea    0x0(,%r15,8),%rcx
add    %rbp,%rcx
lea    (%r11,%rax,8),%rdx
lea    (%rdx,%r14,8),%rdx
cmp    %rdx,%rcx
jae    1cf3 <d1updt+0xbe3>
lea    (%r11,%r14,8),%rcx
cmp    0x20(%rsp),%rcx
jae    1cf3 <d1updt+0xbe3>
mov    %r15,%rsi
lea    (%r11,%r14,8),%rax
lea    0x0(,%rsi,8),%rcx
add    %rbp,%rcx
mov    0x38(%rsp),%rdx
sub    %rsi,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm0
movsd  (%rcx,%rsi,8),%xmm2
movapd %xmm15,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm5,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm5,%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  %xmm4,(%rax,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1cb0 <d1updt+0xba0>
jmp    1a50 <d1updt+0x940>
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
movapd %xmm15,%xmm4
unpcklpd %xmm15,%xmm4
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
cmp    $0x2,%rdx
movapd %xmm5,0x50(%rsp)
jae    1d2e <d1updt+0xc1e>
xor    %edx,%edx
jmp    1dcc <d1updt+0xcbc>
mov    %r12,%rsi
shr    %rsi
add    $0x1,%rsi
mov    0x28(%rsp),%rdx
lea    (%rdx,%r14,8),%rdi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rdx,8),%xmm5
movupd -0x10(%r13,%rdx,8),%xmm6
movapd %xmm4,%xmm7
mulpd  %xmm6,%xmm7
movapd %xmm0,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm7,%xmm2
mulpd  %xmm0,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,-0x10(%r13,%rdx,8)
movupd %xmm2,-0x10(%rdi,%rdx,8)
movupd (%rdi,%rdx,8),%xmm2
movupd 0x0(%r13,%rdx,8),%xmm5
movapd %xmm4,%xmm6
mulpd  %xmm5,%xmm6
movapd %xmm0,%xmm7
mulpd  %xmm2,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm0,%xmm5
mulpd  %xmm3,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm2,0x0(%r13,%rdx,8)
movupd %xmm7,(%rdi,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1d50 <d1updt+0xc40>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
test   $0x1,%cl
je     1e13 <d1updt+0xd03>
lea    (%r15,%rdx,1),%rcx
add    %r14,%rdx
movupd (%r11,%rdx,8),%xmm2
movupd 0x0(%rbp,%rcx,8),%xmm5
mulpd  %xmm5,%xmm4
movapd %xmm0,%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
mulpd  %xmm5,%xmm0
mulpd  %xmm2,%xmm3
addpd  %xmm0,%xmm3
movupd %xmm3,0x0(%rbp,%rcx,8)
movupd %xmm6,(%r11,%rdx,8)
cmp    %rsi,%rax
movapd 0x50(%rsp),%xmm5
je     1a50 <d1updt+0x940>
add    %rsi,%r14
add    %r15,%rsi
jmp    1c8f <d1updt+0xb7f>
mov    %r8,%r9
mov    %r9d,%edx
sub    0x10(%rsp),%edx
jl     1fe7 <d1updt+0xed7>
movslq 0x4c(%rsp),%rax
movslq %r10d,%rcx
cmp    $0x3,%edx
jb     1f52 <d1updt+0xe42>
mov    0x8(%rsp),%rbx
lea    (%rbx,%rcx,8),%rsi
lea    (%rax,%rdx,1),%rdi
mov    (%rsp),%rbp
lea    0x8(,%rdi,8),%rdi
add    %rbp,%rdi
cmp    %rdi,%rsi
jae    1e8f <d1updt+0xd7f>
lea    (%rcx,%rdx,1),%rsi
lea    (%rbx,%rsi,8),%rsi
add    $0x8,%rsi
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
cmp    %rsi,%rdi
jb     1f52 <d1updt+0xe42>
mov    %r9,%r10
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     200c <d1updt+0xefc>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x8(%rsp),%rsi
lea    (%rsi,%rcx,8),%rsi
add    $0x30,%rsi
mov    (%rsp),%rbp
lea    0x30(,%rax,8),%rbx
add    %rbp,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x30(%rbx,%rbp,8),%xmm0
movups -0x20(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x30(%rsi,%rbp,8)
movups %xmm1,-0x20(%rsi,%rbp,8)
movupd -0x10(%rbx,%rbp,8),%xmm0
movupd (%rbx,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,8)
movupd %xmm1,(%rsi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1ee0 <d1updt+0xdd0>
test   $0x1,%r9b
je     1f40 <d1updt+0xe30>
lea    (%rcx,%rbp,1),%rsi
add    %rax,%rbp
mov    (%rsp),%rdi
movupd (%rdi,%rbp,8),%xmm0
movupd 0x10(%rdi,%rbp,8),%xmm1
mov    0x8(%rsp),%rdi
movupd %xmm0,(%rdi,%rsi,8)
movupd %xmm1,0x10(%rdi,%rsi,8)
cmp    %r8,%rdx
je     1fe7 <d1updt+0xed7>
mov    %r10,%r9
add    %r8,%rcx
add    %r8,%rax
mov    %r9d,%esi
sub    %eax,%esi
mov    %eax,%edx
not    %edx
add    %r9d,%edx
and    $0x3,%esi
je     1f88 <d1updt+0xe78>
mov    (%rsp),%rdi
mov    0x8(%rsp),%rbp
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
add    $0x1,%rax
add    $0xffffffff,%esi
jne    1f70 <d1updt+0xe60>
cmp    $0x3,%edx
jb     1fe7 <d1updt+0xed7>
mov    0x8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
add    $0x18,%rcx
sub    %eax,%r9d
mov    (%rsp),%rdx
lea    (%rdx,%rax,8),%rax
add    $0x18,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rdx,8)
movsd  -0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rdx,8)
movsd  -0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %edx,%r9d
jne    1fb0 <d1updt+0xea0>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
test   $0x1,%r10b
jne    124a <d1updt+0x13a>
jmp    1270 <d1updt+0x160>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    1f1a <d1updt+0xe0a>
jmp    1f40 <d1updt+0xe30>

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

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