#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 */
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double sqrt(double);
int Hessenberg_Form_Orthogonal(double *A, double *U, int n) {
  int i, k, col;
  double *u;
  double *p_row, *psubdiag;
  double *pA, *pU;
  double sss;
  double scale;
  double innerproduct;
  if (n <= 2)
    return 0;
  u = (double *)malloc(n * sizeof(double));
  if (u == NULL)
    return -1;
  for (psubdiag = A + n, col = 0; col < (n - 2); psubdiag += (n + 1), col++) {
    for (pA = psubdiag, sss = 0.0, i = col + 1; i < n; pA += n, i++)
      sss += *pA * *pA;
    if (sss == 0.0)
      continue;
    sss = sqrt(sss);
    if (*psubdiag >= 0.0)
      sss = -sss;
    u[col + 1] = *psubdiag - sss;
    *psubdiag = sss;
    for (pA = psubdiag + n, i = col + 2; i < n; pA += n, i++) {
      u[i] = *pA;
      *pA = 0.0;
    }
    scale = -1.0 / (sss * u[col + 1]);
    for (p_row = psubdiag - col, i = col + 1; i < n; i++) {
      pA = A + n * (col + 1) + i;
      for (innerproduct = 0.0, k = col + 1; k < n; pA += n, k++)
        innerproduct += u[k] * *pA;
      innerproduct *= scale;
      for (pA = p_row + i, k = col + 1; k < n; pA += n, k++)
        *pA -= u[k] * innerproduct;
    }
    for (p_row = A, i = 0; i < n; p_row += n, i++) {
      for (innerproduct = 0.0, k = col + 1; k < n; k++)
        innerproduct += u[k] * *(p_row + k);
      innerproduct *= scale;
      for (k = col + 1; k < n; k++)
        *(p_row + k) -= u[k] * innerproduct;
    }
    for (i = 0, pU = U; i < n; pU += n, i++) {
      for (innerproduct = 0.0, k = col + 1; k < n; k++)
        innerproduct += u[k] * *(pU + k);
      innerproduct *= scale;
      for (k = col + 1; k < n; k++)
        *(pU + k) -= u[k] * innerproduct;
    }
  }
  free(u);
  return 0;
}


x86 assembly (clang, -O0):
<Hessenberg_Form_Orthogonal>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jg     1159 <Hessenberg_Form_Orthogonal+0x29>
movl   $0x0,-0x4(%rbp)
jmp    16f9 <Hessenberg_Form_Orthogonal+0x5c9>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1183 <Hessenberg_Form_Orthogonal+0x53>
movl   $0xffffffff,-0x4(%rbp)
jmp    16f9 <Hessenberg_Form_Orthogonal+0x5c9>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    16e9 <Hessenberg_Form_Orthogonal+0x5b9>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1218 <Hessenberg_Form_Orthogonal+0xe8>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c7 <Hessenberg_Form_Orthogonal+0x97>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1235 <Hessenberg_Form_Orthogonal+0x105>
jp     1235 <Hessenberg_Form_Orthogonal+0x105>
jmp    16c3 <Hessenberg_Form_Orthogonal+0x593>
movsd  -0x58(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     127a <Hessenberg_Form_Orthogonal+0x14a>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1311 <Hessenberg_Form_Orthogonal+0x1e1>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x1c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12c2 <Hessenberg_Form_Orthogonal+0x192>
movsd  -0x58(%rbp),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xcd0(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14a0 <Hessenberg_Form_Orthogonal+0x370>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13f6 <Hessenberg_Form_Orthogonal+0x2c6>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13a0 <Hessenberg_Form_Orthogonal+0x270>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    148d <Hessenberg_Form_Orthogonal+0x35d>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x1c(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1421 <Hessenberg_Form_Orthogonal+0x2f1>
jmp    1492 <Hessenberg_Form_Orthogonal+0x362>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    135a <Hessenberg_Form_Orthogonal+0x22a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15af <Hessenberg_Form_Orthogonal+0x47f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1512 <Hessenberg_Form_Orthogonal+0x3e2>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14cc <Hessenberg_Form_Orthogonal+0x39c>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1587 <Hessenberg_Form_Orthogonal+0x457>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x24(%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    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    152a <Hessenberg_Form_Orthogonal+0x3fa>
jmp    158c <Hessenberg_Form_Orthogonal+0x45c>
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14af <Hessenberg_Form_Orthogonal+0x37f>
movl   $0x0,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16be <Hessenberg_Form_Orthogonal+0x58e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1621 <Hessenberg_Form_Orthogonal+0x4f1>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15db <Hessenberg_Form_Orthogonal+0x4ab>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1696 <Hessenberg_Form_Orthogonal+0x566>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x24(%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    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1639 <Hessenberg_Form_Orthogonal+0x509>
jmp    169b <Hessenberg_Form_Orthogonal+0x56b>
mov    -0x1c(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    15be <Hessenberg_Form_Orthogonal+0x48e>
jmp    16c3 <Hessenberg_Form_Orthogonal+0x593>
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    119d <Hessenberg_Form_Orthogonal+0x6d>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Hessenberg_Form_Orthogonal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %rsi,0x28(%rsp)
mov    %rdi,0x48(%rsp)
xor    %eax,%eax
cmp    $0x3,%edx
jl     198d <Hessenberg_Form_Orthogonal+0x85d>
lea    0x0(,%rdx,8),%edi
mov    %rdx,%rbx
call   1040 <malloc@plt>
test   %rax,%rax
je     1988 <Hessenberg_Form_Orthogonal+0x858>
mov    %rax,%r12
mov    %ebx,%r15d
lea    -0x2(%rbx),%eax
mov    %rax,0x90(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rcx,%r15,8),%r8
lea    (%r12,%r15,8),%rax
mov    %rax,0x88(%rsp)
lea    -0x1(%r15),%rdx
lea    -0x2(%r15),%rax
mov    %rax,0xb0(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0xd0(%rsp)
lea    0x8(,%r15,8),%rax
mov    %rax,0xc8(%rsp)
lea    0x0(,%r15,8),%r14
mov    %r15,%rax
shl    $0x4,%rax
add    %rcx,%rax
mov    %rax,0x60(%rsp)
lea    (%rcx,%r15,8),%rsi
add    $0x8,%rsi
lea    0x8(,%r15,8),%rax
mov    %rax,0xc0(%rsp)
mov    0x28(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x78(%rsp)
mov    $0x1,%ebp
movl   $0xffffffff,0x1c(%rsp)
ff
xorpd  %xmm7,%xmm7
movapd 0xde7(%rip),%xmm8
movsd  0xdee(%rip),%xmm9
movq   $0xffffffffffffffff,0x70(%rsp)
ff ff
xor    %eax,%eax
mov    %rdx,0x98(%rsp)
mov    %rcx,0x68(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rsi,0x40(%rsp)
mov    %r15,%r13
mov    %rbx,%r10
mov    %r12,%rbx
mov    %r10,0x50(%rsp)
jmp    1319 <Hessenberg_Form_Orthogonal+0x1e9>
nopw   0x0(%rax,%rax,1)
and    $0xfffffffffffffffc,%r9
mov    %r9,0x80(%rsp)
mov    0x98(%rsp),%rax
sub    %r11,%rax
mov    %rax,0xe0(%rsp)
mov    0xb0(%rsp),%rax
sub    %r11,%rax
mov    %rax,0xd8(%rsp)
mov    %r11,%rax
not    %rax
add    %r15,%rax
mov    %rax,0x10(%rsp)
ucomisd %xmm7,%xmm0
jne    13a5 <Hessenberg_Form_Orthogonal+0x275>
jp     13a5 <Hessenberg_Form_Orthogonal+0x275>
mov    0xc8(%rsp),%rax
add    %rax,%r8
add    $0x1,%rbp
addl   $0xffffffff,0x1c(%rsp)
mov    0xa0(%rsp),%rdx
add    $0xffffffffffffffff,%rdx
add    $0x8,%rbx
add    $0xffffffffffffffff,%r13
add    %rax,0x60(%rsp)
mov    0x40(%rsp),%rcx
add    0xc0(%rsp),%rcx
mov    %rcx,0x40(%rsp)
add    %rax,0x58(%rsp)
addq   $0x8,0x68(%rsp)
addq   $0xffffffffffffffff,0x70(%rsp)
addq   $0x8,0x78(%rsp)
mov    0x8(%rsp),%rax
cmp    0x90(%rsp),%rax
je     197c <Hessenberg_Form_Orthogonal+0x84c>
mov    %rdx,0xa0(%rsp)
mov    %rax,%r11
add    $0x1,%rax
mov    %rax,0x8(%rsp)
cmp    %r15,%rax
jae    12b0 <Hessenberg_Form_Orthogonal+0x180>
mov    0xa0(%rsp),%r9
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0xa8(%rsp)
mov    0x90(%rsp),%rax
mov    %eax,%ecx
sub    %r11d,%ecx
mov    %r11d,%eax
not    %eax
add    %r10d,%eax
test   $0x3,%al
je     13b5 <Hessenberg_Form_Orthogonal+0x285>
xor    %edx,%edx
xorpd  %xmm0,%xmm0
mov    %r8,%rax
mov    0xa8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%edx
add    %r14,%rax
cmp    %edx,%edi
jne    1380 <Hessenberg_Form_Orthogonal+0x250>
sub    0x1c(%rsp),%edx
cmp    $0x3,%ecx
jb     1260 <Hessenberg_Form_Orthogonal+0x130>
jmp    13ca <Hessenberg_Form_Orthogonal+0x29a>
mov    %r8,0x38(%rsp)
jb     141c <Hessenberg_Form_Orthogonal+0x2ec>
sqrtsd %xmm0,%xmm0
jmp    1446 <Hessenberg_Form_Orthogonal+0x316>
xorpd  %xmm0,%xmm0
mov    %r8,%rax
mov    0x8(%rsp),%rdx
cmp    $0x3,%ecx
jb     1260 <Hessenberg_Form_Orthogonal+0x130>
mov    %r10d,%ecx
sub    %edx,%ecx
nop
movsd  (%rax),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rax,%r14,1),%xmm0
add    %r14,%rax
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r14,%rax,1),%xmm1
add    %r14,%rax
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r14,%rax,1),%xmm0
add    %r14,%rax
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    %r14,%rax
add    $0xfffffffc,%ecx
jne    13d0 <Hessenberg_Form_Orthogonal+0x2a0>
jmp    1260 <Hessenberg_Form_Orthogonal+0x130>
mov    %r11,0x20(%rsp)
call   1050 <sqrt@plt>
mov    0x20(%rsp),%r11
movsd  0xbdc(%rip),%xmm9
movapd 0xbc3(%rip),%xmm8
xorpd  %xmm7,%xmm7
mov    0x38(%rsp),%r8
mov    0x8(%rsp),%r10
movsd  (%r8),%xmm2
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movapd %xmm1,%xmm3
andpd  %xmm0,%xmm3
xorpd  %xmm8,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%r10,8)
movlpd %xmm1,(%r8)
add    $0x2,%r11
cmp    %r15,%r11
jae    14ac <Hessenberg_Form_Orthogonal+0x37c>
mov    $0x2,%eax
mov    0x60(%rsp),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movq   $0x0,(%rcx)
add    $0x1,%rax
add    %r14,%rcx
cmp    %rax,%r13
jne    1490 <Hessenberg_Form_Orthogonal+0x360>
mulsd  (%r12,%r10,8),%xmm1
movapd %xmm9,%xmm0
divsd  %xmm1,%xmm0
cmp    %r15,%r10
jae    1552 <Hessenberg_Form_Orthogonal+0x422>
mov    0x58(%rsp),%rax
mov    0x40(%rsp),%rcx
mov    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
mov    $0x1,%esi
mov    %rcx,%rdi
nopl   0x0(%rax)
movsd  (%rbx,%rsi,8),%xmm2
mulsd  (%rdi),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rsi
add    %r14,%rdi
cmp    %rsi,%r13
jne    14f0 <Hessenberg_Form_Orthogonal+0x3c0>
mulsd  %xmm0,%xmm1
mov    $0x1,%esi
mov    %rax,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi),%xmm2
movsd  (%rbx,%rsi,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi)
add    $0x1,%rsi
add    %r14,%rdi
cmp    %rsi,%r13
jne    1520 <Hessenberg_Form_Orthogonal+0x3f0>
add    $0x1,%rdx
add    $0x8,%rcx
add    $0x8,%rax
cmp    %r15,%rdx
jne    14e0 <Hessenberg_Form_Orthogonal+0x3b0>
lea    (%r12,%rbp,8),%rax
mov    %rax,0x20(%rsp)
mov    0x10(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rsp)
lea    (%rax,%rbp,1),%r8
mov    0x48(%rsp),%rdx
mov    0x68(%rsp),%rsi
xor    %edi,%edi
mov    %rbp,%r9
jmp    1594 <Hessenberg_Form_Orthogonal+0x464>
xchg   %ax,%ax
add    %r14,%rdx
add    $0x1,%rdi
add    %r14,%rsi
cmp    0x50(%rsp),%edi
je     1701 <Hessenberg_Form_Orthogonal+0x5d1>
cmp    %r15,%r10
jae    1580 <Hessenberg_Form_Orthogonal+0x450>
mov    %rdi,%rax
imul   %r15,%rax
lea    (%rax,%rbp,1),%rcx
add    %r15,%rax
mov    0x48(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
lea    0x0(,%rax,8),%r11
add    %rbp,%r11
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm2
mulsd  (%rsi,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rax
cmp    %rax,%r13
jne    15d0 <Hessenberg_Form_Orthogonal+0x4a0>
cmp    %r15,%r10
mov    %r9,%rbp
jae    1580 <Hessenberg_Form_Orthogonal+0x450>
mulsd  %xmm0,%xmm1
mov    %rbp,%rax
cmpq   $0x4,0x10(%rsp)
jb     1680 <Hessenberg_Form_Orthogonal+0x550>
cmp    0x88(%rsp),%rcx
jae    1616 <Hessenberg_Form_Orthogonal+0x4e6>
mov    %rbp,%rax
cmp    %r11,0x20(%rsp)
jb     1680 <Hessenberg_Form_Orthogonal+0x550>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
xor    %eax,%eax
mov    0x80(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd 0x8(%rbx,%rax,8),%xmm3
movupd 0x18(%rbx,%rax,8),%xmm4
movupd 0x8(%rsi,%rax,8),%xmm5
movupd 0x18(%rsi,%rax,8),%xmm6
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm6
movupd %xmm5,0x8(%rsi,%rax,8)
movupd %xmm6,0x18(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1630 <Hessenberg_Form_Orthogonal+0x500>
mov    %r8,%rax
mov    0x30(%rsp),%rcx
cmp    %rcx,0x10(%rsp)
je     1580 <Hessenberg_Form_Orthogonal+0x450>
mov    %r15d,%ebp
sub    %eax,%ebp
mov    %rax,%rcx
test   $0x1,%bpl
je     16aa <Hessenberg_Form_Orthogonal+0x57a>
movsd  (%rdx,%rax,8),%xmm2
movsd  (%r12,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdx,%rax,8)
lea    0x1(%rax),%rcx
cmp    %rax,0x98(%rsp)
mov    %r9,%rbp
je     1580 <Hessenberg_Form_Orthogonal+0x450>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rdx,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rdx,%rcx,8),%xmm2
movsd  %xmm3,(%rdx,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    16c0 <Hessenberg_Form_Orthogonal+0x590>
jmp    1580 <Hessenberg_Form_Orthogonal+0x450>
mov    0x30(%rsp),%rax
add    %rbp,%rax
mov    %rax,0xb8(%rsp)
mov    0x70(%rsp),%r11
neg    %r11
mov    0x28(%rsp),%rdi
mov    0x78(%rsp),%rdx
xor    %eax,%eax
mov    0x38(%rsp),%r8
mov    0x50(%rsp),%r10
jmp    1753 <Hessenberg_Form_Orthogonal+0x623>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %r14,%rdi
add    $0x1,%rax
add    %r14,%rdx
cmp    %r10d,%eax
je     12b0 <Hessenberg_Form_Orthogonal+0x180>
cmp    %r15,0x8(%rsp)
jae    1740 <Hessenberg_Form_Orthogonal+0x610>
testb  $0x3,0xe0(%rsp)
03
je     1961 <Hessenberg_Form_Orthogonal+0x831>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    0xa8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  0x8(%rbx,%rcx,8),%xmm2
mulsd  (%rdx,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1780 <Hessenberg_Form_Orthogonal+0x650>
add    %r11,%rcx
cmpq   $0x3,0xd8(%rsp)
jb     17fb <Hessenberg_Form_Orthogonal+0x6cb>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm2
movsd  0x8(%r12,%rcx,8),%xmm3
mulsd  (%rdi,%rcx,8),%xmm2
mulsd  0x8(%rdi,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x10(%r12,%rcx,8),%xmm4
mulsd  0x10(%rdi,%rcx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%r12,%rcx,8),%xmm1
mulsd  0x18(%rdi,%rcx,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rcx
cmp    %rcx,%r15
jne    17b0 <Hessenberg_Form_Orthogonal+0x680>
cmp    %r15,0x8(%rsp)
jae    1740 <Hessenberg_Form_Orthogonal+0x610>
mulsd  %xmm0,%xmm1
mov    %rbp,%rsi
cmpq   $0x4,0x10(%rsp)
jb     18d0 <Hessenberg_Form_Orthogonal+0x7a0>
mov    %rax,%rcx
imul   %r15,%rcx
lea    (%rcx,%rbp,1),%rsi
mov    0x28(%rsp),%r8
lea    (%r8,%rsi,8),%rsi
mov    0x38(%rsp),%r8
cmp    0x88(%rsp),%rsi
jae    1852 <Hessenberg_Form_Orthogonal+0x722>
add    %r15,%rcx
mov    0x28(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
mov    %rbp,%rsi
cmp    %rcx,0x20(%rsp)
jb     18d0 <Hessenberg_Form_Orthogonal+0x7a0>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
xor    %ecx,%ecx
mov    0x80(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x8(%rbx,%rcx,8),%xmm3
movupd 0x18(%rbx,%rcx,8),%xmm4
movupd (%rdx,%rcx,8),%xmm5
movupd 0x10(%rdx,%rcx,8),%xmm6
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm6
movupd %xmm5,(%rdx,%rcx,8)
movupd %xmm6,0x10(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    1870 <Hessenberg_Form_Orthogonal+0x740>
mov    0xb8(%rsp),%rsi
mov    0x30(%rsp),%rcx
cmp    %rcx,0x10(%rsp)
je     1740 <Hessenberg_Form_Orthogonal+0x610>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15d,%ebp
sub    %esi,%ebp
mov    %rsi,%rcx
test   $0x1,%bpl
je     18fa <Hessenberg_Form_Orthogonal+0x7ca>
movsd  (%rdi,%rsi,8),%xmm2
movsd  (%r12,%rsi,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%rsi,8)
lea    0x1(%rsi),%rcx
not    %rsi
cmp    0xd0(%rsp),%rsi
mov    0x50(%rsp),%r10
mov    %r9,%rbp
je     1740 <Hessenberg_Form_Orthogonal+0x610>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rdi,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rdi,%rcx,8),%xmm2
movsd  %xmm3,(%rdi,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    1920 <Hessenberg_Form_Orthogonal+0x7f0>
jmp    1740 <Hessenberg_Form_Orthogonal+0x610>
xorpd  %xmm1,%xmm1
mov    %rbp,%rcx
cmpq   $0x3,0xd8(%rsp)
jae    17b0 <Hessenberg_Form_Orthogonal+0x680>
jmp    17fb <Hessenberg_Form_Orthogonal+0x6cb>
mov    %r12,%rdi
call   1030 <free@plt>
xor    %eax,%eax
jmp    198d <Hessenberg_Form_Orthogonal+0x85d>
mov    $0xffffffff,%eax
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @Hessenberg_Form_Orthogonal(double* %0, double* %1, i32 %2) {
%4 = alloca i32
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double
%17 = alloca double
%18 = alloca double
store double* %0, double** %5
store double* %1, double** %6
store i32 %2, i32* %7
%19 = load i32, i32* %7
%20 = icmp sle i32 %19, 2
br i1 %20, label %21, label %22
21: ; preds = %3
store i32 0, i32* %4
br label %345
22: ; preds = %3
%23 = load i32, i32* %7
%24 = sext i32 %23 to i64
%25 = mul i64 %24, 8
%26 = trunc i64 %25 to i32
%27 = call i64 @malloc(i32 %26)
%28 = inttoptr i64 %27 to double*
store double* %28, double** %11
%29 = load double*, double** %11
%30 = icmp eq double* %29, null
br i1 %30, label %31, label %32
31: ; preds = %22
store i32 -1, i32* %4
br label %345
32: ; preds = %22
%33 = load double*, double** %5
%34 = load i32, i32* %7
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %33, i64 %35
store double* %36, double** %13
store i32 0, i32* %10
br label %37
37: ; preds = %334, %32
%38 = load i32, i32* %10
%39 = load i32, i32* %7
%40 = sub nsw i32 %39, 2
%41 = icmp slt i32 %38, %40
br i1 %41, label %42, label %342
42: ; preds = %37
%43 = load double*, double** %13
store double* %43, double** %14
store double 0.000000e+00, double* %16
%44 = load i32, i32* %10
%45 = add nsw i32 %44, 1
store i32 %45, i32* %8
br label %46
46: ; preds = %57, %42
%47 = load i32, i32* %8
%48 = load i32, i32* %7
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %64
50: ; preds = %46
%51 = load double*, double** %14
%52 = load double, double* %51
%53 = load double*, double** %14
%54 = load double, double* %53
%55 = load double, double* %16
%56 = call double @llvm.fmuladd.f64(double %52, double %54, double %55)
store double %56, double* %16
br label %57
57: ; preds = %50
%58 = load i32, i32* %7
%59 = load double*, double** %14
%60 = sext i32 %58 to i64
%61 = getelementptr inbounds double, double* %59, i64 %60
store double* %61, double** %14
%62 = load i32, i32* %8
%63 = add nsw i32 %62, 1
store i32 %63, i32* %8
br label %46
64: ; preds = %46
%65 = load double, double* %16
%66 = fcmp oeq double %65, 0.000000e+00
br i1 %66, label %67, label %68
67: ; preds = %64
br label %334
68: ; preds = %64
%69 = load double, double* %16
%70 = call double @sqrt(double %69)
store double %70, double* %16
%71 = load double*, double** %13
%72 = load double, double* %71
%73 = fcmp oge double %72, 0.000000e+00
br i1 %73, label %74, label %77
74: ; preds = %68
%75 = load double, double* %16
%76 = fneg double %75
store double %76, double* %16
br label %77
77: ; preds = %74, %68
%78 = load double*, double** %13
%79 = load double, double* %78
%80 = load double, double* %16
%81 = fsub double %79, %80
%82 = load double*, double** %11
%83 = load i32, i32* %10
%84 = add nsw i32 %83, 1
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %82, i64 %85
store double %81, double* %86
%87 = load double, double* %16
%88 = load double*, double** %13
store double %87, double* %88
%89 = load double*, double** %13
%90 = load i32, i32* %7
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %89, i64 %91
store double* %92, double** %14
%93 = load i32, i32* %10
%94 = add nsw i32 %93, 2
store i32 %94, i32* %8
br label %95
95: ; preds = %107, %77
%96 = load i32, i32* %8
%97 = load i32, i32* %7
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %114
99: ; preds = %95
%100 = load double*, double** %14
%101 = load double, double* %100
%102 = load double*, double** %11
%103 = load i32, i32* %8
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %102, i64 %104
store double %101, double* %105
%106 = load double*, double** %14
store double 0.000000e+00, double* %106
br label %107
107: ; preds = %99
%108 = load i32, i32* %7
%109 = load double*, double** %14
%110 = sext i32 %108 to i64
%111 = getelementptr inbounds double, double* %109, i64 %110
store double* %111, double** %14
%112 = load i32, i32* %8
%113 = add nsw i32 %112, 1
store i32 %113, i32* %8
br label %95
114: ; preds = %95
%115 = load double, double* %16
%116 = load double*, double** %11
%117 = load i32, i32* %10
%118 = add nsw i32 %117, 1
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %116, i64 %119
%121 = load double, double* %120
%122 = fmul double %115, %121
%123 = fdiv double -1.000000e+00, %122
store double %123, double* %17
%124 = load double*, double** %13
%125 = load i32, i32* %10
%126 = sext i32 %125 to i64
%127 = sub i64 0, %126
%128 = getelementptr inbounds double, double* %124, i64 %127
store double* %128, double** %12
%129 = load i32, i32* %10
%130 = add nsw i32 %129, 1
store i32 %130, i32* %8
br label %131
131: ; preds = %202, %114
%132 = load i32, i32* %8
%133 = load i32, i32* %7
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %205
135: ; preds = %131
%136 = load double*, double** %5
%137 = load i32, i32* %7
%138 = load i32, i32* %10
%139 = add nsw i32 %138, 1
%140 = mul nsw i32 %137, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %136, i64 %141
%143 = load i32, i32* %8
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds double, double* %142, i64 %144
store double* %145, double** %14
store double 0.000000e+00, double* %18
%146 = load i32, i32* %10
%147 = add nsw i32 %146, 1
store i32 %147, i32* %9
br label %148
148: ; preds = %162, %135
%149 = load i32, i32* %9
%150 = load i32, i32* %7
%151 = icmp slt i32 %149, %150
br i1 %151, label %152, label %169
152: ; preds = %148
%153 = load double*, double** %11
%154 = load i32, i32* %9
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %153, i64 %155
%157 = load double, double* %156
%158 = load double*, double** %14
%159 = load double, double* %158
%160 = load double, double* %18
%161 = call double @llvm.fmuladd.f64(double %157, double %159, double %160)
store double %161, double* %18
br label %162
162: ; preds = %152
%163 = load i32, i32* %7
%164 = load double*, double** %14
%165 = sext i32 %163 to i64
%166 = getelementptr inbounds double, double* %164, i64 %165
store double* %166, double** %14
%167 = load i32, i32* %9
%168 = add nsw i32 %167, 1
store i32 %168, i32* %9
br label %148
169: ; preds = %148
%170 = load double, double* %17
%171 = load double, double* %18
%172 = fmul double %171, %170
store double %172, double* %18
%173 = load double*, double** %12
%174 = load i32, i32* %8
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %173, i64 %175
store double* %176, double** %14
%177 = load i32, i32* %10
%178 = add nsw i32 %177, 1
store i32 %178, i32* %9
br label %179
179: ; preds = %194, %169
%180 = load i32, i32* %9
%181 = load i32, i32* %7
%182 = icmp slt i32 %180, %181
br i1 %182, label %183, label %201
183: ; preds = %179
%184 = load double*, double** %11
%185 = load i32, i32* %9
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %184, i64 %186
%188 = load double, double* %187
%189 = load double, double* %18
%190 = load double*, double** %14
%191 = load double, double* %190
%192 = fneg double %188
%193 = call double @llvm.fmuladd.f64(double %192, double %189, double %191)
store double %193, double* %190
br label %194
194: ; preds = %183
%195 = load i32, i32* %7
%196 = load double*, double** %14
%197 = sext i32 %195 to i64
%198 = getelementptr inbounds double, double* %196, i64 %197
store double* %198, double** %14
%199 = load i32, i32* %9
%200 = add nsw i32 %199, 1
store i32 %200, i32* %9
br label %179
201: ; preds = %179
br label %202
202: ; preds = %201
%203 = load i32, i32* %8
%204 = add nsw i32 %203, 1
store i32 %204, i32* %8
br label %131
205: ; preds = %131
%206 = load double*, double** %5
store double* %206, double** %12
store i32 0, i32* %8
br label %207
207: ; preds = %262, %205
%208 = load i32, i32* %8
%209 = load i32, i32* %7
%210 = icmp slt i32 %208, %209
br i1 %210, label %211, label %269
211: ; preds = %207
store double 0.000000e+00, double* %18
%212 = load i32, i32* %10
%213 = add nsw i32 %212, 1
store i32 %213, i32* %9
br label %214
214: ; preds = %231, %211
%215 = load i32, i32* %9
%216 = load i32, i32* %7
%217 = icmp slt i32 %215, %216
br i1 %217, label %218, label %234
218: ; preds = %214
%219 = load double*, double** %11
%220 = load i32, i32* %9
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %219, i64 %221
%223 = load double, double* %222
%224 = load double*, double** %12
%225 = load i32, i32* %9
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = load double, double* %18
%230 = call double @llvm.fmuladd.f64(double %223, double %228, double %229)
store double %230, double* %18
br label %231
231: ; preds = %218
%232 = load i32, i32* %9
%233 = add nsw i32 %232, 1
store i32 %233, i32* %9
br label %214
234: ; preds = %214
%235 = load double, double* %17
%236 = load double, double* %18
%237 = fmul double %236, %235
store double %237, double* %18
%238 = load i32, i32* %10
%239 = add nsw i32 %238, 1
store i32 %239, i32* %9
br label %240
240: ; preds = %258, %234
%241 = load i32, i32* %9
%242 = load i32, i32* %7
%243 = icmp slt i32 %241, %242
br i1 %243, label %244, label %261
244: ; preds = %240
%245 = load double*, double** %11
%246 = load i32, i32* %9
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
%249 = load double, double* %248
%250 = load double, double* %18
%251 = load double*, double** %12
%252 = load i32, i32* %9
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %251, i64 %253
%255 = load double, double* %254
%256 = fneg double %249
%257 = call double @llvm.fmuladd.f64(double %256, double %250, double %255)
store double %257, double* %254
br label %258
258: ; preds = %244
%259 = load i32, i32* %9
%260 = add nsw i32 %259, 1
store i32 %260, i32* %9
br label %240
261: ; preds = %240
br label %262
262: ; preds = %261
%263 = load i32, i32* %7
%264 = load double*, double** %12
%265 = sext i32 %263 to i64
%266 = getelementptr inbounds double, double* %264, i64 %265
store double* %266, double** %12
%267 = load i32, i32* %8
%268 = add nsw i32 %267, 1
store i32 %268, i32* %8
br label %207
269: ; preds = %207
store i32 0, i32* %8
%270 = load double*, double** %6
store double* %270, double** %15
br label %271
271: ; preds = %326, %269
%272 = load i32, i32* %8
%273 = load i32, i32* %7
%274 = icmp slt i32 %272, %273
br i1 %274, label %275, label %333
275: ; preds = %271
store double 0.000000e+00, double* %18
%276 = load i32, i32* %10
%277 = add nsw i32 %276, 1
store i32 %277, i32* %9
br label %278
278: ; preds = %295, %275
%279 = load i32, i32* %9
%280 = load i32, i32* %7
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %298
282: ; preds = %278
%283 = load double*, double** %11
%284 = load i32, i32* %9
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
%287 = load double, double* %286
%288 = load double*, double** %15
%289 = load i32, i32* %9
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
%292 = load double, double* %291
%293 = load double, double* %18
%294 = call double @llvm.fmuladd.f64(double %287, double %292, double %293)
store double %294, double* %18
br label %295
295: ; preds = %282
%296 = load i32, i32* %9
%297 = add nsw i32 %296, 1
store i32 %297, i32* %9
br label %278
298: ; preds = %278
%299 = load double, double* %17
%300 = load double, double* %18
%301 = fmul double %300, %299
store double %301, double* %18
%302 = load i32, i32* %10
%303 = add nsw i32 %302, 1
store i32 %303, i32* %9
br label %304
304: ; preds = %322, %298
%305 = load i32, i32* %9
%306 = load i32, i32* %7
%307 = icmp slt i32 %305, %306
br i1 %307, label %308, label %325
308: ; preds = %304
%309 = load double*, double** %11
%310 = load i32, i32* %9
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double, double* %309, i64 %311
%313 = load double, double* %312
%314 = load double, double* %18
%315 = load double*, double** %15
%316 = load i32, i32* %9
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %315, i64 %317
%319 = load double, double* %318
%320 = fneg double %313
%321 = call double @llvm.fmuladd.f64(double %320, double %314, double %319)
store double %321, double* %318
br label %322
322: ; preds = %308
%323 = load i32, i32* %9
%324 = add nsw i32 %323, 1
store i32 %324, i32* %9
br label %304
325: ; preds = %304
br label %326
326: ; preds = %325
%327 = load i32, i32* %7
%328 = load double*, double** %15
%329 = sext i32 %327 to i64
%330 = getelementptr inbounds double, double* %328, i64 %329
store double* %330, double** %15
%331 = load i32, i32* %8
%332 = add nsw i32 %331, 1
store i32 %332, i32* %8
br label %271
333: ; preds = %271
br label %334
334: ; preds = %333, %67
%335 = load i32, i32* %7
%336 = add nsw i32 %335, 1
%337 = load double*, double** %13
%338 = sext i32 %336 to i64
%339 = getelementptr inbounds double, double* %337, i64 %338
store double* %339, double** %13
%340 = load i32, i32* %10
%341 = add nsw i32 %340, 1
store i32 %341, i32* %10
br label %37
342: ; preds = %37
%343 = load double*, double** %11
%344 = call i32 @free(double* %343)
store i32 0, i32* %4
br label %345
345: ; preds = %342, %31, %21
%346 = load i32, i32* %4
ret i32 %346
}

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