#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 fabs(double);
double hypot(double, double);
double sqrt(double);
void update_(int n, int npt, double *bmat, double *zmat, int ndim, double *vlag,
             double beta, double denom, int knew, double *w) {
  int i, j;
  double tau;
  double alpha, tempa, tempb, ztest;
  const int nptm = npt - n - 1;
  ztest = 0;
  for (j = 0; j < nptm; ++j) {
    int k;
    for (k = 0; k < npt; ++k) {
      double tmp = fabs(zmat[k + j * npt]);
      if (tmp > ztest) {
        ztest = tmp;
      }
    }
  }
  ztest *= 1e-20;
  for (j = 1; j < nptm; ++j) {
    if (fabs(zmat[knew + j * npt]) > ztest) {
      double temp = hypot(zmat[knew + 0 * npt], zmat[knew + j * npt]);
      tempa = zmat[knew + 0 * npt] / temp;
      tempb = zmat[knew + j * npt] / temp;
      for (i = 0; i < npt; ++i) {
        temp = tempa * zmat[i + 0 * npt] + tempb * zmat[i + j * npt];
        zmat[i + j * npt] =
            tempa * zmat[i + j * npt] - tempb * zmat[i + 0 * npt];
        zmat[i + 0 * npt] = temp;
      }
    }
    zmat[knew + j * npt] = 0;
  }
  for (i = 0; i < npt; ++i) {
    w[i] = zmat[knew + 0 * npt] * zmat[i + 0 * npt];
  }
  alpha = w[knew];
  tau = vlag[knew];
  vlag[knew] -= 1.;
  {
    double temp = sqrt(denom);
    tempb = zmat[knew + 0 * npt] / temp;
    tempa = tau / temp;
  }
  for (i = 0; i < npt; ++i) {
    zmat[i + 0 * npt] = tempa * zmat[i + 0 * npt] - tempb * vlag[i];
  }
  for (j = 0; j < n; ++j) {
    const int jp = npt + j;
    w[jp] = bmat[knew + j * ndim];
    tempa = (alpha * vlag[jp] - tau * w[jp]) / denom;
    tempb = (-beta * w[jp] - tau * vlag[jp]) / denom;
    for (i = 0; i <= jp; ++i) {
      bmat[i + j * ndim] = bmat[i + j * ndim] + tempa * vlag[i] + tempb * w[i];
      if (i >= npt) {
        bmat[jp + (i - npt) * ndim] = bmat[i + j * ndim];
      }
    }
  }
}


x86 assembly (clang, -O0):
<update_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
mov    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    11f4 <update_+0xd4>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11e1 <update_+0xc1>
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe65(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    11ce <update_+0xae>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    11d3 <update_+0xb3>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1180 <update_+0x60>
jmp    11e6 <update_+0xc6>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    116d <update_+0x4d>
movsd  0xe04(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    13da <update_+0x2ba>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdd8(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    13b1 <update_+0x291>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1030 <hypot@plt>
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13ac <update_+0x28c>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12c6 <update_+0x1a6>
jmp    13b1 <update_+0x291>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    120d <update_+0xed>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1432 <update_+0x312>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13e1 <update_+0x2c1>
mov    0x18(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb9d(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    153b <update_+0x41b>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x3c(%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
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   $0x0,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14c1 <update_+0x3a1>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1721 <update_+0x601>
mov    -0x8(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x8c(%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
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x8c(%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
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jg     170e <update_+0x5ee>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jl     16fb <update_+0x5db>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sub    -0x8(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1700 <update_+0x5e0>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1646 <update_+0x526>
jmp    1713 <update_+0x5f3>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1542 <update_+0x422>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
movsd  %xmm1,0x38(%rsp)
movapd %xmm0,0x80(%rsp)
mov    %r9,%r12
mov    %r8d,0x1c(%rsp)
mov    %rcx,%rbp
mov    %rdx,0x78(%rsp)
mov    %esi,%r9d
mov    %edi,0x18(%rsp)
mov    %edi,%esi
not    %esi
add    %r9d,%esi
movslq %r9d,%r10
mov    %r9d,%r11d
movslq 0x100(%rsp),%r14
test   %esi,%esi
mov    %r10,0x8(%rsp)
mov    %r14,0x70(%rsp)
jle    157e <update_+0x45e>
mov    %esi,%r15d
mov    %r11d,%ecx
and    $0xfffffffe,%ecx
lea    0x8(%rbp),%rdx
lea    0x0(,%r10,8),%r8
xorpd  %xmm7,%xmm7
xor    %eax,%eax
movapd 0xe5e(%rip),%xmm10
movapd 0xe56(%rip),%xmm0
jmp    11bc <update_+0x9c>
nopl   0x0(%rax)
add    $0x1,%rax
add    %r8,%rdx
cmp    %r15,%rax
je     121d <update_+0xfd>
test   %r9d,%r9d
jle    11b0 <update_+0x90>
xor    %edi,%edi
cmp    $0x1,%r9d
je     11f8 <update_+0xd8>
movapd %xmm7,%xmm1
nopl   (%rax)
movsd  -0x8(%rdx,%rdi,8),%xmm2
movsd  (%rdx,%rdi,8),%xmm7
andpd  %xmm0,%xmm2
maxsd  %xmm1,%xmm2
andpd  %xmm0,%xmm7
maxsd  %xmm2,%xmm7
add    $0x2,%rdi
movapd %xmm7,%xmm1
cmp    %rdi,%rcx
jne    11d0 <update_+0xb0>
test   $0x1,%r11b
je     11b0 <update_+0x90>
mov    %rax,%rbx
imul   %r10,%rbx
add    %rbx,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
andpd  %xmm10,%xmm1
maxsd  %xmm7,%xmm1
movapd %xmm1,%xmm7
jmp    11b0 <update_+0x90>
cmp    $0x2,%esi
jl     157e <update_+0x45e>
mulsd  0xe22(%rip),%xmm7
lea    (%r10,%r11,1),%rax
mov    %rax,0xb8(%rsp)
lea    0x0(,%r11,8),%rax
add    %rbp,%rax
mov    %rax,0xc0(%rsp)
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    %rax,0xb0(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0xa8(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0xa0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x98(%rsp)
lea    0x10(%rbp),%rdi
lea    0x0(,%r10,8),%r13
add    %rbp,%r13
mov    $0x1,%ebx
xor    %esi,%esi
mov    %r8,%rdx
mov    %r8,0x50(%rsp)
movapd %xmm7,0x40(%rsp)
mov    %r15,0x10(%rsp)
jmp    12e0 <update_+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0x0,0x0(%rbp,%rcx,8)
add    $0x1,%rbx
add    $0x1,%rsi
add    %r8,%rdx
add    %r8,%r13
cmp    %r15,%rbx
je     157e <update_+0x45e>
mov    %rbx,%rax
imul   %r10,%rax
mov    %rax,0x68(%rsp)
lea    (%rax,%r14,1),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm1
movapd %xmm1,%xmm0
andpd  %xmm10,%xmm0
ucomisd %xmm7,%xmm0
jbe    12c0 <update_+0x1a0>
movsd  0x0(%rbp,%r14,8),%xmm0
mov    %rbx,0x60(%rsp)
mov    %r9,%rbx
mov    %rsi,0x58(%rsp)
mov    %rdx,0x20(%rsp)
mov    %r11,%r14
mov    %rdi,%r15
mov    %rcx,(%rsp)
call   1030 <hypot@plt>
mov    (%rsp),%rcx
mov    %r15,%rdi
movapd 0x40(%rsp),%xmm7
movapd 0xcbd(%rip),%xmm10
mov    %r14,%r11
mov    0x20(%rsp),%rdx
mov    0x58(%rsp),%rsi
mov    0x10(%rsp),%r15
mov    0x50(%rsp),%r8
mov    0x70(%rsp),%r14
mov    0x8(%rsp),%r10
mov    %rbx,%r9
mov    0x60(%rsp),%rbx
test   %r9d,%r9d
jle    12c0 <update_+0x1a0>
movsd  0x0(%rbp,%r14,8),%xmm1
divsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
divsd  %xmm0,%xmm2
movapd %xmm2,%xmm11
xorpd  0xc78(%rip),%xmm11
cmp    $0x1,%r9d
jne    13a5 <update_+0x285>
xor    %eax,%eax
jmp    1520 <update_+0x400>
mov    %rsi,%rax
imul   %r10,%rax
lea    (%rax,%r10,1),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
cmp    0xc0(%rsp),%rcx
jae    13e8 <update_+0x2c8>
add    0xb8(%rsp),%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %rbp,%rax
jbe    13e8 <update_+0x2c8>
xor    %eax,%eax
mov    (%rsp),%rcx
jmp    1520 <update_+0x400>
movapd %xmm2,%xmm9
unpcklpd %xmm2,%xmm9
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
movapd %xmm11,%xmm8
unpcklpd %xmm11,%xmm8
cmpq   $0x0,0xa8(%rsp)
je     1569 <update_+0x449>
mov    0x20(%rsp),%rax
lea    (%rdi,%rax,1),%rcx
mov    0x98(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rax,8),%xmm6
movupd -0x10(%rcx,%rax,8),%xmm4
movapd %xmm9,%xmm5
mulpd  %xmm4,%xmm5
movapd %xmm0,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm8,%xmm6
mulpd  %xmm0,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm4,-0x10(%rcx,%rax,8)
movupd %xmm3,-0x10(%rdi,%rax,8)
movupd (%rdi,%rax,8),%xmm3
movupd (%rcx,%rax,8),%xmm5
movapd %xmm9,%xmm6
mulpd  %xmm5,%xmm6
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm8,%xmm3
mulpd  %xmm0,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm5,(%rcx,%rax,8)
movupd %xmm4,(%rdi,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rdx
jne    1430 <update_+0x310>
testb  $0x1,0xa0(%rsp)
01
je     14f4 <update_+0x3d4>
movupd 0x0(%rbp,%rax,8),%xmm3
mov    0x68(%rsp),%rcx
add    %rax,%rcx
movupd 0x0(%rbp,%rcx,8),%xmm5
mulpd  %xmm5,%xmm9
movapd %xmm0,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm9,%xmm6
mulpd  %xmm3,%xmm8
mulpd  %xmm5,%xmm0
addpd  %xmm8,%xmm0
movupd %xmm0,0x0(%rbp,%rcx,8)
movupd %xmm6,0x0(%rbp,%rax,8)
mov    0xb0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r11,%rcx
mov    0x20(%rsp),%rdx
mov    (%rsp),%rcx
je     12c0 <update_+0x1a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm3
movsd  0x0(%r13,%rax,8),%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm1,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm11,%xmm3
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x0(%r13,%rax,8)
movsd  %xmm6,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    1520 <update_+0x400>
jmp    12c0 <update_+0x1a0>
xor    %eax,%eax
testb  $0x1,0xa0(%rsp)
01
jne    14b4 <update_+0x394>
jmp    14f4 <update_+0x3d4>
mov    0x108(%rsp),%rdi
test   %r9d,%r9d
movsd  0x38(%rsp),%xmm3
movapd 0x80(%rsp),%xmm4
jle    1781 <update_+0x661>
lea    0x0(,%r14,8),%rax
add    %rbp,%rax
cmp    $0x4,%r9d
mov    %r14,%r8
jae    165d <update_+0x53d>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r11,%rdx
mov    %r11,%rsi
mov    0x108(%rsp),%rdi
and    $0x3,%rsi
je     15f9 <update_+0x4d9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax),%xmm0
mulsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    15e0 <update_+0x4c0>
cmp    $0x3,%rdx
mov    %r8,%r14
jb     1781 <update_+0x661>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
mulsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  (%rax),%xmm0
mulsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
movsd  (%rax),%xmm0
mulsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rcx,8)
movsd  (%rax),%xmm0
mulsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1610 <update_+0x4f0>
jmp    1781 <update_+0x661>
lea    0x0(,%r11,8),%rcx
add    %rbp,%rcx
mov    %r14,%rdi
mov    0x108(%rsp),%rsi
cmp    %rsi,%rcx
seta   %r14b
lea    (%rsi,%r11,8),%rcx
cmp    %rbp,%rcx
seta   %bl
lea    0x8(,%rdi,8),%rdx
add    %rbp,%rdx
cmp    %rsi,%rdx
seta   %dl
cmp    %rcx,%rax
setb   %sil
xor    %ecx,%ecx
test   %bl,%r14b
jne    15b8 <update_+0x498>
and    %sil,%dl
jne    15b8 <update_+0x498>
mov    %r11d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rdx,%rdx
je     1df2 <update_+0xcd2>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
movsd  (%rax),%xmm0
unpcklpd %xmm0,%xmm0
xor    %edx,%edx
mov    0x108(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd 0x10(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rsi,%rdx,8)
movupd %xmm2,0x10(%rsi,%rdx,8)
movupd 0x20(%rbp,%rdx,8),%xmm1
movupd 0x30(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x20(%rsi,%rdx,8)
movupd %xmm2,0x30(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    16f0 <update_+0x5d0>
test   $0x1,%bl
je     176d <update_+0x64d>
movsd  (%rax),%xmm0
unpcklpd %xmm0,%xmm0
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd 0x10(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
mov    0x108(%rsp),%rsi
movupd %xmm1,(%rsi,%rdx,8)
movupd %xmm2,0x10(%rsi,%rdx,8)
cmp    %r11,%rcx
mov    0x108(%rsp),%rdi
mov    %r8,%r14
jne    15b8 <update_+0x498>
movsd  (%rdi,%r14,8),%xmm15
movsd  (%r12,%r14,8),%xmm13
movsd  0x8c3(%rip),%xmm0
addsd  %xmm13,%xmm0
movsd  %xmm0,(%r12,%r14,8)
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jb     17b3 <update_+0x693>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    17fb <update_+0x6db>
movapd %xmm3,%xmm0
mov    %r9,%rbx
mov    %r11,%r14
movsd  %xmm15,(%rsp)
movapd %xmm13,0x20(%rsp)
call   1040 <sqrt@plt>
movapd 0x20(%rsp),%xmm13
movsd  (%rsp),%xmm15
mov    %r14,%r11
mov    0x70(%rsp),%r14
mov    0x8(%rsp),%r10
mov    %rbx,%r9
movapd 0x80(%rsp),%xmm4
movsd  0x38(%rsp),%xmm3
mov    0x18(%rsp),%esi
test   %r9d,%r9d
jle    1a03 <update_+0x8e3>
movapd %xmm13,%xmm8
divsd  %xmm0,%xmm8
movsd  0x0(%rbp,%r14,8),%xmm9
xorpd  0x7ee(%rip),%xmm9
divsd  %xmm0,%xmm9
cmp    $0x4,%r9d
jb     184e <update_+0x72e>
lea    (%r12,%r11,8),%rax
cmp    %rbp,%rax
jbe    18df <update_+0x7bf>
lea    0x0(,%r11,8),%rax
add    %rbp,%rax
cmp    %r12,%rax
jbe    18df <update_+0x7bf>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r11b
je     1880 <update_+0x760>
movsd  (%r12,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
or     $0x1,%rax
add    %r11,%rcx
je     1a03 <update_+0x8e3>
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    1890 <update_+0x770>
jmp    1a03 <update_+0x8e3>
mov    %r11d,%eax
and    $0xfffffffc,%eax
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1de2 <update_+0xcc2>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%r12,%rcx,8),%xmm4
movupd 0x10(%r12,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd 0x0(%rbp,%rcx,8),%xmm6
movupd 0x10(%rbp,%rcx,8),%xmm7
movupd 0x20(%rbp,%rcx,8),%xmm1
movupd 0x30(%rbp,%rcx,8),%xmm2
mulpd  %xmm0,%xmm6
addpd  %xmm4,%xmm6
mulpd  %xmm0,%xmm7
addpd  %xmm5,%xmm7
movupd %xmm6,0x0(%rbp,%rcx,8)
movupd %xmm7,0x10(%rbp,%rcx,8)
movupd 0x20(%r12,%rcx,8),%xmm4
movupd 0x30(%r12,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,0x20(%rbp,%rcx,8)
movupd %xmm2,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1920 <update_+0x800>
test   $0x1,%dl
je     19eb <update_+0x8cb>
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd 0x10(%rbp,%rcx,8),%xmm2
movupd (%r12,%rcx,8),%xmm4
movupd 0x10(%r12,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,0x0(%rbp,%rcx,8)
movupd %xmm2,0x10(%rbp,%rcx,8)
cmp    %r11,%rax
movsd  0x38(%rsp),%xmm3
movapd 0x80(%rsp),%xmm4
jne    1850 <update_+0x730>
test   %esi,%esi
jle    1dd0 <update_+0xcb0>
movapd 0x5fd(%rip),%xmm0
xorpd  %xmm0,%xmm13
xorpd  %xmm0,%xmm4
movslq 0x1c(%rsp),%rax
mov    %esi,%ecx
mov    %rcx,0x68(%rsp)
mov    %rax,%rsi
add    $0x1,%r9d
movq   %r10,%xmm0
pshufd $0x44,%xmm0,%xmm12
mov    $0x1,%eax
mov    $0x1,%ecx
sub    %r10,%rcx
imul   %rsi,%rcx
add    %r10,%rcx
mov    0x78(%rsp),%rdx
lea    (%rdx,%rcx,8),%r14
mov    %rsi,%rcx
shl    $0x4,%rcx
mov    %rcx,0x80(%rsp)
lea    0x0(,%rsi,8),%rdi
sub    %rsi,%rax
imul   %r10,%rax
lea    (%rdx,%rax,8),%r15
lea    (%rdx,%r10,8),%rax
mov    %rax,(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0x50(%rsp)
xor    %r11d,%r11d
movdqa 0x598(%rip),%xmm9
pxor   %xmm9,%xmm12
pcmpeqd %xmm10,%xmm10
movdqa 0x595(%rip),%xmm11
mov    %r9d,%r8d
mov    %rdx,%rcx
mov    %r9,0x40(%rsp)
mov    %rsi,0x10(%rsp)
jmp    1ae3 <update_+0x9c3>
nopl   (%rax)
add    $0x1,%r11
add    $0x8,%r14
add    %rdi,%rcx
add    $0x8,%r15
add    $0x1,%r8d
addq   $0x8,(%rsp)
cmp    0x68(%rsp),%r11
je     1dd0 <update_+0xcb0>
mov    %r8d,%r8d
mov    %r11,%rax
imul   %rsi,%rax
lea    (%r11,%r10,1),%rbx
mov    0x70(%rsp),%rdx
add    %rax,%rdx
mov    0x78(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm1
mov    0x108(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%rbx,8)
test   %rbx,%rbx
js     1ac0 <update_+0x9a0>
lea    (%r9,%r11,1),%edx
movsd  (%r12,%rbx,8),%xmm5
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm13,%xmm1
movapd %xmm15,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm1,%xmm6
divsd  %xmm3,%xmm6
mulsd  %xmm13,%xmm5
addsd  %xmm2,%xmm5
divsd  %xmm3,%xmm5
mov    %rdx,0x20(%rsp)
cmp    $0x2,%edx
jb     1d15 <update_+0xbf5>
mov    $0x0,%r13d
cmpl   $0x1,0x1c(%rsp)
jne    1d70 <update_+0xc50>
mov    %rbp,%r10
mov    0x78(%rsp),%rbp
lea    0x0(,%r11,8),%rdx
add    %rbp,%rdx
mov    %r12,%rsi
mov    0x20(%rsp),%r12
lea    (%rdx,%r12,8),%rbx
lea    (%rsi,%r12,8),%r9
lea    (%r10,%r12,8),%r10
lea    0x0(,%rax,8),%r13
add    %rbp,%r13
cmp    %r9,%rdx
setb   0x60(%rsp)
cmp    %rsi,%rbx
seta   0x58(%rsp)
cmp    %r10,%rdx
setb   %al
cmp    0x108(%rsp),%rbx
seta   %bpl
lea    0x0(,%r12,8),%rdx
add    %r13,%rdx
mov    %rsi,%r12
cmp    %r9,%r13
setb   %r9b
cmp    %rsi,%rdx
seta   %sil
cmp    %r10,%r13
setb   %bl
cmp    0x108(%rsp),%rdx
seta   %r13b
mov    0x58(%rsp),%dl
test   %dl,0x60(%rsp)
jne    1d40 <update_+0xc20>
and    %bpl,%al
jne    1d40 <update_+0xc20>
and    %sil,%r9b
mov    0x8(%rsp),%r10
mov    0x108(%rsp),%rbp
mov    0x10(%rsp),%rsi
jne    1d5c <update_+0xc3c>
mov    %r13d,%eax
mov    $0x0,%r13d
and    %al,%bl
mov    0x40(%rsp),%r9
jne    1d70 <update_+0xc50>
movapd %xmm13,%xmm8
movapd %xmm4,%xmm14
mov    %r8d,%edx
and    $0xfffffffe,%edx
mov    0x20(%rsp),%r13
and    $0xfffffffe,%r13d
movapd %xmm6,%xmm13
unpcklpd %xmm6,%xmm13
movapd %xmm5,%xmm1
unpcklpd %xmm5,%xmm1
xor    %r10d,%r10d
xor    %r9d,%r9d
movdqa 0x3b2(%rip),%xmm2
mov    0x80(%rsp),%rbx
jmp    1c95 <update_+0xb75>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r9
paddq  %xmm11,%xmm2
add    %rbx,%r10
cmp    %r9,%rdx
je     1d1a <update_+0xbfa>
movupd (%rcx,%r9,8),%xmm3
movupd (%r12,%r9,8),%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm3,%xmm4
movupd 0x0(%rbp,%r9,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rcx,%r9,8)
movdqa %xmm2,%xmm4
pxor   %xmm9,%xmm4
movdqa %xmm12,%xmm0
pcmpgtd %xmm4,%xmm0
pcmpeqd %xmm12,%xmm4
pshufd $0xf5,%xmm4,%xmm7
pand   %xmm0,%xmm7
pshufd $0xf5,%xmm0,%xmm4
por    %xmm7,%xmm4
movd   %xmm4,%eax
not    %eax
test   $0x1,%al
je     1cf8 <update_+0xbd8>
movlpd %xmm3,(%r15,%r10,1)
pxor   %xmm10,%xmm4
pextrw $0x4,%xmm4,%eax
test   $0x1,%al
je     1c80 <update_+0xb60>
movhpd %xmm3,(%r14,%r10,1)
jmp    1c80 <update_+0xb60>
xor    %r13d,%r13d
jmp    1d70 <update_+0xc50>
cmp    0x20(%rsp),%r13
movsd  0x38(%rsp),%xmm3
movapd %xmm14,%xmm4
mov    0x40(%rsp),%r9
mov    0x8(%rsp),%r10
movapd %xmm8,%xmm13
jne    1d70 <update_+0xc50>
jmp    1ac0 <update_+0x9a0>
xor    %r13d,%r13d
mov    0x40(%rsp),%r9
mov    0x8(%rsp),%r10
mov    0x108(%rsp),%rbp
mov    0x10(%rsp),%rsi
jmp    1d70 <update_+0xc50>
xor    %r13d,%r13d
mov    0x40(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x50(%rsp),%rax
add    %r13,%rax
imul   %rsi,%rax
mov    (%rsp),%rdx
lea    (%rdx,%rax,8),%rax
jmp    1da0 <update_+0xc80>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
add    %rdi,%rax
cmp    %r13,%r8
je     1ac0 <update_+0x9a0>
movsd  (%r12,%r13,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%rcx,%r13,8),%xmm0
movsd  0x0(%rbp,%r13,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%r13,8)
cmp    %r10,%r13
jl     1d90 <update_+0xc70>
movsd  %xmm1,(%rax)
jmp    1d90 <update_+0xc70>
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    19ae <update_+0x88e>
jmp    19eb <update_+0x8cb>
xor    %edx,%edx
test   $0x1,%bl
jne    173e <update_+0x61e>
jmp    176d <update_+0x64d>

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

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