#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 *alloca(int);
int /*<<< orphan*/ memset(double *, int /*<<< orphan*/, long);
float vorbis_lpc_from_data(float *data, float *lpci, long n, long m) {
  double *aut = alloca(sizeof(*aut) * (m + 1));
  double *lpc = alloca(sizeof(*lpc) * (m));
  double error;
  double epsilon;
  long i, j;
  j = m + 1;
  while (j--) {
    double d = 0;
    for (i = j; i < n; i++)
      d += (double)data[i] * data[(i - j)];
    aut[j] = d;
  }
  error = aut[0] * (1. + 1e-10);
  epsilon = 1e-9 * aut[0] + 1e-10;
  for (i = 0; i < m; i++) {
    double r = -aut[i + 1];
    if (error < epsilon) {
      memset(lpc + i, 0, (m - i) * sizeof(*lpc));
      goto done;
    }
    for (j = 0; j < i; j++)
      r -= lpc[j] * aut[i - j];
    r /= error;
    lpc[i] = r;
    for (j = 0; j < i / 2; j++) {
      double tmp = lpc[j];
      lpc[j] += r * lpc[i - 1 - j];
      lpc[i - 1 - j] += r * tmp;
    }
    if (i & 1)
      lpc[j] += lpc[j] * r;
    error *= 1. - r * r;
  }
done : {
  double g = .99;
  double damp = g;
  for (j = 0; j < m; j++) {
    lpc[j] *= damp;
    damp *= g;
  }
}
  for (j = 0; j < m; j++)
    lpci[j] = (float)lpc[j];
  return error;
}


x86 assembly (clang, -O0):
<vorbis_lpc_from_data>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <alloca@plt>
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <alloca@plt>
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x50(%rbp)
cmp    $0x0,%rax
je     1208 <vorbis_lpc_from_data+0xe8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    11f1 <vorbis_lpc_from_data+0xd1>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    119a <vorbis_lpc_from_data+0x7a>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1171 <vorbis_lpc_from_data+0x51>
mov    -0x28(%rbp),%rax
movsd  0xdfc(%rip),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xdd3(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xdcf(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    148b <vorbis_lpc_from_data+0x36b>
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12bd <vorbis_lpc_from_data+0x19d>
mov    -0x30(%rbp),%rdi
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rdx
sub    -0x48(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
jmp    1490 <vorbis_lpc_from_data+0x370>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    132b <vorbis_lpc_from_data+0x20b>
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    12c5 <vorbis_lpc_from_data+0x1a5>
movsd  -0x38(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x80(%rbp),%rax
cmp    %rcx,%rax
jge    1401 <vorbis_lpc_from_data+0x2e1>
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
sub    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
sub    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1358 <vorbis_lpc_from_data+0x238>
mov    -0x48(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     143f <vorbis_lpc_from_data+0x31f>
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xbac(%rip),%xmm1
addsd  %xmm1,%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    124a <vorbis_lpc_from_data+0x12a>
jmp    1490 <vorbis_lpc_from_data+0x370>
movsd  0xb88(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    14f4 <vorbis_lpc_from_data+0x3d4>
movsd  -0x78(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14af <vorbis_lpc_from_data+0x38f>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1539 <vorbis_lpc_from_data+0x419>
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14fc <vorbis_lpc_from_data+0x3dc>
movsd  -0x38(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vorbis_lpc_from_data>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r15
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%rbp
lea    0x1(%rcx),%rdi
shl    $0x3,%edi
call   1040 <alloca@plt>
mov    %rax,%r12
lea    0x0(,%r15,8),%edi
call   1040 <alloca@plt>
mov    %rax,%r13
mov    %r15,%rax
inc    %rax
jne    1171 <vorbis_lpc_from_data+0x51>
movsd  (%r12),%xmm6
mulsd  0xe94(%rip),%xmm6
jmp    153a <vorbis_lpc_from_data+0x41a>
mov    %r15,%rax
jmp    118c <vorbis_lpc_from_data+0x6c>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm0,(%r12,%rax,8)
sub    $0x1,%rax
jb     11cb <vorbis_lpc_from_data+0xab>
xorpd  %xmm0,%xmm0
cmp    %rbx,%rax
jge    1180 <vorbis_lpc_from_data+0x60>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    %rax,%rdx
xchg   %ax,%ax
movss  0x0(%rbp,%rdx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x0(%rbp,%rcx,1),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rdx
add    $0x4,%rcx
cmp    %rbx,%rdx
jl     11a0 <vorbis_lpc_from_data+0x80>
jmp    1180 <vorbis_lpc_from_data+0x60>
movsd  (%r12),%xmm0
movsd  0xe27(%rip),%xmm6
mulsd  %xmm0,%xmm6
test   %r15,%r15
jle    153a <vorbis_lpc_from_data+0x41a>
mulsd  0xe1a(%rip),%xmm0
addsd  0xe1a(%rip),%xmm0
lea    0x8(%r13),%r8
lea    -0x8(%r13),%rcx
xor    %r9d,%r9d
movapd 0xe27(%rip),%xmm1
movsd  0xe07(%rip),%xmm2
mov    %r12,%rdx
jmp    124c <vorbis_lpc_from_data+0x12c>
cs nopw 0x0(%rax,%rax,1)
divsd  %xmm6,%xmm3
movsd  %xmm3,0x0(%r13,%rbx,8)
mulsd  %xmm3,%xmm3
movapd %xmm2,%xmm4
subsd  %xmm3,%xmm4
mulsd  %xmm4,%xmm6
add    $0x8,%rdx
add    $0x8,%rcx
cmp    %r15,%r9
je     138e <vorbis_lpc_from_data+0x26e>
mov    %r9,%rbx
mov    %r9,%rsi
shr    %rsi
cmp    $0x2,%rsi
mov    $0x1,%ebp
cmovae %rsi,%rbp
ucomisd %xmm6,%xmm0
ja     1368 <vorbis_lpc_from_data+0x248>
lea    0x1(%rbx),%r9
movsd  (%r12,%r9,8),%xmm3
xorpd  %xmm1,%xmm3
test   %rbx,%rbx
je     1220 <vorbis_lpc_from_data+0x100>
cmp    $0x1,%rbx
jne    1290 <vorbis_lpc_from_data+0x170>
xor    %eax,%eax
test   $0x1,%bl
jne    12d1 <vorbis_lpc_from_data+0x1b1>
jmp    12e8 <vorbis_lpc_from_data+0x1c8>
xchg   %ax,%ax
add    %rsi,%rsi
neg    %rsi
xor    %eax,%eax
mov    %r8,%rdi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi),%xmm4
mulsd  (%rdx,%rax,8),%xmm4
movsd  (%rdi),%xmm5
subsd  %xmm4,%xmm3
mulsd  -0x8(%rdx,%rax,8),%xmm5
subsd  %xmm5,%xmm3
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rax
cmp    %rax,%rsi
jne    12a0 <vorbis_lpc_from_data+0x180>
neg    %rax
test   $0x1,%bl
je     12e8 <vorbis_lpc_from_data+0x1c8>
movsd  0x0(%r13,%rax,8),%xmm4
mov    %rbx,%rsi
sub    %rax,%rsi
mulsd  (%r12,%rsi,8),%xmm4
subsd  %xmm4,%xmm3
divsd  %xmm6,%xmm3
movsd  %xmm3,0x0(%r13,%rbx,8)
cmp    $0x2,%rbx
jae    1300 <vorbis_lpc_from_data+0x1e0>
xor    %ebp,%ebp
jmp    1340 <vorbis_lpc_from_data+0x220>
nopl   (%rax)
mov    %rbp,%rax
neg    %rax
mov    %r13,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm4
movsd  (%rcx,%rdi,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rsi)
mulsd  %xmm3,%xmm4
addsd  (%rcx,%rdi,8),%xmm4
movsd  %xmm4,(%rcx,%rdi,8)
add    $0xffffffffffffffff,%rdi
add    $0x8,%rsi
cmp    %rdi,%rax
jne    1310 <vorbis_lpc_from_data+0x1f0>
test   $0x1,%bl
je     122b <vorbis_lpc_from_data+0x10b>
movsd  0x0(%r13,%rbp,8),%xmm4
movapd %xmm4,%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,0x0(%r13,%rbp,8)
jmp    122b <vorbis_lpc_from_data+0x10b>
lea    0x0(,%rbx,8),%rdi
add    %r13,%rdi
mov    %r15,%rdx
sub    %rbx,%rdx
shl    $0x3,%rdx
xor    %esi,%esi
movsd  %xmm6,(%rsp)
call   1030 <memset@plt>
movsd  (%rsp),%xmm6
test   %r15,%r15
jle    153a <vorbis_lpc_from_data+0x41a>
lea    -0x1(%r15),%rcx
mov    %r15d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    13b3 <vorbis_lpc_from_data+0x293>
movsd  0xc71(%rip),%xmm0
xor    %ecx,%ecx
jmp    1431 <vorbis_lpc_from_data+0x311>
mov    %r15,%rdx
and    $0xfffffffffffffffc,%rdx
movsd  0xc5e(%rip),%xmm1
xor    %ecx,%ecx
movapd %xmm1,%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
mulsd  %xmm1,%xmm0
movsd  0x8(%r13,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%r13,%rcx,8)
mulsd  %xmm1,%xmm0
movsd  0x10(%r13,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%r13,%rcx,8)
mulsd  %xmm1,%xmm0
movsd  0x18(%r13,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x18(%r13,%rcx,8)
mulsd  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    13d0 <vorbis_lpc_from_data+0x2b0>
test   %rax,%rax
je     146b <vorbis_lpc_from_data+0x34b>
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
xor    %edx,%edx
movsd  0xbd5(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rcx,%rdx,8)
mulsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1450 <vorbis_lpc_from_data+0x330>
cmp    $0x4,%r15
jae    1478 <vorbis_lpc_from_data+0x358>
xor    %eax,%eax
jmp    1520 <vorbis_lpc_from_data+0x400>
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1550 <vorbis_lpc_from_data+0x430>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
movupd 0x0(%r13,%rdx,8),%xmm0
movupd 0x10(%r13,%rdx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%r14,%rdx,4)
movupd 0x20(%r13,%rdx,8),%xmm0
movupd 0x30(%r13,%rdx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%r14,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    14a0 <vorbis_lpc_from_data+0x380>
test   $0x1,%cl
je     1510 <vorbis_lpc_from_data+0x3f0>
movupd 0x0(%r13,%rdx,8),%xmm0
movupd 0x10(%r13,%rdx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%r14,%rdx,4)
cmp    %r15,%rax
je     153a <vorbis_lpc_from_data+0x41a>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%r15
jne    1520 <vorbis_lpc_from_data+0x400>
xorps  %xmm0,%xmm0
cvtsd2ss %xmm6,%xmm0
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%cl
jne    14f0 <vorbis_lpc_from_data+0x3d0>
jmp    1510 <vorbis_lpc_from_data+0x3f0>

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

LLVM IR (-O2):
define float @vorbis_lpc_from_data(float* nocapture %0, float* nocapture writeonly %1, i64 %2, i64 %3) {
%5 = add nsw i64 %3, 1
%6 = trunc i64 %5 to i32
%7 = shl i32 %6, 3
%8 = tail call double* @alloca(i32 %7)
%9 = trunc i64 %3 to i32
%10 = shl i32 %9, 3
%11 = tail call double* @alloca(i32 %10)
%12 = icmp eq i64 %5, 0
br i1 %12, label %13, label %16
13: ; preds = %4
%14 = load double, double* %8
%15 = fmul double %14, 0x3FF000000006DF38
br label %253
16: ; preds = %4, %32
%17 = phi i64 [ %35, %32 ], [ %3, %4 ]
%18 = icmp slt i64 %17, %2
br i1 %18, label %19, label %32
19: ; preds = %16, %19
%20 = phi double [ %29, %19 ], [ 0.000000e+00, %16 ]
%21 = phi i64 [ %30, %19 ], [ %17, %16 ]
%22 = getelementptr inbounds float, float* %0, i64 %21
%23 = load float, float* %22
%24 = fpext float %23 to double
%25 = sub nsw i64 %21, %17
%26 = getelementptr inbounds float, float* %0, i64 %25
%27 = load float, float* %26
%28 = fpext float %27 to double
%29 = tail call double @llvm.fmuladd.f64(double %24, double %28, double %20)
%30 = add nsw i64 %21, 1
%31 = icmp slt i64 %30, %2
br i1 %31, label %19, label %32
32: ; preds = %19, %16
%33 = phi double [ 0.000000e+00, %16 ], [ %29, %19 ]
%34 = getelementptr inbounds double, double* %8, i64 %17
store double %33, double* %34
%35 = add nsw i64 %17, -1
%36 = icmp eq i64 %17, 0
br i1 %36, label %37, label %16
37: ; preds = %32
%38 = load double, double* %8
%39 = fmul double %38, 0x3FF000000006DF38
%40 = tail call double @llvm.fmuladd.f64(double %38, double 1.000000e-09, double 1.000000e-10)
%41 = icmp sgt i64 %3, 0
br i1 %41, label %42, label %253
42: ; preds = %37, %128
%43 = phi double [ %132, %128 ], [ %39, %37 ]
%44 = phi i64 [ %47, %128 ], [ 0, %37 ]
%45 = lshr i64 %44, 1
%46 = call i64 @llvm.umax.i64(i64 %45, i64 1)
%47 = add nuw nsw i64 %44, 1
%48 = fcmp olt double %43, %40
br i1 %48, label %49, label %54
49: ; preds = %42
%50 = getelementptr inbounds double, double* %11, i64 %44
%51 = sub nsw i64 %3, %44
%52 = shl i64 %51, 3
%53 = tail call i32 @memset(double* %50, i32 0, i64 %52)
br i1 %41, label %135, label %253
54: ; preds = %42
%55 = getelementptr inbounds double, double* %8, i64 %47
%56 = load double, double* %55
%57 = fneg double %56
%58 = icmp eq i64 %44, 0
br i1 %58, label %64, label %59
59: ; preds = %54
%60 = and i64 %44, 1
%61 = icmp eq i64 %44, 1
br i1 %61, label %89, label %62
62: ; preds = %59
%63 = and i64 %44, 9223372036854775806
br label %67
64: ; preds = %54
%65 = fdiv double %57, %43
%66 = getelementptr inbounds double, double* %11, i64 %44
store double %65, double* %66
br label %128
67: ; preds = %67, %62
%68 = phi double [ %57, %62 ], [ %85, %67 ]
%69 = phi i64 [ 0, %62 ], [ %86, %67 ]
%70 = phi i64 [ 0, %62 ], [ %87, %67 ]
%71 = getelementptr inbounds double, double* %11, i64 %69
%72 = load double, double* %71
%73 = sub nsw i64 %44, %69
%74 = getelementptr inbounds double, double* %8, i64 %73
%75 = load double, double* %74
%76 = fneg double %72
%77 = tail call double @llvm.fmuladd.f64(double %76, double %75, double %68)
%78 = or i64 %69, 1
%79 = getelementptr inbounds double, double* %11, i64 %78
%80 = load double, double* %79
%81 = sub nsw i64 %44, %78
%82 = getelementptr inbounds double, double* %8, i64 %81
%83 = load double, double* %82
%84 = fneg double %80
%85 = tail call double @llvm.fmuladd.f64(double %84, double %83, double %77)
%86 = add nuw nsw i64 %69, 2
%87 = add i64 %70, 2
%88 = icmp eq i64 %87, %63
br i1 %88, label %89, label %67
89: ; preds = %67, %59
%90 = phi double [ undef, %59 ], [ %85, %67 ]
%91 = phi double [ %57, %59 ], [ %85, %67 ]
%92 = phi i64 [ 0, %59 ], [ %86, %67 ]
%93 = icmp eq i64 %60, 0
br i1 %93, label %102, label %94
94: ; preds = %89
%95 = getelementptr inbounds double, double* %11, i64 %92
%96 = load double, double* %95
%97 = sub nsw i64 %44, %92
%98 = getelementptr inbounds double, double* %8, i64 %97
%99 = load double, double* %98
%100 = fneg double %96
%101 = tail call double @llvm.fmuladd.f64(double %100, double %99, double %91)
br label %102
102: ; preds = %89, %94
%103 = phi double [ %90, %89 ], [ %101, %94 ]
%104 = fdiv double %103, %43
%105 = getelementptr inbounds double, double* %11, i64 %44
store double %104, double* %105
%106 = icmp ult i64 %44, 2
br i1 %106, label %120, label %107
107: ; preds = %102, %107
%108 = phi i64 [ %118, %107 ], [ 0, %102 ]
%109 = getelementptr inbounds double, double* %11, i64 %108
%110 = load double, double* %109
%111 = xor i64 %108, -1
%112 = add nsw i64 %44, %111
%113 = getelementptr inbounds double, double* %11, i64 %112
%114 = load double, double* %113
%115 = tail call double @llvm.fmuladd.f64(double %104, double %114, double %110)
store double %115, double* %109
%116 = load double, double* %113
%117 = tail call double @llvm.fmuladd.f64(double %104, double %110, double %116)
store double %117, double* %113
%118 = add nuw nsw i64 %108, 1
%119 = icmp eq i64 %118, %46
br i1 %119, label %120, label %107
120: ; preds = %107, %102
%121 = phi i64 [ 0, %102 ], [ %46, %107 ]
%122 = and i64 %44, 1
%123 = icmp eq i64 %122, 0
br i1 %123, label %128, label %124
124: ; preds = %120
%125 = getelementptr inbounds double, double* %11, i64 %121
%126 = load double, double* %125
%127 = tail call double @llvm.fmuladd.f64(double %126, double %104, double %126)
store double %127, double* %125
br label %128
128: ; preds = %64, %120, %124
%129 = phi double [ %104, %120 ], [ %104, %124 ], [ %65, %64 ]
%130 = fneg double %129
%131 = tail call double @llvm.fmuladd.f64(double %130, double %129, double 1.000000e+00)
%132 = fmul double %43, %131
%133 = icmp eq i64 %47, %3
br i1 %133, label %134, label %42
134: ; preds = %128
br i1 %41, label %135, label %253
135: ; preds = %49, %134
%136 = phi double [ %43, %49 ], [ %132, %134 ]
%137 = add i64 %3, -1
%138 = and i64 %3, 3
%139 = icmp ult i64 %137, 3
br i1 %139, label %168, label %140
140: ; preds = %135
%141 = and i64 %3, -4
br label %142
142: ; preds = %142, %140
%143 = phi double [ 0x3FEFAE147AE147AE, %140 ], [ %164, %142 ]
%144 = phi i64 [ 0, %140 ], [ %165, %142 ]
%145 = phi i64 [ 0, %140 ], [ %166, %142 ]
%146 = getelementptr inbounds double, double* %11, i64 %144
%147 = load double, double* %146
%148 = fmul double %143, %147
store double %148, double* %146
%149 = fmul double %143, 0x3FEFAE147AE147AE
%150 = or i64 %144, 1
%151 = getelementptr inbounds double, double* %11, i64 %150
%152 = load double, double* %151
%153 = fmul double %149, %152
store double %153, double* %151
%154 = fmul double %149, 0x3FEFAE147AE147AE
%155 = or i64 %144, 2
%156 = getelementptr inbounds double, double* %11, i64 %155
%157 = load double, double* %156
%158 = fmul double %154, %157
store double %158, double* %156
%159 = fmul double %154, 0x3FEFAE147AE147AE
%160 = or i64 %144, 3
%161 = getelementptr inbounds double, double* %11, i64 %160
%162 = load double, double* %161
%163 = fmul double %159, %162
store double %163, double* %161
%164 = fmul double %159, 0x3FEFAE147AE147AE
%165 = add nuw nsw i64 %144, 4
%166 = add i64 %145, 4
%167 = icmp eq i64 %166, %141
br i1 %167, label %168, label %142
168: ; preds = %142, %135
%169 = phi double [ 0x3FEFAE147AE147AE, %135 ], [ %164, %142 ]
%170 = phi i64 [ 0, %135 ], [ %165, %142 ]
%171 = icmp eq i64 %138, 0
br i1 %171, label %183, label %172
172: ; preds = %168, %172
%173 = phi double [ %179, %172 ], [ %169, %168 ]
%174 = phi i64 [ %180, %172 ], [ %170, %168 ]
%175 = phi i64 [ %181, %172 ], [ 0, %168 ]
%176 = getelementptr inbounds double, double* %11, i64 %174
%177 = load double, double* %176
%178 = fmul double %173, %177
store double %178, double* %176
%179 = fmul double %173, 0x3FEFAE147AE147AE
%180 = add nuw nsw i64 %174, 1
%181 = add i64 %175, 1
%182 = icmp eq i64 %181, %138
br i1 %182, label %183, label %172
183: ; preds = %172, %168
%184 = icmp ult i64 %3, 4
br i1 %184, label %243, label %185
185: ; preds = %183
%186 = and i64 %3, -4
%187 = add i64 %186, -4
%188 = lshr exact i64 %187, 2
%189 = add nuw nsw i64 %188, 1
%190 = and i64 %189, 1
%191 = icmp eq i64 %187, 0
br i1 %191, label %225, label %192
192: ; preds = %185
%193 = and i64 %189, 9223372036854775806
br label %194
194: ; preds = %194, %192
%195 = phi i64 [ 0, %192 ], [ %222, %194 ]
%196 = phi i64 [ 0, %192 ], [ %223, %194 ]
%197 = getelementptr inbounds double, double* %11, i64 %195
%198 = bitcast double* %197 to <2 x double>*
%199 = load <2 x double>, <2 x double>* %198
%200 = getelementptr inbounds double, double* %197, i64 2
%201 = bitcast double* %200 to <2 x double>*
%202 = load <2 x double>, <2 x double>* %201
%203 = fptrunc <2 x double> %199 to <2 x float>
%204 = fptrunc <2 x double> %202 to <2 x float>
%205 = getelementptr inbounds float, float* %1, i64 %195
%206 = bitcast float* %205 to <2 x float>*
store <2 x float> %203, <2 x float>* %206
%207 = getelementptr inbounds float, float* %205, i64 2
%208 = bitcast float* %207 to <2 x float>*
store <2 x float> %204, <2 x float>* %208
%209 = or i64 %195, 4
%210 = getelementptr inbounds double, double* %11, i64 %209
%211 = bitcast double* %210 to <2 x double>*
%212 = load <2 x double>, <2 x double>* %211
%213 = getelementptr inbounds double, double* %210, i64 2
%214 = bitcast double* %213 to <2 x double>*
%215 = load <2 x double>, <2 x double>* %214
%216 = fptrunc <2 x double> %212 to <2 x float>
%217 = fptrunc <2 x double> %215 to <2 x float>
%218 = getelementptr inbounds float, float* %1, i64 %209
%219 = bitcast float* %218 to <2 x float>*
store <2 x float> %216, <2 x float>* %219
%220 = getelementptr inbounds float, float* %218, i64 2
%221 = bitcast float* %220 to <2 x float>*
store <2 x float> %217, <2 x float>* %221
%222 = add nuw i64 %195, 8
%223 = add i64 %196, 2
%224 = icmp eq i64 %223, %193
br i1 %224, label %225, label %194
225: ; preds = %194, %185
%226 = phi i64 [ 0, %185 ], [ %222, %194 ]
%227 = icmp eq i64 %190, 0
br i1 %227, label %241, label %228
228: ; preds = %225
%229 = getelementptr inbounds double, double* %11, i64 %226
%230 = bitcast double* %229 to <2 x double>*
%231 = load <2 x double>, <2 x double>* %230
%232 = getelementptr inbounds double, double* %229, i64 2
%233 = bitcast double* %232 to <2 x double>*
%234 = load <2 x double>, <2 x double>* %233
%235 = fptrunc <2 x double> %231 to <2 x float>
%236 = fptrunc <2 x double> %234 to <2 x float>
%237 = getelementptr inbounds float, float* %1, i64 %226
%238 = bitcast float* %237 to <2 x float>*
store <2 x float> %235, <2 x float>* %238
%239 = getelementptr inbounds float, float* %237, i64 2
%240 = bitcast float* %239 to <2 x float>*
store <2 x float> %236, <2 x float>* %240
br label %241
241: ; preds = %225, %228
%242 = icmp eq i64 %186, %3
br i1 %242, label %253, label %243
243: ; preds = %183, %241
%244 = phi i64 [ 0, %183 ], [ %186, %241 ]
br label %245
245: ; preds = %243, %245
%246 = phi i64 [ %251, %245 ], [ %244, %243 ]
%247 = getelementptr inbounds double, double* %11, i64 %246
%248 = load double, double* %247
%249 = fptrunc double %248 to float
%250 = getelementptr inbounds float, float* %1, i64 %246
store float %249, float* %250
%251 = add nuw nsw i64 %246, 1
%252 = icmp eq i64 %251, %3
br i1 %252, label %253, label %245
253: ; preds = %245, %241, %37, %13, %49, %134
%254 = phi double [ %15, %13 ], [ %43, %49 ], [ %132, %134 ], [ %39, %37 ], [ %136, %241 ], [ %136, %245 ]
%255 = fptrunc double %254 to float
ret float %255
}