void SKP_Silk_LPC_analysis_filter(const short *in, const short *B, short *S,
                                  short *out, const int len, const int Order) {
  int k, j, idx, Order_half = ((Order) >> (1));
  int Btmp, B_align_Q12[16 >> 1], out32_Q12, out32;
  short SA, SB;
  ;
  for (k = 0; k < Order_half; k++) {
    idx = ((int)((short)(2)) * (int)((short)(k)));
    B_align_Q12[k] = (((int)B[idx]) & 0x0000ffff) | (((int)B[idx + 1]) << (16));
  }
  for (k = 0; k < len; k++) {
    SA = S[0];
    out32_Q12 = 0;
    for (j = 0; j < (Order_half - 1); j++) {
      idx = ((int)((short)(2)) * (int)((short)(j))) + 1;
      Btmp = B_align_Q12[j];
      SB = S[idx];
      S[idx] = SA;
      out32_Q12 = ((out32_Q12) + ((int)((short)(SA))) * (int)((short)(Btmp)));
      out32_Q12 = ((out32_Q12) + ((int)((short)(SB))) * ((Btmp) >> 16));
      SA = S[idx + 1];
      S[idx + 1] = SB;
    }
    Btmp = B_align_Q12[Order_half - 1];
    SB = S[Order - 1];
    S[Order - 1] = SA;
    out32_Q12 = ((out32_Q12) + ((int)((short)(SA))) * (int)((short)(Btmp)));
    out32_Q12 = ((out32_Q12) + ((int)((short)(SB))) * ((Btmp) >> 16));
    out32_Q12 = (((((((int)in[k]) << (12))) - (out32_Q12)) & 0x80000000) == 0
                     ? ((((((int)in[k]) << (12))) & ((out32_Q12) ^ 0x80000000) &
                         0x80000000)
                            ? ((int)0x80000000)
                            : ((((int)in[k]) << (12))) - (out32_Q12))
                     : (((((((int)in[k]) << (12))) ^ 0x80000000) &
                         (out32_Q12)&0x80000000)
                            ? 0x7FFFFFFF
                            : ((((int)in[k]) << (12))) - (out32_Q12)));
    out32 = ((12) == 1 ? ((out32_Q12) >> 1) + ((out32_Q12)&1)
                       : (((out32_Q12) >> ((12) - 1)) + 1) >> 1);
    out[k] =
        (short)((out32) > 0x7FFF
                    ? 0x7FFF
                    : ((out32) < ((short)0x8000) ? ((short)0x8000) : (out32)));
    S[0] = in[k];
  }
}


x86 assembly (clang, -O0):
<SKP_Silk_LPC_analysis_filter>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x28(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1180 <SKP_Silk_LPC_analysis_filter+0x80>
mov    -0x2c(%rbp),%eax
cwtl
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
and    $0xffff,%ecx
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movswl (%rax,%rdx,2),%eax
shl    $0x10,%eax
or     %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    112c <SKP_Silk_LPC_analysis_filter+0x2c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1404 <SKP_Silk_LPC_analysis_filter+0x304>
mov    -0x18(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x6a(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1257 <SKP_Silk_LPC_analysis_filter+0x157>
mov    -0x30(%rbp),%eax
cwtl
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movslq -0x30(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x6c(%rbp)
mov    -0x6a(%rbp),%dx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x64(%rbp),%eax
movswl -0x6a(%rbp),%ecx
mov    -0x3c(%rbp),%edx
movswl %dx,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
movswl -0x6c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sar    $0x10,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x6a(%rbp)
mov    -0x6c(%rbp),%dx
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ac <SKP_Silk_LPC_analysis_filter+0xac>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x60(%rbp,%rax,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x6c(%rbp)
mov    -0x6a(%rbp),%dx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x64(%rbp),%eax
movswl -0x6a(%rbp),%ecx
mov    -0x3c(%rbp),%edx
movswl %dx,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
movswl -0x6c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sar    $0x10,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0xc,%eax
sub    -0x64(%rbp),%eax
and    $0x80000000,%eax
cmp    $0x0,%eax
jne    132f <SKP_Silk_LPC_analysis_filter+0x22f>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0xc,%eax
mov    -0x64(%rbp),%ecx
xor    $0x80000000,%ecx
and    %ecx,%eax
and    $0x80000000,%eax
cmp    $0x0,%eax
je     130f <SKP_Silk_LPC_analysis_filter+0x20f>
mov    $0x80000000,%eax
mov    %eax,-0x70(%rbp)
jmp    1324 <SKP_Silk_LPC_analysis_filter+0x224>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0xc,%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    137c <SKP_Silk_LPC_analysis_filter+0x27c>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0xc,%eax
xor    $0x80000000,%eax
and    -0x64(%rbp),%eax
and    $0x80000000,%eax
cmp    $0x0,%eax
je     1361 <SKP_Silk_LPC_analysis_filter+0x261>
mov    $0x7fffffff,%eax
mov    %eax,-0x78(%rbp)
jmp    1376 <SKP_Silk_LPC_analysis_filter+0x276>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0xc,%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
sar    $0xb,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x7fff,-0x68(%rbp)
jle    13ab <SKP_Silk_LPC_analysis_filter+0x2ab>
mov    $0x7fff,%eax
mov    %eax,-0x7c(%rbp)
jmp    13d1 <SKP_Silk_LPC_analysis_filter+0x2d1>
cmpl   $0xffff8000,-0x68(%rbp)
jge    13c5 <SKP_Silk_LPC_analysis_filter+0x2c5>
mov    $0xffff8000,%eax
mov    %eax,-0x80(%rbp)
jmp    13cb <SKP_Silk_LPC_analysis_filter+0x2cb>
mov    -0x68(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%cx
mov    -0x18(%rbp),%rax
mov    %cx,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1187 <SKP_Silk_LPC_analysis_filter+0x87>
pop    %rbp
ret

x86 assembly (clang, -O2):
<SKP_Silk_LPC_analysis_filter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,-0x8(%rsp)
mov    %rdi,-0x10(%rsp)
mov    %r9d,%r10d
sar    %r10d
mov    %r9,-0x40(%rsp)
cmp    $0x2,%r9d
jl     12a6 <SKP_Silk_LPC_analysis_filter+0x1a6>
cmp    $0x2,%r10d
mov    $0x1,%r11d
cmovge %r10d,%r11d
cmp    $0x4,%r11d
jae    11e6 <SKP_Silk_LPC_analysis_filter+0xe6>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r11b
je     1176 <SKP_Silk_LPC_analysis_filter+0x76>
movswl %ax,%ebp
lea    0x0(%rbp,%rbp,1),%ebx
movslq %ebx,%rbx
movzwl (%rsi,%rbx,2),%ebx
add    %ebp,%ebp
add    $0x1,%ebp
movslq %ebp,%rbp
movzwl (%rsi,%rbp,2),%ebp
shl    $0x10,%ebp
or     %ebx,%ebp
mov    %ebp,-0x38(%rsp,%rax,4)
or     $0x1,%rax
add    %r11,%rcx
je     12a6 <SKP_Silk_LPC_analysis_filter+0x1a6>
mov    %eax,%ecx
shl    $0x10,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ecx,%ebp
sar    $0xf,%ebp
movslq %ebp,%rbp
movzwl (%rsi,%rbp,2),%ebx
or     $0x1,%ebp
movslq %ebp,%rbp
movzwl (%rsi,%rbp,2),%ebp
shl    $0x10,%ebp
or     %ebx,%ebp
mov    %ebp,-0x38(%rsp,%rax,4)
lea    0x10000(%rcx),%ebp
sar    $0xf,%ebp
movslq %ebp,%rbp
movzwl (%rsi,%rbp,2),%ebx
or     $0x1,%ebp
movslq %ebp,%rbp
movzwl (%rsi,%rbp,2),%ebp
shl    $0x10,%ebp
or     %ebx,%ebp
mov    %ebp,-0x34(%rsp,%rax,4)
add    $0x2,%rax
add    $0x20000,%ecx
cmp    %rax,%r11
jne    1190 <SKP_Silk_LPC_analysis_filter+0x90>
jmp    12a6 <SKP_Silk_LPC_analysis_filter+0x1a6>
lea    -0x1(%r11),%rcx
mov    %ecx,%ebp
and    $0x1ffff,%ebp
add    %ebp,%ebp
mov    %ebp,%ebx
shl    $0xf,%ebx
xor    %eax,%eax
sar    $0xf,%ebx
js     1143 <SKP_Silk_LPC_analysis_filter+0x43>
shr    $0x11,%ebp
test   %bpl,%bpl
jne    1143 <SKP_Silk_LPC_analysis_filter+0x43>
cmp    $0x1ffff,%rcx
ja     1143 <SKP_Silk_LPC_analysis_filter+0x43>
mov    %r11d,%eax
and    $0x7ffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     13ff <SKP_Silk_LPC_analysis_filter+0x2ff>
mov    %r9,%r14
and    $0xfffffffffffffffe,%r14
mov    $0x40000,%ebx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
lea    -0x40000(%rbx),%ecx
sar    $0xf,%ecx
movslq %ecx,%rcx
movups (%rsi,%rcx,2),%xmm0
movaps %xmm0,-0x38(%rsp,%rbp,4)
mov    %ebx,%ecx
sar    $0xf,%ecx
movslq %ecx,%rcx
movups (%rsi,%rcx,2),%xmm0
movaps %xmm0,-0x28(%rsp,%rbp,4)
add    $0x8,%rbp
add    $0x80000,%ebx
add    $0xfffffffffffffffe,%r14
jne    1250 <SKP_Silk_LPC_analysis_filter+0x150>
test   $0x1,%r9b
je     129d <SKP_Silk_LPC_analysis_filter+0x19d>
movswl %bp,%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
movups (%rsi,%rcx,2),%xmm0
movaps %xmm0,-0x38(%rsp,%rbp,4)
cmp    %r11,%rax
jne    1143 <SKP_Silk_LPC_analysis_filter+0x43>
test   %r8d,%r8d
jle    13f4 <SKP_Silk_LPC_analysis_filter+0x2f4>
movslq %r10d,%rax
add    $0xffffffff,%r10d
mov    -0x3c(%rsp,%rax,4),%r13d
mov    -0x40(%rsp),%rax
add    $0xffffffff,%eax
movslq %eax,%r11
movswl %r13w,%eax
mov    %eax,-0x44(%rsp)
sar    $0x10,%r13d
cmp    $0x2,%r10d
mov    $0x1,%ebx
cmovge %r10d,%ebx
mov    %r8d,%eax
mov    %rax,-0x18(%rsp)
movzwl (%rdx),%ebp
shl    $0x10,%rbx
xor    %r8d,%r8d
jmp    138a <SKP_Silk_LPC_analysis_filter+0x28a>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
movswl (%rdx,%r11,2),%esi
imul   %r13d,%esi
mov    %bp,(%rdx,%r11,2)
movswl %bp,%edi
imul   -0x44(%rsp),%edi
add    %ecx,%edi
add    %esi,%edi
mov    -0x10(%rsp),%r9
movswl (%r9,%r8,2),%ecx
shl    $0xc,%ecx
mov    %ecx,%esi
sub    %edi,%esi
mov    %ecx,%ebp
cmovns %edi,%ebp
cmovs  %edi,%ecx
mov    $0x7ffff800,%edi
mov    $0x80000000,%eax
cmovns %eax,%edi
not    %ebp
test   %ebp,%ecx
cmovns %esi,%edi
sar    $0xb,%edi
add    $0x1,%edi
sar    %edi
cmp    $0xffff8001,%edi
mov    $0xffff8000,%eax
cmovl  %eax,%edi
cmp    $0x7fff,%edi
mov    $0x7fff,%eax
cmovge %eax,%edi
mov    -0x8(%rsp),%rcx
mov    %di,(%rcx,%r8,2)
movzwl (%r9,%r8,2),%ebp
mov    %bp,(%rdx)
add    $0x1,%r8
cmp    -0x18(%rsp),%r8
je     13f4 <SKP_Silk_LPC_analysis_filter+0x2f4>
cmpl   $0x4,-0x40(%rsp)
jl     1300 <SKP_Silk_LPC_analysis_filter+0x200>
xor    %r10d,%r10d
lea    -0x38(%rsp),%r14
xor    %r9d,%r9d
mov    %r10d,%r12d
sar    $0xf,%r12d
movslq %r12d,%r15
or     $0x1,%r12d
mov    (%r14),%ecx
movslq %r12d,%rsi
movswl (%rdx,%rsi,2),%edi
mov    %bp,(%rdx,%rsi,2)
movswl %bp,%esi
movswl %cx,%ebp
imul   %esi,%ebp
add    %r9d,%ebp
sar    $0x10,%ecx
imul   %edi,%ecx
add    %ebp,%ecx
movzwl 0x4(%rdx,%r15,2),%ebp
mov    %di,0x4(%rdx,%r15,2)
add    $0x10000,%r10
add    $0x4,%r14
mov    %ecx,%r9d
cmp    %r10,%rbx
jne    13a0 <SKP_Silk_LPC_analysis_filter+0x2a0>
jmp    1302 <SKP_Silk_LPC_analysis_filter+0x202>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
test   $0x1,%r9b
jne    128c <SKP_Silk_LPC_analysis_filter+0x18c>
jmp    129d <SKP_Silk_LPC_analysis_filter+0x19d>

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

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