#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*/ autoc(int, float *, int, float *, float *);
int /*<<< orphan*/ durbin(float *, float *, float *, int, float *);
double exp(float);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ hnwindow(float const *, float *, int, float);
float log(double);
scalar_t__ malloc(int);
scalar_t__ realloc(float *, int);
int /*<<< orphan*/ stderr;
int lpc(int lpc_ord, float lpc_stabl, int wsize, const float *data, float *lpca,
        float *ar, float *lpck, float *normerr, float *rms, float preemp) {
  static float *dwind = NULL;
  static int nwind = 0;
  float rho[100 + 1], k[100], a[100 + 1], *r, *kp, *ap, en, er, wfact;
  if ((wsize <= 0) || (!data) || (lpc_ord > 100))
    return (0);
  if (nwind != wsize) {
    if (dwind)
      dwind = (float *)realloc(dwind, wsize * sizeof(float));
    else
      dwind = (float *)malloc(wsize * sizeof(float));
    if (!dwind) {
      (void)fprintf(stderr, "Can't allocate scratch memory in lpc()\n");
      return (0);
    }
    nwind = wsize;
  }
  hnwindow(data, dwind, wsize, preemp);
  if (!(r = ar))
    r = rho;
  if (!(kp = lpck))
    kp = k;
  if (!(ap = lpca))
    ap = a;
  autoc(wsize, dwind, lpc_ord, r, &en);
  if (lpc_stabl > 1.0) {
    int i;
    float ffact;
    ffact = 1.0 / (1.0 + exp((-lpc_stabl / 20.0) * log(10.0)));
    for (i = 1; i <= lpc_ord; i++)
      rho[i] = ffact * r[i];
    *rho = *r;
    r = rho;
    if (ar)
      for (i = 0; i <= lpc_ord; i++)
        ar[i] = r[i];
  }
  durbin(r, kp, &ap[1], lpc_ord, &er);
  wfact = .612372;
  *ap = 1.0;
  if (rms)
    *rms = en / wfact;
  if (normerr)
    *normerr = er;
  return (1);
}


x86 assembly (clang, -O0):
<lpc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x540,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm1,-0x34(%rbp)
cmpl   $0x0,-0x10(%rbp)
jle    11d2 <lpc+0x52>
cmpq   $0x0,-0x18(%rbp)
je     11d2 <lpc+0x52>
cmpl   $0x64,-0x8(%rbp)
jle    11de <lpc+0x5e>
movl   $0x0,-0x4(%rbp)
jmp    150c <lpc+0x38c>
mov    0x2e8c(%rip),%eax
cmp    -0x10(%rbp),%eax
je     126b <lpc+0xeb>
cmpq   $0x0,0x2e73(%rip)
je     121d <lpc+0x9d>
mov    0x2e66(%rip),%rdi
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%esi
call   1080 <realloc@plt>
mov    %rax,0x2e50(%rip)
jmp    1233 <lpc+0xb3>
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,0x2e35(%rip)
cmpq   $0x0,0x2e2d(%rip)
jne    1262 <lpc+0xe2>
mov    0x2d98(%rip),%rax
mov    (%rax),%edi
lea    0xdcf(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    150c <lpc+0x38c>
mov    -0x10(%rbp),%eax
mov    %eax,0x2e05(%rip)
mov    -0x18(%rbp),%rdi
mov    0x2df2(%rip),%rsi
mov    -0x10(%rbp),%edx
movss  -0x34(%rbp),%xmm0
call   1040 <hnwindow@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x508(%rbp)
cmp    $0x0,%rax
jne    12a6 <lpc+0x126>
lea    -0x1d0(%rbp),%rax
mov    %rax,-0x508(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x510(%rbp)
cmp    $0x0,%rax
jne    12c9 <lpc+0x149>
lea    -0x360(%rbp),%rax
mov    %rax,-0x510(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x518(%rbp)
cmp    $0x0,%rax
jne    12ec <lpc+0x16c>
lea    -0x500(%rbp),%rax
mov    %rax,-0x518(%rbp)
mov    -0x10(%rbp),%edi
mov    0x2d72(%rip),%rsi
mov    -0x8(%rbp),%edx
mov    -0x508(%rbp),%rcx
lea    -0x51c(%rbp),%r8
call   10a0 <autoc@plt>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    147c <lpc+0x2fc>
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xccb(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x538(%rbp)
ff
movsd  0xcaf(%rip),%xmm0
call   1090 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x538(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1070 <exp@plt>
movsd  0xc7e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xc72(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x52c(%rbp)
ff
movl   $0x1,-0x528(%rbp)
mov    -0x528(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     13f6 <lpc+0x276>
movss  -0x52c(%rbp),%xmm0
ff
mov    -0x508(%rbp),%rax
movslq -0x528(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movslq -0x528(%rbp),%rax
movss  %xmm0,-0x1d0(%rbp,%rax,4)
ff ff
mov    -0x528(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x528(%rbp)
jmp    13a8 <lpc+0x228>
mov    -0x508(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1d0(%rbp)
ff
lea    -0x1d0(%rbp),%rax
mov    %rax,-0x508(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     1477 <lpc+0x2f7>
movl   $0x0,-0x528(%rbp)
mov    -0x528(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1472 <lpc+0x2f2>
mov    -0x508(%rbp),%rax
movslq -0x528(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x528(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x528(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x528(%rbp)
jmp    142c <lpc+0x2ac>
jmp    1477 <lpc+0x2f7>
jmp    147c <lpc+0x2fc>
mov    -0x508(%rbp),%rdi
mov    -0x510(%rbp),%rsi
mov    -0x518(%rbp),%rdx
add    $0x4,%rdx
mov    -0x8(%rbp),%ecx
lea    -0x520(%rbp),%r8
call   1030 <durbin@plt>
movss  0xb70(%rip),%xmm0
movss  %xmm0,-0x524(%rbp)
ff
mov    -0x518(%rbp),%rax
movss  0xb55(%rip),%xmm0
movss  %xmm0,(%rax)
cmpq   $0x0,0x18(%rbp)
je     14ea <lpc+0x36a>
movss  -0x51c(%rbp),%xmm0
ff
divss  -0x524(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
cmpq   $0x0,0x10(%rbp)
je     1505 <lpc+0x385>
movss  -0x520(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x540,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4f8,%rsp
xor    %ebp,%ebp
cmp    $0x64,%edi
jg     1550 <lpc+0x3c0>
mov    %esi,%r13d
test   %esi,%esi
jle    1550 <lpc+0x3c0>
mov    %rdx,%rbx
test   %rdx,%rdx
je     1550 <lpc+0x3c0>
mov    %r9,%r12
mov    %rcx,%r15
mov    %edi,0x24(%rsp)
mov    0x2e9c(%rip),%rsi
cmp    %r13d,0x2e9d(%rip)
movss  %xmm0,0x18(%rsp)
jne    11eb <lpc+0x5b>
mov    %r8,%r14
mov    %r15,%rbp
jmp    1237 <lpc+0xa7>
movss  %xmm1,0x10(%rsp)
mov    %r8,%r14
lea    0x0(,%r13,4),%eax
test   %rsi,%rsi
je     120d <lpc+0x7d>
mov    %rsi,%rdi
mov    %eax,%esi
call   1090 <realloc@plt>
jmp    1214 <lpc+0x84>
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rsi
mov    %rax,0x2e52(%rip)
test   %rax,%rax
movss  0x10(%rsp),%xmm1
je     13d8 <lpc+0x248>
mov    %r15,%rbp
mov    %r13d,0x2e41(%rip)
mov    %rbx,%rdi
mov    %r13d,%edx
movaps %xmm1,%xmm0
call   1040 <hnwindow@plt>
mov    %r14,%rbx
test   %r14,%r14
lea    0x30(%rsp),%rax
mov    %r14,%r15
cmove  %rax,%r15
test   %r12,%r12
lea    0x1d0(%rsp),%rax
cmovne %r12,%rax
mov    %rax,0x10(%rsp)
mov    %rbp,%r12
test   %rbp,%rbp
lea    0x360(%rsp),%rbp
mov    %r12,0x8(%rsp)
cmove  %rbp,%r12
mov    0x2de7(%rip),%rsi
lea    0x2c(%rsp),%r8
mov    %r13d,%edi
mov    0x24(%rsp),%r14d
mov    %r14d,%edx
mov    %r15,%rcx
call   10b0 <autoc@plt>
movss  0x18(%rsp),%xmm0
ucomiss 0xd52(%rip),%xmm0
jbe    13c3 <lpc+0x233>
cvtss2sd %xmm0,%xmm0
divsd  0xd48(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0xd42(%rip),%xmm0
call   10a0 <log@plt>
cvtss2sd %xmm0,%xmm0
mulsd  0x18(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
call   1080 <exp@plt>
mov    %r14d,%r8d
test   %r14d,%r14d
mov    %rbx,%rdi
mov    0x538(%rsp),%r13
jle    14ac <lpc+0x31c>
movsd  0xd13(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
lea    0x1(%r8),%rcx
mov    $0x1,%edx
cmp    $0x8,%r14d
jb     1424 <lpc+0x294>
lea    0x34(%rsp),%rax
lea    (%r15,%rcx,4),%rsi
cmp    %rsi,%rax
jae    134a <lpc+0x1ba>
lea    (%rsp,%rcx,4),%rax
add    $0x30,%rax
lea    0x4(%r15),%rsi
cmp    %rax,%rsi
jb     1424 <lpc+0x294>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     13f2 <lpc+0x262>
mov    %rbx,%rax
and    $0xfffffffffffffffe,%rax
mov    $0x1,%esi
nopl   0x0(%rax,%rax,1)
movups (%r15,%rsi,4),%xmm2
movups 0x10(%r15,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x30(%rsp,%rsi,4)
movups %xmm3,0x40(%rsp,%rsi,4)
movups 0x20(%r15,%rsi,4),%xmm2
movups 0x30(%r15,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x50(%rsp,%rsi,4)
movups %xmm3,0x60(%rsp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rax
jne    1380 <lpc+0x1f0>
jmp    13f7 <lpc+0x267>
mov    %r15,%rax
mov    0x8(%rsp),%rbx
mov    0x538(%rsp),%r13
jmp    14ef <lpc+0x35f>
mov    0x2c01(%rip),%rax
mov    (%rax),%edi
lea    0xc38(%rip),%rsi
call   1050 <fprintf@plt>
jmp    1550 <lpc+0x3c0>
mov    $0x1,%esi
test   $0x1,%bl
je     1417 <lpc+0x287>
movups (%r15,%rsi,4),%xmm2
movups 0x10(%r15,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x30(%rsp,%rsi,4)
movups %xmm3,0x40(%rsp,%rsi,4)
cmp    %rdx,%r8
je     14ac <lpc+0x31c>
or     $0x1,%rdx
mov    %ecx,%esi
sub    %edx,%esi
mov    %rdx,%rax
not    %rax
add    %rcx,%rax
and    $0x3,%rsi
je     145a <lpc+0x2ca>
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x30(%rsp,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1440 <lpc+0x2b0>
cmp    $0x3,%rax
jb     14ac <lpc+0x31c>
movss  (%r15,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x30(%rsp,%rdx,4)
movss  0x4(%r15,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x34(%rsp,%rdx,4)
movss  0x8(%r15,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x38(%rsp,%rdx,4)
movss  0xc(%r15,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x3c(%rsp,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1460 <lpc+0x2d0>
movss  (%r15),%xmm0
movss  %xmm0,0x30(%rsp)
test   %rdi,%rdi
je     14e5 <lpc+0x355>
test   %r14d,%r14d
mov    0x8(%rsp),%rbx
lea    0x30(%rsp),%rax
js     14ef <lpc+0x35f>
lea    0x30(%rsp),%r15
lea    0x4(,%r8,4),%rdx
mov    %r15,%rsi
call   1060 <memcpy@plt>
mov    %r15,%rax
jmp    14ef <lpc+0x35f>
mov    0x8(%rsp),%rbx
lea    0x30(%rsp),%rax
mov    0x530(%rsp),%r15
test   %rbx,%rbx
cmovne %rbx,%rbp
add    $0x4,%rbp
lea    0x28(%rsp),%r8
mov    %rax,%rdi
mov    0x10(%rsp),%rsi
mov    %rbp,%rdx
mov    %r14d,%ecx
call   1030 <durbin@plt>
movl   $0x3f800000,(%r12)
3f
test   %r13,%r13
je     153b <lpc+0x3ab>
movss  0x2c(%rsp),%xmm0
divss  0xacf(%rip),%xmm0
movss  %xmm0,0x0(%r13)
mov    $0x1,%ebp
test   %r15,%r15
je     1550 <lpc+0x3c0>
movss  0x28(%rsp),%xmm0
movss  %xmm0,(%r15)
mov    %ebp,%eax
add    $0x4f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@lpc.dwind = internal global float* null
@lpc.nwind = internal global i32 0
@stderr = global i32 0
@.str = [40 x i8] c"Can't allocate scratch memory in lpc()\0A\00"
define i32 @lpc(i32 %0, float %1, i32 %2, float* %3, float* %4, float* %5, float* %6, float* %7, float* %8, float %9) {
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca i32
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca float*
%19 = alloca float*
%20 = alloca float*
%21 = alloca float
%22 = alloca [101 x float]
%23 = alloca [100 x float]
%24 = alloca [101 x float]
%25 = alloca float*
%26 = alloca float*
%27 = alloca float*
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca i32
%32 = alloca float
store i32 %0, i32* %12
store float %1, float* %13
store i32 %2, i32* %14
store float* %3, float** %15
store float* %4, float** %16
store float* %5, float** %17
store float* %6, float** %18
store float* %7, float** %19
store float* %8, float** %20
store float %9, float* %21
%33 = load i32, i32* %14
%34 = icmp sle i32 %33, 0
br i1 %34, label %41, label %35
35: ; preds = %10
%36 = load float*, float** %15
%37 = icmp ne float* %36, null
br i1 %37, label %38, label %41
38: ; preds = %35
%39 = load i32, i32* %12
%40 = icmp sgt i32 %39, 100
br i1 %40, label %41, label %42
41: ; preds = %38, %35, %10
store i32 0, i32* %11
br label %181
42: ; preds = %38
%43 = load i32, i32* @lpc.nwind
%44 = load i32, i32* %14
%45 = icmp ne i32 %43, %44
br i1 %45, label %46, label %72
46: ; preds = %42
%47 = load float*, float** @lpc.dwind
%48 = icmp ne float* %47, null
br i1 %48, label %49, label %57
49: ; preds = %46
%50 = load float*, float** @lpc.dwind
%51 = load i32, i32* %14
%52 = sext i32 %51 to i64
%53 = mul i64 %52, 4
%54 = trunc i64 %53 to i32
%55 = call i64 @realloc(float* %50, i32 %54)
%56 = inttoptr i64 %55 to float*
store float* %56, float** @lpc.dwind
br label %64
57: ; preds = %46
%58 = load i32, i32* %14
%59 = sext i32 %58 to i64
%60 = mul i64 %59, 4
%61 = trunc i64 %60 to i32
%62 = call i64 @malloc(i32 %61)
%63 = inttoptr i64 %62 to float*
store float* %63, float** @lpc.dwind
br label %64
64: ; preds = %57, %49
%65 = load float*, float** @lpc.dwind
%66 = icmp ne float* %65, null
br i1 %66, label %70, label %67
67: ; preds = %64
%68 = load i32, i32* @stderr
%69 = call i32 @fprintf(i32 %68, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %11
br label %181
70: ; preds = %64
%71 = load i32, i32* %14
store i32 %71, i32* @lpc.nwind
br label %72
72: ; preds = %70, %42
%73 = load float*, float** %15
%74 = load float*, float** @lpc.dwind
%75 = load i32, i32* %14
%76 = load float, float* %21
%77 = call i32 @hnwindow(float* %73, float* %74, i32 %75, float %76)
%78 = load float*, float** %17
store float* %78, float** %25
%79 = icmp ne float* %78, null
br i1 %79, label %82, label %80
80: ; preds = %72
%81 = getelementptr inbounds [101 x float], [101 x float]* %22, i64 0, i64 0
store float* %81, float** %25
br label %82
82: ; preds = %80, %72
%83 = load float*, float** %18
store float* %83, float** %26
%84 = icmp ne float* %83, null
br i1 %84, label %87, label %85
85: ; preds = %82
%86 = getelementptr inbounds [100 x float], [100 x float]* %23, i64 0, i64 0
store float* %86, float** %26
br label %87
87: ; preds = %85, %82
%88 = load float*, float** %16
store float* %88, float** %27
%89 = icmp ne float* %88, null
br i1 %89, label %92, label %90
90: ; preds = %87
%91 = getelementptr inbounds [101 x float], [101 x float]* %24, i64 0, i64 0
store float* %91, float** %27
br label %92
92: ; preds = %90, %87
%93 = load i32, i32* %14
%94 = load float*, float** @lpc.dwind
%95 = load i32, i32* %12
%96 = load float*, float** %25
%97 = call i32 @autoc(i32 %93, float* %94, i32 %95, float* %96, float* %28)
%98 = load float, float* %13
%99 = fpext float %98 to double
%100 = fcmp ogt double %99, 1.000000e+00
br i1 %100, label %101, label %159
101: ; preds = %92
%102 = load float, float* %13
%103 = fneg float %102
%104 = fpext float %103 to double
%105 = fdiv double %104, 2.000000e+01
%106 = call float @log(double 1.000000e+01)
%107 = fpext float %106 to double
%108 = fmul double %105, %107
%109 = fptrunc double %108 to float
%110 = call double @exp(float %109)
%111 = fadd double 1.000000e+00, %110
%112 = fdiv double 1.000000e+00, %111
%113 = fptrunc double %112 to float
store float %113, float* %32
store i32 1, i32* %31
br label %114
114: ; preds = %129, %101
%115 = load i32, i32* %31
%116 = load i32, i32* %12
%117 = icmp sle i32 %115, %116
br i1 %117, label %118, label %132
118: ; preds = %114
%119 = load float, float* %32
%120 = load float*, float** %25
%121 = load i32, i32* %31
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %120, i64 %122
%124 = load float, float* %123
%125 = fmul float %119, %124
%126 = load i32, i32* %31
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [101 x float], [101 x float]* %22, i64 0, i64 %127
store float %125, float* %128
br label %129
129: ; preds = %118
%130 = load i32, i32* %31
%131 = add nsw i32 %130, 1
store i32 %131, i32* %31
br label %114
132: ; preds = %114
%133 = load float*, float** %25
%134 = load float, float* %133
%135 = getelementptr inbounds [101 x float], [101 x float]* %22, i64 0, i64 0
store float %134, float* %135
%136 = getelementptr inbounds [101 x float], [101 x float]* %22, i64 0, i64 0
store float* %136, float** %25
%137 = load float*, float** %17
%138 = icmp ne float* %137, null
br i1 %138, label %139, label %158
139: ; preds = %132
store i32 0, i32* %31
br label %140
140: ; preds = %154, %139
%141 = load i32, i32* %31
%142 = load i32, i32* %12
%143 = icmp sle i32 %141, %142
br i1 %143, label %144, label %157
144: ; preds = %140
%145 = load float*, float** %25
%146 = load i32, i32* %31
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %145, i64 %147
%149 = load float, float* %148
%150 = load float*, float** %17
%151 = load i32, i32* %31
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %150, i64 %152
store float %149, float* %153
br label %154
154: ; preds = %144
%155 = load i32, i32* %31
%156 = add nsw i32 %155, 1
store i32 %156, i32* %31
br label %140
157: ; preds = %140
br label %158
158: ; preds = %157, %132
br label %159
159: ; preds = %158, %92
%160 = load float*, float** %25
%161 = load float*, float** %26
%162 = load float*, float** %27
%163 = getelementptr inbounds float, float* %162, i64 1
%164 = load i32, i32* %12
%165 = call i32 @durbin(float* %160, float* %161, float* %163, i32 %164, float* %29)
store float 0x3FE3988D20000000, float* %30
%166 = load float*, float** %27
store float 1.000000e+00, float* %166
%167 = load float*, float** %20
%168 = icmp ne float* %167, null
br i1 %168, label %169, label %174
169: ; preds = %159
%170 = load float, float* %28
%171 = load float, float* %30
%172 = fdiv float %170, %171
%173 = load float*, float** %20
store float %172, float* %173
br label %174
174: ; preds = %169, %159
%175 = load float*, float** %19
%176 = icmp ne float* %175, null
br i1 %176, label %177, label %180
177: ; preds = %174
%178 = load float, float* %29
%179 = load float*, float** %19
store float %178, float* %179
br label %180
180: ; preds = %177, %174
store i32 1, i32* %11
br label %181
181: ; preds = %180, %67, %41
%182 = load i32, i32* %11
ret i32 %182
}

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