#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 *dvector(int /*<<< orphan*/, int);
scalar_t__ find_lp_coefficients(float *, float *, int, int, double *, int,
                                double);
int /*<<< orphan*/ free_dvector(double *, int /*<<< orphan*/);
int /*<<< orphan*/ lpc_predict(int, float *, float *, int, int, double *,
                               double *, int);
int /*<<< orphan*/ lpcfixrts(double *, int, int);
int /*<<< orphan*/ riConjD(double *, double *, int);
int /*<<< orphan*/ riMoveConjD(double *, double *, double *, double *, int);
int /*<<< orphan*/ riMoveD(double *, double *, double *, double *, int);
int lpc(int lpDataSize, int lpOrder, float *rdata, float *idata, int icmplx,
        int lpPredSize, float *rpred, float *ipred, int beforeFlag, int lpOpt,
        int lpFixMode, double toler) {
  int i, j, result = 0;
  double *afR, *afI, *abR, *abI;
  double *af, *ab;
  if (lpOrder > 256) {
    lpOrder = 256;
  }
  if (lpPredSize < 1)
    return 0;
  if (lpOrder == 0) {
    for (i = 0; i < lpPredSize; i++) {
      *rpred++ = 0.0;
      *ipred++ = 0.0;
    }
    return 0;
  }
  af = dvector(0, 2 * lpOrder);
  ab = dvector(0, 2 * lpOrder);
  if (beforeFlag) {
    if (lpOpt == 2 || lpOpt == 1) {
      if (find_lp_coefficients(rdata, idata, lpDataSize, lpOrder, ab, 1,
                               toler) > 0)
        result = 2;
    }
    if (result == 0 && (lpOpt == 0 || lpOpt == 1 || lpOpt == 3)) {
      if (find_lp_coefficients(rdata, idata, lpDataSize, lpOrder, af, 0,
                               toler) > 0)
        result = 2;
    }
  } else {
    if (lpOpt == 0 || lpOpt == 1 || lpOpt == 3) {
      if (find_lp_coefficients(rdata, idata, lpDataSize, lpOrder, af, 1,
                               toler) > 0)
        result = 2;
    }
    if (result == 0 && (lpOpt == 2 || lpOpt == 1)) {
      if (find_lp_coefficients(rdata, idata, lpDataSize, lpOrder, ab, 0,
                               toler) > 0)
        result = 2;
    }
  }
  if (result != 0) {
    free_dvector(af, 0);
    free_dvector(ab, 0);
    return result;
  }
  afR = af;
  afI = af + lpOrder;
  abR = ab;
  abI = ab + lpOrder;
  if (lpOpt == 0 || lpOpt == 3) {
    lpcfixrts(af, lpOrder, lpFixMode);
    if (beforeFlag)
      riMoveD(afR, afI, abR, abI, lpOrder);
  } else if (lpOpt == 2) {
    if (beforeFlag) {
      lpcfixrts(ab, lpOrder, lpFixMode);
      riConjD(abR, abI, lpOrder);
    } else {
      riMoveConjD(abR, abI, afR, afI, lpOrder);
      lpcfixrts(af, lpOrder, lpFixMode);
    }
  } else {
    if (!beforeFlag)
      riConjD(abR, abI, lpOrder);
    lpcfixrts(af, lpOrder, lpFixMode);
    lpcfixrts(ab, lpOrder, lpFixMode);
    if (beforeFlag)
      riConjD(abR, abI, lpOrder);
    for (j = 0; j < lpOrder; j++) {
      abR[j] = (abR[j] + afR[j]) * 0.5;
      abI[j] = (abI[j] + afI[j]) * 0.5;
    }
  }
  if (beforeFlag)
    lpc_predict(beforeFlag, rpred, ipred, icmplx, lpPredSize, abR, abI,
                lpOrder);
  else
    lpc_predict(beforeFlag, rpred, ipred, icmplx, lpPredSize, afR, afI,
                lpOrder);
  free_dvector(af, 0);
  free_dvector(ab, 0);
  return result;
}


x86 assembly (clang, -O0):
<lpc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x100,-0xc(%rbp)
jle    11d2 <lpc+0x52>
movl   $0x100,-0xc(%rbp)
cmpl   $0x1,-0x28(%rbp)
jge    11e8 <lpc+0x68>
movl   $0x0,-0x4(%rbp)
jmp    1646 <lpc+0x4c6>
cmpl   $0x0,-0xc(%rbp)
jne    124b <lpc+0xcb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    123f <lpc+0xbf>
mov    0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f9 <lpc+0x79>
movl   $0x0,-0x4(%rbp)
jmp    1646 <lpc+0x4c6>
mov    -0xc(%rbp),%esi
shl    $0x1,%esi
xor    %edi,%edi
call   1070 <dvector@plt>
mov    %rax,-0x68(%rbp)
mov    -0xc(%rbp),%esi
shl    $0x1,%esi
xor    %edi,%edi
call   1070 <dvector@plt>
mov    %rax,-0x70(%rbp)
cmpl   $0x0,0x20(%rbp)
je     1325 <lpc+0x1a5>
cmpl   $0x2,0x28(%rbp)
je     128b <lpc+0x10b>
cmpl   $0x1,0x28(%rbp)
jne    12c3 <lpc+0x143>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0xc(%rbp),%ecx
mov    -0x70(%rbp),%r8
movsd  -0x30(%rbp),%xmm0
mov    $0x1,%r9d
call   1080 <find_lp_coefficients@plt>
cmp    $0x0,%rax
jle    12be <lpc+0x13e>
movl   $0x2,-0x3c(%rbp)
jmp    12c3 <lpc+0x143>
cmpl   $0x0,-0x3c(%rbp)
jne    1320 <lpc+0x1a0>
cmpl   $0x0,0x28(%rbp)
je     12eb <lpc+0x16b>
cmpl   $0x1,0x28(%rbp)
je     12eb <lpc+0x16b>
cmpl   $0x3,0x28(%rbp)
jne    1320 <lpc+0x1a0>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0xc(%rbp),%ecx
mov    -0x68(%rbp),%r8
movsd  -0x30(%rbp),%xmm0
xor    %r9d,%r9d
call   1080 <find_lp_coefficients@plt>
cmp    $0x0,%rax
jle    131b <lpc+0x19b>
movl   $0x2,-0x3c(%rbp)
jmp    1320 <lpc+0x1a0>
jmp    13d3 <lpc+0x253>
cmpl   $0x0,0x28(%rbp)
je     1343 <lpc+0x1c3>
cmpl   $0x1,0x28(%rbp)
je     1343 <lpc+0x1c3>
cmpl   $0x3,0x28(%rbp)
jne    137b <lpc+0x1fb>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0xc(%rbp),%ecx
mov    -0x68(%rbp),%r8
movsd  -0x30(%rbp),%xmm0
mov    $0x1,%r9d
call   1080 <find_lp_coefficients@plt>
cmp    $0x0,%rax
jle    1376 <lpc+0x1f6>
movl   $0x2,-0x3c(%rbp)
jmp    137b <lpc+0x1fb>
cmpl   $0x0,-0x3c(%rbp)
jne    13ce <lpc+0x24e>
cmpl   $0x2,0x28(%rbp)
je     1399 <lpc+0x219>
cmpl   $0x1,0x28(%rbp)
jne    13ce <lpc+0x24e>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0xc(%rbp),%ecx
mov    -0x70(%rbp),%r8
movsd  -0x30(%rbp),%xmm0
xor    %r9d,%r9d
call   1080 <find_lp_coefficients@plt>
cmp    $0x0,%rax
jle    13c9 <lpc+0x249>
movl   $0x2,-0x3c(%rbp)
jmp    13ce <lpc+0x24e>
jmp    13d3 <lpc+0x253>
cmpl   $0x0,-0x3c(%rbp)
je     13fe <lpc+0x27e>
mov    -0x68(%rbp),%rdi
xor    %esi,%esi
call   1090 <free_dvector@plt>
mov    -0x70(%rbp),%rdi
xor    %esi,%esi
call   1090 <free_dvector@plt>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1646 <lpc+0x4c6>
mov    -0x68(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x68(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x70(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
cmpl   $0x0,0x28(%rbp)
je     1448 <lpc+0x2c8>
cmpl   $0x3,0x28(%rbp)
jne    147f <lpc+0x2ff>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    0x30(%rbp),%edx
call   1060 <lpcfixrts@plt>
cmpl   $0x0,0x20(%rbp)
je     147a <lpc+0x2fa>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    -0xc(%rbp),%r8d
call   1040 <riMoveD@plt>
jmp    15c7 <lpc+0x447>
cmpl   $0x2,0x28(%rbp)
jne    14e4 <lpc+0x364>
cmpl   $0x0,0x20(%rbp)
je     14b7 <lpc+0x337>
mov    -0x70(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    0x30(%rbp),%edx
call   1060 <lpcfixrts@plt>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   10a0 <riConjD@plt>
jmp    14df <lpc+0x35f>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    -0xc(%rbp),%r8d
call   1050 <riMoveConjD@plt>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    0x30(%rbp),%edx
call   1060 <lpcfixrts@plt>
jmp    15c2 <lpc+0x442>
cmpl   $0x0,0x20(%rbp)
jne    14fe <lpc+0x37e>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   10a0 <riConjD@plt>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    0x30(%rbp),%edx
call   1060 <lpcfixrts@plt>
mov    -0x70(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    0x30(%rbp),%edx
call   1060 <lpcfixrts@plt>
cmpl   $0x0,0x20(%rbp)
je     1536 <lpc+0x3b6>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   10a0 <riConjD@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15bd <lpc+0x43d>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xa95(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xa62(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    153d <lpc+0x3bd>
jmp    15c2 <lpc+0x442>
jmp    15c7 <lpc+0x447>
cmpl   $0x0,0x20(%rbp)
je     1600 <lpc+0x480>
mov    0x20(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%r8d
mov    -0x58(%rbp),%r9
mov    -0x60(%rbp),%r10
mov    -0xc(%rbp),%eax
mov    %r10,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <lpc_predict@plt>
jmp    162a <lpc+0x4aa>
mov    0x20(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%r8d
mov    -0x48(%rbp),%r9
mov    -0x50(%rbp),%r10
mov    -0xc(%rbp),%eax
mov    %r10,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <lpc_predict@plt>
mov    -0x68(%rbp),%rdi
xor    %esi,%esi
call   1090 <free_dvector@plt>
mov    -0x70(%rbp),%rdi
xor    %esi,%esi
call   1090 <free_dvector@plt>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
cmp    $0x100,%esi
mov    $0x100,%eax
cmovl  %esi,%eax
test   %r9d,%r9d
jle    1295 <lpc+0x115>
mov    0x88(%rsp),%r15
mov    0x80(%rsp),%rbx
test   %eax,%eax
je     129d <lpc+0x11d>
mov    %esi,%r14d
mov    %rdx,0x30(%rsp)
mov    %edi,0x18(%rsp)
mov    %rcx,%r12
movsd  %xmm0,(%rsp)
mov    %r8d,0x3c(%rsp)
mov    %r9,0x40(%rsp)
mov    0x98(%rsp),%r13d
mov    %rax,0x28(%rsp)
lea    (%rax,%rax,1),%ebp
xor    %edi,%edi
mov    %ebp,%esi
call   1070 <dvector@plt>
mov    %rax,0x20(%rsp)
xor    %edi,%edi
mov    %ebp,%esi
call   1070 <dvector@plt>
mov    %rax,0x10(%rsp)
cmpl   $0x0,0x90(%rsp)
je     12fa <lpc+0x17a>
lea    -0x1(%r13),%eax
cmp    $0x1,%eax
mov    0x28(%rsp),%rbp
mov    %r13,%rdx
movsd  (%rsp),%xmm0
ja     1268 <lpc+0xe8>
mov    0x30(%rsp),%rdi
mov    %r12,%rsi
mov    %rdx,%r13
mov    0x18(%rsp),%edx
mov    %ebp,%ecx
mov    0x10(%rsp),%r8
mov    $0x1,%r9d
movsd  (%rsp),%xmm0
call   1080 <find_lp_coefficients@plt>
movsd  (%rsp),%xmm0
mov    %r13,%rdx
mov    $0x2,%r13d
test   %rax,%rax
jg     19f0 <lpc+0x870>
cmp    $0x3,%edx
ja     1387 <lpc+0x207>
cmp    $0x2,%edx
je     1387 <lpc+0x207>
mov    0x30(%rsp),%rdi
mov    %r12,%rsi
mov    %rdx,%r12
mov    0x18(%rsp),%edx
mov    %ebp,%ecx
mov    0x20(%rsp),%r8
jmp    136d <lpc+0x1ed>
xor    %r13d,%r13d
jmp    1a08 <lpc+0x888>
lea    -0x1(%r9),%ecx
xor    %eax,%eax
cmp    $0x7,%ecx
jb     1563 <lpc+0x3e3>
lea    (%r15,%rcx,4),%rdx
add    $0x4,%rdx
cmp    %rbx,%rdx
jbe    12ca <lpc+0x14a>
lea    (%rbx,%rcx,4),%rdx
add    $0x4,%rdx
cmp    %r15,%rdx
ja     1563 <lpc+0x3e3>
add    $0x1,%rcx
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1495 <lpc+0x315>
xor    %edi,%edi
jmp    1510 <lpc+0x390>
cmp    $0x3,%r13d
mov    0x28(%rsp),%rbp
mov    %r13,%rdx
movsd  (%rsp),%xmm0
mov    %r12,%rsi
ja     1352 <lpc+0x1d2>
cmp    $0x2,%edx
je     1352 <lpc+0x1d2>
mov    0x30(%rsp),%rdi
mov    %rdx,%r13
mov    0x18(%rsp),%edx
mov    %ebp,%ecx
mov    0x20(%rsp),%r8
mov    $0x1,%r9d
movsd  (%rsp),%xmm0
call   1080 <find_lp_coefficients@plt>
movsd  (%rsp),%xmm0
mov    %r13,%rdx
mov    %r12,%rsi
mov    $0x2,%r13d
test   %rax,%rax
jg     19f0 <lpc+0x870>
lea    -0x1(%rdx),%eax
cmp    $0x1,%eax
ja     1387 <lpc+0x207>
mov    0x30(%rsp),%rdi
mov    %rdx,%r12
mov    0x18(%rsp),%edx
mov    %ebp,%ecx
mov    0x10(%rsp),%r8
xor    %r9d,%r9d
call   1080 <find_lp_coefficients@plt>
mov    %r12,%rdx
mov    $0x2,%r13d
test   %rax,%rax
jg     19f0 <lpc+0x870>
mov    0xa0(%rsp),%r8d
movslq %ebp,%rbp
mov    0x20(%rsp),%r13
lea    0x0(,%rbp,8),%rcx
add    %r13,%rcx
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,(%rsp)
cmp    $0x3,%edx
je     13c1 <lpc+0x241>
cmp    $0x2,%edx
je     1409 <lpc+0x289>
test   %edx,%edx
jne    1444 <lpc+0x2c4>
mov    %rcx,0x18(%rsp)
mov    %r13,%rdi
mov    0x28(%rsp),%r14
mov    %r14d,%esi
mov    %r8d,%edx
call   1060 <lpcfixrts@plt>
mov    0x90(%rsp),%ebp
test   %ebp,%ebp
mov    0x10(%rsp),%r12
je     19ca <lpc+0x84a>
mov    %r13,%rdi
mov    0x18(%rsp),%rsi
mov    %r12,%rdx
mov    (%rsp),%rcx
mov    %r14d,%r8d
call   1040 <riMoveD@plt>
jmp    19a2 <lpc+0x822>
mov    0x90(%rsp),%ebp
test   %ebp,%ebp
je     1658 <lpc+0x4d8>
mov    0x10(%rsp),%r12
mov    %r12,%rdi
mov    0x28(%rsp),%r14
mov    %r14d,%esi
mov    %r8d,%edx
call   1060 <lpcfixrts@plt>
mov    %r12,%rdi
mov    (%rsp),%rsi
mov    %r14d,%edx
call   10a0 <riConjD@plt>
jmp    19a2 <lpc+0x822>
mov    %rcx,0x18(%rsp)
cmpl   $0x0,0x90(%rsp)
je     168b <lpc+0x50b>
mov    %r13,%rdi
mov    0x28(%rsp),%r13
mov    %r13d,%esi
mov    %r8d,%edx
call   1060 <lpcfixrts@plt>
mov    0x10(%rsp),%r12
mov    %r12,%rdi
mov    %r13d,%esi
mov    0xa0(%rsp),%edx
call   1060 <lpcfixrts@plt>
mov    %r12,%rdi
mov    (%rsp),%rsi
mov    %r13d,%edx
call   10a0 <riConjD@plt>
jmp    16ca <lpc+0x54a>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xorpd  %xmm0,%xmm0
nop
movupd %xmm0,(%rbx,%rdi,4)
movupd %xmm0,0x10(%rbx,%rdi,4)
movupd %xmm0,(%r15,%rdi,4)
movupd %xmm0,0x10(%r15,%rdi,4)
movupd %xmm0,0x20(%rbx,%rdi,4)
movupd %xmm0,0x30(%rbx,%rdi,4)
movupd %xmm0,0x20(%r15,%rdi,4)
movupd %xmm0,0x30(%r15,%rdi,4)
movupd %xmm0,0x40(%rbx,%rdi,4)
movupd %xmm0,0x50(%rbx,%rdi,4)
movupd %xmm0,0x40(%r15,%rdi,4)
movupd %xmm0,0x50(%r15,%rdi,4)
movupd %xmm0,0x60(%rbx,%rdi,4)
movupd %xmm0,0x70(%rbx,%rdi,4)
movupd %xmm0,0x60(%r15,%rdi,4)
movupd %xmm0,0x70(%r15,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    14a0 <lpc+0x320>
test   %rdx,%rdx
je     154f <lpc+0x3cf>
lea    (%r15,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
xorpd  %xmm0,%xmm0
nop
movupd %xmm0,-0x10(%rdi,%rbp,1)
movupd %xmm0,(%rdi,%rbp,1)
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm0,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1530 <lpc+0x3b0>
xor    %r13d,%r13d
cmp    %rax,%rcx
je     1a08 <lpc+0x888>
lea    (%rbx,%rax,4),%rbx
lea    (%r15,%rax,4),%r15
mov    %r9d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r9d,%ecx
and    $0x7,%edx
je     159e <lpc+0x41e>
neg    %edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rbx)
add    $0x4,%rbx
movl   $0x0,(%r15)
add    $0x4,%r15
add    $0xffffffff,%esi
cmp    %esi,%edx
jne    1580 <lpc+0x400>
sub    %esi,%eax
xor    %r13d,%r13d
cmp    $0x7,%ecx
jb     1a08 <lpc+0x888>
sub    %eax,%r9d
xor    %r13d,%r13d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rbx,%rax,4)
movl   $0x0,(%r15,%rax,4)
movl   $0x0,0x4(%rbx,%rax,4)
movl   $0x0,0x4(%r15,%rax,4)
movl   $0x0,0x8(%rbx,%rax,4)
movl   $0x0,0x8(%r15,%rax,4)
movl   $0x0,0xc(%rbx,%rax,4)
movl   $0x0,0xc(%r15,%rax,4)
movl   $0x0,0x10(%rbx,%rax,4)
movl   $0x0,0x10(%r15,%rax,4)
movl   $0x0,0x14(%rbx,%rax,4)
movl   $0x0,0x14(%r15,%rax,4)
movl   $0x0,0x18(%rbx,%rax,4)
movl   $0x0,0x18(%r15,%rax,4)
movl   $0x0,0x1c(%rbx,%rax,4)
movl   $0x0,0x1c(%r15,%rax,4)
add    $0x8,%rax
cmp    %eax,%r9d
jne    15c0 <lpc+0x440>
jmp    1a08 <lpc+0x888>
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
mov    %r13,%rdx
mov    %rcx,0x18(%rsp)
mov    0x28(%rsp),%r14
mov    %r8d,%ebp
mov    %r14d,%r8d
call   1050 <riMoveConjD@plt>
mov    %r13,%rdi
mov    %r14d,%esi
mov    %ebp,%edx
call   1060 <lpcfixrts@plt>
jmp    19ca <lpc+0x84a>
mov    0x10(%rsp),%r12
mov    %r12,%rdi
mov    (%rsp),%rsi
mov    0x28(%rsp),%r13
mov    %r13d,%edx
call   10a0 <riConjD@plt>
mov    0x20(%rsp),%rdi
mov    %r13d,%esi
mov    0xa0(%rsp),%edx
call   1060 <lpcfixrts@plt>
mov    %r12,%rdi
mov    %r13d,%esi
mov    0xa0(%rsp),%edx
call   1060 <lpcfixrts@plt>
test   %r14d,%r14d
mov    0x20(%rsp),%r13
mov    0x10(%rsp),%r12
jle    1992 <lpc+0x812>
mov    0x28(%rsp),%rax
cmp    $0x2,%eax
mov    $0x1,%r9d
cmovge %eax,%r9d
cmp    $0x2,%r9d
jae    16fc <lpc+0x57c>
xor    %ecx,%ecx
jmp    18bf <lpc+0x73f>
lea    (%r12,%r9,8),%rcx
lea    (%r9,%rbp,1),%rax
lea    (%r12,%rax,8),%rdi
lea    0x0(,%r9,8),%rsi
add    %r13,%rsi
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
cmp    %rdi,%r12
setb   0x30(%rsp)
mov    (%rsp),%r10
cmp    %rcx,%r10
setb   %r11b
cmp    %rsi,%r12
setb   %r14b
cmp    %rcx,%r13
setb   %r8b
cmp    %rdx,%r12
mov    %r13,%rax
setb   %r13b
mov    0x18(%rsp),%r12
cmp    %rcx,%r12
setb   0xf(%rsp)
cmp    %rsi,%r10
setb   %sil
cmp    %rdi,%rax
setb   0xe(%rsp)
cmp    %rdx,%r10
setb   %al
cmp    %rdi,%r12
setb   %dl
xor    %ecx,%ecx
test   %r11b,0x30(%rsp)
jne    18b5 <lpc+0x735>
and    %r8b,%r14b
jne    18b5 <lpc+0x735>
and    0xf(%rsp),%r13b
mov    0x10(%rsp),%r12
jne    18ae <lpc+0x72e>
and    0xe(%rsp),%sil
mov    0x20(%rsp),%r13
jne    18bf <lpc+0x73f>
and    %dl,%al
jne    18bf <lpc+0x73f>
mov    %r9d,%ecx
and    $0x7ffffffe,%ecx
lea    -0x2(%rcx),%rax
mov    %rax,%r8
shr    %r8
add    $0x1,%r8
test   %rax,%rax
je     1859 <lpc+0x6d9>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x10(%r12),%rsi
lea    0x10(%r13),%rax
xor    %edx,%edx
movapd 0x817(%rip),%xmm0
movupd -0x10(%rsi),%xmm1
movupd -0x10(%rax),%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%rsi)
movupd -0x10(%rsi,%rbp,8),%xmm1
movupd -0x10(%rax,%rbp,8),%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%rsi,%rbp,8)
movupd (%rsi),%xmm1
movupd (%rax),%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm2,(%rsi)
movupd (%rsi,%rbp,8),%xmm1
movupd (%rax,%rbp,8),%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm2,(%rsi,%rbp,8)
add    $0x4,%rdx
add    $0x20,%rsi
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdi
jne    17e9 <lpc+0x669>
jmp    185b <lpc+0x6db>
xor    %edx,%edx
test   $0x1,%r8b
je     18a4 <lpc+0x724>
movupd (%r12,%rdx,8),%xmm0
movupd 0x0(%r13,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movapd 0x786(%rip),%xmm0
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r12,%rdx,8)
mov    (%rsp),%rax
movupd (%rax,%rdx,8),%xmm1
mov    0x18(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm2,(%rax,%rdx,8)
cmp    %r9,%rcx
jne    18bf <lpc+0x73f>
jmp    1992 <lpc+0x812>
mov    0x20(%rsp),%r13
jmp    18bf <lpc+0x73f>
mov    0x20(%rsp),%r13
mov    0x10(%rsp),%r12
mov    %rcx,%rax
not    %rax
test   $0x1,%r9b
je     190a <lpc+0x78a>
movsd  (%r12,%rcx,8),%xmm0
addsd  0x0(%r13,%rcx,8),%xmm0
movsd  0x730(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    (%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
mov    0x18(%rsp),%rsi
addsd  (%rsi,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
or     $0x1,%rcx
add    %r9,%rax
je     1992 <lpc+0x812>
lea    0x8(,%rbp,8),%rax
add    %r13,%rax
lea    (%r12,%rbp,8),%rdx
add    $0x8,%rdx
movsd  0x6e2(%rip),%xmm0
xchg   %ax,%ax
movsd  (%r12,%rcx,8),%xmm1
addsd  0x0(%r13,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
movsd  -0x8(%rdx,%rcx,8),%xmm1
addsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rdx,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm1
addsd  0x8(%r13,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm1
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1930 <lpc+0x7b0>
mov    0x90(%rsp),%ebp
test   %ebp,%ebp
mov    0x28(%rsp),%r14
je     19ca <lpc+0x84a>
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
mov    0x3c(%rsp),%ecx
mov    0x40(%rsp),%r8
mov    %r12,%r9
push   %r14
push   0x8(%rsp)
call   1030 <lpc_predict@plt>
add    $0x10,%rsp
xor    %r13d,%r13d
jmp    19f0 <lpc+0x870>
mov    %r13,%r9
xor    %r13d,%r13d
xor    %edi,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
mov    0x3c(%rsp),%ecx
mov    0x40(%rsp),%r8
push   %r14
push   0x20(%rsp)
call   1030 <lpc_predict@plt>
add    $0x10,%rsp
mov    0x20(%rsp),%rdi
xor    %esi,%esi
call   1090 <free_dvector@plt>
mov    0x10(%rsp),%rdi
xor    %esi,%esi
call   1090 <free_dvector@plt>
mov    %r13d,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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