void xgeqp3(double A_data[], const int A_size[2], double tau_data[], int perm[],
            double *vn1_data, double *vn2_data, double *work_data) {
  double s;
  double smax;
  double temp2;
  int b_i;
  int exitg1;
  int i;
  int ic0;
  int ii;
  int ip1;
  int ix;
  int iy;
  int k;
  int lastv;
  int ma;
  int minmana;
  int minmn;
  int mmi;
  int nmi;
  int pvt;
  char exitg2;
  ma = A_size[1];
  pvt = A_size[1];
  minmn = A_size[0];
  if (pvt < minmn) {
    minmn = pvt;
  }
  for (pvt = 0; pvt < A_size[0]; pvt++) {
    smax = xnrm2(A_size[1], A_data, pvt * ma + 1);
    vn1_data[pvt] = smax;
    vn2_data[pvt] = smax;
  }
  for (i = 0; i < minmn; i++) {
    ip1 = i + 2;
    iy = i * ma;
    ii = iy + i;
    nmi = A_size[0] - i;
    mmi = A_size[1] - i;
    if (nmi < 1) {
      minmana = -1;
    } else {
      minmana = 0;
      if (nmi > 1) {
        ix = i;
        smax = fabs(vn1_data[i]);
        for (k = 2; k <= nmi; k++) {
          ix++;
          s = fabs(vn1_data[ix]);
          if (s > smax) {
            minmana = k - 1;
            smax = s;
          }
        }
      }
    }
    pvt = i + minmana;
    if (pvt + 1 != i + 1) {
      ix = pvt * ma;
      for (k = 0; k < A_size[1]; k++) {
        smax = A_data[ix];
        A_data[ix] = A_data[iy];
        A_data[iy] = smax;
        ix++;
        iy++;
      }
      minmana = perm[pvt];
      perm[pvt] = perm[i];
      perm[i] = minmana;
      vn1_data[pvt] = vn1_data[i];
      vn2_data[pvt] = vn2_data[i];
    }
    if (i + 1 < A_size[1]) {
      temp2 = A_data[ii];
      minmana = ii + 2;
      tau_data[i] = 0.0;
      if (mmi > 0) {
        smax = xnrm2(mmi - 1, A_data, ii + 2);
        if (smax != 0.0) {
          s = hypot(A_data[ii], smax);
          if (A_data[ii] >= 0.0)
            s = -s;
          if (fabs(s) < 1.0020841800044864E-292) {
            pvt = -1;
            b_i = ii + mmi;
            do {
              pvt++;
              for (k = minmana; k <= b_i; k++)
                A_data[k - 1] *= 9.9792015476736E+291;
              s *= 9.9792015476736E+291;
              temp2 *= 9.9792015476736E+291;
            } while (!(fabs(s) >= 1.0020841800044864E-292));
            s = hypot(temp2, xnrm2(mmi - 1, A_data, ii + 2));
            if (temp2 >= 0.0)
              s = -s;
            tau_data[i] = (s - temp2) / s;
            smax = 1.0 / (temp2 - s);
            for (k = minmana; k <= b_i; k++)
              A_data[k - 1] *= smax;
            for (k = 0; k <= pvt; k++)
              s *= 1.0020841800044864E-292;
            temp2 = s;
          } else {
            tau_data[i] = (s - A_data[ii]) / s;
            smax = 1.0 / (A_data[ii] - s);
            b_i = ii + mmi;
            for (k = minmana; k <= b_i; k++)
              A_data[k - 1] *= smax;
            temp2 = s;
          }
        }
      }
      A_data[ii] = temp2;
    } else {
      tau_data[i] = 0.0;
    }
    if (i + 1 < A_size[0]) {
      temp2 = A_data[ii];
      A_data[ii] = 1.0;
      ic0 = (ii + ma) + 1;
      if (tau_data[i] != 0.0) {
        lastv = mmi;
        minmana = (ii + mmi) - 1;
        while ((lastv > 0) && (A_data[minmana] == 0.0)) {
          lastv--;
          minmana--;
        }
        pvt = nmi - 1;
        exitg2 = 0;
        while ((!exitg2) && (pvt > 0)) {
          minmana = ic0 + (pvt - 1) * ma;
          nmi = minmana;
          do {
            exitg1 = 0;
            if (nmi <= (minmana + lastv) - 1) {
              if (A_data[nmi - 1] != 0.0)
                exitg1 = 1;
              else
                nmi++;
            } else {
              pvt--;
              exitg1 = 2;
            }
          } while (exitg1 == 0);
          if (exitg1 == 1)
            exitg2 = 1;
        }
      } else {
        lastv = 0;
        pvt = 0;
      }
      if (lastv > 0) {
        if (pvt != 0) {
          memset(&work_data[0], 0, pvt * sizeof(double));
          iy = 0;
          b_i = ic0 + ma * (pvt - 1);
          for (k = ic0; ma < 0 ? k >= b_i : k <= b_i; k += ma) {
            ix = ii;
            smax = 0.0;
            minmana = (k + lastv) - 1;
            for (nmi = k; nmi <= minmana; nmi++) {
              smax += A_data[nmi - 1] * A_data[ix];
              ix++;
            }
            work_data[iy] += smax;
            iy++;
          }
        }
        xgerc(lastv, pvt, -tau_data[i], ii + 1, work_data, A_data, ic0, ma);
      }
      A_data[ii] = temp2;
    }
    for (pvt = ip1; pvt <= A_size[0]; pvt++) {
      minmana = i + (pvt - 1) * ma;
      smax = vn1_data[pvt - 1];
      if (smax != 0.0) {
        s = fabs(A_data[minmana]) / smax;
        s = 1.0 - s * s;
        if (s < 0.0)
          s = 0.0;
        temp2 = smax / vn2_data[pvt - 1];
        temp2 = s * (temp2 * temp2);
        if (temp2 <= 1.4901161193847656E-8) {
          if (i + 1 < A_size[1]) {
            smax = xnrm2(mmi - 1, A_data, minmana + 2);
            vn1_data[pvt - 1] = smax;
            vn2_data[pvt - 1] = smax;
          } else {
            vn1_data[pvt - 1] = 0.0;
            vn2_data[pvt - 1] = 0.0;
          }
        } else
          vn1_data[pvt - 1] = smax * sqrt(s);
      }
    }
  }
}


x86 assembly (clang, -O0):
<xgeqp3>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    11af <xgeqp3+0x5f>
mov    -0x88(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1231 <xgeqp3+0xe1>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%edi
mov    -0x8(%rbp),%rsi
mov    -0x88(%rbp),%edx
imul   -0x74(%rbp),%edx
add    $0x1,%edx
mov    $0x0,%al
call   1070 <xnrm2@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    11b9 <xgeqp3+0x69>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1dd0 <xgeqp3+0xc80>
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x74(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x80(%rbp)
cmpl   $0x1,-0x84(%rbp)
jge    1295 <xgeqp3+0x145>
movl   $0xffffffff,-0x78(%rbp)
jmp    1348 <xgeqp3+0x1f8>
movl   $0x0,-0x78(%rbp)
cmpl   $0x1,-0x84(%rbp)
jle    1343 <xgeqp3+0x1f3>
mov    -0x54(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd3d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x2,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x84(%rbp),%eax
jg     133e <xgeqp3+0x1ee>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd01(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    132b <xgeqp3+0x1db>
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1330 <xgeqp3+0x1e0>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12d3 <xgeqp3+0x183>
jmp    1343 <xgeqp3+0x1f3>
jmp    1348 <xgeqp3+0x1f8>
mov    -0x54(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
je     145f <xgeqp3+0x30f>
mov    -0x88(%rbp),%eax
imul   -0x74(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    13ed <xgeqp3+0x29d>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    137f <xgeqp3+0x22f>
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    -0x10(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    17e7 <xgeqp3+0x697>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x80(%rbp)
jle    17d0 <xgeqp3+0x680>
mov    -0x80(%rbp),%edi
sub    $0x1,%edi
mov    -0x8(%rbp),%rsi
mov    -0x5c(%rbp),%edx
add    $0x2,%edx
mov    $0x0,%al
call   1070 <xnrm2@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14e4 <xgeqp3+0x394>
jp     14e4 <xgeqp3+0x394>
jmp    17cb <xgeqp3+0x67b>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm1
call   1050 <hypot@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     153b <xgeqp3+0x3eb>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm1
movaps 0xab9(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xabd(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1730 <xgeqp3+0x5e0>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
mov    -0x5c(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     15be <xgeqp3+0x46e>
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xa7a(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1585 <xgeqp3+0x435>
movsd  0xa5a(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xa48(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
movaps 0xa12(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xa16(%rip),%xmm1
ucomisd %xmm1,%xmm0
setae  %al
xor    $0xff,%al
test   $0x1,%al
jne    1570 <xgeqp3+0x420>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x80(%rbp),%edi
sub    $0x1,%edi
mov    -0x8(%rbp),%rsi
mov    -0x5c(%rbp),%edx
add    $0x2,%edx
mov    $0x0,%al
call   1070 <xnrm2@plt>
movsd  -0x98(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
call   1050 <hypot@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1678 <xgeqp3+0x528>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
movsd  0x972(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     16eb <xgeqp3+0x59b>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    16b5 <xgeqp3+0x565>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jg     1721 <xgeqp3+0x5d1>
movsd  0x907(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    16f2 <xgeqp3+0x5a2>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    17c6 <xgeqp3+0x676>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x38(%rbp),%xmm1
movsd  0x8aa(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     17bc <xgeqp3+0x66c>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1786 <xgeqp3+0x636>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    17cb <xgeqp3+0x67b>
jmp    17d0 <xgeqp3+0x680>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17f7 <xgeqp3+0x6a7>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1ba4 <xgeqp3+0xa54>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  0x7ed(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1861 <xgeqp3+0x711>
jp     1861 <xgeqp3+0x711>
jmp    19e8 <xgeqp3+0x898>
mov    -0x80(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x80(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x70(%rbp)
mov    %al,-0x99(%rbp)
jle    18a7 <xgeqp3+0x757>
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
sete   %al
setnp  %cl
and    %cl,%al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    18ba <xgeqp3+0x76a>
jmp    18d1 <xgeqp3+0x781>
mov    -0x70(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x70(%rbp)
mov    -0x78(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x78(%rbp)
jmp    1873 <xgeqp3+0x723>
mov    -0x84(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x88(%rbp)
movb   $0x0,-0x89(%rbp)
xor    %eax,%eax
cmpb   $0x0,-0x89(%rbp)
mov    %al,-0x9a(%rbp)
jne    190c <xgeqp3+0x7bc>
cmpl   $0x0,-0x88(%rbp)
setg   %al
mov    %al,-0x9a(%rbp)
mov    -0x9a(%rbp),%al
test   $0x1,%al
jne    191f <xgeqp3+0x7cf>
jmp    19e3 <xgeqp3+0x893>
mov    -0x58(%rbp),%eax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x78(%rbp),%ecx
add    -0x70(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     19a8 <xgeqp3+0x858>
mov    -0x8(%rbp),%rax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1988 <xgeqp3+0x838>
jp     1988 <xgeqp3+0x838>
jmp    1994 <xgeqp3+0x844>
movl   $0x1,-0x50(%rbp)
jmp    19a3 <xgeqp3+0x853>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    19be <xgeqp3+0x86e>
mov    -0x88(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
movl   $0x2,-0x50(%rbp)
jmp    19c3 <xgeqp3+0x873>
cmpl   $0x0,-0x50(%rbp)
je     193d <xgeqp3+0x7ed>
cmpl   $0x1,-0x50(%rbp)
jne    19de <xgeqp3+0x88e>
movb   $0x1,-0x89(%rbp)
jmp    18e7 <xgeqp3+0x797>
jmp    19f9 <xgeqp3+0x8a9>
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x88(%rbp)
cmpl   $0x0,-0x70(%rbp)
jle    1b92 <xgeqp3+0xa42>
cmpl   $0x0,-0x88(%rbp)
je     1b46 <xgeqp3+0x9f6>
mov    0x10(%rbp),%rdi
movslq -0x88(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x74(%rbp),%ecx
mov    -0x88(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x74(%rbp)
jge    1a6d <xgeqp3+0x91d>
mov    -0x6c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xa0(%rbp)
jmp    1a81 <xgeqp3+0x931>
mov    -0x6c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    $0x0,%eax
je     1b41 <xgeqp3+0x9f1>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     1b13 <xgeqp3+0x9c3>
mov    -0x8(%rbp),%rax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1ab3 <xgeqp3+0x963>
movsd  -0x40(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x74(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1a4a <xgeqp3+0x8fa>
jmp    1b46 <xgeqp3+0x9f6>
mov    -0x70(%rbp),%edi
mov    -0x88(%rbp),%esi
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
mov    0x10(%rbp),%rcx
mov    -0x8(%rbp),%r8
mov    -0x58(%rbp),%r9d
mov    -0x74(%rbp),%eax
mov    %eax,(%rsp)
mov    $0x1,%al
call   1030 <xgerc@plt>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     1dbd <xgeqp3+0xc6d>
mov    -0x54(%rbp),%eax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x74(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c0b <xgeqp3+0xabb>
jp     1c0b <xgeqp3+0xabb>
jmp    1da4 <xgeqp3+0xc54>
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x3e1(%rip),%xmm1
pand   %xmm1,%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x3be(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1c79 <xgeqp3+0xb29>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x370(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jb     1d64 <xgeqp3+0xc14>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    -0x10(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    1d2f <xgeqp3+0xbdf>
mov    -0x80(%rbp),%edi
sub    $0x1,%edi
mov    -0x8(%rbp),%rsi
mov    -0x78(%rbp),%edx
add    $0x2,%edx
mov    $0x0,%al
call   1070 <xnrm2@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d5f <xgeqp3+0xc0f>
mov    -0x28(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d9f <xgeqp3+0xc4f>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1da4 <xgeqp3+0xc54>
jmp    1da9 <xgeqp3+0xc59>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1bad <xgeqp3+0xa5d>
jmp    1dc2 <xgeqp3+0xc72>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1238 <xgeqp3+0xe8>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xgeqp3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,%r12
mov    %r8,%r15
mov    %rcx,0xd0(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rdi,%r14
movslq 0x4(%rsi),%rdi
mov    (%rsi),%eax
cmp    %eax,%edi
mov    %eax,%ecx
cmovl  %edi,%ecx
mov    %ecx,0x74(%rsp)
test   %eax,%eax
mov    %rsi,0x38(%rsp)
mov    %rdi,0x28(%rsp)
jle    120b <xgeqp3+0xbb>
mov    %r14,%rsi
mov    $0x1,%edx
xor    %eax,%eax
call   1070 <xnrm2@plt>
mov    0x28(%rsp),%rdi
mov    0x38(%rsp),%rsi
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r15)
movsd  %xmm0,(%r12)
mov    (%rsi),%eax
cmp    $0x2,%eax
jl     120b <xgeqp3+0xbb>
lea    0x1(%rdi),%ebx
mov    $0x1,%ebp
mov    %r12,%r13
mov    0x4(%rsi),%edi
mov    %r14,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1070 <xnrm2@plt>
mov    0x28(%rsp),%rdi
mov    0x38(%rsp),%rsi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r15,%rbp,8)
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x1,%rbp
movslq (%rsi),%rax
add    %edi,%ebx
cmp    %rax,%rbp
jl     11d0 <xgeqp3+0x80>
cmpl   $0x0,0x74(%rsp)
jle    21f0 <xgeqp3+0x10a0>
mov    %r12,%rdx
lea    0x8(%r14),%r12
lea    0x30(%r14),%rcx
mov    %rcx,0xb0(%rsp)
lea    0x28(%r14),%rcx
mov    %rcx,0x90(%rsp)
lea    -0x8(%r14),%rbx
lea    0x0(,%rdi,8),%r10
xorpd  %xmm7,%xmm7
movapd 0x1db2(%rip),%xmm8
movapd 0x1da9(%rip),%xmm9
xor    %r9d,%r9d
mov    %rdx,0x78(%rsp)
mov    %r15,0xa8(%rsp)
mov    %r12,0xe0(%rsp)
mov    %rbx,0x40(%rsp)
mov    %r10,0x30(%rsp)
jmp    12a0 <xgeqp3+0x150>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rbx
cmp    0x74(%rsp),%r9d
mov    0xa8(%rsp),%r15
mov    0xe0(%rsp),%r12
jge    21f0 <xgeqp3+0x10a0>
mov    %rdx,%r13
mov    %r9d,%r8d
mov    %edi,%ebp
imul   %r9d,%ebp
mov    0x4(%rsi),%r11d
mov    %eax,%edx
sub    %r9d,%edx
mov    %rdx,0x88(%rsp)
mov    %rbp,0x18(%rsp)
jle    12e0 <xgeqp3+0x190>
cmp    $0x1,%edx
jne    1300 <xgeqp3+0x1b0>
lea    0x1(%r8),%r9d
mov    %r11d,%eax
mov    %r13,%rdx
jmp    1604 <xgeqp3+0x4b4>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r8),%eax
lea    0x1(%r8),%ecx
mov    %ecx,0xc(%rsp)
jmp    13bc <xgeqp3+0x26c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8d,%ecx
movsd  (%r15,%rcx,8),%xmm0
andpd  %xmm8,%xmm0
mov    %r8d,%r9d
not    %r9d
add    %eax,%r9d
add    $0xfffffffe,%eax
cmp    %r8d,%eax
jne    132e <xgeqp3+0x1de>
mov    $0x2,%ebx
xor    %eax,%eax
test   $0x1,%r9b
jne    138d <xgeqp3+0x23d>
jmp    13a3 <xgeqp3+0x253>
mov    %r9d,%edi
and    $0xfffffffe,%edi
neg    %edi
xor    %eax,%eax
mov    $0x1,%ebx
nopl   (%rax)
movsd  0x8(%r15,%rcx,8),%xmm1
andpd  %xmm9,%xmm1
ucomisd %xmm0,%xmm1
maxsd  %xmm0,%xmm1
movsd  0x10(%r15,%rcx,8),%xmm0
cmova  %ebx,%eax
add    $0x2,%rcx
andpd  %xmm9,%xmm0
ucomisd %xmm1,%xmm0
lea    0x1(%rbx),%ebp
cmova  %ebp,%eax
maxsd  %xmm1,%xmm0
mov    %ebx,%ebp
add    $0x2,%ebx
add    %edi,%ebp
add    $0x2,%ebp
cmp    $0x1,%ebp
jne    1340 <xgeqp3+0x1f0>
add    $0x1,%ebx
test   $0x1,%r9b
je     13a3 <xgeqp3+0x253>
movsd  0x8(%r15,%rcx,8),%xmm1
andpd  %xmm8,%xmm1
add    $0xffffffff,%ebx
ucomisd %xmm0,%xmm1
cmova  %ebx,%eax
lea    0x1(%r8),%r9d
test   %eax,%eax
je     18b4 <xgeqp3+0x764>
mov    %r9d,0xc(%rsp)
add    %r8d,%eax
mov    0x40(%rsp),%rbx
mov    %r11,0x10(%rsp)
test   %r11d,%r11d
jle    15b4 <xgeqp3+0x464>
mov    %eax,%ecx
imul   0x28(%rsp),%ecx
mov    0x18(%rsp),%rbp
movslq %ebp,%r9
movslq %ecx,%r10
mov    0x10(%rsp),%rcx
lea    -0x1(%rcx),%edi
xor    %r11d,%r11d
cmp    $0x3,%edi
jb     1530 <xgeqp3+0x3e0>
lea    (%r14,%r10,8),%rcx
lea    (%r9,%rdi,1),%rdx
lea    (%r12,%rdx,8),%rdx
cmp    %rdx,%rcx
jae    1416 <xgeqp3+0x2c6>
lea    (%r10,%rdi,1),%rcx
lea    (%r12,%rcx,8),%rcx
lea    (%r14,%r9,8),%rdx
cmp    %rcx,%rdx
jb     1530 <xgeqp3+0x3e0>
mov    %r8,0x20(%rsp)
add    $0x1,%rdi
mov    %rdi,%r11
movabs $0x1fffffffc,%rcx
and    %rcx,%r11
lea    -0x4(%r11),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1b29 <xgeqp3+0x9d9>
mov    %r8,%rbp
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rbp
mov    0xb0(%rsp),%rdx
lea    (%rdx,%r10,8),%rcx
lea    (%rdx,%r9,8),%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x30(%rcx,%rbx,8),%xmm0
movups -0x20(%rcx,%rbx,8),%xmm1
movups -0x30(%rdx,%rbx,8),%xmm2
movups -0x20(%rdx,%rbx,8),%xmm3
movups %xmm2,-0x30(%rcx,%rbx,8)
movups %xmm3,-0x20(%rcx,%rbx,8)
movups %xmm0,-0x30(%rdx,%rbx,8)
movups %xmm1,-0x20(%rdx,%rbx,8)
movupd -0x10(%rcx,%rbx,8),%xmm0
movupd (%rcx,%rbx,8),%xmm1
movupd -0x10(%rdx,%rbx,8),%xmm2
movupd (%rdx,%rbx,8),%xmm3
movupd %xmm2,-0x10(%rcx,%rbx,8)
movupd %xmm3,(%rcx,%rbx,8)
movupd %xmm0,-0x10(%rdx,%rbx,8)
movupd %xmm1,(%rdx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1470 <xgeqp3+0x320>
test   $0x1,%r8b
je     150f <xgeqp3+0x3bf>
lea    (%rbx,%r10,1),%rcx
add    %r9,%rbx
movupd (%r14,%rcx,8),%xmm0
movupd 0x10(%r14,%rcx,8),%xmm1
movupd (%r14,%rbx,8),%xmm2
movupd 0x10(%r14,%rbx,8),%xmm3
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm3,0x10(%r14,%rcx,8)
movupd %xmm0,(%r14,%rbx,8)
movupd %xmm1,0x10(%r14,%rbx,8)
cmp    %r11,%rdi
mov    0x40(%rsp),%rbx
mov    0x20(%rsp),%r8
je     15b4 <xgeqp3+0x464>
add    %r11,%r10
add    %r11,%r9
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
mov    %ecx,%edx
sub    %r11d,%edx
lea    0x1(%r11),%ecx
test   $0x1,%dl
je     1566 <xgeqp3+0x416>
movsd  (%r14,%r10,8),%xmm0
movsd  (%r14,%r9,8),%xmm1
movsd  %xmm1,(%r14,%r10,8)
movsd  %xmm0,(%r14,%r9,8)
add    $0x1,%r10
add    $0x1,%r9
mov    %ecx,%r11d
cmp    %ecx,0x10(%rsp)
je     15b4 <xgeqp3+0x464>
lea    (%r12,%r10,8),%rcx
lea    (%r12,%r9,8),%rdx
mov    0x10(%rsp),%rdi
sub    %r11d,%edi
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  -0x8(%rdx,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rbp,8)
movsd  %xmm0,-0x8(%rdx,%rbp,8)
movsd  (%rcx,%rbp,8),%xmm0
movsd  (%rdx,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
movsd  %xmm0,(%rdx,%rbp,8)
add    $0x2,%rbp
cmp    %ebp,%edi
jne    1580 <xgeqp3+0x430>
cltq
mov    0xd0(%rsp),%rdi
mov    (%rdi,%rax,4),%ecx
mov    %r8d,%edx
mov    (%rdi,%rdx,4),%ebp
mov    %ebp,(%rdi,%rax,4)
mov    %ecx,(%rdi,%rdx,4)
movsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
mov    %r13,%rcx
movsd  0x0(%r13,%rdx,8),%xmm0
mov    %r13,%rdx
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0x4(%rsi),%eax
mov    0x30(%rsp),%r10
mov    0xc(%rsp),%r9d
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%r11
lea    (%r8,%rbp,1),%r12d
mov    %r11d,%r15d
sub    %r8d,%r15d
cmp    %eax,%r9d
mov    %r9d,0xc(%rsp)
mov    %r12,0x68(%rsp)
jge    1890 <xgeqp3+0x740>
movslq %r12d,%rbx
movsd  (%r14,%rbx,8),%xmm1
mov    %r8d,%ecx
mov    0x58(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
test   %r15d,%r15d
mov    %rbx,0xd8(%rsp)
jle    18aa <xgeqp3+0x75a>
mov    %rcx,0x98(%rsp)
movsd  %xmm1,0x60(%rsp)
mov    %r11,0x10(%rsp)
mov    %r8,0x20(%rsp)
lea    0x2(%r12),%edx
lea    -0x1(%r15),%edi
mov    %edi,0x80(%rsp)
mov    %r14,%rsi
mov    %edx,%ebp
xor    %eax,%eax
call   1070 <xnrm2@plt>
test   %eax,%eax
je     18c9 <xgeqp3+0x779>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  (%r14,%rbx,8),%xmm0
call   1050 <hypot@plt>
movsd  (%r14,%rbx,8),%xmm2
movapd %xmm0,%xmm3
xorpd  0x1965(%rip),%xmm3
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movapd %xmm1,%xmm4
andpd  %xmm0,%xmm4
andnpd %xmm3,%xmm1
orpd   %xmm4,%xmm1
movapd 0x1933(%rip),%xmm8
andpd  %xmm8,%xmm0
movsd  0x1955(%rip),%xmm9
ucomisd %xmm0,%xmm9
jbe    1910 <xgeqp3+0x7c0>
mov    %r15,0x48(%rsp)
mov    0x10(%rsp),%rax
mov    0x18(%rsp),%rcx
lea    (%rax,%rcx,1),%edx
mov    %edx,0x50(%rsp)
movslq %ebp,%r12
lea    (%rax,%rcx,1),%r13d
add    $0x1,%r13d
sub    0x20(%rsp),%eax
add    $0xfffffffe,%eax
lea    0x1(%rax),%r8
mov    %r8,%r9
movabs $0x1fffffffc,%rdx
and    %rdx,%r9
lea    -0x4(%r9),%rdx
mov    %rdx,0xa0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
lea    (%r9,%r12,1),%r10
mov    %rdx,%r11
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%r11
mov    0x90(%rsp),%rsi
lea    (%rsi,%r12,8),%r15
mov    $0xffffffff,%esi
mov    $0x1,%edi
movsd  0x18d8(%rip),%xmm6
movapd 0x18b0(%rip),%xmm7
movsd  0x60(%rsp),%xmm5
jmp    17a2 <xgeqp3+0x652>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%esi
mulsd  %xmm6,%xmm1
mulsd  %xmm6,%xmm5
movapd %xmm1,%xmm0
andpd  %xmm8,%xmm0
lea    0x1(%rbx),%edi
ucomisd %xmm9,%xmm0
jae    1976 <xgeqp3+0x826>
mov    %esi,%ecx
mov    %edi,%ebx
cmp    0x50(%rsp),%ebp
jg     1780 <xgeqp3+0x630>
mov    %r12,%rsi
cmp    $0x3,%eax
jb     1860 <xgeqp3+0x710>
cmpq   $0x0,0xa0(%rsp)
je     1880 <xgeqp3+0x730>
mov    %r11,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x30(%r15,%rsi,8),%xmm0
movupd -0x20(%r15,%rsi,8),%xmm2
movupd -0x10(%r15,%rsi,8),%xmm3
movupd (%r15,%rsi,8),%xmm4
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm2
movupd %xmm0,-0x30(%r15,%rsi,8)
movupd %xmm2,-0x20(%r15,%rsi,8)
mulpd  %xmm7,%xmm3
mulpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%r15,%rsi,8)
movupd %xmm4,(%r15,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    17d0 <xgeqp3+0x680>
test   $0x1,%dl
je     184c <xgeqp3+0x6fc>
add    %r12,%rsi
movupd -0x8(%r14,%rsi,8),%xmm0
movupd 0x8(%r14,%rsi,8),%xmm2
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm2
movupd %xmm0,-0x8(%r14,%rsi,8)
movupd %xmm2,0x8(%r14,%rsi,8)
mov    %r10,%rsi
cmp    %r9,%r8
je     1780 <xgeqp3+0x630>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r14,%rsi,8),%xmm0
mulsd  %xmm6,%xmm0
movsd  %xmm0,-0x8(%r14,%rsi,8)
add    $0x1,%rsi
cmp    %esi,%r13d
jne    1860 <xgeqp3+0x710>
jmp    1780 <xgeqp3+0x630>
xor    %esi,%esi
test   $0x1,%dl
jne    1825 <xgeqp3+0x6d5>
jmp    184c <xgeqp3+0x6fc>
nopl   0x0(%rax)
mov    %r8d,%eax
mov    0x58(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    0x28(%rsp),%rdi
jmp    1dd3 <xgeqp3+0xc83>
mov    0x28(%rsp),%rdi
jmp    1dc0 <xgeqp3+0xc70>
mov    %r11d,%eax
mov    0x40(%rsp),%rbx
mov    0x18(%rsp),%rbp
mov    %r13,%rdx
jmp    1604 <xgeqp3+0x4b4>
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%r10
xorpd  %xmm7,%xmm7
movapd 0x171b(%rip),%xmm8
movapd 0x1712(%rip),%xmm9
mov    0x20(%rsp),%r8
mov    0xc(%rsp),%r9d
mov    0x10(%rsp),%r11
mov    %r13,%rdx
movsd  0x60(%rsp),%xmm1
mov    0x18(%rsp),%rbp
jmp    1dc0 <xgeqp3+0xc70>
movapd %xmm1,%xmm0
subsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
mov    0x58(%rsp),%rax
mov    0x98(%rsp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%rax
add    %r11d,%eax
cmp    %eax,%ebp
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%rdi
xorpd  %xmm7,%xmm7
mov    0x20(%rsp),%r8
mov    %r13,%rdx
jle    1ae5 <xgeqp3+0x995>
mov    0x30(%rsp),%r10
movapd 0x1699(%rip),%xmm9
mov    0xc(%rsp),%r9d
mov    0x18(%rsp),%rbp
jmp    1dc0 <xgeqp3+0xc70>
mov    %r11,0xb8(%rsp)
mov    %rdx,0xc0(%rsp)
mov    %rax,0xc8(%rsp)
mov    0x80(%rsp),%edi
mov    %r14,%rsi
mov    %ebp,%edx
xor    %eax,%eax
movsd  %xmm5,0x60(%rsp)
mov    %rcx,0x80(%rsp)
call   1070 <xnrm2@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x60(%rsp),%xmm0
call   1050 <hypot@plt>
mov    0x80(%rsp),%rcx
movsd  0x60(%rsp),%xmm3
xorpd  %xmm1,%xmm1
cmpnlesd %xmm3,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  0x1628(%rip),%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm1,%xmm0
subsd  %xmm3,%xmm0
divsd  %xmm1,%xmm0
mov    0x58(%rsp),%rax
mov    0x98(%rsp),%rdx
movsd  %xmm0,(%rax,%rdx,8)
cmp    0x50(%rsp),%ebp
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%r10
xorpd  %xmm7,%xmm7
movapd 0x15d2(%rip),%xmm9
mov    0xc(%rsp),%r9d
mov    0x18(%rsp),%rbp
jg     1c5b <xgeqp3+0xb0b>
subsd  %xmm1,%xmm3
movsd  0x15ee(%rip),%xmm0
divsd  %xmm3,%xmm0
mov    0xc8(%rsp),%r11
cmp    $0x3,%r11d
jb     1c40 <xgeqp3+0xaf0>
add    $0x1,%r11
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
cmpq   $0x0,0xa0(%rsp)
je     1bed <xgeqp3+0xa9d>
xor    %eax,%eax
mov    0xb8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%r15,%rax,8),%xmm3
movupd -0x20(%r15,%rax,8),%xmm4
movupd -0x10(%r15,%rax,8),%xmm5
movupd (%r15,%rax,8),%xmm6
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x30(%r15,%rax,8)
movupd %xmm4,-0x20(%r15,%rax,8)
mulpd  %xmm2,%xmm5
mulpd  %xmm2,%xmm6
movupd %xmm5,-0x10(%r15,%rax,8)
movupd %xmm6,(%r15,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1a90 <xgeqp3+0x940>
jmp    1bef <xgeqp3+0xa9f>
movsd  (%r14,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x1541(%rip),%xmm0
divsd  %xmm2,%xmm0
movslq %ebp,%rax
mov    %r11d,%ecx
sub    %r8d,%ecx
add    $0xfffffffe,%ecx
cmp    $0x3,%ecx
jae    1b3a <xgeqp3+0x9ea>
mov    0x30(%rsp),%r10
movapd 0x14e6(%rip),%xmm9
mov    0xc(%rsp),%r9d
mov    0x18(%rsp),%rbp
jmp    1d88 <xgeqp3+0xc38>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    14d4 <xgeqp3+0x384>
jmp    150f <xgeqp3+0x3bf>
add    $0x1,%rcx
mov    %rcx,%r8
movabs $0x1fffffffc,%rdx
and    %rdx,%r8
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
lea    -0x4(%r8),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
mov    0x30(%rsp),%r10
movapd 0x148a(%rip),%xmm9
mov    0x18(%rsp),%r11
je     1d32 <xgeqp3+0xbe2>
mov    %r9,%rbp
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rbp
mov    0x90(%rsp),%rdx
lea    (%rdx,%rax,8),%rbx
xor    %edx,%edx
nop
movupd -0x30(%rbx,%rdx,8),%xmm3
movupd -0x20(%rbx,%rdx,8),%xmm4
movupd -0x10(%rbx,%rdx,8),%xmm5
movupd (%rbx,%rdx,8),%xmm6
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x30(%rbx,%rdx,8)
movupd %xmm4,-0x20(%rbx,%rdx,8)
mulpd  %xmm2,%xmm5
mulpd  %xmm2,%xmm6
movupd %xmm5,-0x10(%rbx,%rdx,8)
movupd %xmm6,(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbp
jne    1ba0 <xgeqp3+0xa50>
jmp    1d34 <xgeqp3+0xbe4>
xor    %eax,%eax
mov    %r11,%r8
movabs $0x1fffffffc,%rdx
and    %rdx,%r8
testb  $0x1,0xc0(%rsp)
01
je     1c30 <xgeqp3+0xae0>
add    %r12,%rax
movupd -0x8(%r14,%rax,8),%xmm3
movupd 0x8(%r14,%rax,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x8(%r14,%rax,8)
movupd %xmm4,0x8(%r14,%rax,8)
cmp    %r8,%r11
je     1c5b <xgeqp3+0xb0b>
add    %r8,%r12
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r14,%r12,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,-0x8(%r14,%r12,8)
add    $0x1,%r12
cmp    %r12d,%r13d
jne    1c40 <xgeqp3+0xaf0>
cmp    $0xffffffff,%ecx
jge    1c82 <xgeqp3+0xb32>
mov    0x78(%rsp),%rdx
movapd 0x1392(%rip),%xmm8
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%r11
mov    0x48(%rsp),%r15
jmp    1dc0 <xgeqp3+0xc70>
lea    0x1(%rcx),%eax
add    $0x2,%ecx
cmp    $0x7,%eax
jae    1cac <xgeqp3+0xb5c>
mov    0x78(%rsp),%rdx
movapd 0x1365(%rip),%xmm8
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%r11
mov    0x48(%rsp),%r15
jmp    1d05 <xgeqp3+0xbb5>
mov    %ebx,%eax
and    $0xfffffff8,%eax
mov    0x78(%rsp),%rdx
movapd 0x1341(%rip),%xmm8
movsd  0x1369(%rip),%xmm0
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%r11
mov    0x48(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
add    $0xfffffff8,%eax
jne    1ce0 <xgeqp3+0xb90>
test   $0x7,%cl
je     1dc0 <xgeqp3+0xc70>
and    $0x7,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  0x1308(%rip),%xmm1
add    $0xffffffff,%ebx
jne    1d20 <xgeqp3+0xbd0>
jmp    1dc0 <xgeqp3+0xc70>
xor    %edx,%edx
test   $0x1,%r9b
mov    %r11,%rbp
je     1d64 <xgeqp3+0xc14>
add    %rax,%rdx
movupd -0x8(%r14,%rdx,8),%xmm3
movupd 0x8(%r14,%rdx,8),%xmm4
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm4
movupd %xmm3,-0x8(%r14,%rdx,8)
movupd %xmm4,0x8(%r14,%rdx,8)
cmp    %r8,%rcx
mov    0xc(%rsp),%r9d
mov    0x10(%rsp),%r11
jne    1d7d <xgeqp3+0xc2d>
mov    0x20(%rsp),%r8
mov    %r13,%rdx
jmp    1dc0 <xgeqp3+0xc70>
add    %r8,%rax
mov    0x20(%rsp),%r8
mov    %r13,%rdx
lea    (%r11,%rbp,1),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r14,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,-0x8(%r14,%rax,8)
add    $0x1,%rax
cmp    %eax,%ecx
jne    1da0 <xgeqp3+0xc50>
nopw   0x0(%rax,%rax,1)
mov    0xd8(%rsp),%rax
movsd  %xmm1,(%r14,%rax,8)
mov    0x40(%rsp),%rbx
lea    0x2(%r8),%r12d
mov    (%rsi),%eax
cmp    %eax,%r9d
jge    2012 <xgeqp3+0xec2>
movslq 0x68(%rsp),%rdx
movsd  (%r14,%rdx,8),%xmm1
movabs $0x3ff0000000000000,%rcx
mov    %rdx,0x50(%rsp)
mov    %rcx,(%r14,%rdx,8)
mov    %r8d,%edx
mov    0x58(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm0
ucomisd %xmm7,%xmm0
mov    %r15,0x48(%rsp)
jne    1e1e <xgeqp3+0xcce>
jnp    1ffd <xgeqp3+0xead>
mov    %rdx,0x10(%rsp)
mov    %r15d,%r13d
test   %r15d,%r15d
jle    1e60 <xgeqp3+0xd10>
add    %ebp,%r11d
movslq %r11d,%rcx
lea    (%rbx,%rcx,8),%rcx
mov    %r15d,%r13d
nopl   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
ucomisd %xmm7,%xmm0
jne    1e60 <xgeqp3+0xd10>
jp     1e60 <xgeqp3+0xd10>
lea    -0x1(%r13),%edx
add    $0xfffffffffffffff8,%rcx
cmp    $0x1,%r13d
mov    %edx,%r13d
jg     1e40 <xgeqp3+0xcf0>
xor    %r13d,%r13d
mov    0x68(%rsp),%rcx
lea    (%rcx,%rdi,1),%r11d
add    $0x1,%r11d
mov    0x88(%rsp),%rdx
lea    -0x1(%rdx),%ecx
cmp    $0x2,%edx
jge    21ac <xgeqp3+0x105c>
mov    %ecx,%r15d
test   %r13d,%r13d
jle    1ffd <xgeqp3+0xead>
mov    %r11d,0x18(%rsp)
movsd  %xmm1,0x88(%rsp)
mov    %r8,0x20(%rsp)
mov    0x68(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x68(%rsp)
test   %r15d,%r15d
je     1f82 <xgeqp3+0xe32>
movslq %r15d,%rdx
shl    $0x3,%rdx
mov    0x120(%rsp),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x30(%rsp),%r11
mov    0x28(%rsp),%rdi
lea    -0x1(%r15),%edx
imul   %edi,%edx
xor    %eax,%eax
xor    %ecx,%ecx
test   %edx,%edx
setle  %al
setns  %cl
test   %edi,%edi
cmovs  %eax,%ecx
cmp    $0x1,%cl
jne    1f82 <xgeqp3+0xe32>
mov    0x18(%rsp),%eax
add    %eax,%edx
cltq
mov    %r13d,%r8d
movslq %edx,%r9
mov    0x50(%rsp),%rcx
lea    (%r14,%rcx,8),%r10
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    (%rax,%r8,1),%rcx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rdx,8),%xmm1
mulsd  (%r10,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
lea    (%rax,%rdx,1),%rbx
add    $0x1,%rbx
add    $0x1,%rdx
cmp    %rcx,%rbx
jl     1f30 <xgeqp3+0xde0>
mov    0x120(%rsp),%rcx
addsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%rbp
add    %rdi,%rax
xor    %ecx,%ecx
xor    %edx,%edx
cmp    %r9,%rax
setge  %cl
setle  %dl
test   %edi,%edi
cmovs  %ecx,%edx
add    %r11,%rsi
test   %dl,%dl
jne    1f20 <xgeqp3+0xdd0>
mov    0x58(%rsp),%rax
mov    0x10(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorpd  0x1077(%rip),%xmm0
mov    %edi,(%rsp)
mov    %r13d,%edi
mov    %r15d,%esi
mov    0x68(%rsp),%rdx
mov    0x120(%rsp),%rcx
mov    %r14,%r8
mov    0x18(%rsp),%r9d
mov    $0x1,%al
call   1030 <xgerc@plt>
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    (%rsi),%eax
mov    0x40(%rsp),%rbx
xorpd  %xmm7,%xmm7
movapd 0x101f(%rip),%xmm8
movapd 0x1016(%rip),%xmm9
mov    0x20(%rsp),%r8
mov    0xc(%rsp),%r9d
movsd  0x88(%rsp),%xmm1
mov    0x50(%rsp),%rcx
movsd  %xmm1,(%r14,%rcx,8)
mov    0x78(%rsp),%rdx
mov    0x48(%rsp),%r15
cmp    %eax,%r12d
jg     1285 <xgeqp3+0x135>
add    $0xffffffff,%r15d
mov    %r15,0x48(%rsp)
movslq %r12d,%rbp
movslq %r8d,%rax
add    $0xffffffffffffffff,%rbp
lea    0x1(%r8),%ecx
imul   %edi,%ecx
lea    (%r8,%rcx,1),%r15d
add    $0x2,%r15d
mov    %rdi,%rcx
imul   %rbp,%rcx
add    %rax,%rcx
lea    (%r14,%rcx,8),%rbx
mov    0xa8(%rsp),%r12
mov    %rdx,%r13
jmp    20b6 <xgeqp3+0xf66>
movsd  %xmm3,0x50(%rsp)
call   1060 <sqrt@plt>
movsd  0x50(%rsp),%xmm3
mov    %r13,%rdx
mov    0xc(%rsp),%r9d
movapd 0xf86(%rip),%xmm9
movapd 0xf7d(%rip),%xmm8
xorpd  %xmm7,%xmm7
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%rdi
mov    0x38(%rsp),%rsi
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%r12,%rbp,8)
movslq (%rsi),%rax
add    $0x1,%rbp
add    %edi,%r15d
add    %r10,%rbx
cmp    %rax,%rbp
jge    1280 <xgeqp3+0x130>
movsd  (%r12,%rbp,8),%xmm3
ucomisd %xmm7,%xmm3
jne    20c4 <xgeqp3+0xf74>
jnp    20a0 <xgeqp3+0xf50>
movsd  (%rbx),%xmm0
andpd  %xmm8,%xmm0
divsd  %xmm3,%xmm0
mulsd  %xmm0,%xmm0
movsd  0xf5b(%rip),%xmm1
subsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
maxsd  %xmm1,%xmm0
movapd %xmm3,%xmm1
divsd  (%rdx,%rbp,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  0xf46(%rip),%xmm2
ucomisd %xmm1,%xmm2
jae    2120 <xgeqp3+0xfd0>
ucomisd %xmm7,%xmm0
jb     2058 <xgeqp3+0xf08>
sqrtsd %xmm0,%xmm0
jmp    2096 <xgeqp3+0xf46>
nopl   0x0(%rax,%rax,1)
cmp    0x4(%rsi),%r9d
jge    217e <xgeqp3+0x102e>
mov    0x48(%rsp),%rdi
mov    %r14,%rsi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <xnrm2@plt>
mov    %r13,%rdx
mov    0xc(%rsp),%r9d
movapd 0xeb7(%rip),%xmm9
movapd 0xeae(%rip),%xmm8
xorpd  %xmm7,%xmm7
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%rdi
mov    0x38(%rsp),%rsi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movsd  %xmm0,0x0(%r13,%rbp,8)
jmp    20a0 <xgeqp3+0xf50>
movq   $0x0,(%r12,%rbp,8)
movq   $0x0,(%rdx,%rbp,8)
jmp    20a0 <xgeqp3+0xf50>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x1,%ecx
mov    %r15d,%ecx
jle    1e84 <xgeqp3+0xd34>
lea    -0x1(%rcx),%r15d
test   %r13d,%r13d
jle    21a0 <xgeqp3+0x1050>
mov    %r15d,%ebp
imul   %edi,%ebp
add    %r11d,%ebp
movslq %ebp,%rdx
add    %r13d,%ebp
movslq %ebp,%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
ucomisd %xmm7,%xmm0
jne    1e81 <xgeqp3+0xd31>
jp     1e81 <xgeqp3+0xd31>
add    $0x1,%rdx
cmp    %rbp,%rdx
jl     21d0 <xgeqp3+0x1080>
jmp    21a0 <xgeqp3+0x1050>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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