#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int out_tmp;

/* Variables and functions */
int /*<<< orphan*/ SKP_Silk_allpass_int(int *, int *, short const, int *, int);
int /*<<< orphan*/ SKP_Silk_lowpass_int(int *, int *, int *, int);
int SKP_min_int(int, int);
void SKP_Silk_resample_3_1(short *out, int *S, const short *in,
                           const int inLen) {
  int k, LSubFrameIn, LSubFrameOut;
  int out_tmp, idx, inLenTmp = inLen;
  int scratch00[40];
  int scratch0[3 * 40];
  int scratch1[3 * 40];
  const short A30[2] = {1773, 17818};
  const short A31[2] = {4942, 25677};
  const short A32[2] = {11786, 29304};
  while (inLenTmp > 0) {
    LSubFrameIn = SKP_min_int(40, inLenTmp);
    LSubFrameOut = ((int)((short)(3)) * (int)((short)(LSubFrameIn)));
    for (k = 0; k < LSubFrameIn; k++) {
      scratch00[k] = (((int)in[k]) << (10));
    }
    SKP_Silk_allpass_int(scratch00, S + 1, A30[0], scratch1, LSubFrameIn);
    SKP_Silk_allpass_int(scratch1, S + 2, A30[1], scratch0, LSubFrameIn);
    SKP_Silk_allpass_int(scratch00, S + 3, A31[0], scratch1, LSubFrameIn);
    SKP_Silk_allpass_int(scratch1, S + 4, A31[1], scratch0 + 40, LSubFrameIn);
    SKP_Silk_allpass_int(scratch00, S + 5, A32[0], scratch1, LSubFrameIn);
    SKP_Silk_allpass_int(scratch1, S + 6, A32[1], scratch0 + 2 * 40,
                         LSubFrameIn);
    for (k = 0; k < LSubFrameIn; k++) {
      idx = ((int)((short)(3)) * (int)((short)(k)));
      scratch1[idx] = scratch0[k];
      scratch1[idx + 1] = scratch0[k + 40];
      scratch1[idx + 2] = scratch0[k + 2 * 40];
    }
    SKP_Silk_lowpass_int(scratch1, S, scratch0, LSubFrameOut);
    for (k = 0; k < LSubFrameOut; k++) {
      out_tmp = scratch0[k];
      out[k] =
          (short)((((10) == 1 ? ((out_tmp) >> 1) + ((out_tmp)&1)
                              : (((out_tmp) >> ((10) - 1)) + 1) >> 1)) > 0x7FFF
                      ? 0x7FFF
                      : ((((10) == 1 ? ((out_tmp) >> 1) + ((out_tmp)&1)
                                     : (((out_tmp) >> ((10) - 1)) + 1) >> 1)) <
                                 ((short)0x8000)
                             ? ((short)0x8000)
                             : (((10) == 1
                                     ? ((out_tmp) >> 1) + ((out_tmp)&1)
                                     : (((out_tmp) >> ((10) - 1)) + 1) >> 1))));
    }
    in += LSubFrameIn;
    inLenTmp -= LSubFrameIn;
    out += LSubFrameOut;
  }
}


x86 assembly (clang, -O0):
<SKP_Silk_resample_3_1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4c0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0xeaa(%rip),%eax
mov    %eax,-0x4a4(%rbp)
mov    0xea2(%rip),%eax
mov    %eax,-0x4a8(%rbp)
mov    0xe9a(%rip),%eax
mov    %eax,-0x4ac(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    1458 <SKP_Silk_resample_3_1+0x328>
mov    -0x34(%rbp),%esi
mov    $0x28,%edi
call   1030 <SKP_min_int@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cwtl
imul   $0x3,%eax,%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11d3 <SKP_Silk_resample_3_1+0xa3>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
shl    $0xa,%ecx
movslq -0x20(%rbp),%rax
mov    %ecx,-0xe0(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    119f <SKP_Silk_resample_3_1+0x6f>
lea    -0xe0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x4,%rsi
mov    -0x4a4(%rbp),%ax
lea    -0x4a0(%rbp),%rcx
mov    -0x24(%rbp),%r8d
movswl %ax,%edx
call   1050 <SKP_Silk_allpass_int@plt>
lea    -0x4a0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
mov    -0x4a2(%rbp),%ax
lea    -0x2c0(%rbp),%rcx
mov    -0x24(%rbp),%r8d
movswl %ax,%edx
call   1050 <SKP_Silk_allpass_int@plt>
lea    -0xe0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0xc,%rsi
mov    -0x4a8(%rbp),%ax
lea    -0x4a0(%rbp),%rcx
mov    -0x24(%rbp),%r8d
movswl %ax,%edx
call   1050 <SKP_Silk_allpass_int@plt>
lea    -0x4a0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x10,%rsi
mov    -0x4a6(%rbp),%ax
lea    -0x2c0(%rbp),%rcx
add    $0xa0,%rcx
mov    -0x24(%rbp),%r8d
movswl %ax,%edx
call   1050 <SKP_Silk_allpass_int@plt>
lea    -0xe0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x14,%rsi
mov    -0x4ac(%rbp),%ax
lea    -0x4a0(%rbp),%rcx
mov    -0x24(%rbp),%r8d
movswl %ax,%edx
call   1050 <SKP_Silk_allpass_int@plt>
lea    -0x4a0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x18,%rsi
mov    -0x4aa(%rbp),%ax
lea    -0x2c0(%rbp),%rcx
add    $0x140,%rcx
mov    -0x24(%rbp),%r8d
movswl %ax,%edx
call   1050 <SKP_Silk_allpass_int@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1354 <SKP_Silk_resample_3_1+0x224>
mov    -0x20(%rbp),%eax
cwtl
imul   $0x3,%eax,%eax
mov    %eax,-0x30(%rbp)
movslq -0x20(%rbp),%rax
mov    -0x2c0(%rbp,%rax,4),%ecx
movslq -0x30(%rbp),%rax
mov    %ecx,-0x4a0(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x28,%eax
cltq
mov    -0x2c0(%rbp,%rax,4),%ecx
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x4a0(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x50,%eax
cltq
mov    -0x2c0(%rbp,%rax,4),%ecx
mov    -0x30(%rbp),%eax
add    $0x2,%eax
cltq
mov    %ecx,-0x4a0(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12de <SKP_Silk_resample_3_1+0x1ae>
lea    -0x4a0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0x2c0(%rbp),%rdx
mov    -0x28(%rbp),%ecx
call   1040 <SKP_Silk_lowpass_int@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    141e <SKP_Silk_resample_3_1+0x2ee>
movslq -0x20(%rbp),%rax
mov    -0x2c0(%rbp,%rax,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sar    $0x9,%eax
add    $0x1,%eax
sar    $0x1,%eax
cmp    $0x7fff,%eax
jle    13b6 <SKP_Silk_resample_3_1+0x286>
mov    $0x7fff,%eax
mov    %eax,-0x4b0(%rbp)
jmp    13fb <SKP_Silk_resample_3_1+0x2cb>
mov    -0x2c(%rbp),%eax
sar    $0x9,%eax
add    $0x1,%eax
sar    $0x1,%eax
cmp    $0xffff8000,%eax
jge    13dd <SKP_Silk_resample_3_1+0x2ad>
mov    $0xffff8000,%eax
mov    %eax,-0x4b4(%rbp)
jmp    13ef <SKP_Silk_resample_3_1+0x2bf>
mov    -0x2c(%rbp),%eax
sar    $0x9,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x4b4(%rbp)
mov    -0x4b4(%rbp),%eax
mov    %eax,-0x4b0(%rbp)
mov    -0x4b0(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1375 <SKP_Silk_resample_3_1+0x245>
mov    -0x24(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x34(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    1174 <SKP_Silk_resample_3_1+0x44>
add    $0x4c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SKP_Silk_resample_3_1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4a8,%rsp
mov    %rsi,0x38(%rsp)
test   %ecx,%ecx
jle    17a3 <SKP_Silk_resample_3_1+0x673>
mov    %rdx,%rbx
mov    %rdi,%r13
mov    0x38(%rsp),%rax
lea    0x4(%rax),%rdx
mov    %rdx,0x30(%rsp)
lea    0x8(%rax),%rdx
mov    %rdx,0x28(%rsp)
lea    0xc(%rax),%rdx
mov    %rdx,0x20(%rsp)
lea    0x10(%rax),%rdx
mov    %rdx,0x18(%rsp)
lea    0x14(%rax),%rdx
mov    %rdx,0x10(%rsp)
add    $0x18,%rax
mov    %rax,0x8(%rsp)
jmp    11bc <SKP_Silk_resample_3_1+0x8c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r14d,%rax
lea    (%rbx,%rax,2),%rbx
movslq %r12d,%rax
lea    0x0(%r13,%rax,2),%r13
mov    0x4(%rsp),%ecx
sub    %r14d,%ecx
jle    17a3 <SKP_Silk_resample_3_1+0x673>
mov    $0x28,%edi
mov    %ecx,0x4(%rsp)
mov    %ecx,%esi
call   1030 <SKP_min_int@plt>
mov    %eax,%r14d
shl    $0x10,%eax
mov    %eax,(%rsp)
test   %r14d,%r14d
jle    11f0 <SKP_Silk_resample_3_1+0xc0>
mov    %r14d,%ebp
cmp    $0x8,%r14d
jae    12b0 <SKP_Silk_resample_3_1+0x180>
xor    %eax,%eax
jmp    1390 <SKP_Silk_resample_3_1+0x260>
xchg   %ax,%ax
lea    0x40(%rsp),%r15
mov    %r15,%rdi
mov    0x30(%rsp),%rsi
mov    $0x6ed,%edx
lea    0x2c0(%rsp),%rbp
mov    %rbp,%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %rbp,%rdi
mov    0x28(%rsp),%rsi
mov    $0x459a,%edx
lea    0xe0(%rsp),%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %r15,%rdi
mov    0x20(%rsp),%rsi
mov    $0x134e,%edx
mov    %rbp,%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %rbp,%rdi
mov    0x18(%rsp),%rsi
mov    $0x644d,%edx
lea    0x180(%rsp),%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %r15,%rdi
mov    0x10(%rsp),%rsi
mov    $0x2e0a,%edx
mov    %rbp,%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %rbp,%rdi
mov    0x8(%rsp),%rsi
mov    $0x7278,%edx
lea    0x220(%rsp),%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
jmp    14b4 <SKP_Silk_resample_3_1+0x384>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1793 <SKP_Silk_resample_3_1+0x663>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movq   (%rbx,%rcx,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x8(%rbx,%rcx,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
psrad  $0x10,%xmm1
pslld  $0xa,%xmm0
pslld  $0xa,%xmm1
movdqa %xmm0,0x40(%rsp,%rcx,4)
movdqa %xmm1,0x50(%rsp,%rcx,4)
movq   0x10(%rbx,%rcx,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x18(%rbx,%rcx,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
psrad  $0x10,%xmm1
pslld  $0xa,%xmm0
pslld  $0xa,%xmm1
movdqa %xmm0,0x60(%rsp,%rcx,4)
movdqa %xmm1,0x70(%rsp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    12e0 <SKP_Silk_resample_3_1+0x1b0>
test   $0x1,%dl
je     1389 <SKP_Silk_resample_3_1+0x259>
movq   (%rbx,%rcx,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x8(%rbx,%rcx,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
psrad  $0x10,%xmm1
pslld  $0xa,%xmm0
pslld  $0xa,%xmm1
movdqa %xmm0,0x40(%rsp,%rcx,4)
movdqa %xmm1,0x50(%rsp,%rcx,4)
cmp    %rbp,%rax
je     13a4 <SKP_Silk_resample_3_1+0x274>
xchg   %ax,%ax
movswl (%rbx,%rax,2),%ecx
shl    $0xa,%ecx
mov    %ecx,0x40(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1390 <SKP_Silk_resample_3_1+0x260>
lea    0x40(%rsp),%r12
mov    %r12,%rdi
mov    0x30(%rsp),%rsi
mov    $0x6ed,%edx
lea    0x2c0(%rsp),%r15
mov    %r15,%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %r15,%rdi
mov    0x28(%rsp),%rsi
mov    $0x459a,%edx
lea    0xe0(%rsp),%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %r12,%rdi
mov    0x20(%rsp),%rsi
mov    $0x134e,%edx
mov    %r15,%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %r15,%rdi
mov    0x18(%rsp),%rsi
mov    $0x644d,%edx
lea    0x180(%rsp),%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %r12,%rdi
mov    0x10(%rsp),%rsi
mov    $0x2e0a,%edx
mov    %r15,%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
mov    %r15,%rdi
mov    0x8(%rsp),%rsi
mov    $0x7278,%edx
lea    0x220(%rsp),%rcx
mov    %r14d,%r8d
call   1050 <SKP_Silk_allpass_int@plt>
test   %r14d,%r14d
jle    14b4 <SKP_Silk_resample_3_1+0x384>
cmp    $0x4,%r14d
jae    1647 <SKP_Silk_resample_3_1+0x517>
xor    %eax,%eax
mov    %eax,%ecx
shl    $0x10,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    %ecx,%edx
sar    $0x10,%edx
lea    (%rdx,%rdx,2),%edx
movslq %edx,%rdx
mov    0xe0(%rsp,%rax,4),%esi
mov    0x180(%rsp,%rax,4),%edi
mov    %esi,0x2c0(%rsp,%rdx,4)
mov    %edi,0x2c4(%rsp,%rdx,4)
mov    0x220(%rsp,%rax,4),%esi
mov    %esi,0x2c8(%rsp,%rdx,4)
add    $0x1,%rax
add    $0x10000,%ecx
cmp    %rax,%rbp
jne    1470 <SKP_Silk_resample_3_1+0x340>
movswl %r14w,%eax
lea    (%rax,%rax,2),%r12d
lea    0x2c0(%rsp),%rdi
mov    0x38(%rsp),%rsi
lea    0xe0(%rsp),%rdx
mov    %r12d,%ecx
call   1040 <SKP_Silk_lowpass_int@plt>
cmpl   $0x0,(%rsp)
pcmpeqd %xmm8,%xmm8
movdqa 0xb16(%rip),%xmm6
movdqa 0xb1e(%rip),%xmm7
movdqa 0xb26(%rip),%xmm5
mov    $0x8000,%edi
mov    $0x7fff,%ebp
jle    11a0 <SKP_Silk_resample_3_1+0x70>
cmp    $0x2,%r12d
mov    $0x1,%eax
cmovge %r12d,%eax
cmp    $0x8,%eax
jae    1530 <SKP_Silk_resample_3_1+0x400>
xor    %ecx,%ecx
jmp    1610 <SKP_Silk_resample_3_1+0x4e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %eax,%ecx
and    $0x7ffffff8,%ecx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqa 0xe0(%rsp,%rdx,4),%xmm0
movdqa 0xf0(%rsp,%rdx,4),%xmm1
movdqa %xmm0,%xmm3
psrad  $0x9,%xmm3
movdqa %xmm1,%xmm2
psrad  $0x9,%xmm2
psubd  %xmm8,%xmm3
psubd  %xmm8,%xmm2
psrad  $0x1,%xmm3
psrad  $0x1,%xmm2
pcmpgtd %xmm6,%xmm0
packssdw %xmm0,%xmm0
pcmpgtd %xmm6,%xmm1
packssdw %xmm1,%xmm1
movdqa %xmm3,%xmm4
pcmpgtd %xmm7,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm7,%xmm4
por    %xmm3,%xmm4
movdqa %xmm2,%xmm3
pcmpgtd %xmm7,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm7,%xmm3
por    %xmm2,%xmm3
pshuflw $0xe8,%xmm4,%xmm2
pshufhw $0xe8,%xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshuflw $0xe8,%xmm3,%xmm3
pshufhw $0xe8,%xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm3
movdqa %xmm0,%xmm4
pandn  %xmm2,%xmm4
pand   %xmm5,%xmm0
por    %xmm4,%xmm0
movdqa %xmm1,%xmm2
pandn  %xmm3,%xmm2
pand   %xmm5,%xmm1
por    %xmm2,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x0(%r13,%rdx,2)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1540 <SKP_Silk_resample_3_1+0x410>
cmp    %rax,%rcx
je     11a0 <SKP_Silk_resample_3_1+0x70>
nop
mov    0xe0(%rsp,%rcx,4),%edx
mov    %edx,%esi
sar    $0x9,%esi
add    $0x1,%esi
sar    %esi
cmp    $0xffff8001,%esi
cmovl  %edi,%esi
cmp    $0x1fffe00,%edx
cmovge %ebp,%esi
mov    %si,0x0(%r13,%rcx,2)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1610 <SKP_Silk_resample_3_1+0x4e0>
jmp    11a0 <SKP_Silk_resample_3_1+0x70>
lea    -0x1(%rbp),%rcx
mov    %ecx,%eax
mov    $0x3,%edx
mul    %edx
mov    %eax,%esi
seto   %dil
mov    %rcx,%rax
mov    $0xc,%edx
mul    %rdx
seto   %dl
test   %esi,%esi
js     145f <SKP_Silk_resample_3_1+0x32f>
test   %dil,%dil
jne    145f <SKP_Silk_resample_3_1+0x32f>
cmp    $0x7fff,%rcx
ja     145f <SKP_Silk_resample_3_1+0x32f>
lea    0x2c4(%rsp),%rsi
lea    (%rsi,%rax,1),%rcx
cmp    %rsi,%rcx
jb     145f <SKP_Silk_resample_3_1+0x32f>
test   %dl,%dl
jne    145f <SKP_Silk_resample_3_1+0x32f>
lea    0x2c8(%rsp),%rsi
lea    (%rsi,%rax,1),%rcx
cmp    %rsi,%rcx
jb     145f <SKP_Silk_resample_3_1+0x32f>
test   %dl,%dl
jne    145f <SKP_Silk_resample_3_1+0x32f>
add    %rsp,%rax
add    $0x2c0,%rax
lea    0x2c0(%rsp),%rcx
cmp    %rcx,%rax
jb     145f <SKP_Silk_resample_3_1+0x32f>
mov    $0x0,%eax
test   %dl,%dl
jne    1461 <SKP_Silk_resample_3_1+0x331>
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rbp,%rcx
shl    $0x10,%rcx
and    $0xfffffffffffc0000,%rcx
xor    %edx,%edx
lea    0xe0(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edx,%edi
sar    $0x10,%edi
lea    (%rdi,%rdi,2),%edi
movaps (%rsi),%xmm0
movaps 0xa0(%rsi),%xmm1
movaps 0x140(%rsi),%xmm2
or     $0x2,%edi
movslq %edi,%rdi
movaps %xmm2,%xmm3
shufps $0xd4,%xmm0,%xmm3
movaps %xmm0,%xmm4
unpcklps %xmm1,%xmm4
shufps $0x84,%xmm3,%xmm4
movaps %xmm0,%xmm3
unpckhpd %xmm1,%xmm3
movaps %xmm2,%xmm5
shufps $0x11,%xmm1,%xmm5
shufps $0x82,%xmm3,%xmm5
shufps $0xff,%xmm2,%xmm1
unpckhps %xmm0,%xmm2
shufps $0x8c,%xmm1,%xmm2
movups %xmm2,0x2d8(%rsp,%rdi,4)
movups %xmm5,0x2c8(%rsp,%rdi,4)
movups %xmm4,0x2b8(%rsp,%rdi,4)
add    $0x10,%rsi
add    $0x40000,%rdx
cmp    %rdx,%rcx
jne    1710 <SKP_Silk_resample_3_1+0x5e0>
cmp    %rbp,%rax
jne    1461 <SKP_Silk_resample_3_1+0x331>
jmp    14b4 <SKP_Silk_resample_3_1+0x384>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1356 <SKP_Silk_resample_3_1+0x226>
jmp    1389 <SKP_Silk_resample_3_1+0x259>
add    $0x4a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.SKP_Silk_resample_3_1.A30 = [2 x i16] [i16 1773, i16 17818]
@__const.SKP_Silk_resample_3_1.A31 = [2 x i16] [i16 4942, i16 25677]
@__const.SKP_Silk_resample_3_1.A32 = [2 x i16] [i16 11786, i16 29304]
define void @SKP_Silk_resample_3_1(i16* %0, i32* %1, i16* %2, i32 %3) {
%5 = alloca i16*
%6 = alloca i32*
%7 = alloca i16*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca [40 x i32]
%16 = alloca [120 x i32]
%17 = alloca [120 x i32]
%18 = alloca [2 x i16]
%19 = alloca [2 x i16]
%20 = alloca [2 x i16]
store i16* %0, i16** %5
store i32* %1, i32** %6
store i16* %2, i16** %7
store i32 %3, i32* %8
%21 = load i32, i32* %8
store i32 %21, i32* %14
%22 = bitcast [2 x i16]* %18 to i8*
%23 = bitcast [2 x i16]* %19 to i8*
%24 = bitcast [2 x i16]* %20 to i8*
br label %25
25: ; preds = %186, %4
%26 = load i32, i32* %14
%27 = icmp sgt i32 %26, 0
br i1 %27, label %28, label %198
28: ; preds = %25
%29 = load i32, i32* %14
%30 = call i32 @SKP_min_int(i32 40, i32 %29)
store i32 %30, i32* %10
%31 = load i32, i32* %10
%32 = trunc i32 %31 to i16
%33 = sext i16 %32 to i32
%34 = mul nsw i32 3, %33
store i32 %34, i32* %11
store i32 0, i32* %9
br label %35
35: ; preds = %50, %28
%36 = load i32, i32* %9
%37 = load i32, i32* %10
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %53
39: ; preds = %35
%40 = load i16*, i16** %7
%41 = load i32, i32* %9
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i16, i16* %40, i64 %42
%44 = load i16, i16* %43
%45 = sext i16 %44 to i32
%46 = shl i32 %45, 10
%47 = load i32, i32* %9
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [40 x i32], [40 x i32]* %15, i64 0, i64 %48
store i32 %46, i32* %49
br label %50
50: ; preds = %39
%51 = load i32, i32* %9
%52 = add nsw i32 %51, 1
store i32 %52, i32* %9
br label %35
53: ; preds = %35
%54 = getelementptr inbounds [40 x i32], [40 x i32]* %15, i64 0, i64 0
%55 = load i32*, i32** %6
%56 = getelementptr inbounds i32, i32* %55, i64 1
%57 = getelementptr inbounds [2 x i16], [2 x i16]* %18, i64 0, i64 0
%58 = load i16, i16* %57
%59 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 0
%60 = load i32, i32* %10
%61 = call i32 @SKP_Silk_allpass_int(i32* %54, i32* %56, i16 signext %58, i32* %59, i32 %60)
%62 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 0
%63 = load i32*, i32** %6
%64 = getelementptr inbounds i32, i32* %63, i64 2
%65 = getelementptr inbounds [2 x i16], [2 x i16]* %18, i64 0, i64 1
%66 = load i16, i16* %65
%67 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 0
%68 = load i32, i32* %10
%69 = call i32 @SKP_Silk_allpass_int(i32* %62, i32* %64, i16 signext %66, i32* %67, i32 %68)
%70 = getelementptr inbounds [40 x i32], [40 x i32]* %15, i64 0, i64 0
%71 = load i32*, i32** %6
%72 = getelementptr inbounds i32, i32* %71, i64 3
%73 = getelementptr inbounds [2 x i16], [2 x i16]* %19, i64 0, i64 0
%74 = load i16, i16* %73
%75 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 0
%76 = load i32, i32* %10
%77 = call i32 @SKP_Silk_allpass_int(i32* %70, i32* %72, i16 signext %74, i32* %75, i32 %76)
%78 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 0
%79 = load i32*, i32** %6
%80 = getelementptr inbounds i32, i32* %79, i64 4
%81 = getelementptr inbounds [2 x i16], [2 x i16]* %19, i64 0, i64 1
%82 = load i16, i16* %81
%83 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 0
%84 = getelementptr inbounds i32, i32* %83, i64 40
%85 = load i32, i32* %10
%86 = call i32 @SKP_Silk_allpass_int(i32* %78, i32* %80, i16 signext %82, i32* %84, i32 %85)
%87 = getelementptr inbounds [40 x i32], [40 x i32]* %15, i64 0, i64 0
%88 = load i32*, i32** %6
%89 = getelementptr inbounds i32, i32* %88, i64 5
%90 = getelementptr inbounds [2 x i16], [2 x i16]* %20, i64 0, i64 0
%91 = load i16, i16* %90
%92 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 0
%93 = load i32, i32* %10
%94 = call i32 @SKP_Silk_allpass_int(i32* %87, i32* %89, i16 signext %91, i32* %92, i32 %93)
%95 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 0
%96 = load i32*, i32** %6
%97 = getelementptr inbounds i32, i32* %96, i64 6
%98 = getelementptr inbounds [2 x i16], [2 x i16]* %20, i64 0, i64 1
%99 = load i16, i16* %98
%100 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 0
%101 = getelementptr inbounds i32, i32* %100, i64 80
%102 = load i32, i32* %10
%103 = call i32 @SKP_Silk_allpass_int(i32* %95, i32* %97, i16 signext %99, i32* %101, i32 %102)
store i32 0, i32* %9
br label %104
104: ; preds = %138, %53
%105 = load i32, i32* %9
%106 = load i32, i32* %10
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %141
108: ; preds = %104
%109 = load i32, i32* %9
%110 = trunc i32 %109 to i16
%111 = sext i16 %110 to i32
%112 = mul nsw i32 3, %111
store i32 %112, i32* %13
%113 = load i32, i32* %9
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 %114
%116 = load i32, i32* %115
%117 = load i32, i32* %13
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 %118
store i32 %116, i32* %119
%120 = load i32, i32* %9
%121 = add nsw i32 %120, 40
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 %122
%124 = load i32, i32* %123
%125 = load i32, i32* %13
%126 = add nsw i32 %125, 1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 %127
store i32 %124, i32* %128
%129 = load i32, i32* %9
%130 = add nsw i32 %129, 80
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 %131
%133 = load i32, i32* %132
%134 = load i32, i32* %13
%135 = add nsw i32 %134, 2
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 %136
store i32 %133, i32* %137
br label %138
138: ; preds = %108
%139 = load i32, i32* %9
%140 = add nsw i32 %139, 1
store i32 %140, i32* %9
br label %104
141: ; preds = %104
%142 = getelementptr inbounds [120 x i32], [120 x i32]* %17, i64 0, i64 0
%143 = load i32*, i32** %6
%144 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 0
%145 = load i32, i32* %11
%146 = call i32 @SKP_Silk_lowpass_int(i32* %142, i32* %143, i32* %144, i32 %145)
store i32 0, i32* %9
br label %147
147: ; preds = %183, %141
%148 = load i32, i32* %9
%149 = load i32, i32* %11
%150 = icmp slt i32 %148, %149
br i1 %150, label %151, label %186
151: ; preds = %147
%152 = load i32, i32* %9
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [120 x i32], [120 x i32]* %16, i64 0, i64 %153
%155 = load i32, i32* %154
store i32 %155, i32* %12
%156 = load i32, i32* %12
%157 = ashr i32 %156, 9
%158 = add nsw i32 %157, 1
%159 = ashr i32 %158, 1
%160 = icmp sgt i32 %159, 32767
br i1 %160, label %161, label %162
161: ; preds = %151
br label %176
162: ; preds = %151
%163 = load i32, i32* %12
%164 = ashr i32 %163, 9
%165 = add nsw i32 %164, 1
%166 = ashr i32 %165, 1
%167 = icmp slt i32 %166, -32768
br i1 %167, label %168, label %169
168: ; preds = %162
br label %174
169: ; preds = %162
%170 = load i32, i32* %12
%171 = ashr i32 %170, 9
%172 = add nsw i32 %171, 1
%173 = ashr i32 %172, 1
br label %174
174: ; preds = %169, %168
%175 = phi i32 [ -32768, %168 ], [ %173, %169 ]
br label %176
176: ; preds = %174, %161
%177 = phi i32 [ 32767, %161 ], [ %175, %174 ]
%178 = trunc i32 %177 to i16
%179 = load i16*, i16** %5
%180 = load i32, i32* %9
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i16, i16* %179, i64 %181
store i16 %178, i16* %182
br label %183
183: ; preds = %176
%184 = load i32, i32* %9
%185 = add nsw i32 %184, 1
store i32 %185, i32* %9
br label %147
186: ; preds = %147
%187 = load i32, i32* %10
%188 = load i16*, i16** %7
%189 = sext i32 %187 to i64
%190 = getelementptr inbounds i16, i16* %188, i64 %189
store i16* %190, i16** %7
%191 = load i32, i32* %10
%192 = load i32, i32* %14
%193 = sub nsw i32 %192, %191
store i32 %193, i32* %14
%194 = load i32, i32* %11
%195 = load i16*, i16** %5
%196 = sext i32 %194 to i64
%197 = getelementptr inbounds i16, i16* %195, i64 %196
store i16* %197, i16** %5
br label %25
198: ; preds = %25
ret void
}

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