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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ nrerror(char *);
float *vector(int, int);
void toeplz(float r[], float x[], float y[], int n) {
  int j, k, m, m1, m2;
  float pp, pt1, pt2, qq, qt1, qt2, sd, sgd, sgn, shn, sxn;
  float *g, *h;
  if (r[n] == 0.0)
    nrerror("toeplz-1 singular principal minor");
  g = vector(1, n);
  h = vector(1, n);
  x[1] = y[1] / r[n];
  if (n == 1) {
    free_vector(h, 1, n);
    free_vector(g, 1, n);
    return;
  }
  g[1] = r[n - 1] / r[n];
  h[1] = r[n + 1] / r[n];
  for (m = 1; m <= n; m++) {
    m1 = m + 1;
    sxn = -y[m1];
    sd = -r[n];
    for (j = 1; j <= m; j++) {
      sxn += r[n + m1 - j] * x[j];
      sd += r[n + m1 - j] * g[m - j + 1];
    }
    if (sd == 0.0)
      nrerror("toeplz-2 singular principal minor");
    x[m1] = sxn / sd;
    for (j = 1; j <= m; j++)
      x[j] -= x[m1] * g[m - j + 1];
    if (m1 == n) {
      free_vector(h, 1, n);
      free_vector(g, 1, n);
      return;
    }
    sgn = -r[n - m1];
    shn = -r[n + m1];
    sgd = -r[n];
    for (j = 1; j <= m; j++) {
      sgn += r[n + j - m1] * g[j];
      shn += r[n + m1 - j] * h[j];
      sgd += r[n + j - m1] * h[m - j + 1];
    }
    if (sgd == 0.0)
      nrerror("toeplz-3 singular principal minor");
    g[m1] = sgn / sgd;
    h[m1] = shn / sd;
    k = m;
    m2 = (m + 1) >> 1;
    pp = g[m1];
    qq = h[m1];
    for (j = 1; j <= m2; j++) {
      pt1 = g[j];
      pt2 = g[k];
      qt1 = h[j];
      qt2 = h[k];
      g[j] = pt1 - pp * qt2;
      g[k] = pt2 - pp * qt1;
      h[j] = qt1 - qq * pt2;
      h[k--] = qt2 - qq * pt1;
    }
  }
  nrerror("toeplz - should not arrive here!");
}


x86 assembly (clang, -O0):
<toeplz>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1177 <toeplz+0x47>
jp     1177 <toeplz+0x47>
lea    0xe8e(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x68(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
cmpl   $0x1,-0x1c(%rbp)
jne    11e9 <toeplz+0xb9>
mov    -0x70(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x68(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
jmp    170f <toeplz+0x5df>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1703 <toeplz+0x5d3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1324 <toeplz+0x1f4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129a <toeplz+0x16a>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    134c <toeplz+0x21c>
jp     134c <toeplz+0x21c>
lea    0xcdb(%rip),%rdi
call   1030 <nrerror@plt>
movss  -0x5c(%rbp),%xmm0
divss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     13ce <toeplz+0x29e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    136a <toeplz+0x23a>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1401 <toeplz+0x2d1>
mov    -0x70(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x68(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
jmp    170f <toeplz+0x5df>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     152d <toeplz+0x3fd>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    146f <toeplz+0x33f>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1555 <toeplz+0x425>
jp     1555 <toeplz+0x425>
lea    0xaf4(%rip),%rdi
call   1030 <nrerror@plt>
movss  -0x54(%rbp),%xmm0
divss  -0x50(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
divss  -0x4c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     16f0 <toeplz+0x5c0>
mov    -0x68(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    15c0 <toeplz+0x490>
jmp    16f5 <toeplz+0x5c5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1240 <toeplz+0x110>
lea    0x95c(%rip),%rdi
call   1030 <nrerror@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<toeplz>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %ecx,%r15d
mov    %rdx,0x38(%rsp)
mov    %rsi,%r13
mov    %rdi,%rbx
movslq %ecx,%rax
mov    %rax,0x10(%rsp)
movss  (%rdi,%rax,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1172 <toeplz+0x42>
jp     1172 <toeplz+0x42>
lea    0xea7(%rip),%rdi
call   1030 <nrerror@plt>
mov    $0x1,%edi
mov    0x10(%rsp),%r14
mov    %r14d,%esi
call   1050 <vector@plt>
mov    %rax,%rbp
mov    $0x1,%edi
mov    %r14d,%esi
call   1050 <vector@plt>
mov    %r14,%r8
mov    %rax,%r14
mov    0x38(%rsp),%rax
movss  0x4(%rax),%xmm0
divss  (%rbx,%r8,4),%xmm0
movss  %xmm0,0x4(%r13)
cmp    $0x1,%r8d
jne    11da <toeplz+0xaa>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
call   1040 <free_vector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
jmp    166f <toeplz+0x53f>
mov    %r15d,0x24(%rsp)
movss  -0x4(%rbx,%r8,4),%xmm0
divss  (%rbx,%r8,4),%xmm0
movss  %xmm0,0x4(%rbp)
movss  0x4(%rbx,%r8,4),%xmm0
divss  (%rbx,%r8,4),%xmm0
movss  %xmm0,0x4(%r14)
test   %r8d,%r8d
jle    1635 <toeplz+0x505>
movabs $0x100000000,%rax
mov    %r8d,%ecx
mov    %rcx,0x98(%rsp)
lea    0x2(%r8),%ecx
mov    %rcx,0x88(%rsp)
lea    0x4(%r13),%rcx
mov    %rcx,0x90(%rsp)
mov    %r8,%rcx
shl    $0x20,%rcx
add    %rax,%rcx
lea    (%rbx,%r8,4),%rdi
add    $0x4,%rdi
lea    -0x1(%r8),%r9d
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    $0x2,%r10d
xor    %r11d,%r11d
movaps 0xd96(%rip),%xmm6
movabs $0xffffffff00000000,%rsi
ff ff ff
mov    %rbp,0x28(%rsp)
xor    %edx,%edx
mov    %rdi,0x30(%rsp)
mov    0x8(%rsp),%r12
mov    %r10,%rax
shr    %rax
mov    %rax,0xa0(%rsp)
mov    %rdx,0x18(%rsp)
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    %rdx,0x60(%rsp)
lea    0x1(%r12),%rax
mov    %rax,0x8(%rsp)
movss  (%rbx,%r8,4),%xmm0
mov    0x38(%rsp),%rax
movss  0x4(%rax,%r12,4),%xmm4
unpcklps %xmm0,%xmm4
xorps  %xmm6,%xmm4
lea    0x1(%r12,%r8,1),%rax
mov    %rax,0x70(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %rcx,%rax
mov    %r12,%rcx
mov    0x90(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%r15
mov    %rax,%rsi
sar    $0x1e,%rsi
movss  (%rbx,%rsi,1),%xmm0
mov    %r15,%rsi
shufps $0x0,%xmm0,%xmm0
movss  0x0(%rbp,%rcx,4),%xmm1
movss  (%rdx),%xmm2
unpcklps %xmm1,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm2,%xmm4
add    $0x4,%rdx
add    %r15,%rax
add    $0xffffffffffffffff,%rcx
jne    12f0 <toeplz+0x1c0>
movaps %xmm4,%xmm3
shufps $0x55,%xmm4,%xmm3
ucomiss 0xcdc(%rip),%xmm3
mov    %r9,0x48(%rsp)
mov    %r10,0x40(%rsp)
movaps %xmm3,0xb0(%rsp)
jne    1396 <toeplz+0x266>
jp     1396 <toeplz+0x266>
lea    0xce5(%rip),%rdi
mov    %r11,0x50(%rsp)
movaps %xmm4,0xc0(%rsp)
call   1030 <nrerror@plt>
movaps 0xc0(%rsp),%xmm4
movaps 0xb0(%rsp),%xmm3
mov    %r15,%rsi
movaps 0xc83(%rip),%xmm6
mov    0x50(%rsp),%r11
mov    0x40(%rsp),%r10
mov    0x48(%rsp),%r9
mov    0x30(%rsp),%rdi
mov    0x10(%rsp),%r8
divss  %xmm3,%xmm4
mov    0x8(%rsp),%rdx
movss  %xmm4,0x0(%r13,%rdx,4)
mulss  0x0(%rbp,%r12,4),%xmm4
movss  0x4(%r13),%xmm0
subss  %xmm4,%xmm0
movss  %xmm0,0x4(%r13)
cmp    $0x2,%r10
je     1477 <toeplz+0x347>
mov    $0x2,%eax
cmpq   $0x1,0x18(%rsp)
mov    0x60(%rsp),%r8
je     1446 <toeplz+0x316>
mov    $0x2,%eax
mov    0x28(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%r13,%rdx,4),%xmm0
mulss  (%rcx),%xmm0
movss  0x0(%r13,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  0x4(%r13,%rax,4),%xmm0
movss  %xmm1,0x0(%r13,%rax,4)
movss  0x0(%r13,%rdx,4),%xmm1
mulss  -0x4(%rcx),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%r13,%rax,4)
add    $0xfffffffffffffff8,%rcx
lea    (%r8,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x2,%rdx
mov    0x8(%rsp),%rdx
jne    13f0 <toeplz+0x2c0>
testb  $0x1,0x18(%rsp)
mov    0x10(%rsp),%r8
je     1477 <toeplz+0x347>
movss  0x0(%r13,%rdx,4),%xmm0
mov    %rdx,%rcx
sub    %rax,%rcx
movss  0x0(%r13,%rax,4),%xmm1
mulss  0x0(%rbp,%rcx,4),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
cmp    0x98(%rsp),%rdx
je     1652 <toeplz+0x522>
mov    %r8,%rax
sub    %rdx,%rax
mov    0x70(%rsp),%rcx
movss  (%rbx,%rcx,4),%xmm7
xorps  %xmm6,%xmm7
movss  (%rbx,%r8,4),%xmm0
movss  (%rbx,%rax,4),%xmm4
unpcklps %xmm0,%xmm4
xorps  %xmm6,%xmm4
xor    %eax,%eax
mov    %r11,%rcx
xchg   %ax,%ax
lea    (%r9,%rax,1),%edx
movss  (%rdi,%rcx,1),%xmm0
mulss  0x4(%r14,%rax,4),%xmm0
movslq %edx,%rdx
addss  %xmm0,%xmm7
movss  (%rbx,%rdx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  0x4(%r14,%rcx,1),%xmm1
movss  0x4(%rbp,%rax,4),%xmm2
unpcklps %xmm1,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm2,%xmm4
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rax
cmp    %rax,%r12
jne    14b0 <toeplz+0x380>
movaps %xmm4,%xmm0
shufps $0x55,%xmm4,%xmm0
ucomiss 0xb0f(%rip),%xmm0
jne    155b <toeplz+0x42b>
jp     155b <toeplz+0x42b>
lea    0xb4c(%rip),%rdi
mov    %r11,%r12
movaps %xmm7,0x70(%rsp)
movaps %xmm4,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
call   1030 <nrerror@plt>
movaps 0x50(%rsp),%xmm0
movaps 0x60(%rsp),%xmm4
movaps 0x70(%rsp),%xmm7
movaps 0xb0(%rsp),%xmm3
mov    %r15,%rsi
movaps 0xabc(%rip),%xmm6
mov    %r12,%r11
mov    0x40(%rsp),%r10
mov    0x48(%rsp),%r9
mov    0x30(%rsp),%rdi
mov    0x10(%rsp),%r8
divss  %xmm0,%xmm4
mov    0x8(%rsp),%rax
movss  %xmm4,0x0(%rbp,%rax,4)
divss  %xmm3,%xmm7
movss  %xmm7,(%r14,%rax,4)
movss  0x0(%rbp,%rax,4),%xmm0
xorps  %xmm6,%xmm0
xorps  %xmm6,%xmm7
xor    %eax,%eax
mov    %r11,%rcx
mov    0xa0(%rsp),%rdx
nopl   (%rax)
movss  0x4(%rbp,%rax,4),%xmm1
movss  0x4(%rbp,%rcx,1),%xmm2
movss  0x4(%r14,%rax,4),%xmm3
movss  0x4(%r14,%rcx,1),%xmm4
movaps %xmm0,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,0x4(%rbp,%rax,4)
movaps %xmm0,%xmm5
mulss  %xmm3,%xmm5
addss  %xmm2,%xmm5
movss  %xmm5,0x4(%rbp,%rcx,1)
mulss  %xmm7,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x4(%r14,%rax,4)
mulss  %xmm7,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,0x4(%r14,%rcx,1)
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rax
cmp    %rax,%rdx
jne    1590 <toeplz+0x460>
add    $0x1,%r10
mov    0x18(%rsp),%rdx
add    $0x1,%rdx
movabs $0x100000000,%rax
mov    0xa8(%rsp),%rcx
add    %rax,%rcx
addq   $0x4,0x28(%rsp)
add    $0x4,%r11
add    $0xffffffffffffffff,%r9
cmp    0x88(%rsp),%r10
jne    1280 <toeplz+0x150>
lea    0xa3e(%rip),%rdi
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <nrerror@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    0x24(%rsp),%ebx
mov    %ebx,%edx
call   1040 <free_vector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>

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

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