void SKP_Silk_decode_short_term_prediction(int *vec_Q10, int *pres_Q10,
                                           int *sLPC_Q14, short *A_Q12_tmp,
                                           int LPC_order, int subfr_length) {
  int i;
  int LPC_pred_Q10;
  int j;
  for (i = 0; i < subfr_length; i++) {
    LPC_pred_Q10 =
        ((((sLPC_Q14[16 + i - 1]) >> 16) * (int)((short)(A_Q12_tmp[0]))) +
         ((((sLPC_Q14[16 + i - 1]) & 0x0000FFFF) *
           (int)((short)(A_Q12_tmp[0]))) >>
          16));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 2]) >> 16) * (int)((short)(A_Q12_tmp[1]))) +
          ((((sLPC_Q14[16 + i - 2]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[1]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 3]) >> 16) * (int)((short)(A_Q12_tmp[2]))) +
          ((((sLPC_Q14[16 + i - 3]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[2]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 4]) >> 16) * (int)((short)(A_Q12_tmp[3]))) +
          ((((sLPC_Q14[16 + i - 4]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[3]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 5]) >> 16) * (int)((short)(A_Q12_tmp[4]))) +
          ((((sLPC_Q14[16 + i - 5]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[4]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 6]) >> 16) * (int)((short)(A_Q12_tmp[5]))) +
          ((((sLPC_Q14[16 + i - 6]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[5]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 7]) >> 16) * (int)((short)(A_Q12_tmp[6]))) +
          ((((sLPC_Q14[16 + i - 7]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[6]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 8]) >> 16) * (int)((short)(A_Q12_tmp[7]))) +
          ((((sLPC_Q14[16 + i - 8]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[7]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 9]) >> 16) * (int)((short)(A_Q12_tmp[8]))) +
          ((((sLPC_Q14[16 + i - 9]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[8]))) >>
           16)));
    LPC_pred_Q10 =
        ((LPC_pred_Q10) +
         ((((sLPC_Q14[16 + i - 10]) >> 16) * (int)((short)(A_Q12_tmp[9]))) +
          ((((sLPC_Q14[16 + i - 10]) & 0x0000FFFF) *
            (int)((short)(A_Q12_tmp[9]))) >>
           16)));
    for (j = 10; j < LPC_order; j++) {
      LPC_pred_Q10 =
          ((LPC_pred_Q10) + ((((sLPC_Q14[16 + i - j - 1]) >> 16) *
                              (int)((short)(A_Q12_tmp[j]))) +
                             ((((sLPC_Q14[16 + i - j - 1]) & 0x0000FFFF) *
                               (int)((short)(A_Q12_tmp[j]))) >>
                              16)));
    }
    vec_Q10[i] = ((pres_Q10[i]) + (LPC_pred_Q10));
    sLPC_Q14[16 + i] = ((vec_Q10[i]) << (4));
  }
}


x86 assembly (clang, -O0):
<SKP_Silk_decode_short_term_prediction>:
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)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1522 <SKP_Silk_decode_short_term_prediction+0x422>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x10,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sar    $0x10,%eax
mov    -0x20(%rbp),%rcx
movswl (%rcx),%ecx
imul   %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
and    $0xffff,%ecx
mov    -0x20(%rbp),%rdx
movswl (%rdx),%edx
imul   %edx,%ecx
sar    $0x10,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x2,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0x2(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x2,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0x2(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x3,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0x4(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x3,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0x4(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x4,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0x6(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x4,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0x6(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x5,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0x8(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x5,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0x8(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x6,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0xa(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x6,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0xa(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x7,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0xc(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x7,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0xc(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x8,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0xe(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x8,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0xe(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0x9,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0x10(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0x9,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0x10(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    $0xa,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movswl 0x12(%rdx),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    $0xa,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movswl 0x12(%rsi),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
movl   $0xa,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14dd <SKP_Silk_decode_short_term_prediction+0x3dd>
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x10,%edx
sub    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x10,%ecx
mov    -0x20(%rbp),%rdx
movslq -0x34(%rbp),%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
mov    -0x18(%rbp),%rdx
mov    -0x2c(%rbp),%esi
add    $0x10,%esi
sub    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rsi
movslq -0x34(%rbp),%rdi
movswl (%rsi,%rdi,2),%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1463 <SKP_Silk_decode_short_term_prediction+0x363>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    -0x30(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x4,%edx
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1123 <SKP_Silk_decode_short_term_prediction+0x23>
pop    %rbp
ret

x86 assembly (clang, -O2):
<SKP_Silk_decode_short_term_prediction>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,-0x10(%rsp)
mov    %rdi,-0x8(%rsp)
test   %r9d,%r9d
jle    14b3 <SKP_Silk_decode_short_term_prediction+0x3b3>
movswl (%rcx),%eax
mov    %eax,-0x3c(%rsp)
movswl 0x2(%rcx),%eax
mov    %eax,-0x40(%rsp)
movswl 0x4(%rcx),%eax
mov    %eax,-0x44(%rsp)
movswl 0x6(%rcx),%eax
mov    %eax,-0x48(%rsp)
movswl 0x8(%rcx),%eax
mov    %eax,-0x4c(%rsp)
movswl 0xa(%rcx),%eax
mov    %eax,-0x50(%rsp)
movswl 0xc(%rcx),%eax
mov    %eax,-0x54(%rsp)
movswl 0xe(%rcx),%eax
mov    %eax,-0x58(%rsp)
movswl 0x10(%rcx),%eax
mov    %eax,-0x5c(%rsp)
movswl 0x12(%rcx),%eax
mov    %eax,-0x60(%rsp)
mov    %r9d,%eax
mov    %rax,-0x18(%rsp)
mov    %r8d,%r9d
lea    -0xa(%r9),%rax
mov    %rax,-0x38(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,%r13
neg    %r13
movdqa 0xe6d(%rip),%xmm8
mov    %rax,-0x20(%rsp)
add    $0xa,%rax
mov    %rax,-0x28(%rsp)
lea    0x8(%rdx),%r10
lea    0x1c(%rcx),%rax
mov    %rax,-0x30(%rsp)
lea    0x3c(%rdx),%r14
xor    %r11d,%r11d
jmp    11f1 <SKP_Silk_decode_short_term_prediction+0xf1>
nopw   0x0(%rax,%rax,1)
mov    -0x10(%rsp),%rax
add    (%rax,%r11,4),%ebx
mov    -0x8(%rsp),%rax
mov    %ebx,(%rax,%r11,4)
shl    $0x4,%ebx
mov    %esi,%eax
mov    %ebx,(%rdx,%rax,4)
add    $0x1,%r11
add    $0x4,%r10
add    $0x4,%r14
cmp    -0x18(%rsp),%r11
je     14b3 <SKP_Silk_decode_short_term_prediction+0x3b3>
mov    0x3c(%rdx,%r11,4),%eax
movzwl %ax,%ebx
sar    $0x10,%eax
mov    -0x3c(%rsp),%edi
imul   %edi,%eax
imul   %edi,%ebx
sar    $0x10,%ebx
add    %eax,%ebx
mov    0x38(%rdx,%r11,4),%eax
movzwl %ax,%ebp
sar    $0x10,%eax
mov    -0x40(%rsp),%edi
imul   %edi,%eax
add    %ebx,%eax
imul   %edi,%ebp
sar    $0x10,%ebp
add    %eax,%ebp
mov    0x34(%rdx,%r11,4),%eax
movzwl %ax,%ebx
sar    $0x10,%eax
mov    -0x44(%rsp),%edi
imul   %edi,%eax
add    %ebp,%eax
imul   %edi,%ebx
sar    $0x10,%ebx
add    %eax,%ebx
mov    0x30(%rdx,%r11,4),%eax
movzwl %ax,%ebp
sar    $0x10,%eax
mov    -0x48(%rsp),%edi
imul   %edi,%eax
add    %ebx,%eax
mov    0x2c(%rdx,%r11,4),%ebx
imul   %edi,%ebp
sar    $0x10,%ebp
add    %eax,%ebp
movzwl %bx,%eax
sar    $0x10,%ebx
mov    -0x4c(%rsp),%edi
imul   %edi,%ebx
add    %ebp,%ebx
imul   %edi,%eax
sar    $0x10,%eax
add    %ebx,%eax
lea    0xa(%r11),%ebx
mov    (%rdx,%rbx,4),%ebx
movzwl %bx,%ebp
sar    $0x10,%ebx
mov    -0x50(%rsp),%edi
imul   %edi,%ebx
add    %eax,%ebx
imul   %edi,%ebp
sar    $0x10,%ebp
add    %ebx,%ebp
lea    0x9(%r11),%eax
mov    (%rdx,%rax,4),%eax
movzwl %ax,%ebx
sar    $0x10,%eax
mov    -0x54(%rsp),%edi
imul   %edi,%eax
add    %ebp,%eax
imul   %edi,%ebx
sar    $0x10,%ebx
add    %eax,%ebx
lea    0x8(%r11),%eax
mov    (%rdx,%rax,4),%eax
movzwl %ax,%ebp
sar    $0x10,%eax
mov    -0x58(%rsp),%edi
imul   %edi,%eax
add    %ebx,%eax
imul   %edi,%ebp
sar    $0x10,%ebp
add    %eax,%ebp
lea    0x7(%r11),%eax
mov    (%rdx,%rax,4),%eax
movzwl %ax,%ebx
sar    $0x10,%eax
mov    -0x5c(%rsp),%edi
imul   %edi,%eax
add    %ebp,%eax
imul   %edi,%ebx
sar    $0x10,%ebx
add    %eax,%ebx
lea    0x6(%r11),%eax
mov    (%rdx,%rax,4),%eax
mov    %eax,%ebp
sar    $0x10,%ebp
mov    -0x60(%rsp),%edi
imul   %edi,%ebp
add    %ebx,%ebp
movzwl %ax,%ebx
imul   %edi,%ebx
sar    $0x10,%ebx
add    %ebp,%ebx
lea    0x10(%r11),%rsi
cmp    $0xb,%r8d
jl     11c0 <SKP_Silk_decode_short_term_prediction+0xc0>
mov    $0xa,%ebp
cmpq   $0x8,-0x38(%rsp)
jb     1468 <SKP_Silk_decode_short_term_prediction+0x368>
movd   %ebx,%xmm2
pxor   %xmm1,%xmm1
mov    -0x30(%rsp),%r15
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%r10,%r12,4),%xmm0
movdqu (%r10,%r12,4),%xmm3
pshufd $0x1b,%xmm3,%xmm7
pshufd $0x1b,%xmm0,%xmm4
movq   -0x8(%r15),%xmm6
movq   (%r15),%xmm10
punpcklwd %xmm6,%xmm0
psrad  $0x10,%xmm0
punpcklwd %xmm10,%xmm9
psrad  $0x10,%xmm9
movdqa %xmm7,%xmm3
psrad  $0x10,%xmm3
packssdw %xmm3,%xmm3
movdqa %xmm3,%xmm5
pmulhw %xmm6,%xmm5
pmullw %xmm6,%xmm3
punpcklwd %xmm5,%xmm3
paddd  %xmm2,%xmm3
movdqa %xmm4,%xmm6
psrad  $0x10,%xmm6
packssdw %xmm6,%xmm6
movdqa %xmm6,%xmm2
pmulhw %xmm10,%xmm2
pmullw %xmm10,%xmm6
punpcklwd %xmm2,%xmm6
paddd  %xmm1,%xmm6
pand   %xmm8,%xmm7
pand   %xmm8,%xmm4
pshufd $0xf5,%xmm7,%xmm1
pmuludq %xmm0,%xmm7
pshufd $0xe8,%xmm7,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm1,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm9,%xmm4
pshufd $0xe8,%xmm4,%xmm1
pshufd $0xf5,%xmm9,%xmm4
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm0
punpckldq %xmm0,%xmm1
psrad  $0x10,%xmm2
paddd  %xmm3,%xmm2
psrad  $0x10,%xmm1
paddd  %xmm6,%xmm1
add    $0xfffffffffffffff8,%r12
add    $0x10,%r15
cmp    %r12,%r13
jne    1350 <SKP_Silk_decode_short_term_prediction+0x250>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebx
mov    -0x28(%rsp),%rbp
mov    -0x20(%rsp),%rax
cmp    %rax,-0x38(%rsp)
je     11c0 <SKP_Silk_decode_short_term_prediction+0xc0>
lea    0x0(,%rbp,4),%rdi
mov    %r14,%rax
sub    %rdi,%rax
cs nopw 0x0(%rax,%rax,1)
mov    (%rax),%r15d
mov    %r15d,%edi
sar    $0x10,%edi
movswl (%rcx,%rbp,2),%r12d
imul   %r12d,%edi
add    %ebx,%edi
movzwl %r15w,%ebx
imul   %r12d,%ebx
sar    $0x10,%ebx
add    %edi,%ebx
add    $0x1,%rbp
add    $0xfffffffffffffffc,%rax
cmp    %rbp,%r9
jne    1480 <SKP_Silk_decode_short_term_prediction+0x380>
jmp    11c0 <SKP_Silk_decode_short_term_prediction+0xc0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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