#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 Ctmp2;
typedef int Ctmp1;

/* Variables and functions */
int SKP_Silk_CLZ32(int const);
int SKP_max_32(int, int);
void SKP_Silk_schur(short *rc_Q15, const int *c, const int order) {
  int k, n, lz;
  int C[16 + 1][2];
  int Ctmp1, Ctmp2, rc_tmp_Q15;
  lz = SKP_Silk_CLZ32(c[0]);
  if (lz < 2) {
    for (k = 0; k < order + 1; k++) {
      C[k][0] = C[k][1] = ((c[k]) >> (1));
    }
  } else if (lz > 2) {
    lz -= 2;
    for (k = 0; k < order + 1; k++) {
      C[k][0] = C[k][1] = ((c[k]) << (lz));
    }
  } else {
    for (k = 0; k < order + 1; k++) {
      C[k][0] = C[k][1] = c[k];
    }
  }
  for (k = 0; k < order; k++) {
    rc_tmp_Q15 = -((int)((C[k + 1][0]) / (SKP_max_32(((C[0][1]) >> (15)), 1))));
    rc_tmp_Q15 = ((rc_tmp_Q15) > 0x7FFF
                      ? 0x7FFF
                      : ((rc_tmp_Q15) < ((short)0x8000) ? ((short)0x8000)
                                                        : (rc_tmp_Q15)));
    rc_Q15[k] = (short)rc_tmp_Q15;
    for (n = 0; n < order - k; n++) {
      Ctmp1 = C[n + k + 1][0];
      Ctmp2 = C[n][1];
      C[n + k + 1][0] =
          ((Ctmp1) +
           ((((((Ctmp2) << (1))) >> 16) * (int)((short)(rc_tmp_Q15))) +
            ((((((Ctmp2) << (1))) & 0x0000FFFF) * (int)((short)(rc_tmp_Q15))) >>
             16)));
      C[n][1] =
          ((Ctmp2) +
           ((((((Ctmp1) << (1))) >> 16) * (int)((short)(rc_tmp_Q15))) +
            ((((((Ctmp1) << (1))) & 0x0000FFFF) * (int)((short)(rc_tmp_Q15))) >>
             16)));
    }
  }
}


x86 assembly (clang, -O0):
<SKP_Silk_schur>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%edi
call   1040 <SKP_Silk_CLZ32@plt>
mov    %eax,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    119d <SKP_Silk_schur+0x7d>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1198 <SKP_Silk_schur+0x78>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
sar    $0x1,%ecx
movslq -0x18(%rbp),%rax
mov    %ecx,-0xac(%rbp,%rax,8)
movslq -0x18(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1155 <SKP_Silk_schur+0x35>
jmp    1254 <SKP_Silk_schur+0x134>
cmpl   $0x2,-0x20(%rbp)
jle    1203 <SKP_Silk_schur+0xe3>
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    11fe <SKP_Silk_schur+0xde>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
movslq -0x18(%rbp),%rax
mov    %ecx,-0xac(%rbp,%rax,8)
movslq -0x18(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11b7 <SKP_Silk_schur+0x97>
jmp    124f <SKP_Silk_schur+0x12f>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    124a <SKP_Silk_schur+0x12a>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x18(%rbp),%rax
mov    %ecx,-0xac(%rbp,%rax,8)
movslq -0x18(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    120a <SKP_Silk_schur+0xea>
jmp    124f <SKP_Silk_schur+0x12f>
jmp    1254 <SKP_Silk_schur+0x134>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    141e <SKP_Silk_schur+0x2fe>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0xb0(%rbp,%rax,8),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xac(%rbp),%edi
sar    $0xf,%edi
mov    $0x1,%esi
call   1030 <SKP_max_32@plt>
mov    %eax,%ecx
mov    -0xc0(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xbc(%rbp)
cmpl   $0x7fff,-0xbc(%rbp)
jle    12c6 <SKP_Silk_schur+0x1a6>
mov    $0x7fff,%eax
mov    %eax,-0xc4(%rbp)
jmp    12fe <SKP_Silk_schur+0x1de>
cmpl   $0xffff8000,-0xbc(%rbp)
80 ff ff
jge    12e6 <SKP_Silk_schur+0x1c6>
mov    $0xffff8000,%eax
mov    %eax,-0xc8(%rbp)
jmp    12f2 <SKP_Silk_schur+0x1d2>
mov    -0xbc(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    140b <SKP_Silk_schur+0x2eb>
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0xb0(%rbp,%rax,8),%eax
mov    %eax,-0xb4(%rbp)
movslq -0x1c(%rbp),%rax
mov    -0xac(%rbp,%rax,8),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb4(%rbp),%ecx
mov    -0xb8(%rbp),%eax
shl    $0x1,%eax
sar    $0x10,%eax
mov    -0xbc(%rbp),%edx
movswl %dx,%edx
imul   %edx,%eax
mov    -0xb8(%rbp),%edx
shl    $0x1,%edx
and    $0xffff,%edx
mov    -0xbc(%rbp),%esi
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%eax
add    %eax,%ecx
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0xb0(%rbp,%rax,8)
mov    -0xb8(%rbp),%ecx
mov    -0xb4(%rbp),%eax
shl    $0x1,%eax
sar    $0x10,%eax
mov    -0xbc(%rbp),%edx
movswl %dx,%edx
imul   %edx,%eax
mov    -0xb4(%rbp),%edx
shl    $0x1,%edx
and    $0xffff,%edx
mov    -0xbc(%rbp),%esi
movswl %si,%esi
imul   %esi,%edx
sar    $0x10,%edx
add    %edx,%eax
add    %eax,%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0xac(%rbp,%rax,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1326 <SKP_Silk_schur+0x206>
jmp    1410 <SKP_Silk_schur+0x2f0>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    125b <SKP_Silk_schur+0x13b>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SKP_Silk_schur>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %edx,%r12d
mov    %rsi,%rbx
mov    %rdi,0x10(%rsp)
mov    (%rsi),%edi
call   1040 <SKP_Silk_CLZ32@plt>
cmp    $0x1,%eax
jg     1163 <SKP_Silk_schur+0x43>
test   %r12d,%r12d
js     1585 <SKP_Silk_schur+0x465>
lea    0x1(%r12),%eax
cmp    $0x3,%r12d
jae    11ab <SKP_Silk_schur+0x8b>
xor    %ecx,%ecx
jmp    1290 <SKP_Silk_schur+0x170>
mov    %eax,%ecx
cmp    $0x2,%eax
jne    1189 <SKP_Silk_schur+0x69>
test   %r12d,%r12d
js     1585 <SKP_Silk_schur+0x465>
lea    0x1(%r12),%eax
cmp    $0x3,%r12d
jae    12ab <SKP_Silk_schur+0x18b>
xor    %ecx,%ecx
jmp    1370 <SKP_Silk_schur+0x250>
test   %r12d,%r12d
js     1585 <SKP_Silk_schur+0x465>
add    $0xfffffffe,%ecx
lea    0x1(%r12),%eax
cmp    $0x3,%r12d
jae    1389 <SKP_Silk_schur+0x269>
xor    %edx,%edx
jmp    1470 <SKP_Silk_schur+0x350>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1597 <SKP_Silk_schur+0x477>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%rbx,%rdx,4),%xmm0
movq   0x8(%rbx,%rdx,4),%xmm1
psrad  $0x1,%xmm0
psrad  $0x1,%xmm1
pshufd $0x50,%xmm0,%xmm0
movdqa %xmm0,0x20(%rsp,%rdx,8)
pshufd $0x50,%xmm1,%xmm0
movdqa %xmm0,0x30(%rsp,%rdx,8)
movq   0x10(%rbx,%rdx,4),%xmm0
movq   0x18(%rbx,%rdx,4),%xmm1
psrad  $0x1,%xmm0
psrad  $0x1,%xmm1
pshufd $0x50,%xmm0,%xmm0
movdqa %xmm0,0x40(%rsp,%rdx,8)
pshufd $0x50,%xmm1,%xmm0
movdqa %xmm0,0x50(%rsp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    11e0 <SKP_Silk_schur+0xc0>
test   $0x1,%sil
je     127e <SKP_Silk_schur+0x15e>
movq   (%rbx,%rdx,4),%xmm0
movq   0x8(%rbx,%rdx,4),%xmm1
psrad  $0x1,%xmm0
psrad  $0x1,%xmm1
lea    0x0(,%rdx,8),%rsi
or     $0x10,%rsi
pshufd $0x50,%xmm0,%xmm0
movdqa %xmm0,0x20(%rsp,%rdx,8)
pshufd $0x50,%xmm1,%xmm0
movdqa %xmm0,0x20(%rsp,%rsi,1)
cmp    %rax,%rcx
je     1486 <SKP_Silk_schur+0x366>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edx
sar    %edx
mov    %edx,0x24(%rsp,%rcx,8)
mov    %edx,0x20(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1290 <SKP_Silk_schur+0x170>
jmp    1486 <SKP_Silk_schur+0x366>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     15a8 <SKP_Silk_schur+0x488>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%rbx,%rsi,4),%xmm0
movq   0x8(%rbx,%rsi,4),%xmm1
pshufd $0x50,%xmm0,%xmm0
movdqa %xmm0,0x20(%rsp,%rsi,8)
pshufd $0x50,%xmm1,%xmm0
movdqa %xmm0,0x30(%rsp,%rsi,8)
movq   0x10(%rbx,%rsi,4),%xmm0
movq   0x18(%rbx,%rsi,4),%xmm1
pshufd $0x50,%xmm0,%xmm0
movdqa %xmm0,0x40(%rsp,%rsi,8)
pshufd $0x50,%xmm1,%xmm0
movdqa %xmm0,0x50(%rsp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    12e0 <SKP_Silk_schur+0x1c0>
test   $0x1,%dl
je     135f <SKP_Silk_schur+0x23f>
movq   (%rbx,%rsi,4),%xmm0
movq   0x8(%rbx,%rsi,4),%xmm1
lea    0x0(,%rsi,8),%rdx
or     $0x10,%rdx
pshufd $0x50,%xmm0,%xmm0
movdqa %xmm0,0x20(%rsp,%rsi,8)
pshufd $0x50,%xmm1,%xmm0
movdqa %xmm0,0x20(%rsp,%rdx,1)
cmp    %rax,%rcx
je     1486 <SKP_Silk_schur+0x366>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edx
mov    %edx,0x24(%rsp,%rcx,8)
mov    %edx,0x20(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1370 <SKP_Silk_schur+0x250>
jmp    1486 <SKP_Silk_schur+0x366>
mov    %eax,%edx
and    $0xfffffffc,%edx
movd   %ecx,%xmm0
lea    -0x4(%rdx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     15b8 <SKP_Silk_schur+0x498>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xorps  %xmm1,%xmm1
movss  %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movq   (%rbx,%rsi,4),%xmm2
movq   0x8(%rbx,%rsi,4),%xmm3
pslld  %xmm1,%xmm2
pslld  %xmm1,%xmm3
pshufd $0x50,%xmm2,%xmm2
movdqa %xmm2,0x20(%rsp,%rsi,8)
pshufd $0x50,%xmm3,%xmm2
movdqa %xmm2,0x30(%rsp,%rsi,8)
movq   0x10(%rbx,%rsi,4),%xmm2
movq   0x18(%rbx,%rsi,4),%xmm3
pslld  %xmm1,%xmm2
pslld  %xmm1,%xmm3
pshufd $0x50,%xmm2,%xmm2
movdqa %xmm2,0x40(%rsp,%rsi,8)
pshufd $0x50,%xmm3,%xmm2
movdqa %xmm2,0x50(%rsp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    13c0 <SKP_Silk_schur+0x2a0>
test   $0x1,%r8b
je     1460 <SKP_Silk_schur+0x340>
movq   (%rbx,%rsi,4),%xmm1
movq   0x8(%rbx,%rsi,4),%xmm2
pxor   %xmm3,%xmm3
movss  %xmm0,%xmm3
pslld  %xmm3,%xmm1
pslld  %xmm3,%xmm2
lea    0x0(,%rsi,8),%rdi
or     $0x10,%rdi
pshufd $0x50,%xmm1,%xmm0
movdqa %xmm0,0x20(%rsp,%rsi,8)
pshufd $0x50,%xmm2,%xmm0
movdqa %xmm0,0x20(%rsp,%rdi,1)
cmp    %rax,%rdx
je     1486 <SKP_Silk_schur+0x366>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rdx,4),%esi
shl    %cl,%esi
mov    %esi,0x24(%rsp,%rdx,8)
mov    %esi,0x20(%rsp,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1470 <SKP_Silk_schur+0x350>
test   %r12d,%r12d
jle    1585 <SKP_Silk_schur+0x465>
mov    %r12d,%eax
mov    %rax,0x8(%rsp)
lea    0x20(%rsp),%rbx
xor    %r15d,%r15d
mov    %r12d,%r13d
jmp    14c8 <SKP_Silk_schur+0x3a8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffff,%r13d
add    $0x8,%rbx
mov    0x18(%rsp),%r15
cmp    0x8(%rsp),%r15
je     1585 <SKP_Silk_schur+0x465>
mov    %r13d,%r13d
lea    0x1(%r15),%rax
mov    %rax,0x18(%rsp)
mov    0x28(%rsp,%r15,8),%ebp
mov    0x24(%rsp),%r14d
mov    %r14d,%edi
sar    $0xf,%edi
mov    $0x1,%esi
call   1030 <SKP_max_32@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
neg    %eax
cmp    $0xffff8001,%eax
mov    $0xffff8000,%ecx
cmovl  %ecx,%eax
cmp    $0x7fff,%eax
mov    $0x7fff,%ecx
cmovge %ecx,%eax
mov    0x10(%rsp),%rcx
mov    %ax,(%rcx,%r15,2)
cmp    %r12d,%r15d
jge    14b0 <SKP_Silk_schur+0x390>
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rcx,8),%edx
lea    (%r14,%r14,1),%esi
mov    %r14d,%edi
shr    $0xf,%edi
movswl %di,%edi
imul   %eax,%edi
movzwl %si,%esi
imul   %eax,%esi
sar    $0x10,%esi
add    %edx,%edi
add    %esi,%edi
mov    %edi,(%rbx,%rcx,8)
lea    (%rdx,%rdx,1),%esi
shr    $0xf,%edx
movswl %dx,%edx
imul   %eax,%edx
movzwl %si,%esi
imul   %eax,%esi
sar    $0x10,%esi
add    %r14d,%edx
add    %esi,%edx
mov    %edx,0x1c(%rsp,%rcx,8)
cmp    %rcx,%r13
je     14b0 <SKP_Silk_schur+0x390>
mov    0x24(%rsp,%rcx,8),%r14d
add    $0x1,%rcx
jmp    1530 <SKP_Silk_schur+0x410>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1247 <SKP_Silk_schur+0x127>
jmp    127e <SKP_Silk_schur+0x15e>
xor    %esi,%esi
test   $0x1,%dl
jne    1332 <SKP_Silk_schur+0x212>
jmp    135f <SKP_Silk_schur+0x23f>
xor    %esi,%esi
test   $0x1,%r8b
jne    1423 <SKP_Silk_schur+0x303>
jmp    1460 <SKP_Silk_schur+0x340>

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

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