#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 sqrt(double);
void Householder2(int n, double **V, double *d, double *e) {
  int i, j, k;
  for (j = 0; j < n; j++) {
    d[j] = V[n - 1][j];
  }
  for (i = n - 1; i > 0; i--) {
    double scale = 0.0;
    double h = 0.0;
    for (k = 0; k < i; k++) {
      scale = scale + fabs(d[k]);
    }
    if (scale == 0.0) {
      e[i] = d[i - 1];
      for (j = 0; j < i; j++) {
        d[j] = V[i - 1][j];
        V[i][j] = 0.0;
        V[j][i] = 0.0;
      }
    } else {
      double f, g, hh;
      for (k = 0; k < i; k++) {
        d[k] /= scale;
        h += d[k] * d[k];
      }
      f = d[i - 1];
      g = sqrt(h);
      if (f > 0) {
        g = -g;
      }
      e[i] = scale * g;
      h = h - f * g;
      d[i - 1] = f - g;
      for (j = 0; j < i; j++) {
        e[j] = 0.0;
      }
      for (j = 0; j < i; j++) {
        f = d[j];
        V[j][i] = f;
        g = e[j] + V[j][j] * f;
        for (k = j + 1; k <= i - 1; k++) {
          g += V[k][j] * d[k];
          e[k] += V[k][j] * f;
        }
        e[j] = g;
      }
      f = 0.0;
      for (j = 0; j < i; j++) {
        e[j] /= h;
        f += e[j] * d[j];
      }
      hh = f / (h + h);
      for (j = 0; j < i; j++) {
        e[j] -= hh * d[j];
      }
      for (j = 0; j < i; j++) {
        f = d[j];
        g = e[j];
        for (k = j; k <= i - 1; k++) {
          V[k][j] -= (f * e[k] + g * d[k]);
        }
        d[j] = V[i - 1][j];
        V[i][j] = 0.0;
      }
    }
    d[i] = h;
  }
  for (i = 0; i < n - 1; i++) {
    double h;
    V[n - 1][i] = V[i][i];
    V[i][i] = 1.0;
    h = d[i + 1];
    if (h != 0.0) {
      for (k = 0; k <= i; k++) {
        d[k] = V[k][i + 1] / h;
      }
      for (j = 0; j <= i; j++) {
        double g = 0.0;
        for (k = 0; k <= i; k++) {
          g += V[k][i + 1] * V[k][j];
        }
        for (k = 0; k <= i; k++) {
          V[k][j] -= g * d[k];
        }
      }
    }
    for (k = 0; k <= i; k++) {
      V[k][i + 1] = 0.0;
    }
  }
  for (j = 0; j < n; j++) {
    d[j] = V[n - 1][j];
    V[n - 1][j] = 0.0;
  }
  V[n - 1][n - 1] = 1.0;
  e[0] = 0.0;
}


x86 assembly (clang, -O0):
<Householder2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    116f <Householder2+0x5f>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    112e <Householder2+0x1e>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    170c <Householder2+0x5fc>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11d9 <Householder2+0xc9>
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe52(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1199 <Householder2+0x89>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    128d <Householder2+0x17d>
jp     128d <Householder2+0x17d>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1288 <Householder2+0x178>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1217 <Householder2+0x107>
jmp    16ec <Householder2+0x5dc>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12f5 <Householder2+0x1e5>
movsd  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1294 <Householder2+0x184>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    134e <Householder2+0x23e>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13e5 <Householder2+0x2d5>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13bb <Householder2+0x2ab>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1508 <Householder2+0x3f8>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     14e8 <Householder2+0x3d8>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x20(%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    1461 <Householder2+0x351>
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13ec <Householder2+0x2dc>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1578 <Householder2+0x468>
movsd  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1517 <Householder2+0x407>
movsd  -0x48(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15f4 <Householder2+0x4e4>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1597 <Householder2+0x487>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    16e7 <Householder2+0x5d7>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     169a <Householder2+0x58a>
movsd  -0x48(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1631 <Householder2+0x521>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15fb <Householder2+0x4eb>
jmp    16ec <Householder2+0x5dc>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1178 <Householder2+0x68>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1943 <Householder2+0x833>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  0x895(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17a4 <Householder2+0x694>
jp     17a4 <Householder2+0x694>
jmp    18f2 <Householder2+0x7e2>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     17f1 <Householder2+0x6e1>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17ab <Householder2+0x69b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     18ed <Householder2+0x7dd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     186e <Householder2+0x75e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1813 <Householder2+0x703>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     18da <Householder2+0x7ca>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1875 <Householder2+0x765>
jmp    18df <Householder2+0x7cf>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17f8 <Householder2+0x6e8>
jmp    18f2 <Householder2+0x7e2>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1930 <Householder2+0x820>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18f9 <Householder2+0x7e9>
jmp    1935 <Householder2+0x825>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1713 <Householder2+0x603>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    19a8 <Householder2+0x898>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    194a <Householder2+0x83a>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x636(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Householder2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rcx,%r14
mov    %rsi,%r12
lea    -0x1(%rdi),%ecx
movabs $0x3ff0000000000000,%r13
test   %edi,%edi
jle    1cdf <Householder2+0xbbf>
mov    %rdx,%r15
mov    %ecx,%r9d
mov    (%r12,%r9,8),%rax
mov    %edi,%ebx
mov    %rdi,0x20(%rsp)
cmp    $0x4,%edi
mov    %ecx,0x34(%rsp)
jb     117c <Householder2+0x5c>
lea    (%rax,%rbx,8),%rcx
cmp    %r15,%rcx
jbe    11f0 <Householder2+0xd0>
lea    (%r15,%rbx,8),%rcx
cmp    %rcx,%rax
jae    11f0 <Householder2+0xd0>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
mov    %rbx,%rsi
and    $0x3,%rsi
je     11a5 <Householder2+0x85>
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1190 <Householder2+0x70>
cmp    $0x3,%rdx
jb     12d8 <Householder2+0x1b8>
nop
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rcx,8)
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rcx,8)
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    11b0 <Householder2+0x90>
jmp    12d8 <Householder2+0x1b8>
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1216 <Householder2+0xf6>
xor    %edi,%edi
jmp    1294 <Householder2+0x174>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rax,%rdi,8),%xmm0
movups 0x10(%rax,%rdi,8),%xmm1
movups %xmm0,(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
movups 0x20(%rax,%rdi,8),%xmm0
movups 0x30(%rax,%rdi,8),%xmm1
movups %xmm0,0x20(%r15,%rdi,8)
movups %xmm1,0x30(%r15,%rdi,8)
movups 0x40(%rax,%rdi,8),%xmm0
movups 0x50(%rax,%rdi,8),%xmm1
movups %xmm0,0x40(%r15,%rdi,8)
movups %xmm1,0x50(%r15,%rdi,8)
movupd 0x60(%rax,%rdi,8),%xmm0
movupd 0x70(%rax,%rdi,8),%xmm1
movupd %xmm0,0x60(%r15,%rdi,8)
movupd %xmm1,0x70(%r15,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1230 <Householder2+0x110>
test   %rdx,%rdx
je     12cf <Householder2+0x1af>
lea    (%r15,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rax,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nop
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    12b0 <Householder2+0x190>
cmp    %rbx,%rcx
jne    117e <Householder2+0x5e>
mov    %rbx,0x18(%rsp)
cmpl   $0x2,0x20(%rsp)
jl     1cba <Householder2+0xb9a>
lea    0x0(,%r9,8),%rax
mov    %rax,0x60(%rsp)
mov    0x18(%rsp),%r13
add    $0xffffffffffffffff,%r13
lea    0x8(%r14),%rbx
lea    0x8(%r15),%rbp
lea    0x8(%r12),%r8
xor    %r10d,%r10d
xorpd  %xmm8,%xmm8
movapd 0xcf4(%rip),%xmm10
movapd 0xcdb(%rip),%xmm9
movapd 0xcd3(%rip),%xmm6
mov    %r9,0x8(%rsp)
mov    %r8,0x28(%rsp)
mov    %rbx,0x40(%rsp)
mov    %rbp,0x38(%rsp)
jmp    1366 <Householder2+0x246>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm11,(%r15,%r13,8)
add    $0x1,%r10
mov    %r11,%r13
cmp    %r9,%r10
je     1a48 <Householder2+0x928>
lea    -0x1(%r13),%rsi
mov    %r13d,%eax
and    $0x3,%eax
cmp    $0x3,%rsi
jae    1380 <Householder2+0x260>
xor    %ecx,%ecx
xorpd  %xmm4,%xmm4
jmp    13d8 <Householder2+0x2b8>
xchg   %ax,%ax
mov    %r13,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   (%rax)
movsd  (%r15,%rcx,8),%xmm1
movsd  0x8(%r15,%rcx,8),%xmm2
movsd  0x10(%r15,%rcx,8),%xmm3
movsd  0x18(%r15,%rcx,8),%xmm4
andpd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
andpd  %xmm6,%xmm2
addsd  %xmm1,%xmm2
andpd  %xmm6,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm6,%xmm4
addsd  %xmm3,%xmm4
add    $0x4,%rcx
movapd %xmm4,%xmm0
cmp    %rcx,%rdx
jne    1390 <Householder2+0x270>
test   %rax,%rax
je     1407 <Householder2+0x2e7>
lea    (%r15,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm0
andpd  %xmm9,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rdx
cmp    %rdx,%rax
jne    13f0 <Householder2+0x2d0>
ucomisd %xmm8,%xmm4
jne    14a0 <Householder2+0x380>
jp     14a0 <Householder2+0x380>
mov    %r13,%r11
movsd  -0x8(%r15,%r13,8),%xmm0
movsd  %xmm0,(%r14,%r13,8)
mov    -0x8(%r12,%r13,8),%rcx
mov    (%r12,%r13,8),%rax
add    $0xffffffffffffffff,%r11
je     1510 <Householder2+0x3f0>
mov    %r13,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdx,8)
movq   $0x0,(%rax,%rdx,8)
mov    -0x8(%r8,%rdx,8),%rdi
movq   $0x0,(%rdi,%r13,8)
movsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
movq   $0x0,0x8(%rax,%rdx,8)
mov    (%r8,%rdx,8),%rdi
movq   $0x0,(%rdi,%r13,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1450 <Householder2+0x330>
jmp    1512 <Householder2+0x3f2>
nopl   0x0(%rax)
test   %rsi,%rsi
je     1545 <Householder2+0x425>
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
movsd  0x8(%r15,%rax,8),%xmm3
divsd  %xmm4,%xmm1
movsd  %xmm1,(%r15,%rax,8)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm4,%xmm3
movsd  %xmm3,0x8(%r15,%rax,8)
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
add    $0x2,%rax
movapd %xmm3,%xmm0
cmp    %rax,%rcx
jne    14c0 <Householder2+0x3a0>
jmp    154b <Householder2+0x42b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
xorpd  %xmm11,%xmm11
test   $0x1,%r13b
je     1350 <Householder2+0x230>
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movq   $0x0,(%rax,%rdx,8)
mov    (%r12,%rdx,8),%rax
movq   $0x0,(%rax,%r13,8)
jmp    1350 <Householder2+0x230>
xorpd  %xmm3,%xmm3
xor    %eax,%eax
lea    0x0(,%r10,8),%rcx
test   $0x1,%r13b
je     1571 <Householder2+0x451>
movsd  (%r15,%rax,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r15,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
mov    0x60(%rsp),%rdx
sub    %rcx,%rdx
movsd  -0x8(%r15,%r13,8),%xmm5
ucomisd %xmm8,%xmm3
mov    %r10,0x48(%rsp)
mov    %rsi,0x68(%rsp)
jb     159a <Householder2+0x47a>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    15da <Householder2+0x4ba>
movapd %xmm3,%xmm0
movsd  %xmm3,0x10(%rsp)
movapd %xmm4,0x70(%rsp)
mov    %rdx,0x58(%rsp)
movsd  %xmm5,0x50(%rsp)
call   1040 <sqrt@plt>
movsd  0x50(%rsp),%xmm5
mov    0x58(%rsp),%rdx
movapd 0x70(%rsp),%xmm4
movsd  0x10(%rsp),%xmm3
movapd 0xa36(%rip),%xmm10
movapd %xmm0,%xmm1
xorpd  %xmm10,%xmm1
xorpd  %xmm2,%xmm2
cmpltsd %xmm5,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
orpd   %xmm1,%xmm2
mulsd  %xmm2,%xmm4
movsd  %xmm4,(%r14,%r13,8)
movapd %xmm5,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm3
movsd  %xmm3,0x10(%rsp)
subsd  %xmm2,%xmm5
movsd  %xmm5,-0x8(%r15,%r13,8)
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movabs $0x200000000,%r9
mov    0x28(%rsp),%r10
mov    %rbp,%rdx
mov    %rbx,%rsi
xor    %edi,%edi
movabs $0x100000000,%r11
xorpd  %xmm8,%xmm8
movapd 0x9a8(%rip),%xmm9
movapd 0x9a0(%rip),%xmm6
jmp    168d <Householder2+0x56d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm0,(%r14,%rdi,8)
add    $0x8,%rsi
add    $0x8,%rdx
add    $0x8,%r10
add    %r11,%r9
mov    %r8,%rdi
cmp    %r13,%r8
je     1700 <Householder2+0x5e0>
movsd  (%r15,%rdi,8),%xmm1
mov    (%r12,%rdi,8),%rax
movsd  %xmm1,(%rax,%r13,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%r14,%rdi,8),%xmm0
lea    0x1(%rdi),%r8
cmp    %r13,%r8
jge    1670 <Householder2+0x550>
mov    %r9,%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r10,%rbp,1),%rbx
movsd  (%rbx,%rdi,8),%xmm2
movsd  (%rdx,%rbp,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rbp,1),%xmm2
movsd  %xmm2,(%rsi,%rbp,1)
mov    %rcx,%rax
sar    $0x20,%rax
add    $0x8,%rbp
add    %r11,%rcx
cmp    %r13,%rax
jl     16c0 <Householder2+0x5a0>
jmp    1670 <Householder2+0x550>
nopl   0x0(%rax)
mov    0x68(%rsp),%r11
test   %r11,%r11
je     1858 <Householder2+0x738>
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x8(%rsp),%r9
movapd 0x8e7(%rip),%xmm10
mov    0x40(%rsp),%rbx
mov    0x38(%rsp),%rbp
mov    0x28(%rsp),%r8
mov    0x48(%rsp),%r10
movsd  0x10(%rsp),%xmm11
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rbx,%rax,8),%xmm2
movsd  (%rbx,%rax,8),%xmm0
divsd  %xmm11,%xmm2
movsd  %xmm2,-0x8(%rbx,%rax,8)
mulsd  -0x8(%rbp,%rax,8),%xmm2
divsd  %xmm11,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%rcx
jne    1750 <Householder2+0x630>
test   $0x1,%r13b
je     17b2 <Householder2+0x692>
movsd  (%r14,%rax,8),%xmm1
divsd  %xmm11,%xmm1
movsd  %xmm1,(%r14,%rax,8)
mulsd  (%r15,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movapd %xmm11,%xmm1
addsd  %xmm11,%xmm1
xorpd  %xmm10,%xmm0
divsd  %xmm1,%xmm0
cmp    $0x4,%r13
jb     17e5 <Householder2+0x6c5>
lea    (%r15,%r13,8),%rax
cmp    %r14,%rax
jbe    1896 <Householder2+0x776>
lea    (%r14,%r13,8),%rax
cmp    %r15,%rax
jbe    1896 <Householder2+0x776>
xor    %eax,%eax
mov    %rax,%rcx
or     $0x1,%rcx
test   $0x1,%r13b
je     180d <Householder2+0x6ed>
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
mov    %rcx,%rax
cmp    %rcx,%r13
je     1990 <Householder2+0x870>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1820 <Householder2+0x700>
jmp    1990 <Householder2+0x870>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x8(%rsp),%r9
movapd 0x7a4(%rip),%xmm10
mov    0x40(%rsp),%rbx
mov    0x38(%rsp),%rbp
mov    0x28(%rsp),%r8
mov    0x48(%rsp),%r10
movsd  0x10(%rsp),%xmm11
test   $0x1,%r13b
jne    1797 <Householder2+0x677>
jmp    17b2 <Householder2+0x692>
mov    %r13,%rax
and    $0xfffffffffffffffc,%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1a38 <Householder2+0x918>
mov    %rdx,%rsi
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rsi
xor    %ecx,%ecx
nop
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r14,%rcx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r14,%rcx,8),%xmm2
movupd 0x20(%r14,%rcx,8),%xmm5
movupd 0x30(%r14,%rcx,8),%xmm7
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r14,%rcx,8)
movupd %xmm3,0x10(%r14,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm2
movupd 0x30(%r15,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm7,%xmm3
movupd %xmm2,0x20(%r14,%rcx,8)
movupd %xmm3,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    18d0 <Householder2+0x7b0>
test   $0x1,%dl
je     1987 <Householder2+0x867>
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
movupd (%r14,%rcx,8),%xmm4
movupd 0x10(%r14,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm3,0x10(%r14,%rcx,8)
cmp    %rax,%r13
jne    17e7 <Householder2+0x6c7>
mov    -0x8(%r12,%r13,8),%rax
mov    (%r12,%r13,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm0
movsd  (%r14,%rdx,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mov    (%r12,%rdx,8),%rsi
movsd  (%rsi,%rdx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%rdx,8)
lea    0x1(%rdx),%rsi
cmp    %r13,%rsi
jge    1a13 <Householder2+0x8f3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%r14,%rsi,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    (%r12,%rsi,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
add    $0x1,%rsi
cmp    %r13,%rsi
jl     19e0 <Householder2+0x8c0>
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movq   $0x0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %r13,%rdx
jne    19a0 <Householder2+0x880>
jmp    1350 <Householder2+0x230>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1950 <Householder2+0x830>
jmp    1987 <Householder2+0x867>
cmpl   $0x2,0x20(%rsp)
movabs $0x3ff0000000000000,%r13
jl     1cba <Householder2+0xb9a>
mov    (%r12,%r9,8),%r8
mov    $0x1,%r10d
xor    %edx,%edx
xorpd  %xmm0,%xmm0
jmp    1a7d <Householder2+0x95d>
nop
add    $0x1,%r10
cmp    %r9,%rdx
je     1cba <Householder2+0xb9a>
mov    %rdx,%r9
mov    %r10d,%esi
and    $0x3,%esi
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
mov    (%r12,%rdx,8),%rax
movsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%r8,%rdx,8)
mov    %r13,(%rax,%rdx,8)
add    $0x1,%rdx
movsd  0x8(%r15,%r9,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1ab7 <Householder2+0x997>
jnp    1c30 <Householder2+0xb10>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
test   %r9,%r9
je     1b01 <Householder2+0x9e1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rax,8)
mov    0x8(%r12,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1ad0 <Householder2+0x9b0>
test   $0x1,%r10b
je     1b1a <Householder2+0x9fa>
mov    (%r12,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rax,8)
xor    %ebp,%ebp
jmp    1b2d <Householder2+0xa0d>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %r10,%rbp
je     1c30 <Householder2+0xb10>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
cmp    $0x3,%r9
jb     1b94 <Householder2+0xa74>
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rdi
mov    0x8(%r12,%rax,8),%rbx
movsd  (%rdi,%rdx,8),%xmm2
mulsd  (%rdi,%rbp,8),%xmm2
addsd  %xmm1,%xmm2
movsd  (%rbx,%rdx,8),%xmm3
mulsd  (%rbx,%rbp,8),%xmm3
addsd  %xmm2,%xmm3
mov    0x10(%r12,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm2
mulsd  (%rdi,%rbp,8),%xmm2
mov    0x18(%r12,%rax,8),%rdi
movsd  (%rdi,%rdx,8),%xmm1
mulsd  (%rdi,%rbp,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rax
cmp    %rax,%r11
jne    1b40 <Householder2+0xa20>
test   $0x3,%r10b
je     1bbb <Householder2+0xa9b>
lea    (%r12,%rax,8),%rax
xor    %edi,%edi
mov    (%rax,%rdi,8),%rbx
movsd  (%rbx,%rdx,8),%xmm2
mulsd  (%rbx,%rbp,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1ba0 <Householder2+0xa80>
xorpd  %xmm10,%xmm1
xor    %eax,%eax
test   %r9,%r9
je     1c0b <Householder2+0xaeb>
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rax,8),%rdi
movsd  (%r15,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rbp,8),%xmm2
movsd  %xmm2,(%rdi,%rbp,8)
mov    0x8(%r12,%rax,8),%rdi
movsd  0x8(%r15,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rbp,8),%xmm2
movsd  %xmm2,(%rdi,%rbp,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1bd0 <Householder2+0xab0>
test   $0x1,%r10b
je     1b20 <Householder2+0xa00>
mulsd  (%r15,%rax,8),%xmm1
mov    (%r12,%rax,8),%rax
addsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
jmp    1b20 <Householder2+0xa00>
xchg   %ax,%ax
xor    %eax,%eax
cmp    $0x3,%r9
jae    1c40 <Householder2+0xb20>
mov    0x8(%rsp),%r9
jmp    1c8c <Householder2+0xb6c>
nop
mov    0x8(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
mov    0x8(%r12,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
mov    0x10(%r12,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
mov    0x18(%r12,%rax,8),%rcx
movq   $0x0,(%rcx,%rdx,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    1c50 <Householder2+0xb30>
test   $0x3,%r10b
je     1a70 <Householder2+0x950>
lea    (%r12,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rax,%rcx,8),%rdi
movq   $0x0,(%rdi,%rdx,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1ca0 <Householder2+0xb80>
jmp    1a70 <Householder2+0x950>
mov    0x20(%rsp),%rax
test   %eax,%eax
mov    0x34(%rsp),%ecx
jle    1cdf <Householder2+0xbbf>
mov    %rax,%rcx
mov    (%r12,%r9,8),%rax
cmp    $0x4,%ecx
jae    1ceb <Householder2+0xbcb>
xor    %ecx,%ecx
mov    0x18(%rsp),%rbp
jmp    1dc4 <Householder2+0xca4>
movslq %ecx,%r9
mov    (%r12,%r9,8),%rax
jmp    1e6e <Householder2+0xd4e>
mov    0x18(%rsp),%rbp
lea    (%rax,%rbp,8),%rcx
cmp    %r15,%rcx
jbe    1d09 <Householder2+0xbe9>
lea    (%r15,%rbp,8),%rcx
cmp    %rcx,%rax
jae    1d09 <Householder2+0xbe9>
xor    %ecx,%ecx
jmp    1dc4 <Householder2+0xca4>
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1e8b <Householder2+0xd6b>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rax,%rsi,8),%xmm1
movups 0x10(%rax,%rsi,8),%xmm2
movups %xmm1,(%r15,%rsi,8)
movups %xmm2,0x10(%r15,%rsi,8)
movupd %xmm0,(%rax,%rsi,8)
movupd %xmm0,0x10(%rax,%rsi,8)
movupd 0x20(%rax,%rsi,8),%xmm1
movupd 0x30(%rax,%rsi,8),%xmm2
movupd %xmm1,0x20(%r15,%rsi,8)
movupd %xmm2,0x30(%r15,%rsi,8)
movupd %xmm0,0x20(%rax,%rsi,8)
movupd %xmm0,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1d40 <Householder2+0xc20>
test   $0x1,%dl
je     1dbb <Householder2+0xc9b>
movupd (%rax,%rsi,8),%xmm0
movupd 0x10(%rax,%rsi,8),%xmm1
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm1,0x10(%r15,%rsi,8)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rax,%rsi,8)
movupd %xmm0,0x10(%rax,%rsi,8)
cmp    %rbp,%rcx
je     1e6e <Householder2+0xd4e>
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
mov    %rbp,%rsi
and    $0x3,%rsi
je     1dfd <Householder2+0xcdd>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movq   $0x0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1de0 <Householder2+0xcc0>
cmp    $0x3,%rdx
jb     1e6e <Householder2+0xd4e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movq   $0x0,(%rax,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rcx,8)
movq   $0x0,0x8(%rax,%rcx,8)
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rcx,8)
movq   $0x0,0x10(%rax,%rcx,8)
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rcx,8)
movq   $0x0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1e10 <Householder2+0xcf0>
mov    %r13,(%rax,%r9,8)
movq   $0x0,(%r14)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    1d94 <Householder2+0xc74>
jmp    1dbb <Householder2+0xc9b>

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

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