#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 */

/* Variables and functions */
unsigned char *Ptngc_warnmalloc_x(int const, char *, int);
int /*<<< orphan*/ comp_conv_from_mtf_byte(unsigned char *, int const,
                                           unsigned char *);
int /*<<< orphan*/ free(unsigned char *);
int /*<<< orphan*/ memset(unsigned int *, unsigned int, int);
void Ptngc_comp_conv_from_mtf_partial3(unsigned char *valsmtf, const int nvals,
                                       unsigned int *vals) {
  unsigned char *tmp = Ptngc_warnmalloc_x(
      nvals,
      "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
      "2022-01-22/02-19-57/repos/ctk3b/mdtraj/refs/heads/master/mdtraj/formats/"
      "tng/src/compression/mtf.c",
      160);
  int i, j;
  memset(vals, 0U, sizeof(unsigned int) * nvals);
  for (j = 0; j < 3; j++) {
    comp_conv_from_mtf_byte(valsmtf + j * nvals, nvals, tmp);
    for (i = 0; i < nvals; i++)
      vals[i] |= (((unsigned int)(tmp[i])) << (8 * j));
  }
  free(tmp);
}


x86 assembly (clang, -O0):
<Ptngc_comp_conv_from_mtf_partial3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%edi
lea    0xea3(%rip),%rsi
mov    $0xa0,%edx
call   1060 <Ptngc_warnmalloc_x@plt>
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1203 <Ptngc_comp_conv_from_mtf_partial3+0xc3>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
add    %rax,%rdi
mov    -0xc(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   1050 <comp_conv_from_mtf_byte@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f0 <Ptngc_comp_conv_from_mtf_partial3+0xb0>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x28(%rbp),%ecx
shl    $0x3,%ecx
shl    %cl,%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b4 <Ptngc_comp_conv_from_mtf_partial3+0x74>
jmp    11f5 <Ptngc_comp_conv_from_mtf_partial3+0xb5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1187 <Ptngc_comp_conv_from_mtf_partial3+0x47>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Ptngc_comp_conv_from_mtf_partial3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%rbx
mov    %esi,%r15d
mov    %rdi,%r12
lea    0xea5(%rip),%rsi
mov    %r15d,%edi
mov    $0xa0,%edx
call   1060 <Ptngc_warnmalloc_x@plt>
mov    %rax,%r14
lea    0x0(,%r15,4),%edx
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14,%rdx
call   1050 <comp_conv_from_mtf_byte@plt>
movslq %r15d,%r13
test   %r15d,%r15d
jle    1224 <Ptngc_comp_conv_from_mtf_partial3+0xe4>
mov    %r15d,%ebp
cmp    $0x8,%r15d
jb     11ba <Ptngc_comp_conv_from_mtf_partial3+0x7a>
lea    (%r14,%rbp,1),%rax
cmp    %rbx,%rax
jbe    1238 <Ptngc_comp_conv_from_mtf_partial3+0xf8>
lea    (%rbx,%rbp,4),%rax
cmp    %rax,%r14
jae    1238 <Ptngc_comp_conv_from_mtf_partial3+0xf8>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     11e2 <Ptngc_comp_conv_from_mtf_partial3+0xa2>
xchg   %ax,%ax
movzbl (%r14,%rax,1),%esi
or     %esi,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11d0 <Ptngc_comp_conv_from_mtf_partial3+0x90>
cmp    $0x3,%rcx
jb     1344 <Ptngc_comp_conv_from_mtf_partial3+0x204>
nopl   0x0(%rax)
movzbl (%r14,%rax,1),%ecx
or     %ecx,(%rbx,%rax,4)
movzbl 0x1(%r14,%rax,1),%ecx
or     %ecx,0x4(%rbx,%rax,4)
movzbl 0x2(%r14,%rax,1),%ecx
or     %ecx,0x8(%rbx,%rax,4)
movzbl 0x3(%r14,%rax,1),%ecx
or     %ecx,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    11f0 <Ptngc_comp_conv_from_mtf_partial3+0xb0>
jmp    1344 <Ptngc_comp_conv_from_mtf_partial3+0x204>
lea    (%r12,%r13,1),%rdi
mov    %r13d,%esi
mov    %r14,%rdx
call   1050 <comp_conv_from_mtf_byte@plt>
jmp    13c6 <Ptngc_comp_conv_from_mtf_partial3+0x286>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     16ad <Ptngc_comp_conv_from_mtf_partial3+0x56d>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%r14,%rcx,1),%xmm1
movd   0x4(%r14,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu (%rbx,%rcx,4),%xmm3
por    %xmm1,%xmm3
movdqu 0x10(%rbx,%rcx,4),%xmm1
por    %xmm2,%xmm1
movdqu 0x20(%rbx,%rcx,4),%xmm2
movdqu 0x30(%rbx,%rcx,4),%xmm4
movdqu %xmm3,(%rbx,%rcx,4)
movdqu %xmm1,0x10(%rbx,%rcx,4)
movd   0x8(%r14,%rcx,1),%xmm1
movd   0xc(%r14,%rcx,1),%xmm3
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
por    %xmm2,%xmm1
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
por    %xmm4,%xmm3
movdqu %xmm1,0x20(%rbx,%rcx,4)
movdqu %xmm3,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1270 <Ptngc_comp_conv_from_mtf_partial3+0x130>
test   $0x1,%dl
je     133b <Ptngc_comp_conv_from_mtf_partial3+0x1fb>
movd   (%r14,%rcx,1),%xmm0
movd   0x4(%r14,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
movdqu (%rbx,%rcx,4),%xmm2
por    %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
por    %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
cmp    %rbp,%rax
jne    11bc <Ptngc_comp_conv_from_mtf_partial3+0x7c>
lea    (%r12,%r13,1),%rdi
mov    %r15d,%esi
mov    %r14,%rdx
call   1050 <comp_conv_from_mtf_byte@plt>
test   %r15d,%r15d
jle    13c6 <Ptngc_comp_conv_from_mtf_partial3+0x286>
cmp    $0x8,%r15d
jb     1374 <Ptngc_comp_conv_from_mtf_partial3+0x234>
lea    (%r14,%rbp,1),%rax
cmp    %rbx,%rax
jbe    13eb <Ptngc_comp_conv_from_mtf_partial3+0x2ab>
lea    (%rbx,%rbp,4),%rax
cmp    %rax,%r14
jae    13eb <Ptngc_comp_conv_from_mtf_partial3+0x2ab>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     1391 <Ptngc_comp_conv_from_mtf_partial3+0x251>
movzbl (%r14,%rax,1),%edx
shl    $0x8,%edx
or     %edx,(%rbx,%rax,4)
or     $0x1,%rax
add    %rbp,%rcx
je     1512 <Ptngc_comp_conv_from_mtf_partial3+0x3d2>
nopw   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ecx
shl    $0x8,%ecx
or     %ecx,(%rbx,%rax,4)
movzbl 0x1(%r14,%rax,1),%ecx
shl    $0x8,%ecx
or     %ecx,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    13a0 <Ptngc_comp_conv_from_mtf_partial3+0x260>
jmp    1512 <Ptngc_comp_conv_from_mtf_partial3+0x3d2>
lea    (%r12,%r13,2),%rdi
mov    %r15d,%esi
mov    %r14,%rdx
call   1050 <comp_conv_from_mtf_byte@plt>
mov    %r14,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     16bd <Ptngc_comp_conv_from_mtf_partial3+0x57d>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movd   (%r14,%rcx,1),%xmm1
movd   0x4(%r14,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
pslld  $0x8,%xmm1
pslld  $0x8,%xmm2
movdqu (%rbx,%rcx,4),%xmm3
por    %xmm1,%xmm3
movdqu 0x10(%rbx,%rcx,4),%xmm1
por    %xmm2,%xmm1
movdqu 0x20(%rbx,%rcx,4),%xmm2
movdqu 0x30(%rbx,%rcx,4),%xmm4
movdqu %xmm3,(%rbx,%rcx,4)
movdqu %xmm1,0x10(%rbx,%rcx,4)
movd   0x8(%r14,%rcx,1),%xmm1
movd   0xc(%r14,%rcx,1),%xmm3
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
pslld  $0x8,%xmm1
por    %xmm2,%xmm1
pslld  $0x8,%xmm3
por    %xmm4,%xmm3
movdqu %xmm1,0x20(%rbx,%rcx,4)
movdqu %xmm3,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1420 <Ptngc_comp_conv_from_mtf_partial3+0x2e0>
test   $0x1,%dl
je     1509 <Ptngc_comp_conv_from_mtf_partial3+0x3c9>
movd   (%r14,%rcx,1),%xmm0
movd   0x4(%r14,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
movdqu (%rbx,%rcx,4),%xmm2
por    %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
por    %xmm1,%xmm0
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm0,0x10(%rbx,%rcx,4)
cmp    %rbp,%rax
jne    1376 <Ptngc_comp_conv_from_mtf_partial3+0x236>
lea    (%r12,%r13,2),%rdi
mov    %r15d,%esi
mov    %r14,%rdx
call   1050 <comp_conv_from_mtf_byte@plt>
test   %r15d,%r15d
jle    13d5 <Ptngc_comp_conv_from_mtf_partial3+0x295>
cmp    $0x8,%r15d
jb     1542 <Ptngc_comp_conv_from_mtf_partial3+0x402>
lea    (%r14,%rbp,1),%rax
cmp    %rbx,%rax
jbe    1596 <Ptngc_comp_conv_from_mtf_partial3+0x456>
lea    (%rbx,%rbp,4),%rax
cmp    %rax,%r14
jae    1596 <Ptngc_comp_conv_from_mtf_partial3+0x456>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     155f <Ptngc_comp_conv_from_mtf_partial3+0x41f>
movzbl (%r14,%rax,1),%edx
shl    $0x10,%edx
or     %edx,(%rbx,%rax,4)
or     $0x1,%rax
add    %rbp,%rcx
je     13d5 <Ptngc_comp_conv_from_mtf_partial3+0x295>
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ecx
shl    $0x10,%ecx
or     %ecx,(%rbx,%rax,4)
movzbl 0x1(%r14,%rax,1),%ecx
shl    $0x10,%ecx
or     %ecx,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1570 <Ptngc_comp_conv_from_mtf_partial3+0x430>
jmp    13d5 <Ptngc_comp_conv_from_mtf_partial3+0x295>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     16cd <Ptngc_comp_conv_from_mtf_partial3+0x58d>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
movd   (%r14,%rcx,1),%xmm1
movd   0x4(%r14,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
pxor   %xmm3,%xmm3
punpcklwd %xmm1,%xmm3
pxor   %xmm1,%xmm1
punpcklwd %xmm2,%xmm1
movdqu (%rbx,%rcx,4),%xmm2
por    %xmm3,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm3
por    %xmm1,%xmm3
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm4
movdqu %xmm2,(%rbx,%rcx,4)
movdqu %xmm3,0x10(%rbx,%rcx,4)
movd   0x8(%r14,%rcx,1),%xmm2
movd   0xc(%r14,%rcx,1),%xmm3
punpcklbw %xmm0,%xmm2
punpcklbw %xmm0,%xmm3
pxor   %xmm5,%xmm5
punpcklwd %xmm2,%xmm5
por    %xmm1,%xmm5
pxor   %xmm1,%xmm1
punpcklwd %xmm3,%xmm1
por    %xmm4,%xmm1
movdqu %xmm5,0x20(%rbx,%rcx,4)
movdqu %xmm1,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15c0 <Ptngc_comp_conv_from_mtf_partial3+0x480>
test   $0x1,%dl
je     169f <Ptngc_comp_conv_from_mtf_partial3+0x55f>
movd   (%r14,%rcx,1),%xmm0
movd   0x4(%r14,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
pxor   %xmm3,%xmm3
punpcklwd %xmm0,%xmm3
punpcklwd %xmm1,%xmm2
movdqu (%rbx,%rcx,4),%xmm0
por    %xmm3,%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
por    %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rcx,4)
movdqu %xmm1,0x10(%rbx,%rcx,4)
cmp    %rbp,%rax
je     13d5 <Ptngc_comp_conv_from_mtf_partial3+0x295>
jmp    1544 <Ptngc_comp_conv_from_mtf_partial3+0x404>
xor    %ecx,%ecx
test   $0x1,%dl
jne    12fc <Ptngc_comp_conv_from_mtf_partial3+0x1bc>
jmp    133b <Ptngc_comp_conv_from_mtf_partial3+0x1fb>
xor    %ecx,%ecx
test   $0x1,%dl
jne    14c0 <Ptngc_comp_conv_from_mtf_partial3+0x380>
jmp    1509 <Ptngc_comp_conv_from_mtf_partial3+0x3c9>
xor    %ecx,%ecx
test   $0x1,%dl
jne    165c <Ptngc_comp_conv_from_mtf_partial3+0x51c>
jmp    169f <Ptngc_comp_conv_from_mtf_partial3+0x55f>

LLVM IR (-O0):
@.str = [162 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/ctk3b/mdtraj/refs/heads/master/mdtraj/formats/tng/src/compression/mtf.c\00"
define void @Ptngc_comp_conv_from_mtf_partial3(i8* %0, i32 %1, i32* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32* %2, i32** %6
%10 = load i32, i32* %5
%11 = call i8* @Ptngc_warnmalloc_x(i32 %10, i8* getelementptr inbounds ([162 x i8], [162 x i8]* @.str, i64 0, i64 0), i32 160)
store i8* %11, i8** %7
%12 = load i32*, i32** %6
%13 = load i32, i32* %5
%14 = sext i32 %13 to i64
%15 = mul i64 4, %14
%16 = trunc i64 %15 to i32
%17 = call i32 @memset(i32* %12, i32 0, i32 %16)
store i32 0, i32* %9
br label %18
18: ; preds = %55, %3
%19 = load i32, i32* %9
%20 = icmp slt i32 %19, 3
br i1 %20, label %21, label %58
21: ; preds = %18
%22 = load i8*, i8** %4
%23 = load i32, i32* %9
%24 = load i32, i32* %5
%25 = mul nsw i32 %23, %24
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %22, i64 %26
%28 = load i32, i32* %5
%29 = load i8*, i8** %7
%30 = call i32 @comp_conv_from_mtf_byte(i8* %27, i32 %28, i8* %29)
store i32 0, i32* %8
br label %31
31: ; preds = %51, %21
%32 = load i32, i32* %8
%33 = load i32, i32* %5
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %54
35: ; preds = %31
%36 = load i8*, i8** %7
%37 = load i32, i32* %8
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = load i32, i32* %9
%43 = mul nsw i32 8, %42
%44 = shl i32 %41, %43
%45 = load i32*, i32** %6
%46 = load i32, i32* %8
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
%49 = load i32, i32* %48
%50 = or i32 %49, %44
store i32 %50, i32* %48
br label %51
51: ; preds = %35
%52 = load i32, i32* %8
%53 = add nsw i32 %52, 1
store i32 %53, i32* %8
br label %31
54: ; preds = %31
br label %55
55: ; preds = %54
%56 = load i32, i32* %9
%57 = add nsw i32 %56, 1
store i32 %57, i32* %9
br label %18
58: ; preds = %18
%59 = load i8*, i8** %7
%60 = call i32 @free(i8* %59)
ret void
}

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