#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*/ memset(double *, int /*<<< orphan*/, int);
int /*<<< orphan*/ xgerc(int, int, double const, int, double *, double *, int,
                         int);
void xorgqr(int n, int k, double A_data[], int lda, const double tau_data[],
            double *work_data) {
  double c;
  int b_i;
  int c_i;
  int exitg1;
  int i;
  int i1;
  int ia;
  int iac;
  int iaii;
  int ic0;
  int itau;
  int ix;
  int lastc;
  int lastv;
  char exitg2;
  i = n - 1;
  for (b_i = k; b_i <= i; b_i++) {
    ia = b_i * lda;
    i1 = n - 1;
    memset(&A_data[ia], 0, (i1 + 1) * sizeof(double));
    A_data[ia + b_i] = 1.0;
  }
  itau = k - 1;
  for (c_i = k; c_i >= 1; c_i--) {
    iaii = c_i + (c_i - 1) * lda;
    if (c_i < n) {
      A_data[iaii - 1] = 1.0;
      ic0 = iaii + lda;
      if (tau_data[itau] != 0.0) {
        lastv = (n - c_i) + 1;
        b_i = (iaii + n) - c_i;
        while ((lastv > 0) && (A_data[b_i - 1] == 0.0)) {
          lastv--;
          b_i--;
        }
        lastc = n - c_i;
        exitg2 = 0;
        while ((!exitg2) && (lastc > 0)) {
          b_i = ic0 + (lastc - 1) * lda;
          ia = b_i;
          do {
            exitg1 = 0;
            if (ia <= (b_i + lastv) - 1) {
              if (A_data[ia - 1] != 0.0)
                exitg1 = 1;
              else
                ia++;
            } else {
              lastc--;
              exitg1 = 2;
            }
          } while (exitg1 == 0);
          if (exitg1 == 1)
            exitg2 = 1;
        }
      } else {
        lastv = 0;
        lastc = 0;
      }
      if (lastv > 0) {
        if (lastc != 0) {
          memset(&work_data[0], 0, lastc * sizeof(double));
          b_i = 0;
          i = ic0 + lda * (lastc - 1);
          for (iac = ic0; lda < 0 ? iac >= i : iac <= i; iac += lda) {
            ix = iaii;
            c = 0.0;
            i1 = (iac + lastv) - 1;
            for (ia = iac; ia <= i1; ia++) {
              c += A_data[ia - 1] * A_data[ix - 1];
              ix++;
            }
            work_data[b_i] += c;
            b_i++;
          }
        }
        xgerc(lastv, lastc, -tau_data[itau], iaii, work_data, A_data, ic0, lda);
      }
    }
    if (c_i < n) {
      b_i = iaii + 1;
      i = (iaii + n) - c_i;
      for (ix = b_i; ix <= i; ix++)
        A_data[ix - 1] *= -tau_data[itau];
    }
    A_data[iaii - 1] = 1.0 - tau_data[itau];
    for (b_i = 0; b_i <= c_i - 2; b_i++)
      A_data[(iaii - b_i) - 2] = 0.0;
    itau--;
  }
}


x86 assembly (clang, -O0):
<xorgqr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     11ba <xorgqr+0x9a>
mov    -0x34(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x44(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xe59(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114f <xorgqr+0x2f>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x1,-0x38(%rbp)
jl     1616 <xorgqr+0x4f6>
mov    -0x38(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1519 <xorgqr+0x3f9>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xdfa(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1239 <xorgqr+0x119>
jp     1239 <xorgqr+0x119>
jmp    138f <xorgqr+0x26f>
mov    -0x4(%rbp),%eax
sub    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x50(%rbp),%eax
add    -0x4(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x64(%rbp)
mov    %al,-0x66(%rbp)
jle    1284 <xorgqr+0x164>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
sete   %al
setnp  %cl
and    %cl,%al
mov    %al,-0x66(%rbp)
mov    -0x66(%rbp),%al
test   $0x1,%al
jne    1294 <xorgqr+0x174>
jmp    12ab <xorgqr+0x18b>
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1251 <xorgqr+0x131>
mov    -0x4(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x60(%rbp)
movb   $0x0,-0x65(%rbp)
xor    %eax,%eax
cmpb   $0x0,-0x65(%rbp)
mov    %al,-0x67(%rbp)
jne    12d1 <xorgqr+0x1b1>
cmpl   $0x0,-0x60(%rbp)
setg   %al
mov    %al,-0x67(%rbp)
mov    -0x67(%rbp),%al
test   $0x1,%al
jne    12e1 <xorgqr+0x1c1>
jmp    138a <xorgqr+0x26a>
mov    -0x54(%rbp),%eax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    -0x64(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1358 <xorgqr+0x238>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    133e <xorgqr+0x21e>
jp     133e <xorgqr+0x21e>
jmp    134a <xorgqr+0x22a>
movl   $0x1,-0x3c(%rbp)
jmp    1353 <xorgqr+0x233>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1368 <xorgqr+0x248>
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
movl   $0x2,-0x3c(%rbp)
jmp    136d <xorgqr+0x24d>
cmpl   $0x0,-0x3c(%rbp)
je     12f9 <xorgqr+0x1d9>
cmpl   $0x1,-0x3c(%rbp)
jne    1385 <xorgqr+0x265>
movb   $0x1,-0x65(%rbp)
jmp    12b8 <xorgqr+0x198>
jmp    139d <xorgqr+0x27d>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x0,-0x64(%rbp)
jle    1514 <xorgqr+0x3f4>
cmpl   $0x0,-0x60(%rbp)
je     14d0 <xorgqr+0x3b0>
mov    -0x28(%rbp),%rdi
movslq -0x60(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    1407 <xorgqr+0x2e7>
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x6c(%rbp)
jmp    1418 <xorgqr+0x2f8>
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    $0x0,%eax
je     14cb <xorgqr+0x3ab>
mov    -0x50(%rbp),%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     149d <xorgqr+0x37d>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1444 <xorgqr+0x324>
movsd  -0x30(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    13e7 <xorgqr+0x2c7>
jmp    14d0 <xorgqr+0x3b0>
mov    -0x64(%rbp),%edi
mov    -0x60(%rbp),%esi
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x50(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x54(%rbp),%r9d
mov    -0x14(%rbp),%eax
mov    %eax,(%rsp)
call   1030 <xgerc@plt>
jmp    1519 <xorgqr+0x3f9>
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    159a <xorgqr+0x47a>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x50(%rbp),%eax
add    -0x4(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1595 <xorgqr+0x475>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1540 <xorgqr+0x420>
jmp    159a <xorgqr+0x47a>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  0xa56(%rip),%xmm0
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     15ff <xorgqr+0x4df>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    -0x34(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15c8 <xorgqr+0x4a8>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    11c9 <xorgqr+0xa9>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xorgqr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,0x88(%rsp)
mov    %r8,0x58(%rsp)
mov    %ecx,%r8d
mov    %rdx,%r12
movslq %ecx,%rax
mov    %rax,0x70(%rsp)
mov    %rdi,0x68(%rsp)
mov    %rsi,0x38(%rsp)
cmp    %edi,%esi
mov    %r8,0x60(%rsp)
jge    11da <xorgqr+0xba>
mov    0x68(%rsp),%rcx
lea    0x0(,%rcx,8),%eax
mov    %eax,0x18(%rsp)
mov    0x38(%rsp),%rsi
movslq %esi,%r15
mov    %r8d,%ebx
imul   %esi,%ebx
mov    0x70(%rsp),%rdx
mov    %rdx,%rax
imul   %r15,%rax
lea    (%r12,%rax,8),%rbp
lea    0x0(,%rdx,8),%rax
mov    %rax,0x40(%rsp)
mov    %ecx,%r13d
sub    %esi,%r13d
movslq %ebx,%rbx
lea    (%r15,%rbx,1),%r14
mov    %rbp,%rdi
xor    %esi,%esi
mov    0x18(%rsp),%edx
call   1040 <memset@plt>
movabs $0x3ff0000000000000,%r10
mov    0x60(%rsp),%r8
mov    %r10,(%r12,%r14,8)
add    $0x1,%r15
add    %r8d,%ebx
add    0x40(%rsp),%rbp
add    $0xffffffff,%r13d
jne    11a0 <xorgqr+0x80>
mov    0x38(%rsp),%rcx
test   %ecx,%ecx
mov    0x58(%rsp),%rbx
jle    1a49 <xorgqr+0x929>
lea    -0x1(%rcx),%r15d
mov    %r15d,%eax
imul   %r8d,%eax
mov    0x68(%rsp),%rdx
lea    (%rax,%rdx,1),%r11d
mov    0x70(%rsp),%r14
lea    0x1(%r14),%esi
imul   %ecx,%esi
mov    %esi,0x24(%rsp)
mov    %r14d,%esi
not    %esi
mov    %rsi,0xc8(%rsp)
lea    (%rax,%rcx,1),%r9d
mov    %ecx,%esi
movslq %edx,%rdi
mov    %rdi,0xb8(%rsp)
lea    -0x2(%rax,%rcx,1),%edi
lea    -0xa(%rax,%rcx,1),%ebp
mov    %rbp,0xd0(%rsp)
lea    -0x6(%rax,%rcx,1),%ebp
mov    %rbp,0xa8(%rsp)
lea    -0xe(%rax,%rcx,1),%r10d
lea    -0x5(%rax,%rcx,1),%edx
mov    %edx,0x50(%rsp)
lea    -0x4(%rax,%rcx,1),%edx
mov    %edx,0x4c(%rsp)
add    %ecx,%eax
add    $0xfffffffd,%eax
mov    %eax,0x48(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0xc0(%rsp)
xorpd  %xmm5,%xmm5
movapd 0xd7e(%rip),%xmm6
movsd  0xd85(%rip),%xmm8
xorps  %xmm7,%xmm7
lea    -0x8(%r12),%rax
mov    %rax,0x80(%rsp)
lea    0x0(,%r14,8),%rax
mov    %rax,0x110(%rsp)
lea    0x30(%r12),%rax
mov    %rax,0xe8(%rsp)
lea    -0x4(%r15),%rax
mov    %rax,0xb0(%rsp)
mov    %edi,%eax
mov    %edi,0x14(%rsp)
mov    %rdi,0x100(%rsp)
mov    %rsi,%rax
mov    %rsi,0xf0(%rsp)
xor    %esi,%esi
mov    %r15,0x108(%rsp)
mov    %r15,0x18(%rsp)
mov    %r11d,0x78(%rsp)
mov    %r11d,0x54(%rsp)
mov    %rdi,%r11
jmp    137f <xorgqr+0x25f>
xchg   %ax,%ax
sub    %r8d,0x54(%rsp)
mov    0xc8(%rsp),%rax
add    %eax,0x24(%rsp)
mov    %r15d,%r9d
add    %eax,%r9d
addq   $0xffffffffffffffff,0x18(%rsp)
mov    0x30(%rsp),%rsi
add    $0x1,%rsi
add    %rax,%r13
mov    %r13,0xd0(%rsp)
add    %rax,0xa8(%rsp)
add    %rax,%r10
mov    0xe0(%rsp),%r11
add    %rax,%r11
addq   $0xffffffffffffffff,0xb0(%rsp)
add    %eax,0x14(%rsp)
add    %eax,0x50(%rsp)
add    %eax,0x4c(%rsp)
add    %eax,0x48(%rsp)
addq   $0x1,0xc0(%rsp)
cmpq   $0x2,0x40(%rsp)
mov    0x38(%rsp),%rax
mov    0x58(%rsp),%rbx
jl     1a49 <xorgqr+0x929>
mov    %rax,%r14
mov    %rsi,%rax
not    %rax
mov    %rax,0xd8(%rsp)
lea    -0x1(%r14),%rbp
mov    %ebp,%r13d
imul   %r8d,%r13d
lea    (%r14,%r13,1),%eax
add    $0xffffffff,%eax
movslq %eax,%rdx
cmp    0xb8(%rsp),%r14
mov    %rsi,0x30(%rsp)
mov    %r11,0xe0(%rsp)
mov    %rbp,0x38(%rsp)
mov    %r14,0x40(%rsp)
jge    1811 <xorgqr+0x6f1>
movslq %r9d,%r15
movslq 0x54(%rsp),%rax
mov    %rax,0xa0(%rsp)
add    %r14d,%r13d
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r12,%rdx,8)
movsd  (%rbx,%rbp,8),%xmm0
ucomisd %xmm5,%xmm0
mov    %rdx,0x28(%rsp)
jne    1401 <xorgqr+0x2e1>
jnp    1662 <xorgqr+0x542>
lea    (%r8,%r13,1),%ebx
mov    0xb8(%rsp),%rbp
sub    0x40(%rsp),%rbp
lea    0x1(%rbp),%r14d
test   %rbp,%rbp
js     14e5 <xorgqr+0x3c5>
mov    0x80(%rsp),%rdi
mov    0xa0(%rsp),%rax
lea    (%rdi,%rax,8),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx),%xmm0
ucomisd %xmm5,%xmm0
jne    1464 <xorgqr+0x344>
jp     1464 <xorgqr+0x344>
lea    -0x1(%r14),%eax
add    $0xfffffffffffffff8,%rcx
cmp    $0x1,%r14d
mov    %eax,%r14d
jg     1440 <xorgqr+0x320>
test   %rbp,%rbp
jg     1495 <xorgqr+0x375>
jmp    146c <xorgqr+0x34c>
mov    %r14d,%eax
test   %rbp,%rbp
jg     1495 <xorgqr+0x375>
mov    %eax,%r14d
test   %r14d,%r14d
jg     14ee <xorgqr+0x3ce>
jmp    1662 <xorgqr+0x542>
nopl   0x0(%rax)
cmp    $0x1,%ebp
mov    %ecx,%ebp
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
jle    1a36 <xorgqr+0x916>
lea    -0x1(%rbp),%ecx
test   %eax,%eax
jle    1480 <xorgqr+0x360>
mov    %ecx,%edx
imul   %r8d,%edx
lea    (%rdx,%rbx,1),%esi
add    %eax,%esi
add    0x24(%rsp),%edx
movslq %edx,%rdx
movslq %esi,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm0
ucomisd %xmm5,%xmm0
jne    14d8 <xorgqr+0x3b8>
jp     14d8 <xorgqr+0x3b8>
add    $0x1,%rdx
cmp    %rsi,%rdx
jl     14c0 <xorgqr+0x3a0>
jmp    1480 <xorgqr+0x360>
mov    %eax,%r14d
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
test   %r14d,%r14d
jle    1662 <xorgqr+0x542>
mov    %rbx,0x90(%rsp)
mov    %r10,0xf8(%rsp)
mov    %r9d,0x7c(%rsp)
mov    %rbp,0x98(%rsp)
test   %ebp,%ebp
mov    0x88(%rsp),%rcx
je     15f7 <xorgqr+0x4d7>
mov    0x98(%rsp),%rbx
lea    0x0(,%rbx,8),%edx
mov    %rcx,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movapd 0xac4(%rip),%xmm6
mov    0x88(%rsp),%rcx
lea    -0x1(%rbx),%edi
mov    0x60(%rsp),%rsi
imul   %esi,%edi
xor    %eax,%eax
xor    %edx,%edx
test   %edi,%edi
setle  %al
setns  %dl
test   %esi,%esi
cmovs  %eax,%edx
cmp    $0x1,%dl
jne    15f7 <xorgqr+0x4d7>
movslq 0x24(%rsp),%rax
mov    0x80(%rsp),%rsi
lea    (%rsi,%rax,8),%rdx
lea    (%rsi,%r15,8),%r10
add    0x90(%rsp),%edi
mov    %r14d,%r8d
movslq %edi,%r9
xor    %ebx,%ebx
nopl   (%rax)
lea    (%rax,%r8,1),%rbp
xorpd  %xmm0,%xmm0
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm1
mulsd  (%r10,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
lea    (%rax,%rsi,1),%rdi
add    $0x1,%rdi
add    $0x1,%rsi
cmp    %rbp,%rdi
jl     15a0 <xorgqr+0x480>
addsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x1,%rbx
add    0x70(%rsp),%rax
xor    %esi,%esi
xor    %edi,%edi
cmp    %r9,%rax
setge  %sil
setle  %dil
cmpl   $0x0,0x60(%rsp)
cmovs  %esi,%edi
add    0x110(%rsp),%rdx
test   %dil,%dil
jne    1590 <xorgqr+0x470>
mov    0x38(%rsp),%rax
mov    0x58(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
xorpd  %xmm6,%xmm0
mov    0x60(%rsp),%rbx
mov    %ebx,(%rsp)
mov    %r14d,%edi
mov    0x98(%rsp),%rsi
mov    %r13d,%edx
mov    %r12,%r8
mov    0x90(%rsp),%r9
call   1030 <xgerc@plt>
movapd 0x9c8(%rip),%xmm6
mov    %rbx,%r8
mov    0x7c(%rsp),%r9d
mov    0xf8(%rsp),%r10
xorpd  %xmm5,%xmm5
movsd  0x9bb(%rip),%xmm8
xorps  %xmm7,%xmm7
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x38(%rsp),%rbp
mov    %ebp,%eax
imul   %r8d,%eax
add    0x68(%rsp),%eax
cmp    %eax,%r13d
mov    0x40(%rsp),%r14
mov    0x58(%rsp),%rbx
jge    1811 <xorgqr+0x6f1>
mov    %esi,%ecx
imul   %r8d,%ecx
mov    0x78(%rsp),%edx
sub    %ecx,%edx
movslq %edx,%rdx
mov    %rdx,%rcx
sub    %r15,%rcx
cmp    $0x4,%rcx
jae    16a9 <xorgqr+0x589>
mov    0x28(%rsp),%rdx
jmp    17e0 <xorgqr+0x6c0>
lea    (%r12,%r15,8),%rsi
lea    (%rbx,%r14,8),%rdi
cmp    %rdi,%rsi
jae    16e5 <xorgqr+0x5c5>
mov    0xf0(%rsp),%rsi
mov    0xd8(%rsp),%rdi
add    %rdi,%rsi
lea    (%r12,%rdx,8),%rdx
lea    (%rbx,%rsi,8),%rsi
cmp    %rdx,%rsi
jae    16e5 <xorgqr+0x5c5>
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
jmp    17e0 <xorgqr+0x6c0>
lea    -0x4(%rcx),%rsi
mov    %rsi,%r13
shr    $0x2,%r13
add    $0x1,%r13
cmp    $0x4,%rsi
jae    1701 <xorgqr+0x5e1>
xor    %esi,%esi
jmp    1788 <xorgqr+0x668>
mov    0xa0(%rsp),%rdx
sub    %r15,%rdx
add    $0xfffffffffffffffc,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    0xe8(%rsp),%rsi
lea    (%rsi,%r15,8),%rdi
and    $0xfffffffffffffffe,%rdx
movsd  (%rbx,%rbp,8),%xmm0
unpcklpd %xmm0,%xmm0
xorpd  %xmm6,%xmm0
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdi,%rsi,8),%xmm1
movupd -0x20(%rdi,%rsi,8),%xmm2
movupd -0x10(%rdi,%rsi,8),%xmm3
movupd (%rdi,%rsi,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,-0x30(%rdi,%rsi,8)
movupd %xmm2,-0x20(%rdi,%rsi,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,-0x10(%rdi,%rsi,8)
movupd %xmm4,(%rdi,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1740 <xorgqr+0x620>
mov    %rcx,%rdi
and    $0xfffffffffffffffc,%rdi
test   $0x1,%r13b
je     17c7 <xorgqr+0x6a7>
add    %r15,%rsi
movsd  (%rbx,%rbp,8),%xmm0
unpcklpd %xmm0,%xmm0
xorpd  %xmm6,%xmm0
movupd (%r12,%rsi,8),%xmm1
movupd 0x10(%r12,%rsi,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%r12,%rsi,8)
movupd %xmm2,0x10(%r12,%rsi,8)
cmp    %rdi,%rcx
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
je     1811 <xorgqr+0x6f1>
add    %rdi,%r15
nopl   0x0(%rax)
cltq
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rbp,8),%xmm0
xorpd  %xmm6,%xmm0
mulsd  (%r12,%r15,8),%xmm0
movsd  %xmm0,(%r12,%r15,8)
lea    0x1(%r15),%rcx
mov    %rcx,%r15
cmp    %rax,%rcx
jl     17f0 <xorgqr+0x6d0>
movapd %xmm8,%xmm0
subsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%r12,%rdx,8)
cmp    $0x2,%r14
jl     1a49 <xorgqr+0x929>
mov    0xd8(%rsp),%r11
add    0x108(%rsp),%r11
cmpq   $0x4,0x18(%rsp)
mov    0xd0(%rsp),%r13
mov    %r9d,%r15d
jb     18b0 <xorgqr+0x790>
mov    %esi,%eax
imul   0xc8(%rsp),%eax
add    0x100(%rsp),%eax
mov    %eax,%ecx
sub    %r11d,%ecx
cmp    %eax,%ecx
jg     18b0 <xorgqr+0x790>
mov    %r11,%rax
shr    $0x20,%rax
mov    $0x0,%eax
jne    18b2 <xorgqr+0x792>
mov    0xb0(%rsp),%r9
shr    $0x2,%r9
mov    0x18(%rsp),%rdi
lea    -0x4(%rdi),%rax
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    $0xc,%rax
jae    1966 <xorgqr+0x846>
xor    %edx,%edx
jmp    19ed <xorgqr+0x8cd>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
sub    %rax,%r11
mov    0x18(%rsp),%rcx
test   $0x3,%cl
je     18ea <xorgqr+0x7ca>
and    $0x3,%ecx
neg    %rcx
mov    0x14(%rsp),%edx
sub    %eax,%edx
xor    %esi,%esi
nopl   (%rax)
lea    (%rdx,%rsi,1),%edi
movslq %edi,%rdi
movq   $0x0,(%r12,%rdi,8)
add    $0xffffffffffffffff,%rsi
cmp    %rsi,%rcx
jne    18d0 <xorgqr+0x7b0>
sub    %rsi,%rax
cmp    $0x3,%r11
jb     1300 <xorgqr+0x1e0>
mov    %eax,%ebp
mov    0x50(%rsp),%ecx
sub    %eax,%ecx
mov    0x4c(%rsp),%edx
sub    %eax,%edx
mov    0x48(%rsp),%esi
sub    %eax,%esi
add    0xc0(%rsp),%rax
mov    0x14(%rsp),%edi
sub    %ebp,%edi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rbp,1),%ebx
movslq %ebx,%rbx
movq   $0x0,(%r12,%rbx,8)
lea    (%rsi,%rbp,1),%ebx
movslq %ebx,%rbx
movq   $0x0,(%r12,%rbx,8)
lea    (%rdx,%rbp,1),%ebx
movslq %ebx,%rbx
movq   $0x0,(%r12,%rbx,8)
lea    (%rcx,%rbp,1),%ebx
movslq %ebx,%rbx
movq   $0x0,(%r12,%rbx,8)
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%rax
jne    1920 <xorgqr+0x800>
jmp    1300 <xorgqr+0x1e0>
lea    0x1(%r9),%rax
and    $0xfffffffffffffffc,%rax
xor    %edx,%edx
mov    0xa8(%rsp),%rbx
mov    %r10,%rbp
mov    0xe0(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rcx,%rdx,1),%edi
movslq %edi,%rdi
movups %xmm7,-0x8(%r12,%rdi,8)
movups %xmm7,-0x18(%r12,%rdi,8)
lea    (%rbx,%rdx,1),%edi
movslq %edi,%rdi
movups %xmm7,-0x8(%r12,%rdi,8)
movups %xmm7,-0x18(%r12,%rdi,8)
lea    0x0(%r13,%rdx,1),%edi
movslq %edi,%rdi
movups %xmm7,-0x8(%r12,%rdi,8)
movups %xmm7,-0x18(%r12,%rdi,8)
lea    0x0(%rbp,%rdx,1),%edi
movslq %edi,%rdi
movups %xmm7,-0x8(%r12,%rdi,8)
movups %xmm7,-0x18(%r12,%rdi,8)
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffc,%rax
jne    1990 <xorgqr+0x870>
neg    %rdx
mov    0x18(%rsp),%rdi
mov    %rdi,%rax
and    $0xfffffffffffffffc,%rax
test   $0x3,%sil
je     1a28 <xorgqr+0x908>
add    $0x1,%r9b
movzbl %r9b,%ecx
and    $0x3,%ecx
mov    0x14(%rsp),%esi
sub    %edx,%esi
nopl   0x0(%rax,%rax,1)
movslq %esi,%rsi
movups %xmm7,-0x8(%r12,%rsi,8)
movups %xmm7,-0x18(%r12,%rsi,8)
add    $0xfffffffc,%esi
add    $0xffffffffffffffff,%rcx
jne    1a10 <xorgqr+0x8f0>
cmp    %rax,%rdi
je     1300 <xorgqr+0x1e0>
jmp    18b2 <xorgqr+0x792>
mov    %eax,%r14d
mov    %ecx,%ebp
test   %r14d,%r14d
jg     14ee <xorgqr+0x3ce>
jmp    1662 <xorgqr+0x542>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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