void SKP_Silk_LPC_synthesis_filter(const short *in, const short *A_Q12,
                                   const int Gain_Q26, int *S, short *out,
                                   const int len, const int Order) {
  int k, j, idx, Order_half = ((Order) >> (1));
  int SA, SB, Atmp, A_align_Q12[16 >> 1], out32_Q10, out32;
  ;
  for (k = 0; k < Order_half; k++) {
    idx = ((int)((short)(2)) * (int)((short)(k)));
    A_align_Q12[k] =
        (((int)A_Q12[idx]) & 0x0000ffff) | (((int)A_Q12[idx + 1]) << (16));
  }
  for (k = 0; k < len; k++) {
    SA = S[Order - 1];
    out32_Q10 = 0;
    for (j = 0; j < (Order_half - 1); j++) {
      idx = ((int)((short)(2)) * (int)((short)(j))) + 1;
      Atmp = A_align_Q12[j];
      SB = S[Order - 1 - idx];
      S[Order - 1 - idx] = SA;
      out32_Q10 =
          ((out32_Q10) + ((((SA) >> 16) * (int)((short)(Atmp))) +
                          ((((SA)&0x0000FFFF) * (int)((short)(Atmp))) >> 16)));
      out32_Q10 = ((out32_Q10) + (((SB) >> 16) * ((Atmp) >> 16)) +
                   ((((SB)&0x0000FFFF) * ((Atmp) >> 16)) >> 16));
      SA = S[Order - 2 - idx];
      S[Order - 2 - idx] = SB;
    }
    Atmp = A_align_Q12[Order_half - 1];
    SB = S[0];
    S[0] = SA;
    out32_Q10 =
        ((out32_Q10) + ((((SA) >> 16) * (int)((short)(Atmp))) +
                        ((((SA)&0x0000FFFF) * (int)((short)(Atmp))) >> 16)));
    out32_Q10 = ((out32_Q10) + (((SB) >> 16) * ((Atmp) >> 16)) +
                 ((((SB)&0x0000FFFF) * ((Atmp) >> 16)) >> 16));
    out32_Q10 =
        ((((out32_Q10) +
           (((((Gain_Q26) >> 16) * (int)((short)(in[k]))) +
             ((((Gain_Q26)&0x0000FFFF) * (int)((short)(in[k]))) >> 16)))) &
          0x80000000) == 0
             ? ((((out32_Q10) &
                  (((((Gain_Q26) >> 16) * (int)((short)(in[k]))) +
                    ((((Gain_Q26)&0x0000FFFF) * (int)((short)(in[k]))) >>
                     16)))) &
                 0x80000000) != 0
                    ? ((int)0x80000000)
                    : (out32_Q10) +
                          (((((Gain_Q26) >> 16) * (int)((short)(in[k]))) +
                            ((((Gain_Q26)&0x0000FFFF) *
                              (int)((short)(in[k]))) >>
                             16))))
             : ((((out32_Q10) |
                  (((((Gain_Q26) >> 16) * (int)((short)(in[k]))) +
                    ((((Gain_Q26)&0x0000FFFF) * (int)((short)(in[k]))) >>
                     16)))) &
                 0x80000000) == 0
                    ? 0x7FFFFFFF
                    : (out32_Q10) +
                          (((((Gain_Q26) >> 16) * (int)((short)(in[k]))) +
                            ((((Gain_Q26)&0x0000FFFF) *
                              (int)((short)(in[k]))) >>
                             16)))));
    out32 = ((10) == 1 ? ((out32_Q10) >> 1) + ((out32_Q10)&1)
                       : (((out32_Q10) >> ((10) - 1)) + 1) >> 1);
    out[k] =
        (short)((out32) > 0x7FFF
                    ? 0x7FFF
                    : ((out32) < ((short)0x8000) ? ((short)0x8000) : (out32)));
    S[Order - 1] =
        (((((((((int)0x80000000)) >> ((4)))) > (((0x7FFFFFFF) >> ((4))))
                ? (((out32_Q10)) > (((((int)0x80000000)) >> ((4))))
                       ? (((((int)0x80000000)) >> ((4))))
                       : (((out32_Q10)) < (((0x7FFFFFFF) >> ((4))))
                              ? (((0x7FFFFFFF) >> ((4))))
                              : ((out32_Q10))))
                : (((out32_Q10)) > (((0x7FFFFFFF) >> ((4))))
                       ? (((0x7FFFFFFF) >> ((4))))
                       : (((out32_Q10)) < (((((int)0x80000000)) >> ((4))))
                              ? (((((int)0x80000000)) >> ((4))))
                              : ((out32_Q10))))))
          << ((4))));
  }
}


x86 assembly (clang, -O0):
<SKP_Silk_LPC_synthesis_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1186 <SKP_Silk_LPC_synthesis_filter+0x86>
mov    -0x30(%rbp),%eax
cwtl
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
and    $0xffff,%ecx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movswl (%rax,%rdx,2),%eax
shl    $0x10,%eax
or     %eax,%ecx
movslq -0x30(%rbp),%rax
mov    %ecx,-0x70(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1132 <SKP_Silk_LPC_synthesis_filter+0x32>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1588 <SKP_Silk_LPC_synthesis_filter+0x488>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12a5 <SKP_Silk_LPC_synthesis_filter+0x1a5>
mov    -0x34(%rbp),%eax
cwtl
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movslq -0x34(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
mov    -0x40(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x48(%rbp),%edx
movswl %dx,%edx
imul   %edx,%ecx
mov    -0x40(%rbp),%edx
and    $0xffff,%edx
mov    -0x48(%rbp),%esi
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x44(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x48(%rbp),%edx
sar    $0x10,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x44(%rbp),%ecx
and    $0xffff,%ecx
mov    -0x48(%rbp),%edx
sar    $0x10,%edx
imul   %edx,%ecx
sar    $0x10,%ecx
add    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ba <SKP_Silk_LPC_synthesis_filter+0xba>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x70(%rbp,%rax,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x74(%rbp),%eax
mov    -0x40(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x48(%rbp),%edx
movswl %dx,%edx
imul   %edx,%ecx
mov    -0x40(%rbp),%edx
and    $0xffff,%edx
mov    -0x48(%rbp),%esi
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x44(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x48(%rbp),%edx
sar    $0x10,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x44(%rbp),%ecx
and    $0xffff,%ecx
mov    -0x48(%rbp),%edx
sar    $0x10,%edx
imul   %edx,%ecx
sar    $0x10,%ecx
add    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x8(%rbp),%rdx
movslq -0x30(%rbp),%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
and    $0xffff,%edx
mov    -0x8(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
and    $0x80000000,%eax
cmp    $0x0,%eax
jne    13fe <SKP_Silk_LPC_synthesis_filter+0x2fe>
mov    -0x74(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x8(%rbp),%rdx
movslq -0x30(%rbp),%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
and    $0xffff,%edx
mov    -0x8(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
and    %ecx,%eax
and    $0x80000000,%eax
cmp    $0x0,%eax
je     13b9 <SKP_Silk_LPC_synthesis_filter+0x2b9>
mov    $0x80000000,%eax
mov    %eax,-0x7c(%rbp)
jmp    13f3 <SKP_Silk_LPC_synthesis_filter+0x2f3>
mov    -0x74(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x8(%rbp),%rdx
movslq -0x30(%rbp),%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
and    $0xffff,%edx
mov    -0x8(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    1499 <SKP_Silk_LPC_synthesis_filter+0x399>
mov    -0x74(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x8(%rbp),%rdx
movslq -0x30(%rbp),%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
and    $0xffff,%edx
mov    -0x8(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
or     %ecx,%eax
and    $0x80000000,%eax
cmp    $0x0,%eax
jne    1453 <SKP_Silk_LPC_synthesis_filter+0x353>
mov    $0x7fffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    1490 <SKP_Silk_LPC_synthesis_filter+0x390>
mov    -0x74(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x8(%rbp),%rdx
movslq -0x30(%rbp),%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
and    $0xffff,%edx
mov    -0x8(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
sar    $0x9,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x78(%rbp)
cmpl   $0x7fff,-0x78(%rbp)
jle    14cb <SKP_Silk_LPC_synthesis_filter+0x3cb>
mov    $0x7fff,%eax
mov    %eax,-0x88(%rbp)
jmp    14fd <SKP_Silk_LPC_synthesis_filter+0x3fd>
cmpl   $0xffff8000,-0x78(%rbp)
jge    14e8 <SKP_Silk_LPC_synthesis_filter+0x3e8>
mov    $0xffff8000,%eax
mov    %eax,-0x8c(%rbp)
jmp    14f1 <SKP_Silk_LPC_synthesis_filter+0x3f1>
mov    -0x78(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
cmpl   $0x7ffffff,-0x74(%rbp)
jle    152f <SKP_Silk_LPC_synthesis_filter+0x42f>
mov    $0x7ffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    1561 <SKP_Silk_LPC_synthesis_filter+0x461>
cmpl   $0xf8000000,-0x74(%rbp)
jge    154c <SKP_Silk_LPC_synthesis_filter+0x44c>
mov    $0xf8000000,%eax
mov    %eax,-0x94(%rbp)
jmp    1555 <SKP_Silk_LPC_synthesis_filter+0x455>
mov    -0x74(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%edx
shl    $0x4,%edx
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118d <SKP_Silk_LPC_synthesis_filter+0x8d>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SKP_Silk_LPC_synthesis_filter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,-0x10(%rsp)
mov    %rdi,-0x18(%rsp)
mov    0x38(%rsp),%eax
mov    %eax,%r11d
sar    %r11d
cmp    $0x2,%eax
jl     12a4 <SKP_Silk_LPC_synthesis_filter+0x1a4>
cmp    $0x2,%r11d
mov    $0x1,%r10d
cmovge %r11d,%r10d
cmp    $0x4,%r10d
jae    11e2 <SKP_Silk_LPC_synthesis_filter+0xe2>
xor    %ebx,%ebx
mov    %rbx,%rax
not    %rax
test   $0x1,%r10b
je     1173 <SKP_Silk_LPC_synthesis_filter+0x73>
movswl %bx,%edi
lea    (%rdi,%rdi,1),%ebp
movslq %ebp,%rbp
movzwl (%rsi,%rbp,2),%ebp
add    %edi,%edi
add    $0x1,%edi
movslq %edi,%rdi
movzwl (%rsi,%rdi,2),%edi
shl    $0x10,%edi
or     %ebp,%edi
mov    %edi,-0x48(%rsp,%rbx,4)
or     $0x1,%rbx
add    %r10,%rax
je     12a4 <SKP_Silk_LPC_synthesis_filter+0x1a4>
mov    %ebx,%edi
shl    $0x10,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edi,%eax
sar    $0xf,%eax
cltq
movzwl (%rsi,%rax,2),%ebp
or     $0x1,%eax
cltq
movzwl (%rsi,%rax,2),%eax
shl    $0x10,%eax
or     %ebp,%eax
mov    %eax,-0x48(%rsp,%rbx,4)
lea    0x10000(%rdi),%eax
sar    $0xf,%eax
cltq
movzwl (%rsi,%rax,2),%ebp
or     $0x1,%eax
cltq
movzwl (%rsi,%rax,2),%eax
shl    $0x10,%eax
or     %ebp,%eax
mov    %eax,-0x44(%rsp,%rbx,4)
add    $0x2,%rbx
add    $0x20000,%edi
cmp    %rbx,%r10
jne    1190 <SKP_Silk_LPC_synthesis_filter+0x90>
jmp    12a4 <SKP_Silk_LPC_synthesis_filter+0x1a4>
lea    -0x1(%r10),%rax
mov    %eax,%edi
and    $0x1ffff,%edi
add    %edi,%edi
mov    %edi,%ebp
shl    $0xf,%ebp
xor    %ebx,%ebx
sar    $0xf,%ebp
js     1141 <SKP_Silk_LPC_synthesis_filter+0x41>
shr    $0x11,%edi
test   %dil,%dil
jne    1141 <SKP_Silk_LPC_synthesis_filter+0x41>
cmp    $0x1ffff,%rax
ja     1141 <SKP_Silk_LPC_synthesis_filter+0x41>
mov    %r10d,%ebx
and    $0x7ffffffc,%ebx
lea    -0x4(%rbx),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     14a1 <SKP_Silk_LPC_synthesis_filter+0x3a1>
mov    %r8,%r14
and    $0xfffffffffffffffe,%r14
mov    $0x40000,%eax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    -0x40000(%rax),%edi
sar    $0xf,%edi
movslq %edi,%rdi
movups (%rsi,%rdi,2),%xmm0
movaps %xmm0,-0x48(%rsp,%rbp,4)
mov    %eax,%edi
sar    $0xf,%edi
movslq %edi,%rdi
movups (%rsi,%rdi,2),%xmm0
movaps %xmm0,-0x38(%rsp,%rbp,4)
add    $0x8,%rbp
add    $0x80000,%eax
add    $0xfffffffffffffffe,%r14
jne    1250 <SKP_Silk_LPC_synthesis_filter+0x150>
test   $0x1,%r8b
je     129b <SKP_Silk_LPC_synthesis_filter+0x19b>
movswl %bp,%eax
add    %eax,%eax
cltq
movups (%rsi,%rax,2),%xmm0
movaps %xmm0,-0x48(%rsp,%rbp,4)
cmp    %r10,%rbx
jne    1141 <SKP_Silk_LPC_synthesis_filter+0x41>
test   %r9d,%r9d
jle    1496 <SKP_Silk_LPC_synthesis_filter+0x396>
mov    0x38(%rsp),%eax
movslq %eax,%rdi
lea    -0x1(%rdi),%rsi
lea    -0x2(%rax),%r14d
movslq %r11d,%rbp
add    $0xffffffff,%r11d
mov    -0x4c(%rsp,%rbp,4),%ebp
movswl %bp,%eax
mov    %eax,-0x50(%rsp)
sar    $0x10,%ebp
mov    %ebp,-0x4c(%rsp)
mov    %edx,%eax
sar    $0x10,%eax
mov    %eax,-0x54(%rsp)
cmp    $0x2,%r11d
mov    $0x1,%ebp
cmovge %r11d,%ebp
movzwl %dx,%eax
mov    %eax,-0x58(%rsp)
mov    %r9d,%eax
mov    %rax,-0x20(%rsp)
mov    -0x4(%rcx,%rdi,4),%r8d
shl    $0x10,%rbp
xor    %eax,%eax
jmp    1382 <SKP_Silk_LPC_synthesis_filter+0x282>
nopw   0x0(%rax,%rax,1)
or     %ebx,%edi
mov    $0x7fffffff,%edx
cmovns %edx,%r8d
mov    %r8d,%edx
sar    $0x9,%edx
add    $0x1,%edx
sar    %edx
cmp    $0xffff8001,%edx
mov    $0xffff8000,%edi
cmovl  %edi,%edx
cmp    $0x7fff,%edx
mov    $0x7fff,%edi
cmovge %edi,%edx
cmp    $0xf8000001,%r8d
mov    $0xf8000000,%edi
cmovl  %edi,%r8d
mov    -0x10(%rsp),%rdi
mov    %dx,(%rdi,%rax,2)
cmp    $0x7ffffff,%r8d
mov    $0x7ffffff,%edx
cmovge %edx,%r8d
shl    $0x4,%r8d
mov    %r8d,(%rcx,%rsi,4)
add    $0x1,%rax
cmp    -0x20(%rsp),%rax
je     1496 <SKP_Silk_LPC_synthesis_filter+0x396>
mov    0x38(%rsp),%edx
cmp    $0x4,%edx
mov    %rax,-0x8(%rsp)
jl     1420 <SKP_Silk_LPC_synthesis_filter+0x320>
xor    %edi,%edi
lea    -0x48(%rsp),%r13
xor    %r10d,%r10d
xchg   %ax,%ax
mov    %edi,%r12d
sar    $0xf,%r12d
or     $0x1,%r12d
mov    0x0(%r13),%r9d
mov    %esi,%ebx
sub    %r12d,%ebx
movslq %ebx,%rbx
mov    (%rcx,%rbx,4),%r11d
mov    %r8d,(%rcx,%rbx,4)
movzwl %r8w,%ebx
sar    $0x10,%r8d
movswl %r9w,%r15d
imul   %r15d,%r8d
add    %r10d,%r8d
imul   %r15d,%ebx
sar    $0x10,%ebx
mov    %r11d,%edx
sar    $0x10,%edx
sar    $0x10,%r9d
imul   %r9d,%edx
add    %r8d,%edx
add    %ebx,%edx
movzwl %r11w,%r10d
imul   %r9d,%r10d
sar    $0x10,%r10d
add    %edx,%r10d
mov    %r14d,%edx
sub    %r12d,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%r8d
mov    %r11d,(%rcx,%rdx,4)
add    $0x10000,%rdi
add    $0x4,%r13
cmp    %rdi,%rbp
jne    13a0 <SKP_Silk_LPC_synthesis_filter+0x2a0>
jmp    1423 <SKP_Silk_LPC_synthesis_filter+0x323>
xchg   %ax,%ax
xor    %r10d,%r10d
mov    (%rcx),%edx
mov    %r8d,(%rcx)
movzwl %r8w,%ebx
sar    $0x10,%r8d
mov    -0x50(%rsp),%eax
imul   %eax,%r8d
add    %r10d,%r8d
imul   %eax,%ebx
sar    $0x10,%ebx
movzwl %dx,%edi
sar    $0x10,%edx
mov    -0x4c(%rsp),%eax
imul   %eax,%edx
add    %r8d,%edx
add    %ebx,%edx
imul   %eax,%edi
sar    $0x10,%edi
add    %edx,%edi
mov    -0x18(%rsp),%rdx
mov    -0x8(%rsp),%rax
movswl (%rdx,%rax,2),%ebx
mov    -0x54(%rsp),%edx
imul   %ebx,%edx
imul   -0x58(%rsp),%ebx
sar    $0x10,%ebx
add    %edx,%ebx
mov    %edi,%r8d
add    %ebx,%r8d
js     1310 <SKP_Silk_LPC_synthesis_filter+0x210>
test   %ebx,%edi
mov    $0x80000000,%edx
cmovs  %edx,%r8d
jmp    131b <SKP_Silk_LPC_synthesis_filter+0x21b>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
test   $0x1,%r8b
jne    128b <SKP_Silk_LPC_synthesis_filter+0x18b>
jmp    129b <SKP_Silk_LPC_synthesis_filter+0x19b>

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

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