#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double hypot2(double, double);
double pow(double, double);
void tql2(double V[3][3], double d[3], double e[3]) {
  int i, j, k, l, m;
  double f;
  double tst1;
  double eps;
  int iter;
  double g, p, r;
  double dl1, h, c, c2, c3, el1, s, s2;
  for (i = 1; i < 3; i++) {
    e[i - 1] = e[i];
  }
  e[3 - 1] = 0.0;
  f = 0.0;
  tst1 = 0.0;
  eps = pow(2.0, -52.0);
  for (l = 0; l < 3; l++) {
    tst1 = ((tst1) > (fabs(d[l]) + fabs(e[l])) ? (tst1)
                                               : (fabs(d[l]) + fabs(e[l])));
    m = l;
    while (m < 3) {
      if (fabs(e[m]) <= eps * tst1) {
        break;
      }
      m++;
    }
    if (m > l) {
      iter = 0;
      do {
        iter = iter + 1;
        g = d[l];
        p = (d[l + 1] - g) / (2.0 * e[l]);
        r = hypot2(p, 1.0);
        if (p < 0) {
          r = -r;
        }
        d[l] = e[l] / (p + r);
        d[l + 1] = e[l] * (p + r);
        dl1 = d[l + 1];
        h = g - d[l];
        for (i = l + 2; i < 3; i++) {
          d[i] -= h;
        }
        f = f + h;
        p = d[m];
        c = 1.0;
        c2 = c;
        c3 = c;
        el1 = e[l + 1];
        s = 0.0;
        s2 = 0.0;
        for (i = m - 1; i >= l; i--) {
          c3 = c2;
          c2 = c;
          s2 = s;
          g = c * e[i];
          h = c * p;
          r = hypot2(p, e[i]);
          e[i + 1] = s * r;
          s = e[i] / r;
          c = p / r;
          p = c * d[i] - s * g;
          d[i + 1] = h + s * (c * g + s * d[i]);
          for (k = 0; k < 3; k++) {
            h = V[k][i + 1];
            V[k][i + 1] = s * V[k][i] + c * h;
            V[k][i] = c * V[k][i] - s * h;
          }
        }
        p = -s * s2 * c3 * el1 * e[l] / dl1;
        e[l] = s * p;
        d[l] = c * p;
      } while (fabs(e[l]) > eps * tst1);
    }
    d[l] = d[l] + f;
    e[l] = 0.0;
  }
  for (i = 0; i < 3 - 1; i++) {
    k = i;
    p = d[i];
    for (j = i + 1; j < 3; j++) {
      if (d[j] < p) {
        k = j;
        p = d[j];
      }
    }
    if (k != i) {
      d[k] = d[i];
      d[i] = p;
      for (j = 0; j < 3; j++) {
        p = V[j][i];
        V[j][i] = V[j][k];
        V[j][k] = p;
      }
    }
  }
}


x86 assembly (clang, -O0):
<tql2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1175 <tql2+0x55>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    113e <tql2+0x1e>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe67(%rip),%xmm0
movsd  0xe67(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    17d7 <tql2+0x6b7>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe4b(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0xe33(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1211 <tql2+0xf1>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    124d <tql2+0x12d>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdfb(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xde3(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    12a9 <tql2+0x189>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xda2(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     129b <tql2+0x17b>
jmp    12a9 <tql2+0x189>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1260 <tql2+0x140>
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    179a <tql2+0x67a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  0xd02(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xcf7(%rip),%xmm1
call   1030 <hypot2@plt>
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1352 <tql2+0x232>
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1411 <tql2+0x2f1>
movsd  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13de <tql2+0x2be>
movsd  -0x38(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xbd6(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     16ea <tql2+0x5ca>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1030 <hypot2@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm4
movsd  -0xa0(%rbp),%xmm3
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    16d7 <tql2+0x5b7>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15ed <tql2+0x4cd>
jmp    16dc <tql2+0x5bc>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1492 <tql2+0x372>
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x8a3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
ucomisd %xmm1,%xmm0
ja     12bc <tql2+0x19c>
jmp    179a <tql2+0x67a>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b2 <tql2+0x92>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jge    1933 <tql2+0x813>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    185a <tql2+0x73a>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1847 <tql2+0x727>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    184c <tql2+0x72c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1809 <tql2+0x6e9>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1920 <tql2+0x800>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    191b <tql2+0x7fb>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1899 <tql2+0x779>
jmp    1920 <tql2+0x800>
jmp    1925 <tql2+0x805>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    17de <tql2+0x6be>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tql2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
movupd 0x8(%rdx),%xmm0
movupd %xmm0,(%rdx)
movq   $0x0,0x10(%rdx)
mov    $0x2,%eax
mov    %rax,0x18(%rsp)
xor    %ebp,%ebp
movsd  0xed9(%rip),%xmm1
xorpd  %xmm5,%xmm5
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
jmp    118e <tql2+0x7e>
nop
addsd  0x8(%rsp),%xmm8
movsd  %xmm8,(%r14,%rbp,8)
movq   $0x0,(%r15,%rbp,8)
addq   $0x1,0x18(%rsp)
mov    %r12,%rbp
cmp    $0x3,%r12
movsd  0x30(%rsp),%xmm5
je     1526 <tql2+0x416>
movsd  (%r14,%rbp,8),%xmm8
movapd %xmm8,%xmm4
movapd 0xe5f(%rip),%xmm3
andpd  %xmm3,%xmm4
movsd  (%r15,%rbp,8),%xmm6
movapd %xmm6,%xmm2
andpd  %xmm3,%xmm2
addsd  %xmm2,%xmm4
maxsd  %xmm4,%xmm5
movapd %xmm5,%xmm3
mulsd  0xe59(%rip),%xmm3
ucomisd %xmm2,%xmm3
mov    %rbp,%rax
jae    1240 <tql2+0x130>
lea    0x1(%rbp),%rax
cmp    $0x3,%rax
jne    11f0 <tql2+0xe0>
mov    $0x3,%eax
jmp    1240 <tql2+0x130>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r15,%rbp,8),%xmm2
andpd  0xe01(%rip),%xmm2
ucomisd %xmm2,%xmm3
jae    1240 <tql2+0x130>
lea    0x2(%rbp),%rcx
mov    $0x3,%eax
cmp    $0x3,%rcx
je     1240 <tql2+0x130>
movsd  0x10(%r15,%rbp,8),%xmm2
andpd  0xddd(%rip),%xmm2
ucomisd %xmm2,%xmm3
mov    %rcx,%rax
jae    1240 <tql2+0x130>
lea    0x3(%rbp),%rax
test   %rbp,%rbp
mov    $0x3,%ecx
cmove  %rcx,%rax
nopl   0x0(%rax)
mov    %eax,%r13d
lea    0x1(%rbp),%r12
cmp    %rbp,%r13
movsd  %xmm5,0x30(%rsp)
jbe    1160 <tql2+0x50>
mulsd  0xdc2(%rip),%xmm5
movsd  %xmm5,0x38(%rsp)
mov    %r12,0x48(%rsp)
mov    %r13,0x40(%rsp)
xchg   %ax,%ax
movapd %xmm8,0x20(%rsp)
movsd  (%r14,%r12,8),%xmm0
subsd  %xmm8,%xmm0
addsd  %xmm6,%xmm6
divsd  %xmm6,%xmm0
movsd  %xmm0,0x10(%rsp)
call   1030 <hypot2@plt>
movapd 0x20(%rsp),%xmm2
movsd  0x10(%rsp),%xmm4
movapd %xmm4,%xmm3
cmpltsd 0xd82(%rip),%xmm3
movapd %xmm3,%xmm1
andnpd %xmm0,%xmm1
xorpd  0xd52(%rip),%xmm0
andpd  %xmm3,%xmm0
orpd   %xmm1,%xmm0
movsd  (%r15,%rbp,8),%xmm1
addsd  %xmm4,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbp,8)
mulsd  (%r15,%rbp,8),%xmm0
movapd %xmm0,0x70(%rsp)
movsd  %xmm0,(%r14,%r12,8)
subsd  %xmm1,%xmm2
test   %rbp,%rbp
jne    130a <tql2+0x1fa>
mov    0x18(%rsp),%rax
movsd  (%r14,%rax,8),%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rsp),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%r15,%r12,8),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  (%r14,%r13,8),%xmm0
xorps  %xmm7,%xmm7
mov    %r13,%r12
movsd  0xcee(%rip),%xmm2
movapd %xmm2,%xmm1
xchg   %ax,%ax
movapd %xmm0,0x80(%rsp)
movsd  %xmm2,0x20(%rsp)
movsd  %xmm1,0x58(%rsp)
movsd  %xmm7,0x60(%rsp)
lea    -0x1(%r12),%r13
movsd  -0x8(%r15,%r12,8),%xmm1
movapd %xmm2,%xmm3
mulsd  %xmm1,%xmm3
movsd  %xmm3,0x68(%rsp)
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x10(%rsp)
call   1030 <hypot2@plt>
movsd  0x60(%rsp),%xmm9
movapd 0xc79(%rip),%xmm6
movapd %xmm9,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%r12,8)
movapd 0x80(%rsp),%xmm8
movhpd -0x8(%r15,%r12,8),%xmm8
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm8
movsd  -0x8(%r14,%r12,8),%xmm0
movapd %xmm8,%xmm7
unpckhpd %xmm8,%xmm7
movapd %xmm7,%xmm1
xorpd  %xmm6,%xmm1
movapd %xmm7,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm8,%xmm3
movsd  0x68(%rsp),%xmm10
mulsd  %xmm10,%xmm3
mulsd  %xmm7,%xmm10
addsd  %xmm2,%xmm3
mulsd  %xmm7,%xmm3
addsd  0x10(%rsp),%xmm3
movsd  %xmm3,(%r14,%r12,8)
movsd  -0x8(%rbx,%r12,8),%xmm2
movsd  (%rbx,%r12,8),%xmm3
movsd  0x10(%rbx,%r12,8),%xmm4
movsd  0x18(%rbx,%r12,8),%xmm5
unpcklpd %xmm3,%xmm3
unpcklpd %xmm8,%xmm1
mulpd  %xmm1,%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm8,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,-0x8(%rbx,%r12,8)
unpcklpd %xmm5,%xmm5
mulpd  %xmm1,%xmm5
unpcklpd %xmm4,%xmm4
mulpd  %xmm8,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,0x10(%rbx,%r12,8)
movsd  0x30(%rbx,%r12,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
movsd  0x28(%rbx,%r12,8),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x28(%rbx,%r12,8)
mulsd  %xmm8,%xmm0
subsd  %xmm10,%xmm0
mov    %r13,%r12
movsd  0x20(%rsp),%xmm1
movapd %xmm8,%xmm2
cmp    %rbp,%r13
jg     1340 <tql2+0x230>
movapd %xmm7,%xmm1
xorpd  %xmm6,%xmm1
mulsd  %xmm1,%xmm9
movsd  0x58(%rsp),%xmm2
mulsd  %xmm9,%xmm2
movsd  0x50(%rsp),%xmm1
mulsd  %xmm2,%xmm1
mulsd  (%r15,%rbp,8),%xmm1
divsd  0x70(%rsp),%xmm1
mulsd  %xmm1,%xmm7
movsd  %xmm7,(%r15,%rbp,8)
mulsd  %xmm1,%xmm8
movsd  %xmm8,(%r14,%rbp,8)
movsd  (%r15,%rbp,8),%xmm6
movapd %xmm6,%xmm1
andpd  0xafd(%rip),%xmm1
ucomisd 0x38(%rsp),%xmm1
movsd  0xb17(%rip),%xmm1
mov    0x48(%rsp),%r12
mov    0x40(%rsp),%r13
ja     1270 <tql2+0x160>
jmp    1160 <tql2+0x50>
movsd  (%r14),%xmm0
movsd  0x8(%r14),%xmm1
xor    %ecx,%ecx
ucomisd %xmm1,%xmm0
seta   %cl
minsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm2
ucomisd %xmm2,%xmm1
mov    $0x2,%eax
cmovbe %rcx,%rax
test   %rax,%rax
je     15a3 <tql2+0x493>
minsd  %xmm1,%xmm2
movsd  %xmm0,(%r14,%rax,8)
movsd  %xmm2,(%r14)
movsd  (%rbx),%xmm0
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx)
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x18(%rbx),%xmm0
movsd  0x18(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x18(%rbx)
movsd  %xmm0,0x18(%rbx,%rax,8)
movsd  0x30(%rbx),%xmm0
movsd  0x30(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x30(%rbx)
movsd  %xmm0,0x30(%rbx,%rax,8)
movsd  0x8(%r14),%xmm0
movsd  0x10(%r14),%xmm1
xor    %eax,%eax
ucomisd %xmm1,%xmm0
seta   %cl
ucomisd %xmm1,%xmm0
jbe    1610 <tql2+0x500>
mov    %cl,%al
add    $0x1,%rax
movsd  %xmm0,(%r14,%rax,8)
movsd  %xmm1,0x8(%r14)
movsd  0x8(%rbx),%xmm0
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx)
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x20(%rbx),%xmm0
movsd  0x18(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x20(%rbx)
movsd  %xmm0,0x18(%rbx,%rax,8)
movsd  0x38(%rbx),%xmm0
movsd  0x30(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x38(%rbx)
movsd  %xmm0,0x30(%rbx,%rax,8)
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @tql2([3 x double]* nocapture %0, double* nocapture %1, double* nocapture %2) {
%4 = bitcast double* %2 to i8*
%5 = getelementptr double, double* %2, i64 1
%6 = bitcast double* %5 to i8*
%7 = getelementptr inbounds double, double* %2, i64 2
store double 0.000000e+00, double* %7
br label %8
8: ; preds = %163, %3
%9 = phi i64 [ 2, %3 ], [ %167, %163 ]
%10 = phi i64 [ 0, %3 ], [ %49, %163 ]
%11 = phi double [ 0.000000e+00, %3 ], [ %21, %163 ]
%12 = phi double [ 0.000000e+00, %3 ], [ %165, %163 ]
%13 = getelementptr inbounds double, double* %1, i64 %10
%14 = load double, double* %13
%15 = tail call double @llvm.fabs.f64(double %14)
%16 = getelementptr inbounds double, double* %2, i64 %10
%17 = load double, double* %16
%18 = tail call double @llvm.fabs.f64(double %17)
%19 = fadd double %15, %18
%20 = fcmp ogt double %11, %19
%21 = select i1 %20, double %11, double %19
%22 = fmul double %21, 0x3CB0000000000000
%23 = tail call double @llvm.fabs.f64(double %17)
%24 = fcmp ugt double %23, %22
br i1 %24, label %25, label %45
25: ; preds = %8
%26 = add nuw nsw i64 %10, 1
%27 = icmp eq i64 %26, 3
br i1 %27, label %45, label %28
28: ; preds = %25
%29 = getelementptr inbounds double, double* %2, i64 %26
%30 = load double, double* %29
%31 = tail call double @llvm.fabs.f64(double %30)
%32 = fcmp ugt double %31, %22
br i1 %32, label %33, label %45
33: ; preds = %28
%34 = add nuw nsw i64 %10, 2
%35 = icmp eq i64 %34, 3
br i1 %35, label %45, label %36
36: ; preds = %33
%37 = getelementptr inbounds double, double* %2, i64 %34
%38 = load double, double* %37
%39 = tail call double @llvm.fabs.f64(double %38)
%40 = fcmp ugt double %39, %22
br i1 %40, label %41, label %45
41: ; preds = %36
%42 = icmp eq i64 %10, 0
%43 = add nuw nsw i64 %10, 3
%44 = select i1 %42, i64 3, i64 %43
br label %45
45: ; preds = %41, %28, %25, %33, %36, %8
%46 = phi i64 [ %10, %8 ], [ %26, %28 ], [ 3, %25 ], [ 3, %33 ], [ %34, %36 ], [ %44, %41 ]
%47 = and i64 %46, 4294967295
%48 = icmp ugt i64 %47, %10
%49 = add nuw nsw i64 %10, 1
br i1 %48, label %50, label %163
50: ; preds = %45
%51 = getelementptr inbounds double, double* %1, i64 %49
%52 = icmp eq i64 %10, 0
%53 = getelementptr inbounds double, double* %1, i64 %47
%54 = getelementptr inbounds double, double* %2, i64 %49
%55 = fmul double %21, 0x3CB0000000000000
%56 = getelementptr inbounds double, double* %1, i64 %9
br label %57
57: ; preds = %50, %149
%58 = phi double [ %160, %149 ], [ %17, %50 ]
%59 = phi double [ %159, %149 ], [ %14, %50 ]
%60 = phi double [ %79, %149 ], [ %12, %50 ]
%61 = load double, double* %51
%62 = fsub double %61, %59
%63 = fmul double %58, 2.000000e+00
%64 = fdiv double %62, %63
%65 = tail call double @hypot2(double %64, double 1.000000e+00)
%66 = fcmp olt double %64, 0.000000e+00
%67 = fneg double %65
%68 = select i1 %66, double %67, double %65
%69 = load double, double* %16
%70 = fadd double %64, %68
%71 = fdiv double %69, %70
store double %71, double* %13
%72 = load double, double* %16
%73 = fmul double %72, %70
store double %73, double* %51
%74 = fsub double %59, %71
br i1 %52, label %75, label %78
75: ; preds = %57
%76 = load double, double* %56
%77 = fsub double %76, %74
store double %77, double* %56
br label %78
78: ; preds = %57, %75
%79 = fadd double %60, %74
%80 = load double, double* %54
%81 = load double, double* %53
br label %82
82: ; preds = %78, %82
%83 = phi i64 [ %47, %78 ], [ %88, %82 ]
%84 = phi double [ 0.000000e+00, %78 ], [ %104, %82 ]
%85 = phi double [ 1.000000e+00, %78 ], [ %86, %82 ]
%86 = phi double [ 1.000000e+00, %78 ], [ %108, %82 ]
%87 = phi double [ %81, %78 ], [ %147, %82 ]
%88 = add nsw i64 %83, -1
%89 = getelementptr inbounds double, double* %2, i64 %88
%90 = load double, double* %89
%91 = fmul double %86, %90
%92 = fmul double %87, %86
%93 = tail call double @hypot2(double %87, double %90)
%94 = fmul double %84, %93
%95 = getelementptr inbounds double, double* %2, i64 %83
store double %94, double* %95
%96 = load double, double* %89
%97 = insertelement <2 x double> poison, double %87, i64 0
%98 = insertelement <2 x double> %97, double %96, i64 1
%99 = insertelement <2 x double> poison, double %93, i64 0
%100 = shufflevector <2 x double> %99, <2 x double> poison, <2 x i32> zeroinitializer
%101 = fdiv <2 x double> %98, %100
%102 = getelementptr inbounds double, double* %1, i64 %88
%103 = load double, double* %102
%104 = extractelement <2 x double> %101, i64 1
%105 = fneg double %104
%106 = fmul double %91, %105
%107 = fmul double %104, %103
%108 = extractelement <2 x double> %101, i64 0
%109 = tail call double @llvm.fmuladd.f64(double %108, double %91, double %107)
%110 = tail call double @llvm.fmuladd.f64(double %104, double %109, double %92)
%111 = getelementptr inbounds double, double* %1, i64 %83
store double %110, double* %111
%112 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %83
%113 = load double, double* %112
%114 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %88
%115 = load double, double* %114
%116 = insertelement <2 x double> poison, double %113, i64 0
%117 = shufflevector <2 x double> %116, <2 x double> poison, <2 x i32> zeroinitializer
%118 = insertelement <2 x double> poison, double %105, i64 0
%119 = shufflevector <2 x double> %118, <2 x double> %101, <2 x i32> <i32 0, i32 2>
%120 = fmul <2 x double> %117, %119
%121 = insertelement <2 x double> poison, double %115, i64 0
%122 = shufflevector <2 x double> %121, <2 x double> poison, <2 x i32> zeroinitializer
%123 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> %122, <2 x double> %120)
%124 = bitcast double* %114 to <2 x double>*
store <2 x double> %123, <2 x double>* %124
%125 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 %83
%126 = load double, double* %125
%127 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 %88
%128 = load double, double* %127
%129 = insertelement <2 x double> poison, double %126, i64 0
%130 = shufflevector <2 x double> %129, <2 x double> poison, <2 x i32> zeroinitializer
%131 = fmul <2 x double> %130, %119
%132 = insertelement <2 x double> poison, double %128, i64 0
%133 = shufflevector <2 x double> %132, <2 x double> poison, <2 x i32> zeroinitializer
%134 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> %133, <2 x double> %131)
%135 = bitcast double* %127 to <2 x double>*
store <2 x double> %134, <2 x double>* %135
%136 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 %83
%137 = load double, double* %136
%138 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 %88
%139 = load double, double* %138
%140 = insertelement <2 x double> poison, double %137, i64 0
%141 = shufflevector <2 x double> %140, <2 x double> poison, <2 x i32> zeroinitializer
%142 = fmul <2 x double> %141, %119
%143 = insertelement <2 x double> poison, double %139, i64 0
%144 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> zeroinitializer
%145 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> %144, <2 x double> %142)
%146 = bitcast double* %138 to <2 x double>*
store <2 x double> %145, <2 x double>* %146
%147 = tail call double @llvm.fmuladd.f64(double %108, double %103, double %106)
%148 = icmp sgt i64 %88, %10
br i1 %148, label %82, label %149
149: ; preds = %82
%150 = extractelement <2 x double> %101, i64 0
%151 = fneg double %104
%152 = fmul double %84, %151
%153 = fmul double %85, %152
%154 = fmul double %80, %153
%155 = load double, double* %16
%156 = fmul double %154, %155
%157 = fdiv double %156, %73
%158 = fmul double %104, %157
store double %158, double* %16
%159 = fmul double %150, %157
store double %159, double* %13
%160 = load double, double* %16
%161 = tail call double @llvm.fabs.f64(double %160)
%162 = fcmp ogt double %161, %55
br i1 %162, label %57, label %163
163: ; preds = %149, %45
%164 = phi double [ %14, %45 ], [ %159, %149 ]
%165 = phi double [ %12, %45 ], [ %79, %149 ]
%166 = fadd double %165, %164
store double %166, double* %13
store double 0.000000e+00, double* %16
%167 = add nuw nsw i64 %9, 1
%168 = icmp eq i64 %49, 3
br i1 %168, label %169, label %8
169: ; preds = %163
%170 = load double, double* %1
%171 = getelementptr inbounds double, double* %1, i64 1
%172 = load double, double* %171
%173 = fcmp olt double %172, %170
%174 = select i1 %173, double %172, double %170
%175 = getelementptr inbounds double, double* %1, i64 2
%176 = load double, double* %175
%177 = fcmp olt double %176, %174
%178 = zext i1 %173 to i64
%179 = select i1 %177, i64 2, i64 %178
%180 = icmp eq i64 %179, 0
br i1 %180, label %196, label %181
181: ; preds = %169
%182 = select i1 %177, double %176, double %174
%183 = getelementptr inbounds double, double* %1, i64 %179
store double %170, double* %183
store double %182, double* %1
%184 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%185 = load double, double* %184
%186 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %179
%187 = load double, double* %186
store double %187, double* %184
store double %185, double* %186
%188 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 0
%189 = load double, double* %188
%190 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 %179
%191 = load double, double* %190
store double %191, double* %188
store double %189, double* %190
%192 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 0
%193 = load double, double* %192
%194 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 %179
%195 = load double, double* %194
store double %195, double* %192
store double %193, double* %194
br label %196
196: ; preds = %181, %169
%197 = getelementptr inbounds double, double* %1, i64 1
%198 = load double, double* %197
%199 = getelementptr inbounds double, double* %1, i64 2
%200 = load double, double* %199
%201 = fcmp olt double %200, %198
%202 = select i1 %201, i64 2, i64 1
br i1 %201, label %203, label %217
203: ; preds = %196
%204 = getelementptr inbounds double, double* %1, i64 %202
store double %198, double* %204
store double %200, double* %197
%205 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%206 = load double, double* %205
%207 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 %202
%208 = load double, double* %207
store double %208, double* %205
store double %206, double* %207
%209 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 1
%210 = load double, double* %209
%211 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 %202
%212 = load double, double* %211
store double %212, double* %209
store double %210, double* %211
%213 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 1
%214 = load double, double* %213
%215 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 %202
%216 = load double, double* %215
store double %216, double* %213
store double %214, double* %215
br label %217
217: ; preds = %203, %196
ret void
}