#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 */
float fabs(float);
int /*<<< orphan*/ nrerror(char *);
void tqli(float d[], float e[], int n, float **z) {
  float pythag(float a, float b);
  int m, l, iter, i, k;
  float s, r, p, g, f, dd, c, b;
  for (i = 2; i <= n; i++)
    e[i - 1] = e[i];
  e[n] = 0.0;
  for (l = 1; l <= n; l++) {
    iter = 0;
    do {
      for (m = l; m <= n - 1; m++) {
        dd = fabs(d[m]) + fabs(d[m + 1]);
        if ((float)(fabs(e[m]) + dd) == dd)
          break;
      }
      if (m != l) {
        if (iter++ == 30)
          nrerror("Too many iterations in tqli");
        g = (d[l + 1] - d[l]) / (2.0 * e[l]);
        r = pythag(g, 1.0);
        g = d[m] - d[l] + e[l] / (g + ((g) >= 0.0 ? fabs(r) : -fabs(r)));
        s = c = 1.0;
        p = 0.0;
        for (i = m - 1; i >= l; i--) {
          f = s * e[i];
          b = c * e[i];
          e[i + 1] = (r = pythag(f, g));
          if (r == 0.0) {
            d[i + 1] -= p;
            e[m] = 0.0;
            break;
          }
          s = f / r;
          c = g / r;
          g = d[i + 1] - p;
          r = (d[i] - g) * s + 2.0 * c * b;
          d[i + 1] = g + (p = s * r);
          g = c * r - b;
          for (k = 1; k <= n; k++) {
            f = z[k][i + 1];
            z[k][i + 1] = s * z[k][i] + c * f;
            z[k][i] = c * z[k][i] - s * f;
          }
        }
        if (r == 0.0 && i >= l)
          continue;
        d[l] -= p;
        e[l] = g;
        e[m] = 0.0;
      }
    } while (m != l);
  }
}


x86 assembly (clang, -O0):
<tqli>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1187 <tqli+0x57>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    114e <tqli+0x1e>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16a4 <tqli+0x574>
movl   $0x0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1246 <tqli+0x116>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
addss  -0x4c(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jne    1233 <tqli+0x103>
jp     1233 <tqli+0x103>
jmp    1246 <tqli+0x116>
jmp    1238 <tqli+0x108>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b7 <tqli+0x87>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1680 <tqli+0x550>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x1e,%eax
jne    1272 <tqli+0x142>
lea    0xda3(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xd5a(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
movss  0xd34(%rip),%xmm1
call   1050 <pythag@plt>
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     133b <tqli+0x20b>
movss  -0x3c(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x68(%rbp)
jmp    1357 <tqli+0x227>
movss  -0x3c(%rbp),%xmm0
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm3
addss  %xmm3,%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xc7c(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0xc6f(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1616 <tqli+0x4e6>
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
call   1050 <pythag@plt>
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1458 <tqli+0x328>
jp     1458 <tqli+0x328>
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1616 <tqli+0x4e6>
movss  -0x48(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x44(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x44(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xb4a(%rip),%xmm0
mulsd  %xmm2,%xmm0
movss  -0x54(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movss  %xmm1,-0x40(%rbp)
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1603 <tqli+0x4d3>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1536 <tqli+0x406>
jmp    1608 <tqli+0x4d8>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13a7 <tqli+0x277>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1643 <tqli+0x513>
jp     1643 <tqli+0x513>
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1643 <tqli+0x513>
jmp    1685 <tqli+0x555>
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1685 <tqli+0x555>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    11b1 <tqli+0x81>
jmp    1696 <tqli+0x566>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    119e <tqli+0x6e>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tqli>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%rbx
mov    %rsi,%r15
mov    %rdi,%r12
cmp    $0x2,%edx
mov    %rdx,0x20(%rsp)
jge    1170 <tqli+0x40>
movslq %edx,%rsi
movl   $0x0,(%r15,%rsi,4)
cmp    $0x1,%edx
je     1193 <tqli+0x63>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x4(%r15),%rdi
lea    0x8(%r15),%rsi
add    $0xffffffff,%edx
shl    $0x2,%rdx
call   1050 <memmove@plt>
mov    0x20(%rsp),%rdx
mov    %edx,%esi
movl   $0x0,(%r15,%rsi,4)
lea    0x1(%rdx),%r14d
mov    $0x1,%r13d
movdqa 0xe5b(%rip),%xmm2
movss  0xe73(%rip),%xmm1
mov    %rsi,0x28(%rsp)
jmp    11d2 <tqli+0xa2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp),%rax
mov    %rax,%r13
cmp    %r14,%rax
mov    0x20(%rsp),%rdx
je     1161 <tqli+0x31>
cmp    %r13d,%edx
mov    %r13d,%eax
cmovg  %edx,%eax
mov    %eax,0x10(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x40(%rsp)
mov    %eax,%eax
mov    %rax,0x48(%rsp)
xor    %ebp,%ebp
jmp    123d <tqli+0x10d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r12,%r13,4),%xmm0
subss  %xmm8,%xmm0
movss  %xmm0,(%r12,%r13,4)
movss  %xmm1,(%r15,%r13,4)
mov    0x8(%rsp),%rax
movl   $0x0,(%r15,%rax,4)
mov    0x28(%rsp),%rsi
movdqa 0xdcf(%rip),%xmm2
movss  0xde7(%rip),%xmm1
mov    0x4(%rsp),%ebp
mov    %r13,%rcx
cmp    %rsi,%rcx
jge    1280 <tqli+0x150>
lea    0x1(%rcx),%rax
movq   (%r12,%rcx,4),%xmm0
pand   %xmm2,%xmm0
pshufd $0x55,%xmm0,%xmm3
addss  %xmm0,%xmm3
movd   (%r15,%rcx,4),%xmm0
pand   %xmm2,%xmm0
addss  %xmm3,%xmm0
ucomiss %xmm3,%xmm0
mov    %rax,%rcx
jne    1240 <tqli+0x110>
jp     1240 <tqli+0x110>
add    $0xffffffff,%eax
jmp    1284 <tqli+0x154>
nopl   0x0(%rax)
mov    0x10(%rsp),%eax
mov    %eax,%eax
cmp    %rax,%r13
je     11c0 <tqli+0x90>
mov    %rax,0x8(%rsp)
cmp    $0x1e,%ebp
jne    12ad <tqli+0x17d>
lea    0xd88(%rip),%rdi
call   1030 <nrerror@plt>
movss  0xd73(%rip),%xmm1
mov    0x48(%rsp),%rax
movss  (%r12,%rax,4),%xmm0
subss  (%r12,%r13,4),%xmm0
add    $0x1,%ebp
cvtss2sd %xmm0,%xmm0
movss  (%r15,%r13,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
divsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x30(%rsp)
call   1040 <pythag@plt>
mov    0x8(%rsp),%rax
movss  (%r12,%rax,4),%xmm4
subss  (%r12,%r13,4),%xmm4
movss  (%r15,%r13,4),%xmm1
movaps %xmm0,%xmm2
andps  0xcf9(%rip),%xmm2
orps   0xd02(%rip),%xmm0
xorps  %xmm8,%xmm8
xorps  %xmm3,%xmm3
movss  0x30(%rsp),%xmm5
cmpnless %xmm5,%xmm3
andps  %xmm3,%xmm0
andnps %xmm2,%xmm3
orps   %xmm0,%xmm3
addss  %xmm5,%xmm3
divss  %xmm3,%xmm1
addss  %xmm4,%xmm1
cmp    %rax,%r13
mov    %ebp,0x4(%rsp)
jae    1200 <tqli+0xd0>
xorps  %xmm8,%xmm8
mov    %rax,%rbp
movss  0xccf(%rip),%xmm0
movaps %xmm0,%xmm6
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  %xmm1,0x14(%rsp)
movss  %xmm6,0x1c(%rsp)
movaps %xmm8,0x30(%rsp)
movss  -0x4(%r15,%rbp,4),%xmm2
movss  %xmm2,0x18(%rsp)
mulss  %xmm2,%xmm0
movaps %xmm0,0x50(%rsp)
call   1040 <pythag@plt>
movss  %xmm0,(%r15,%rbp,4)
ucomiss 0xc8a(%rip),%xmm0
jne    13a2 <tqli+0x272>
jnp    1490 <tqli+0x360>
lea    -0x1(%rbp),%rax
movss  0x1c(%rsp),%xmm7
mulss  0x18(%rsp),%xmm7
movaps 0x50(%rsp),%xmm5
divss  %xmm0,%xmm5
movss  0x14(%rsp),%xmm6
divss  %xmm0,%xmm6
movss  (%r12,%rbp,4),%xmm0
subss  0x30(%rsp),%xmm0
movss  (%r12,%rax,4),%xmm2
subss  %xmm0,%xmm2
mulss  %xmm5,%xmm2
cvtss2sd %xmm2,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm6,%xmm3
addsd  %xmm3,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm7,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm2,%xmm4
xorps  %xmm1,%xmm1
cvtsd2ss %xmm4,%xmm1
movaps %xmm5,%xmm8
mulss  %xmm1,%xmm8
addss  %xmm8,%xmm0
movss  %xmm0,(%r12,%rbp,4)
mulss  %xmm6,%xmm1
subss  %xmm7,%xmm1
movaps %xmm5,%xmm7
xorps  0xbe6(%rip),%xmm7
mov    $0x1,%ecx
movaps %xmm5,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rcx,8),%rdx
movss  (%rdx,%rbp,4),%xmm5
movss  (%rdx,%rax,4),%xmm2
movaps %xmm6,%xmm3
mulss  %xmm5,%xmm3
movaps %xmm0,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,(%rdx,%rbp,4)
mulss  %xmm7,%xmm5
mulss  %xmm6,%xmm2
addss  %xmm5,%xmm2
movss  %xmm2,(%rdx,%rax,4)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1440 <tqli+0x310>
mov    %rax,%rbp
cmp    %r13,%rax
jg     1360 <tqli+0x230>
jmp    1200 <tqli+0xd0>
movss  (%r12,%rbp,4),%xmm0
subss  0x30(%rsp),%xmm0
movss  %xmm0,(%r12,%rbp,4)
jmp    1217 <tqli+0xe7>

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

LLVM IR (-O2):
@.str = [28 x i8] c"Too many iterations in tqli\00"
define void @tqli(float* nocapture %0, float* nocapture %1, i32 %2, float** nocapture %3) {
%5 = icmp slt i32 %2, 2
br i1 %5, label %16, label %6
6: ; preds = %4
%7 = getelementptr float, float* %1, i64 1
%8 = bitcast float* %7 to i8*
%9 = getelementptr float, float* %1, i64 2
%10 = bitcast float* %9 to i8*
%11 = add nsw i32 %2, -1
%12 = zext i32 %11 to i64
%13 = shl nuw nsw i64 %12, 2
%14 = zext i32 %2 to i64
%15 = getelementptr inbounds float, float* %1, i64 %14
store float 0.000000e+00, float* %15
br label %20
16: ; preds = %4
%17 = sext i32 %2 to i64
%18 = getelementptr inbounds float, float* %1, i64 %17
store float 0.000000e+00, float* %18
%19 = icmp eq i32 %2, 1
br i1 %19, label %20, label %151
20: ; preds = %6, %16
%21 = phi i64 [ %14, %6 ], [ %17, %16 ]
%22 = add nuw i32 %2, 1
%23 = zext i32 %22 to i64
br label %24
24: ; preds = %20, %149
%25 = phi i64 [ 1, %20 ], [ %28, %149 ]
%26 = trunc i64 %25 to i32
%27 = call i32 @llvm.smax.i32(i32 %2, i32 %26)
%28 = add nuw nsw i64 %25, 1
%29 = and i64 %28, 4294967295
%30 = getelementptr inbounds float, float* %0, i64 %29
%31 = getelementptr inbounds float, float* %0, i64 %25
%32 = getelementptr inbounds float, float* %1, i64 %25
br label %33
33: ; preds = %147, %24
%34 = phi i32 [ %59, %147 ], [ 0, %24 ]
br label %35
35: ; preds = %38, %33
%36 = phi i64 [ %40, %38 ], [ %25, %33 ]
%37 = icmp slt i64 %36, %21
br i1 %37, label %38, label %54
38: ; preds = %35
%39 = getelementptr inbounds float, float* %0, i64 %36
%40 = add nuw nsw i64 %36, 1
%41 = bitcast float* %39 to <2 x float>*
%42 = load <2 x float>, <2 x float>* %41
%43 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %42)
%44 = shufflevector <2 x float> %43, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%45 = fadd <2 x float> %43, %44
%46 = extractelement <2 x float> %45, i64 0
%47 = getelementptr inbounds float, float* %1, i64 %36
%48 = load float, float* %47
%49 = tail call float @llvm.fabs.f32(float %48)
%50 = fadd float %49, %46
%51 = fcmp oeq float %50, %46
br i1 %51, label %52, label %35
52: ; preds = %38
%53 = trunc i64 %36 to i32
br label %54
54: ; preds = %35, %52
%55 = phi i32 [ %53, %52 ], [ %27, %35 ]
%56 = zext i32 %55 to i64
%57 = icmp eq i64 %25, %56
br i1 %57, label %149, label %58
58: ; preds = %54
%59 = add nuw nsw i32 %34, 1
%60 = icmp eq i32 %34, 30
br i1 %60, label %61, label %63
61: ; preds = %58
%62 = tail call i32 @nrerror(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
br label %63
63: ; preds = %61, %58
%64 = load float, float* %30
%65 = load float, float* %31
%66 = fsub float %64, %65
%67 = fpext float %66 to double
%68 = load float, float* %32
%69 = fpext float %68 to double
%70 = fmul double %69, 2.000000e+00
%71 = fdiv double %67, %70
%72 = fptrunc double %71 to float
%73 = tail call float @pythag(float %72, float 1.000000e+00)
%74 = getelementptr inbounds float, float* %0, i64 %56
%75 = load float, float* %74
%76 = load float, float* %31
%77 = fsub float %75, %76
%78 = load float, float* %32
%79 = fcmp ult float %72, 0.000000e+00
%80 = tail call float @llvm.fabs.f32(float %73)
%81 = fneg float %80
%82 = select i1 %79, float %81, float %80
%83 = fadd float %82, %72
%84 = fdiv float %78, %83
%85 = fadd float %77, %84
%86 = icmp ult i64 %25, %56
br i1 %86, label %89, label %142
87: ; preds = %124
%88 = icmp sgt i64 %95, %25
br i1 %88, label %89, label %142
89: ; preds = %63, %87
%90 = phi i64 [ %95, %87 ], [ %56, %63 ]
%91 = phi float [ %105, %87 ], [ 1.000000e+00, %63 ]
%92 = phi float [ %122, %87 ], [ %85, %63 ]
%93 = phi float [ %119, %87 ], [ 0.000000e+00, %63 ]
%94 = phi float [ %104, %87 ], [ 1.000000e+00, %63 ]
%95 = add nsw i64 %90, -1
%96 = getelementptr inbounds float, float* %1, i64 %95
%97 = load float, float* %96
%98 = fmul float %94, %97
%99 = fmul float %91, %97
%100 = tail call float @pythag(float %98, float %92)
%101 = getelementptr inbounds float, float* %1, i64 %90
store float %100, float* %101
%102 = fcmp oeq float %100, 0.000000e+00
br i1 %102, label %138, label %103
103: ; preds = %89
%104 = fdiv float %98, %100
%105 = fdiv float %92, %100
%106 = getelementptr inbounds float, float* %0, i64 %90
%107 = load float, float* %106
%108 = fsub float %107, %93
%109 = getelementptr inbounds float, float* %0, i64 %95
%110 = load float, float* %109
%111 = fsub float %110, %108
%112 = fmul float %104, %111
%113 = fpext float %112 to double
%114 = fpext float %105 to double
%115 = fmul double %114, 2.000000e+00
%116 = fpext float %99 to double
%117 = tail call double @llvm.fmuladd.f64(double %115, double %116, double %113)
%118 = fptrunc double %117 to float
%119 = fmul float %104, %118
%120 = fadd float %108, %119
store float %120, float* %106
%121 = fneg float %99
%122 = tail call float @llvm.fmuladd.f32(float %105, float %118, float %121)
%123 = fneg float %104
br label %124
124: ; preds = %103, %124
%125 = phi i64 [ 1, %103 ], [ %136, %124 ]
%126 = getelementptr inbounds float*, float** %3, i64 %125
%127 = load float*, float** %126
%128 = getelementptr inbounds float, float* %127, i64 %90
%129 = load float, float* %128
%130 = getelementptr inbounds float, float* %127, i64 %95
%131 = load float, float* %130
%132 = fmul float %105, %129
%133 = tail call float @llvm.fmuladd.f32(float %104, float %131, float %132)
store float %133, float* %128
%134 = fmul float %129, %123
%135 = tail call float @llvm.fmuladd.f32(float %105, float %131, float %134)
store float %135, float* %130
%136 = add nuw nsw i64 %125, 1
%137 = icmp eq i64 %136, %23
br i1 %137, label %87, label %124
138: ; preds = %89
%139 = getelementptr inbounds float, float* %0, i64 %90
%140 = load float, float* %139
%141 = fsub float %140, %93
store float %141, float* %139
br label %147
142: ; preds = %87, %63
%143 = phi float [ 0.000000e+00, %63 ], [ %119, %87 ]
%144 = phi float [ %85, %63 ], [ %122, %87 ]
%145 = load float, float* %31
%146 = fsub float %145, %143
store float %146, float* %31
store float %144, float* %32
br label %147
147: ; preds = %138, %142
%148 = getelementptr inbounds float, float* %1, i64 %56
store float 0.000000e+00, float* %148
br label %33
149: ; preds = %54
%150 = icmp eq i64 %28, %23
br i1 %150, label %151, label %24
151: ; preds = %149, %16
ret void
}