#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 uint8_t;
typedef int uint16_t;

/* Variables and functions */
int *malloc(int);
uint16_t get_keysizes(const void *ks_desc, uint16_t **list) {
  uint8_t type;
  uint16_t items;
  uint8_t i;
  type = *((uint8_t *)ks_desc);
  ks_desc = (uint8_t *)ks_desc + 1;
  if (type == 0x01) {
    items = *((uint8_t *)ks_desc);
    ks_desc = (uint8_t *)ks_desc + 1;
    if (!*list) {
      *list = malloc(items * 2);
      if (!*list) {
        return 0;
      }
    }
    for (i = 0; i < items; ++i) {
      ((uint16_t *)(*list))[i] = *((uint16_t *)ks_desc);
      ks_desc = (uint8_t *)ks_desc + 2;
    }
    return items;
  }
  if (type == 0x03) {
    uint16_t min, max, distance, offset;
    min = *((uint16_t *)ks_desc);
    ks_desc = (uint8_t *)ks_desc + 2;
    max = *((uint16_t *)ks_desc);
    ks_desc = (uint8_t *)ks_desc + 2;
    distance = *((uint16_t *)ks_desc);
    ks_desc = (uint8_t *)ks_desc + 2;
    offset = *((uint16_t *)ks_desc);
    items = (max - min) / distance + 1;
    if (min % distance != offset) {
      --items;
      min += (distance - (min % distance - offset)) % distance;
    }
    if (!*list) {
      *list = malloc(items * 2);
      if (!*list) {
        return 0;
      }
    }
    i = 0;
    while (min < max) {
      ((uint16_t *)*list)[i++] = min;
      min += distance;
    }
    return i;
  }
  if (type == 0x02) {
    uint16_t min, max, distance = 8, offset = 0;
    min = *((uint16_t *)ks_desc);
    ks_desc = (uint8_t *)ks_desc + 2;
    max = *((uint16_t *)ks_desc);
    items = (max - min) / distance + 1;
    if (min % distance != offset) {
      --items;
      min += (distance - (min % distance - offset)) % distance;
    }
    if (!*list) {
      *list = malloc(items * 2);
      if (!*list) {
        return 0;
      }
    }
    i = 0;
    while (min < max) {
      ((uint16_t *)*list)[i++] = min;
      min += distance;
    }
    return i;
  }
  return 0;
}


x86 assembly (clang, -O0):
<get_keysizes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jne    11e2 <get_keysizes+0xd2>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1196 <get_keysizes+0x86>
mov    -0x20(%rbp),%edi
shl    $0x1,%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1191 <get_keysizes+0x81>
movl   $0x0,-0x4(%rbp)
jmp    1413 <get_keysizes+0x303>
jmp    1196 <get_keysizes+0x86>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11d7 <get_keysizes+0xc7>
mov    -0x10(%rbp),%rax
mov    (%rax),%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    119d <get_keysizes+0x8d>
mov    -0x20(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1413 <get_keysizes+0x303>
cmpl   $0x3,-0x1c(%rbp)
jne    1305 <get_keysizes+0x1f5>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x28(%rbp),%eax
cltd
idivl  -0x30(%rbp)
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x30(%rbp)
cmp    -0x34(%rbp),%edx
je     127c <get_keysizes+0x16c>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
cltd
idivl  -0x30(%rbp)
mov    -0x48(%rbp),%eax
sub    -0x34(%rbp),%edx
sub    %edx,%eax
cltd
idivl  -0x30(%rbp)
add    -0x28(%rbp),%edx
mov    %edx,-0x28(%rbp)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    12be <get_keysizes+0x1ae>
mov    -0x20(%rbp),%edi
shl    $0x1,%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    12b9 <get_keysizes+0x1a9>
movl   $0x0,-0x4(%rbp)
jmp    1413 <get_keysizes+0x303>
jmp    12be <get_keysizes+0x1ae>
movl   $0x0,-0x24(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12fa <get_keysizes+0x1ea>
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    12c5 <get_keysizes+0x1b5>
mov    -0x24(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1413 <get_keysizes+0x303>
cmpl   $0x2,-0x1c(%rbp)
jne    140c <get_keysizes+0x2fc>
movl   $0x8,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x38(%rbp),%eax
cltd
idivl  -0x40(%rbp)
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
cltd
idivl  -0x40(%rbp)
cmp    -0x44(%rbp),%edx
je     1383 <get_keysizes+0x273>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x38(%rbp),%eax
cltd
idivl  -0x40(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x44(%rbp),%edx
sub    %edx,%eax
cltd
idivl  -0x40(%rbp)
add    -0x38(%rbp),%edx
mov    %edx,-0x38(%rbp)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    13c5 <get_keysizes+0x2b5>
mov    -0x20(%rbp),%edi
shl    $0x1,%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    13c0 <get_keysizes+0x2b0>
movl   $0x0,-0x4(%rbp)
jmp    1413 <get_keysizes+0x303>
jmp    13c5 <get_keysizes+0x2b5>
movl   $0x0,-0x24(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1401 <get_keysizes+0x2f1>
mov    -0x38(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    13cc <get_keysizes+0x2bc>
mov    -0x24(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1413 <get_keysizes+0x303>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_keysizes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r12
mov    %rdi,%rbx
mov    (%rdi),%eax
xor    %r14d,%r14d
cmp    $0x3,%eax
je     1195 <get_keysizes+0x85>
cmp    $0x2,%eax
je     11c4 <get_keysizes+0xb4>
cmp    $0x1,%eax
jne    163f <get_keysizes+0x52f>
mov    0x4(%rbx),%ebp
mov    (%r12),%rax
test   %rax,%rax
jne    115f <get_keysizes+0x4f>
lea    0x0(%rbp,%rbp,1),%edi
call   1030 <malloc@plt>
mov    %rax,(%r12)
test   %rax,%rax
je     163f <get_keysizes+0x52f>
test   %ebp,%ebp
jle    1448 <get_keysizes+0x338>
cmp    $0x9,%ebp
jb     118e <get_keysizes+0x7e>
lea    (%rbx,%rbp,8),%rcx
add    $0x4,%rcx
cmp    %rax,%rcx
jbe    1381 <get_keysizes+0x271>
lea    (%rax,%rbp,4),%rcx
lea    0x8(%rbx),%rdx
cmp    %rcx,%rdx
jae    1381 <get_keysizes+0x271>
xor    %ecx,%ecx
jmp    13d1 <get_keysizes+0x2c1>
mov    0x4(%rbx),%r15d
mov    0xc(%rbx),%r13d
mov    0x14(%rbx),%ebp
mov    0x1c(%rbx),%ecx
mov    %r13d,%eax
sub    %r15d,%eax
cltd
idiv   %ebp
mov    %eax,%edi
mov    %r15d,%eax
cltd
idiv   %ebp
cmp    %edx,%ecx
jne    1254 <get_keysizes+0x144>
add    $0x1,%edi
jmp    1263 <get_keysizes+0x153>
mov    0x4(%rbx),%r13d
lea    0x7(%r13),%eax
test   %r13d,%r13d
cmovns %r13d,%eax
and    $0xfffffff8,%eax
mov    %r13d,%ecx
sub    %eax,%ecx
mov    %ecx,%r15d
neg    %r15d
and    $0x7,%r15d
test   %ecx,%ecx
cmove  %ecx,%r15d
mov    0xc(%rbx),%ebx
lea    (%r15,%r13,1),%ebp
mov    (%r12),%rax
test   %rax,%rax
jne    1225 <get_keysizes+0x115>
mov    %ebx,%eax
sub    %r13d,%eax
lea    0x7(%rax),%edi
test   %eax,%eax
cmovns %eax,%edi
sar    $0x3,%edi
cmp    $0x1,%ecx
adc    $0x0,%edi
add    %edi,%edi
call   1030 <malloc@plt>
mov    %rax,(%r12)
test   %rax,%rax
je     163f <get_keysizes+0x52f>
cmp    %ebx,%ebp
jge    163f <get_keysizes+0x52f>
lea    (%r15,%r13,1),%ecx
add    $0x8,%ecx
cmp    %ecx,%ebx
cmovg  %ebx,%ecx
not    %r15d
add    %ecx,%r15d
sub    %r13d,%r15d
cmp    $0x38,%r15d
jae    133c <get_keysizes+0x22c>
xor    %r14d,%r14d
jmp    1630 <get_keysizes+0x520>
add    %ebp,%ecx
sub    %edx,%ecx
mov    %ecx,%eax
cltd
idiv   %ebp
add    %r15d,%edx
mov    %edx,%r15d
mov    (%r12),%rcx
test   %rcx,%rcx
je     1276 <get_keysizes+0x166>
cmp    %r13d,%r15d
jl     1296 <get_keysizes+0x186>
jmp    163f <get_keysizes+0x52f>
add    %edi,%edi
call   1030 <malloc@plt>
mov    %rax,(%r12)
test   %rax,%rax
je     163f <get_keysizes+0x52f>
mov    %rax,%rcx
cmp    %r13d,%r15d
jge    163f <get_keysizes+0x52f>
lea    (%r15,%rbp,1),%edx
xor    %esi,%esi
cmp    %edx,%r13d
mov    %edx,%eax
cmovg  %r13d,%eax
setg   %sil
add    %esi,%edx
sub    %edx,%eax
cmp    $0x2,%ebp
mov    $0x1,%edi
cmovae %ebp,%edi
xor    %r14d,%r14d
xor    %edx,%edx
div    %edi
add    %esi,%eax
cmp    $0x7,%eax
jb     1500 <get_keysizes+0x3f0>
add    $0x1,%rax
mov    %rax,%r14
and    $0xfffffffffffffff8,%r14
movd   %r15d,%xmm0
pshufd $0x0,%xmm0,%xmm2
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xda0(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm3
movdqa 0xd9f(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm3,%xmm1
paddd  %xmm2,%xmm1
pslld  $0x2,%xmm0
lea    -0x8(%r14),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1450 <get_keysizes+0x340>
xor    %edi,%edi
jmp    14bc <get_keysizes+0x3ac>
shr    $0x3,%r15d
add    $0x1,%r15d
mov    %r15d,%r14d
and    $0xfffffff8,%r14d
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xca4(%rip),%xmm0
lea    -0x8(%r14),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1515 <get_keysizes+0x405>
xor    %esi,%esi
jmp    15d8 <get_keysizes+0x4c8>
mov    %ebp,%ecx
and    $0x7,%ecx
test   %rcx,%rcx
mov    $0x8,%edx
cmovne %rcx,%rdx
mov    %rbp,%rcx
sub    %rdx,%rcx
lea    (%rbx,%rcx,8),%rdx
xor    %esi,%esi
xchg   %ax,%ax
movups 0x8(%rbx,%rsi,8),%xmm0
movups 0x18(%rbx,%rsi,8),%xmm1
shufps $0x88,%xmm1,%xmm0
movups 0x28(%rbx,%rsi,8),%xmm1
movups 0x38(%rbx,%rsi,8),%xmm2
shufps $0x88,%xmm2,%xmm1
movups %xmm0,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    13a0 <get_keysizes+0x290>
mov    %rdx,%rbx
mov    %ebp,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x3,%rsi
je     1404 <get_keysizes+0x2f4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rbx),%edi
add    $0x8,%rbx
mov    %edi,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    13f0 <get_keysizes+0x2e0>
cmp    $0x3,%rdx
jb     1448 <get_keysizes+0x338>
mov    %rbp,%rdx
sub    %rcx,%rdx
lea    (%rax,%rcx,4),%rax
add    $0xc,%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rcx,8),%esi
mov    %esi,-0xc(%rax,%rcx,4)
mov    0x10(%rbx,%rcx,8),%esi
mov    %esi,-0x8(%rax,%rcx,4)
mov    0x18(%rbx,%rcx,8),%esi
mov    %esi,-0x4(%rax,%rcx,4)
mov    0x20(%rbx,%rcx,8),%esi
mov    %esi,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1420 <get_keysizes+0x310>
mov    %ebp,%r14d
jmp    163f <get_keysizes+0x52f>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu %xmm1,(%rcx,%rdi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x10(%rcx,%rdi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x20(%rcx,%rdi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x30(%rcx,%rdi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x40(%rcx,%rdi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x50(%rcx,%rdi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x60(%rcx,%rdi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x70(%rcx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm0,%xmm1
add    $0x4,%rbx
cmp    %rsi,%rbx
jne    1460 <get_keysizes+0x350>
test   %rdx,%rdx
je     14ee <get_keysizes+0x3de>
lea    (%rcx,%rdi,4),%rsi
add    $0x10,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu %xmm1,-0x10(%rsi)
paddd  %xmm0,%xmm1
movdqu %xmm1,(%rsi)
paddd  %xmm0,%xmm1
add    $0x1,%rdi
add    $0x20,%rsi
cmp    %rdx,%rdi
jne    14d0 <get_keysizes+0x3c0>
cmp    %r14,%rax
je     163f <get_keysizes+0x52f>
mov    %ebp,%eax
imul   %r14d,%eax
add    %eax,%r15d
mov    %r15d,(%rcx,%r14,4)
add    $0x1,%r14
add    %ebp,%r15d
cmp    %r13d,%r15d
jl     1500 <get_keysizes+0x3f0>
jmp    163f <get_keysizes+0x52f>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
movdqa 0xaec(%rip),%xmm8
movdqa 0xaf3(%rip),%xmm9
movdqa 0xafa(%rip),%xmm10
movdqa 0xb02(%rip),%xmm4
movdqa 0xb0a(%rip),%xmm5
movdqa 0xb12(%rip),%xmm6
movdqa 0xb1a(%rip),%xmm7
movdqa 0xb22(%rip),%xmm1
xchg   %ax,%ax
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rax,%rsi,4)
movdqu %xmm2,0x10(%rax,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rax,%rsi,4)
movdqu %xmm3,0x30(%rax,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rax,%rsi,4)
movdqu %xmm3,0x50(%rax,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rax,%rsi,4)
movdqu %xmm3,0x70(%rax,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    1560 <get_keysizes+0x450>
test   %rcx,%rcx
je     1620 <get_keysizes+0x510>
lea    (%rax,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0xa1d(%rip),%xmm1
movdqa 0xa25(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm3,(%rdx,%rsi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1600 <get_keysizes+0x4f0>
cmp    %r15,%r14
je     163f <get_keysizes+0x52f>
lea    0x0(%rbp,%r14,8),%ebp
nopw   0x0(%rax,%rax,1)
mov    %ebp,(%rax,%r14,4)
add    $0x1,%r14
add    $0x8,%ebp
cmp    %ebx,%ebp
jl     1630 <get_keysizes+0x520>
mov    %r14d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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