#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_to_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_to_mtf_partial(unsigned int *vals, const int nvals,
                                    unsigned int *valsmtf) {
  unsigned char *tmp = Ptngc_warnmalloc_x(
      nvals * 2,
      "/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",
      65);
  int i, j;
  memset(valsmtf, 0U, sizeof(unsigned int) * nvals);
  for (j = 0; j < 3; j++) {
    for (i = 0; i < nvals; i++)
      tmp[i] = (unsigned char)((vals[i] >> (8 * j)) & 0xFF);
    comp_conv_to_mtf_byte(tmp, nvals, tmp + nvals);
    for (i = 0; i < nvals; i++)
      valsmtf[i] |= (((unsigned int)(tmp[nvals + i])) << (8 * j));
  }
  free(tmp);
}


x86 assembly (clang, -O0):
<Ptngc_comp_conv_to_mtf_partial>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%edi
shl    $0x1,%edi
lea    0xea0(%rip),%rsi
mov    $0x41,%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   1050 <memset@plt>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    124c <Ptngc_comp_conv_to_mtf_partial+0x10c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11da <Ptngc_comp_conv_to_mtf_partial+0x9a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%ecx
shl    $0x3,%ecx
shr    %cl,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    119b <Ptngc_comp_conv_to_mtf_partial+0x5b>
mov    -0x20(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x20(%rbp),%rdx
movslq -0xc(%rbp),%rax
add    %rax,%rdx
call   1040 <comp_conv_to_mtf_byte@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1239 <Ptngc_comp_conv_to_mtf_partial+0xf9>
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%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    11f8 <Ptngc_comp_conv_to_mtf_partial+0xb8>
jmp    123e <Ptngc_comp_conv_to_mtf_partial+0xfe>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    118a <Ptngc_comp_conv_to_mtf_partial+0x4a>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Ptngc_comp_conv_to_mtf_partial>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %esi,%r15d
mov    %rdi,%rbx
lea    (%r15,%r15,1),%edi
lea    0xeb1(%rip),%rsi
mov    $0x41,%edx
call   1060 <Ptngc_warnmalloc_x@plt>
mov    %rax,%r13
movslq %r15d,%r12
lea    0x0(,%r12,4),%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
lea    (%r12,%r13,1),%rdx
test   %r12d,%r12d
mov    %rdx,(%rsp)
jle    1225 <Ptngc_comp_conv_to_mtf_partial+0xe5>
mov    %r15d,%ebp
cmp    $0x8,%r15d
jb     11b7 <Ptngc_comp_conv_to_mtf_partial+0x77>
lea    (%rbx,%rbp,4),%rax
cmp    %rax,%r13
jae    1235 <Ptngc_comp_conv_to_mtf_partial+0xf5>
mov    %r13,%rax
add    %rbp,%rax
cmp    %rbx,%rax
jbe    1235 <Ptngc_comp_conv_to_mtf_partial+0xf5>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbp,%rsi
mov    %rbp,%rdi
and    $0x3,%rdi
je     11e3 <Ptngc_comp_conv_to_mtf_partial+0xa3>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,4),%ecx
mov    %cl,0x0(%r13,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    11d0 <Ptngc_comp_conv_to_mtf_partial+0x90>
cmp    $0x3,%rsi
jb     1325 <Ptngc_comp_conv_to_mtf_partial+0x1e5>
nopl   (%rax)
movzbl (%rbx,%rax,4),%ecx
mov    %cl,0x0(%r13,%rax,1)
movzbl 0x4(%rbx,%rax,4),%ecx
mov    %cl,0x1(%r13,%rax,1)
movzbl 0x8(%rbx,%rax,4),%ecx
mov    %cl,0x2(%r13,%rax,1)
movzbl 0xc(%rbx,%rax,4),%ecx
mov    %cl,0x3(%r13,%rax,1)
add    $0x4,%rax
cmp    %rax,%rbp
jne    11f0 <Ptngc_comp_conv_to_mtf_partial+0xb0>
jmp    1325 <Ptngc_comp_conv_to_mtf_partial+0x1e5>
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <comp_conv_to_mtf_byte@plt>
jmp    1576 <Ptngc_comp_conv_to_mtf_partial+0x436>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     1746 <Ptngc_comp_conv_to_mtf_partial+0x606>
mov    %rdi,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movdqa 0xd9d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rbx,%rcx,4),%xmm1
movdqu 0x10(%rbx,%rcx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x0(%r13,%rcx,1)
movd   %xmm2,0x4(%r13,%rcx,1)
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%r13,%rcx,1)
movd   %xmm2,0xc(%r13,%rcx,1)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1270 <Ptngc_comp_conv_to_mtf_partial+0x130>
test   $0x1,%dil
je     131c <Ptngc_comp_conv_to_mtf_partial+0x1dc>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
movdqa 0xd0a(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,0x0(%r13,%rcx,1)
movd   %xmm1,0x4(%r13,%rcx,1)
cmp    %rbp,%rax
jne    11b9 <Ptngc_comp_conv_to_mtf_partial+0x79>
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <comp_conv_to_mtf_byte@plt>
test   %r15d,%r15d
jle    1576 <Ptngc_comp_conv_to_mtf_partial+0x436>
cmp    $0x8,%r15d
jb     1358 <Ptngc_comp_conv_to_mtf_partial+0x218>
lea    (%r12,%rbp,1),%rax
add    %r13,%rax
cmp    %r14,%rax
mov    (%rsp),%rcx
jbe    13b0 <Ptngc_comp_conv_to_mtf_partial+0x270>
lea    (%r14,%rbp,4),%rax
cmp    %rax,%rcx
jae    13b0 <Ptngc_comp_conv_to_mtf_partial+0x270>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     1378 <Ptngc_comp_conv_to_mtf_partial+0x238>
lea    (%rax,%r12,1),%rdx
movzbl 0x0(%r13,%rdx,1),%edx
or     %edx,(%r14,%rax,4)
or     $0x1,%rax
add    %rbp,%rcx
je     14d1 <Ptngc_comp_conv_to_mtf_partial+0x391>
lea    (%r12,%r13,1),%rcx
add    $0x1,%rcx
nopl   0x0(%rax)
movzbl -0x1(%rcx,%rax,1),%edx
or     %edx,(%r14,%rax,4)
movzbl (%rcx,%rax,1),%edx
or     %edx,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1390 <Ptngc_comp_conv_to_mtf_partial+0x250>
jmp    14d1 <Ptngc_comp_conv_to_mtf_partial+0x391>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1866 <Ptngc_comp_conv_to_mtf_partial+0x726>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r12,%r13,1),%rdi
add    $0xc,%rdi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   -0xc(%rdi,%rcx,1),%xmm1
movd   -0x8(%rdi,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu (%r14,%rcx,4),%xmm3
por    %xmm1,%xmm3
movdqu 0x10(%r14,%rcx,4),%xmm1
por    %xmm2,%xmm1
movdqu 0x20(%r14,%rcx,4),%xmm2
movdqu 0x30(%r14,%rcx,4),%xmm4
movdqu %xmm3,(%r14,%rcx,4)
movdqu %xmm1,0x10(%r14,%rcx,4)
movd   -0x4(%rdi,%rcx,1),%xmm1
movd   (%rdi,%rcx,1),%xmm3
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
por    %xmm2,%xmm1
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
por    %xmm4,%xmm3
movdqu %xmm1,0x20(%r14,%rcx,4)
movdqu %xmm3,0x30(%r14,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13f0 <Ptngc_comp_conv_to_mtf_partial+0x2b0>
test   $0x1,%dl
je     14c8 <Ptngc_comp_conv_to_mtf_partial+0x388>
lea    (%rcx,%r12,1),%rdx
movd   0x0(%r13,%rdx,1),%xmm0
movd   0x4(%r13,%rdx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
movdqu (%r14,%rcx,4),%xmm2
por    %xmm0,%xmm2
movdqu 0x10(%r14,%rcx,4),%xmm0
por    %xmm1,%xmm0
movdqu %xmm2,(%r14,%rcx,4)
movdqu %xmm0,0x10(%r14,%rcx,4)
cmp    %rbp,%rax
jne    135a <Ptngc_comp_conv_to_mtf_partial+0x21a>
test   %r15d,%r15d
jle    1576 <Ptngc_comp_conv_to_mtf_partial+0x436>
cmp    $0x8,%r15d
mov    (%rsp),%rdx
jb     1500 <Ptngc_comp_conv_to_mtf_partial+0x3c0>
lea    (%rbx,%rbp,4),%rax
cmp    %rax,%r13
jae    15ac <Ptngc_comp_conv_to_mtf_partial+0x46c>
mov    %r13,%rax
add    %rbp,%rax
cmp    %rbx,%rax
jbe    15ac <Ptngc_comp_conv_to_mtf_partial+0x46c>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbp,%rsi
mov    %rbp,%rdi
and    $0x3,%rdi
je     1534 <Ptngc_comp_conv_to_mtf_partial+0x3f4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x1(%rbx,%rax,4),%ecx
mov    %cl,0x0(%r13,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1520 <Ptngc_comp_conv_to_mtf_partial+0x3e0>
cmp    $0x3,%rsi
jb     16b7 <Ptngc_comp_conv_to_mtf_partial+0x577>
xchg   %ax,%ax
movzbl 0x1(%rbx,%rax,4),%ecx
mov    %cl,0x0(%r13,%rax,1)
movzbl 0x5(%rbx,%rax,4),%ecx
mov    %cl,0x1(%r13,%rax,1)
movzbl 0x9(%rbx,%rax,4),%ecx
mov    %cl,0x2(%r13,%rax,1)
movzbl 0xd(%rbx,%rax,4),%ecx
mov    %cl,0x3(%r13,%rax,1)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1540 <Ptngc_comp_conv_to_mtf_partial+0x400>
jmp    16b7 <Ptngc_comp_conv_to_mtf_partial+0x577>
mov    %r13,%rdi
mov    %r15d,%esi
mov    (%rsp),%rbx
mov    %rbx,%rdx
call   1040 <comp_conv_to_mtf_byte@plt>
mov    %rbx,%rdx
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <comp_conv_to_mtf_byte@plt>
mov    %r13,%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,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     1937 <Ptngc_comp_conv_to_mtf_partial+0x7f7>
mov    %rdi,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movdqa 0xa26(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rcx,4),%xmm1
movdqu 0x10(%rbx,%rcx,4),%xmm2
psrld  $0x8,%xmm1
psrld  $0x8,%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x0(%r13,%rcx,1)
movd   %xmm2,0x4(%r13,%rcx,1)
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm2
psrld  $0x8,%xmm1
psrld  $0x8,%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%r13,%rcx,1)
movd   %xmm2,0xc(%r13,%rcx,1)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15e0 <Ptngc_comp_conv_to_mtf_partial+0x4a0>
test   $0x1,%dil
je     16ae <Ptngc_comp_conv_to_mtf_partial+0x56e>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
psrld  $0x8,%xmm0
psrld  $0x8,%xmm1
movdqa 0x978(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,0x0(%r13,%rcx,1)
movd   %xmm1,0x4(%r13,%rcx,1)
cmp    %rbp,%rax
jne    1502 <Ptngc_comp_conv_to_mtf_partial+0x3c2>
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <comp_conv_to_mtf_byte@plt>
mov    (%rsp),%rdx
test   %r15d,%r15d
jle    158b <Ptngc_comp_conv_to_mtf_partial+0x44b>
cmp    $0x8,%r15d
jb     16ea <Ptngc_comp_conv_to_mtf_partial+0x5aa>
lea    (%r12,%rbp,1),%rax
add    %r13,%rax
cmp    %r14,%rax
jbe    1757 <Ptngc_comp_conv_to_mtf_partial+0x617>
lea    (%r14,%rbp,4),%rax
cmp    %rax,%rdx
jae    1757 <Ptngc_comp_conv_to_mtf_partial+0x617>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     170d <Ptngc_comp_conv_to_mtf_partial+0x5cd>
lea    (%rax,%r12,1),%rsi
movzbl 0x0(%r13,%rsi,1),%esi
shl    $0x8,%esi
or     %esi,(%r14,%rax,4)
or     $0x1,%rax
add    %rbp,%rcx
je     17c9 <Ptngc_comp_conv_to_mtf_partial+0x689>
lea    (%r12,%r13,1),%rcx
add    $0x1,%rcx
xchg   %ax,%ax
movzbl -0x1(%rcx,%rax,1),%esi
shl    $0x8,%esi
or     %esi,(%r14,%rax,4)
movzbl (%rcx,%rax,1),%esi
shl    $0x8,%esi
or     %esi,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1720 <Ptngc_comp_conv_to_mtf_partial+0x5e0>
jmp    17c9 <Ptngc_comp_conv_to_mtf_partial+0x689>
xor    %ecx,%ecx
test   $0x1,%dil
jne    12e3 <Ptngc_comp_conv_to_mtf_partial+0x1a3>
jmp    131c <Ptngc_comp_conv_to_mtf_partial+0x1dc>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    (%r12,%r13,1),%rcx
add    $0x4,%rcx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movd   -0x4(%rcx,%rsi,1),%xmm1
movd   (%rcx,%rsi,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
pslld  $0x8,%xmm1
pslld  $0x8,%xmm2
movdqu (%r14,%rsi,4),%xmm3
por    %xmm1,%xmm3
movdqu 0x10(%r14,%rsi,4),%xmm1
por    %xmm2,%xmm1
movdqu %xmm3,(%r14,%rsi,4)
movdqu %xmm1,0x10(%r14,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rax
jne    1770 <Ptngc_comp_conv_to_mtf_partial+0x630>
cmp    %rbp,%rax
jne    16ec <Ptngc_comp_conv_to_mtf_partial+0x5ac>
test   %r15d,%r15d
jle    158b <Ptngc_comp_conv_to_mtf_partial+0x44b>
cmp    $0x8,%r15d
jb     17f4 <Ptngc_comp_conv_to_mtf_partial+0x6b4>
lea    (%rbx,%rbp,4),%rax
cmp    %rax,%r13
jae    1876 <Ptngc_comp_conv_to_mtf_partial+0x736>
mov    %r13,%rax
add    %rbp,%rax
cmp    %rbx,%rax
jbe    1876 <Ptngc_comp_conv_to_mtf_partial+0x736>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbp,%rsi
mov    %rbp,%rdi
and    $0x3,%rdi
je     1824 <Ptngc_comp_conv_to_mtf_partial+0x6e4>
nopl   0x0(%rax,%rax,1)
movzbl 0x2(%rbx,%rax,4),%ecx
mov    %cl,0x0(%r13,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1810 <Ptngc_comp_conv_to_mtf_partial+0x6d0>
cmp    $0x3,%rsi
jb     199c <Ptngc_comp_conv_to_mtf_partial+0x85c>
xchg   %ax,%ax
movzbl 0x2(%rbx,%rax,4),%ecx
mov    %cl,0x0(%r13,%rax,1)
movzbl 0x6(%rbx,%rax,4),%ecx
mov    %cl,0x1(%r13,%rax,1)
movzbl 0xa(%rbx,%rax,4),%ecx
mov    %cl,0x2(%r13,%rax,1)
movzbl 0xe(%rbx,%rax,4),%ecx
mov    %cl,0x3(%r13,%rax,1)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1830 <Ptngc_comp_conv_to_mtf_partial+0x6f0>
jmp    199c <Ptngc_comp_conv_to_mtf_partial+0x85c>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1480 <Ptngc_comp_conv_to_mtf_partial+0x340>
jmp    14c8 <Ptngc_comp_conv_to_mtf_partial+0x388>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     1948 <Ptngc_comp_conv_to_mtf_partial+0x808>
mov    %rdi,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movdqa 0x75c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rbx,%rcx,4),%xmm1
movdqu 0x10(%rbx,%rcx,4),%xmm2
psrld  $0x10,%xmm1
psrld  $0x10,%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x0(%r13,%rcx,1)
movd   %xmm2,0x4(%r13,%rcx,1)
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm2
psrld  $0x10,%xmm1
psrld  $0x10,%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%r13,%rcx,1)
movd   %xmm2,0xc(%r13,%rcx,1)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    18b0 <Ptngc_comp_conv_to_mtf_partial+0x770>
jmp    194a <Ptngc_comp_conv_to_mtf_partial+0x80a>
xor    %ecx,%ecx
test   $0x1,%dil
jne    166b <Ptngc_comp_conv_to_mtf_partial+0x52b>
jmp    16ae <Ptngc_comp_conv_to_mtf_partial+0x56e>
xor    %ecx,%ecx
test   $0x1,%dil
je     1993 <Ptngc_comp_conv_to_mtf_partial+0x853>
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
psrld  $0x10,%xmm0
psrld  $0x10,%xmm1
movdqa 0x693(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,0x0(%r13,%rcx,1)
movd   %xmm1,0x4(%r13,%rcx,1)
cmp    %rbp,%rax
jne    17f6 <Ptngc_comp_conv_to_mtf_partial+0x6b6>
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <comp_conv_to_mtf_byte@plt>
test   %r15d,%r15d
jle    1596 <Ptngc_comp_conv_to_mtf_partial+0x456>
cmp    $0x8,%r15d
jb     19cc <Ptngc_comp_conv_to_mtf_partial+0x88c>
lea    (%r12,%rbp,1),%rax
add    %r13,%rax
cmp    %r14,%rax
jbe    1a26 <Ptngc_comp_conv_to_mtf_partial+0x8e6>
lea    (%r14,%rbp,4),%rax
cmp    %rax,(%rsp)
jae    1a26 <Ptngc_comp_conv_to_mtf_partial+0x8e6>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     19ef <Ptngc_comp_conv_to_mtf_partial+0x8af>
lea    (%rax,%r12,1),%rdx
movzbl 0x0(%r13,%rdx,1),%edx
shl    $0x10,%edx
or     %edx,(%r14,%rax,4)
or     $0x1,%rax
add    %rbp,%rcx
je     1596 <Ptngc_comp_conv_to_mtf_partial+0x456>
lea    (%r12,%r13,1),%rcx
add    $0x1,%rcx
movzbl -0x1(%rcx,%rax,1),%edx
shl    $0x10,%edx
or     %edx,(%r14,%rax,4)
movzbl (%rcx,%rax,1),%edx
shl    $0x10,%edx
or     %edx,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1a00 <Ptngc_comp_conv_to_mtf_partial+0x8c0>
jmp    1596 <Ptngc_comp_conv_to_mtf_partial+0x456>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    (%r12,%r13,1),%rcx
add    $0x4,%rcx
xor    %edx,%edx
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movd   -0x4(%rcx,%rdx,1),%xmm1
movd   (%rcx,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
pxor   %xmm3,%xmm3
punpcklwd %xmm1,%xmm3
pxor   %xmm1,%xmm1
punpcklwd %xmm2,%xmm1
movdqu (%r14,%rdx,4),%xmm2
por    %xmm3,%xmm2
movdqu 0x10(%r14,%rdx,4),%xmm3
por    %xmm1,%xmm3
movdqu %xmm2,(%r14,%rdx,4)
movdqu %xmm3,0x10(%r14,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    1a40 <Ptngc_comp_conv_to_mtf_partial+0x900>
cmp    %rbp,%rax
je     1596 <Ptngc_comp_conv_to_mtf_partial+0x456>
jmp    19ce <Ptngc_comp_conv_to_mtf_partial+0x88e>

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_to_mtf_partial(i32* %0, i32 %1, i32* %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32* %2, i32** %6
%10 = load i32, i32* %5
%11 = mul nsw i32 %10, 2
%12 = call i8* @Ptngc_warnmalloc_x(i32 %11, i8* getelementptr inbounds ([162 x i8], [162 x i8]* @.str, i64 0, i64 0), i32 65)
store i8* %12, i8** %7
%13 = load i32*, i32** %6
%14 = load i32, i32* %5
%15 = sext i32 %14 to i64
%16 = mul i64 4, %15
%17 = trunc i64 %16 to i32
%18 = call i32 @memset(i32* %13, i32 0, i32 %17)
store i32 0, i32* %9
br label %19
19: ; preds = %79, %3
%20 = load i32, i32* %9
%21 = icmp slt i32 %20, 3
br i1 %21, label %22, label %82
22: ; preds = %19
store i32 0, i32* %8
br label %23
23: ; preds = %42, %22
%24 = load i32, i32* %8
%25 = load i32, i32* %5
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %45
27: ; preds = %23
%28 = load i32*, i32** %4
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32, i32* %28, i64 %30
%32 = load i32, i32* %31
%33 = load i32, i32* %9
%34 = mul nsw i32 8, %33
%35 = lshr i32 %32, %34
%36 = and i32 %35, 255
%37 = trunc i32 %36 to i8
%38 = load i8*, i8** %7
%39 = load i32, i32* %8
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
store i8 %37, i8* %41
br label %42
42: ; preds = %27
%43 = load i32, i32* %8
%44 = add nsw i32 %43, 1
store i32 %44, i32* %8
br label %23
45: ; preds = %23
%46 = load i8*, i8** %7
%47 = load i32, i32* %5
%48 = load i8*, i8** %7
%49 = load i32, i32* %5
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
%52 = call i32 @comp_conv_to_mtf_byte(i8* %46, i32 %47, i8* %51)
store i32 0, i32* %8
br label %53
53: ; preds = %75, %45
%54 = load i32, i32* %8
%55 = load i32, i32* %5
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %78
57: ; preds = %53
%58 = load i8*, i8** %7
%59 = load i32, i32* %5
%60 = load i32, i32* %8
%61 = add nsw i32 %59, %60
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %58, i64 %62
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = load i32, i32* %9
%67 = mul nsw i32 8, %66
%68 = shl i32 %65, %67
%69 = load i32*, i32** %6
%70 = load i32, i32* %8
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %69, i64 %71
%73 = load i32, i32* %72
%74 = or i32 %73, %68
store i32 %74, i32* %72
br label %75
75: ; preds = %57
%76 = load i32, i32* %8
%77 = add nsw i32 %76, 1
store i32 %77, i32* %8
br label %53
78: ; preds = %53
br label %79
79: ; preds = %78
%80 = load i32, i32* %9
%81 = add nsw i32 %80, 1
store i32 %81, i32* %9
br label %19
82: ; preds = %19
%83 = load i8*, i8** %7
%84 = call i32 @free(i8* %83)
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_to_mtf_partial(i32* nocapture %0, i32 %1, i32* %2) {
%4 = bitcast i32* %0 to i8*
%5 = bitcast i32* %2 to i8*
%6 = shl nsw i32 %1, 1
%7 = tail call i8* @Ptngc_warnmalloc_x(i32 %6, i8* getelementptr inbounds ([162 x i8], [162 x i8]* @.str, i64 0, i64 0), i32 65)
%8 = sext i32 %1 to i64
%9 = shl i32 %1, 2
%10 = tail call i32 @memset(i32* %2, i32 0, i32 %9)
%11 = icmp sgt i32 %1, 0
%12 = getelementptr inbounds i8, i8* %7, i64 %8
br i1 %11, label %15, label %13
13: ; preds = %3
%14 = tail call i32 @comp_conv_to_mtf_byte(i8* %7, i32 %1, i8* %12)
br label %377
15: ; preds = %3
%16 = zext i32 %1 to i64
%17 = icmp ult i32 %1, 8
br i1 %17, label %83, label %18
18: ; preds = %15
%19 = getelementptr i8, i8* %7, i64 %16
%20 = getelementptr i32, i32* %0, i64 %16
%21 = bitcast i32* %20 to i8*
%22 = icmp ult i8* %7, %21
%23 = icmp ugt i8* %19, %4
%24 = and i1 %22, %23
br i1 %24, label %83, label %25
25: ; preds = %18
%26 = and i64 %16, 4294967288
%27 = add nsw i64 %26, -8
%28 = lshr exact i64 %27, 3
%29 = add nuw nsw i64 %28, 1
%30 = and i64 %29, 1
%31 = icmp eq i64 %27, 0
br i1 %31, label %65, label %32
32: ; preds = %25
%33 = and i64 %29, 4611686018427387902
br label %34
34: ; preds = %34, %32
%35 = phi i64 [ 0, %32 ], [ %62, %34 ]
%36 = phi i64 [ 0, %32 ], [ %63, %34 ]
%37 = getelementptr inbounds i32, i32* %0, i64 %35
%38 = bitcast i32* %37 to <4 x i32>*
%39 = load <4 x i32>, <4 x i32>* %38
%40 = getelementptr inbounds i32, i32* %37, i64 4
%41 = bitcast i32* %40 to <4 x i32>*
%42 = load <4 x i32>, <4 x i32>* %41
%43 = trunc <4 x i32> %39 to <4 x i8>
%44 = trunc <4 x i32> %42 to <4 x i8>
%45 = getelementptr inbounds i8, i8* %7, i64 %35
%46 = bitcast i8* %45 to <4 x i8>*
store <4 x i8> %43, <4 x i8>* %46
%47 = getelementptr inbounds i8, i8* %45, i64 4
%48 = bitcast i8* %47 to <4 x i8>*
store <4 x i8> %44, <4 x i8>* %48
%49 = or i64 %35, 8
%50 = getelementptr inbounds i32, i32* %0, i64 %49
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = trunc <4 x i32> %52 to <4 x i8>
%57 = trunc <4 x i32> %55 to <4 x i8>
%58 = getelementptr inbounds i8, i8* %7, i64 %49
%59 = bitcast i8* %58 to <4 x i8>*
store <4 x i8> %56, <4 x i8>* %59
%60 = getelementptr inbounds i8, i8* %58, i64 4
%61 = bitcast i8* %60 to <4 x i8>*
store <4 x i8> %57, <4 x i8>* %61
%62 = add nuw i64 %35, 16
%63 = add i64 %36, 2
%64 = icmp eq i64 %63, %33
br i1 %64, label %65, label %34
65: ; preds = %34, %25
%66 = phi i64 [ 0, %25 ], [ %62, %34 ]
%67 = icmp eq i64 %30, 0
br i1 %67, label %81, label %68
68: ; preds = %65
%69 = getelementptr inbounds i32, i32* %0, i64 %66
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = getelementptr inbounds i32, i32* %69, i64 4
%73 = bitcast i32* %72 to <4 x i32>*
%74 = load <4 x i32>, <4 x i32>* %73
%75 = trunc <4 x i32> %71 to <4 x i8>
%76 = trunc <4 x i32> %74 to <4 x i8>
%77 = getelementptr inbounds i8, i8* %7, i64 %66
%78 = bitcast i8* %77 to <4 x i8>*
store <4 x i8> %75, <4 x i8>* %78
%79 = getelementptr inbounds i8, i8* %77, i64 4
%80 = bitcast i8* %79 to <4 x i8>*
store <4 x i8> %76, <4 x i8>* %80
br label %81
81: ; preds = %65, %68
%82 = icmp eq i64 %26, %16
br i1 %82, label %125, label %83
83: ; preds = %18, %15, %81
%84 = phi i64 [ 0, %18 ], [ 0, %15 ], [ %26, %81 ]
%85 = xor i64 %84, -1
%86 = add nsw i64 %85, %16
%87 = and i64 %16, 3
%88 = icmp eq i64 %87, 0
br i1 %88, label %99, label %89
89: ; preds = %83, %89
%90 = phi i64 [ %96, %89 ], [ %84, %83 ]
%91 = phi i64 [ %97, %89 ], [ 0, %83 ]
%92 = getelementptr inbounds i32, i32* %0, i64 %90
%93 = load i32, i32* %92
%94 = trunc i32 %93 to i8
%95 = getelementptr inbounds i8, i8* %7, i64 %90
store i8 %94, i8* %95
%96 = add nuw nsw i64 %90, 1
%97 = add i64 %91, 1
%98 = icmp eq i64 %97, %87
br i1 %98, label %99, label %89
99: ; preds = %89, %83
%100 = phi i64 [ %84, %83 ], [ %96, %89 ]
%101 = icmp ult i64 %86, 3
br i1 %101, label %125, label %102
102: ; preds = %99, %102
%103 = phi i64 [ %123, %102 ], [ %100, %99 ]
%104 = getelementptr inbounds i32, i32* %0, i64 %103
%105 = load i32, i32* %104
%106 = trunc i32 %105 to i8
%107 = getelementptr inbounds i8, i8* %7, i64 %103
store i8 %106, i8* %107
%108 = add nuw nsw i64 %103, 1
%109 = getelementptr inbounds i32, i32* %0, i64 %108
%110 = load i32, i32* %109
%111 = trunc i32 %110 to i8
%112 = getelementptr inbounds i8, i8* %7, i64 %108
store i8 %111, i8* %112
%113 = add nuw nsw i64 %103, 2
%114 = getelementptr inbounds i32, i32* %0, i64 %113
%115 = load i32, i32* %114
%116 = trunc i32 %115 to i8
%117 = getelementptr inbounds i8, i8* %7, i64 %113
store i8 %116, i8* %117
%118 = add nuw nsw i64 %103, 3
%119 = getelementptr inbounds i32, i32* %0, i64 %118
%120 = load i32, i32* %119
%121 = trunc i32 %120 to i8
%122 = getelementptr inbounds i8, i8* %7, i64 %118
store i8 %121, i8* %122
%123 = add nuw nsw i64 %103, 4
%124 = icmp eq i64 %123, %16
br i1 %124, label %125, label %102
125: ; preds = %99, %102, %81
%126 = tail call i32 @comp_conv_to_mtf_byte(i8* %7, i32 %1, i8* %12)
br i1 %11, label %127, label %377
127: ; preds = %125
%128 = zext i32 %1 to i64
%129 = icmp ult i32 %1, 8
br i1 %129, label %218, label %130
130: ; preds = %127
%131 = getelementptr i32, i32* %2, i64 %16
%132 = bitcast i32* %131 to i8*
%133 = getelementptr i8, i8* %7, i64 %8
%134 = add nsw i64 %8, %16
%135 = getelementptr i8, i8* %7, i64 %134
%136 = icmp ugt i8* %135, %5
%137 = icmp ult i8* %133, %132
%138 = and i1 %136, %137
br i1 %138, label %218, label %139
139: ; preds = %130
%140 = and i64 %16, 4294967288
%141 = add nsw i64 %140, -8
%142 = lshr exact i64 %141, 3
%143 = add nuw nsw i64 %142, 1
%144 = and i64 %143, 1
%145 = icmp eq i64 %141, 0
br i1 %145, label %193, label %146
146: ; preds = %139
%147 = and i64 %143, 4611686018427387902
br label %148
148: ; preds = %148, %146
%149 = phi i64 [ 0, %146 ], [ %190, %148 ]
%150 = phi i64 [ 0, %146 ], [ %191, %148 ]
%151 = add nsw i64 %149, %8
%152 = getelementptr inbounds i8, i8* %7, i64 %151
%153 = bitcast i8* %152 to <4 x i8>*
%154 = load <4 x i8>, <4 x i8>* %153
%155 = getelementptr inbounds i8, i8* %152, i64 4
%156 = bitcast i8* %155 to <4 x i8>*
%157 = load <4 x i8>, <4 x i8>* %156
%158 = zext <4 x i8> %154 to <4 x i32>
%159 = zext <4 x i8> %157 to <4 x i32>
%160 = getelementptr inbounds i32, i32* %2, i64 %149
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = getelementptr inbounds i32, i32* %160, i64 4
%164 = bitcast i32* %163 to <4 x i32>*
%165 = load <4 x i32>, <4 x i32>* %164
%166 = or <4 x i32> %162, %158
%167 = or <4 x i32> %165, %159
%168 = bitcast i32* %160 to <4 x i32>*
store <4 x i32> %166, <4 x i32>* %168
%169 = bitcast i32* %163 to <4 x i32>*
store <4 x i32> %167, <4 x i32>* %169
%170 = or i64 %149, 8
%171 = add nsw i64 %170, %8
%172 = getelementptr inbounds i8, i8* %7, i64 %171
%173 = bitcast i8* %172 to <4 x i8>*
%174 = load <4 x i8>, <4 x i8>* %173
%175 = getelementptr inbounds i8, i8* %172, i64 4
%176 = bitcast i8* %175 to <4 x i8>*
%177 = load <4 x i8>, <4 x i8>* %176
%178 = zext <4 x i8> %174 to <4 x i32>
%179 = zext <4 x i8> %177 to <4 x i32>
%180 = getelementptr inbounds i32, i32* %2, i64 %170
%181 = bitcast i32* %180 to <4 x i32>*
%182 = load <4 x i32>, <4 x i32>* %181
%183 = getelementptr inbounds i32, i32* %180, i64 4
%184 = bitcast i32* %183 to <4 x i32>*
%185 = load <4 x i32>, <4 x i32>* %184
%186 = or <4 x i32> %182, %178
%187 = or <4 x i32> %185, %179
%188 = bitcast i32* %180 to <4 x i32>*
store <4 x i32> %186, <4 x i32>* %188
%189 = bitcast i32* %183 to <4 x i32>*
store <4 x i32> %187, <4 x i32>* %189
%190 = add nuw i64 %149, 16
%191 = add i64 %150, 2
%192 = icmp eq i64 %191, %147
br i1 %192, label %193, label %148
193: ; preds = %148, %139
%194 = phi i64 [ 0, %139 ], [ %190, %148 ]
%195 = icmp eq i64 %144, 0
br i1 %195, label %216, label %196
196: ; preds = %193
%197 = add nsw i64 %194, %8
%198 = getelementptr inbounds i8, i8* %7, 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 = getelementptr inbounds i32, i32* %2, i64 %194
%207 = bitcast i32* %206 to <4 x i32>*
%208 = load <4 x i32>, <4 x i32>* %207
%209 = getelementptr inbounds i32, i32* %206, i64 4
%210 = bitcast i32* %209 to <4 x i32>*
%211 = load <4 x i32>, <4 x i32>* %210
%212 = or <4 x i32> %208, %204
%213 = or <4 x i32> %211, %205
%214 = bitcast i32* %206 to <4 x i32>*
store <4 x i32> %212, <4 x i32>* %214
%215 = bitcast i32* %209 to <4 x i32>*
store <4 x i32> %213, <4 x i32>* %215
br label %216
216: ; preds = %193, %196
%217 = icmp eq i64 %140, %16
br i1 %217, label %255, label %218
218: ; preds = %130, %127, %216
%219 = phi i64 [ 0, %130 ], [ 0, %127 ], [ %140, %216 ]
%220 = xor i64 %219, -1
%221 = and i64 %16, 1
%222 = icmp eq i64 %221, 0
br i1 %222, label %232, label %223
223: ; preds = %218
%224 = add nsw i64 %219, %8
%225 = getelementptr inbounds i8, i8* %7, i64 %224
%226 = load i8, i8* %225
%227 = zext i8 %226 to i32
%228 = getelementptr inbounds i32, i32* %2, i64 %219
%229 = load i32, i32* %228
%230 = or i32 %229, %227
store i32 %230, i32* %228
%231 = or i64 %219, 1
br label %232
232: ; preds = %223, %218
%233 = phi i64 [ %219, %218 ], [ %231, %223 ]
%234 = sub nsw i64 0, %16
%235 = icmp eq i64 %220, %234
br i1 %235, label %255, label %236
236: ; preds = %232, %236
%237 = phi i64 [ %253, %236 ], [ %233, %232 ]
%238 = add nsw i64 %237, %8
%239 = getelementptr inbounds i8, i8* %7, i64 %238
%240 = load i8, i8* %239
%241 = zext i8 %240 to i32
%242 = getelementptr inbounds i32, i32* %2, i64 %237
%243 = load i32, i32* %242
%244 = or i32 %243, %241
store i32 %244, i32* %242
%245 = add nuw nsw i64 %237, 1
%246 = add nsw i64 %245, %8
%247 = getelementptr inbounds i8, i8* %7, i64 %246
%248 = load i8, i8* %247
%249 = zext i8 %248 to i32
%250 = getelementptr inbounds i32, i32* %2, i64 %245
%251 = load i32, i32* %250
%252 = or i32 %251, %249
store i32 %252, i32* %250
%253 = add nuw nsw i64 %237, 2
%254 = icmp eq i64 %253, %128
br i1 %254, label %255, label %236
255: ; preds = %232, %236, %216
br i1 %11, label %256, label %377
256: ; preds = %255
%257 = zext i32 %1 to i64
%258 = icmp ult i32 %1, 8
br i1 %258, label %330, label %259
259: ; preds = %256
%260 = getelementptr i8, i8* %7, i64 %16
%261 = getelementptr i32, i32* %0, i64 %16
%262 = bitcast i32* %261 to i8*
%263 = icmp ult i8* %7, %262
%264 = icmp ugt i8* %260, %4
%265 = and i1 %263, %264
br i1 %265, label %330, label %266
266: ; preds = %259
%267 = and i64 %16, 4294967288
%268 = add nsw i64 %267, -8
%269 = lshr exact i64 %268, 3
%270 = add nuw nsw i64 %269, 1
%271 = and i64 %270, 1
%272 = icmp eq i64 %268, 0
br i1 %272, label %310, label %273
273: ; preds = %266
%274 = and i64 %270, 4611686018427387902
br label %275
275: ; preds = %275, %273
%276 = phi i64 [ 0, %273 ], [ %307, %275 ]
%277 = phi i64 [ 0, %273 ], [ %308, %275 ]
%278 = getelementptr inbounds i32, i32* %0, i64 %276
%279 = bitcast i32* %278 to <4 x i32>*
%280 = load <4 x i32>, <4 x i32>* %279
%281 = getelementptr inbounds i32, i32* %278, i64 4
%282 = bitcast i32* %281 to <4 x i32>*
%283 = load <4 x i32>, <4 x i32>* %282
%284 = lshr <4 x i32> %280, <i32 8, i32 8, i32 8, i32 8>
%285 = lshr <4 x i32> %283, <i32 8, i32 8, i32 8, i32 8>
%286 = trunc <4 x i32> %284 to <4 x i8>
%287 = trunc <4 x i32> %285 to <4 x i8>
%288 = getelementptr inbounds i8, i8* %7, i64 %276
%289 = bitcast i8* %288 to <4 x i8>*
store <4 x i8> %286, <4 x i8>* %289
%290 = getelementptr inbounds i8, i8* %288, i64 4
%291 = bitcast i8* %290 to <4 x i8>*
store <4 x i8> %287, <4 x i8>* %291
%292 = or i64 %276, 8
%293 = getelementptr inbounds i32, i32* %0, i64 %292
%294 = bitcast i32* %293 to <4 x i32>*
%295 = load <4 x i32>, <4 x i32>* %294
%296 = getelementptr inbounds i32, i32* %293, i64 4
%297 = bitcast i32* %296 to <4 x i32>*
%298 = load <4 x i32>, <4 x i32>* %297
%299 = lshr <4 x i32> %295, <i32 8, i32 8, i32 8, i32 8>
%300 = lshr <4 x i32> %298, <i32 8, i32 8, i32 8, i32 8>
%301 = trunc <4 x i32> %299 to <4 x i8>
%302 = trunc <4 x i32> %300 to <4 x i8>
%303 = getelementptr inbounds i8, i8* %7, i64 %292
%304 = bitcast i8* %303 to <4 x i8>*
store <4 x i8> %301, <4 x i8>* %304
%305 = getelementptr inbounds i8, i8* %303, i64 4
%306 = bitcast i8* %305 to <4 x i8>*
store <4 x i8> %302, <4 x i8>* %306
%307 = add nuw i64 %276, 16
%308 = add i64 %277, 2
%309 = icmp eq i64 %308, %274
br i1 %309, label %310, label %275
310: ; preds = %275, %266
%311 = phi i64 [ 0, %266 ], [ %307, %275 ]
%312 = icmp eq i64 %271, 0
br i1 %312, label %328, label %313
313: ; preds = %310
%314 = getelementptr inbounds i32, i32* %0, i64 %311
%315 = bitcast i32* %314 to <4 x i32>*
%316 = load <4 x i32>, <4 x i32>* %315
%317 = getelementptr inbounds i32, i32* %314, i64 4
%318 = bitcast i32* %317 to <4 x i32>*
%319 = load <4 x i32>, <4 x i32>* %318
%320 = lshr <4 x i32> %316, <i32 8, i32 8, i32 8, i32 8>
%321 = lshr <4 x i32> %319, <i32 8, i32 8, i32 8, i32 8>
%322 = trunc <4 x i32> %320 to <4 x i8>
%323 = trunc <4 x i32> %321 to <4 x i8>
%324 = getelementptr inbounds i8, i8* %7, i64 %311
%325 = bitcast i8* %324 to <4 x i8>*
store <4 x i8> %322, <4 x i8>* %325
%326 = getelementptr inbounds i8, i8* %324, i64 4
%327 = bitcast i8* %326 to <4 x i8>*
store <4 x i8> %323, <4 x i8>* %327
br label %328
328: ; preds = %310, %313
%329 = icmp eq i64 %267, %16
br i1 %329, label %379, label %330
330: ; preds = %259, %256, %328
%331 = phi i64 [ 0, %259 ], [ 0, %256 ], [ %267, %328 ]
%332 = xor i64 %331, -1
%333 = add nsw i64 %332, %16
%334 = and i64 %16, 3
%335 = icmp eq i64 %334, 0
br i1 %335, label %347, label %336
336: ; preds = %330, %336
%337 = phi i64 [ %344, %336 ], [ %331, %330 ]
%338 = phi i64 [ %345, %336 ], [ 0, %330 ]
%339 = getelementptr inbounds i32, i32* %0, i64 %337
%340 = load i32, i32* %339
%341 = lshr i32 %340, 8
%342 = trunc i32 %341 to i8
%343 = getelementptr inbounds i8, i8* %7, i64 %337
store i8 %342, i8* %343
%344 = add nuw nsw i64 %337, 1
%345 = add i64 %338, 1
%346 = icmp eq i64 %345, %334
br i1 %346, label %347, label %336
347: ; preds = %336, %330
%348 = phi i64 [ %331, %330 ], [ %344, %336 ]
%349 = icmp ult i64 %333, 3
br i1 %349, label %379, label %350
350: ; preds = %347, %350
%351 = phi i64 [ %375, %350 ], [ %348, %347 ]
%352 = getelementptr inbounds i32, i32* %0, i64 %351
%353 = load i32, i32* %352
%354 = lshr i32 %353, 8
%355 = trunc i32 %354 to i8
%356 = getelementptr inbounds i8, i8* %7, i64 %351
store i8 %355, i8* %356
%357 = add nuw nsw i64 %351, 1
%358 = getelementptr inbounds i32, i32* %0, i64 %357
%359 = load i32, i32* %358
%360 = lshr i32 %359, 8
%361 = trunc i32 %360 to i8
%362 = getelementptr inbounds i8, i8* %7, i64 %357
store i8 %361, i8* %362
%363 = add nuw nsw i64 %351, 2
%364 = getelementptr inbounds i32, i32* %0, i64 %363
%365 = load i32, i32* %364
%366 = lshr i32 %365, 8
%367 = trunc i32 %366 to i8
%368 = getelementptr inbounds i8, i8* %7, i64 %363
store i8 %367, i8* %368
%369 = add nuw nsw i64 %351, 3
%370 = getelementptr inbounds i32, i32* %0, i64 %369
%371 = load i32, i32* %370
%372 = lshr i32 %371, 8
%373 = trunc i32 %372 to i8
%374 = getelementptr inbounds i8, i8* %7, i64 %369
store i8 %373, i8* %374
%375 = add nuw nsw i64 %351, 4
%376 = icmp eq i64 %375, %257
br i1 %376, label %379, label %350
377: ; preds = %255, %13, %125
%378 = tail call i32 @comp_conv_to_mtf_byte(i8* %7, i32 %1, i8* %12)
br label %584
379: ; preds = %347, %350, %328
%380 = tail call i32 @comp_conv_to_mtf_byte(i8* %7, i32 %1, i8* %12)
br i1 %11, label %381, label %584
381: ; preds = %379
%382 = zext i32 %1 to i64
%383 = icmp ult i32 %1, 8
br i1 %383, label %422, label %384
384: ; preds = %381
%385 = getelementptr i32, i32* %2, i64 %16
%386 = bitcast i32* %385 to i8*
%387 = getelementptr i8, i8* %7, i64 %8
%388 = add nsw i64 %8, %16
%389 = getelementptr i8, i8* %7, i64 %388
%390 = icmp ugt i8* %389, %5
%391 = icmp ult i8* %387, %386
%392 = and i1 %390, %391
br i1 %392, label %422, label %393
393: ; preds = %384
%394 = and i64 %16, 4294967288
br label %395
395: ; preds = %395, %393
%396 = phi i64 [ 0, %393 ], [ %418, %395 ]
%397 = add nsw i64 %396, %8
%398 = getelementptr inbounds i8, i8* %7, i64 %397
%399 = bitcast i8* %398 to <4 x i8>*
%400 = load <4 x i8>, <4 x i8>* %399
%401 = getelementptr inbounds i8, i8* %398, i64 4
%402 = bitcast i8* %401 to <4 x i8>*
%403 = load <4 x i8>, <4 x i8>* %402
%404 = zext <4 x i8> %400 to <4 x i32>
%405 = zext <4 x i8> %403 to <4 x i32>
%406 = shl nuw nsw <4 x i32> %404, <i32 8, i32 8, i32 8, i32 8>
%407 = shl nuw nsw <4 x i32> %405, <i32 8, i32 8, i32 8, i32 8>
%408 = getelementptr inbounds i32, i32* %2, i64 %396
%409 = bitcast i32* %408 to <4 x i32>*
%410 = load <4 x i32>, <4 x i32>* %409
%411 = getelementptr inbounds i32, i32* %408, i64 4
%412 = bitcast i32* %411 to <4 x i32>*
%413 = load <4 x i32>, <4 x i32>* %412
%414 = or <4 x i32> %406, %410
%415 = or <4 x i32> %407, %413
%416 = bitcast i32* %408 to <4 x i32>*
store <4 x i32> %414, <4 x i32>* %416
%417 = bitcast i32* %411 to <4 x i32>*
store <4 x i32> %415, <4 x i32>* %417
%418 = add nuw i64 %396, 8
%419 = icmp eq i64 %418, %394
br i1 %419, label %420, label %395
420: ; preds = %395
%421 = icmp eq i64 %394, %16
br i1 %421, label %462, label %422
422: ; preds = %384, %381, %420
%423 = phi i64 [ 0, %384 ], [ 0, %381 ], [ %394, %420 ]
%424 = xor i64 %423, -1
%425 = and i64 %16, 1
%426 = icmp eq i64 %425, 0
br i1 %426, label %437, label %427
427: ; preds = %422
%428 = add nsw i64 %423, %8
%429 = getelementptr inbounds i8, i8* %7, i64 %428
%430 = load i8, i8* %429
%431 = zext i8 %430 to i32
%432 = shl nuw nsw i32 %431, 8
%433 = getelementptr inbounds i32, i32* %2, i64 %423
%434 = load i32, i32* %433
%435 = or i32 %432, %434
store i32 %435, i32* %433
%436 = or i64 %423, 1
br label %437
437: ; preds = %427, %422
%438 = phi i64 [ %423, %422 ], [ %436, %427 ]
%439 = sub nsw i64 0, %16
%440 = icmp eq i64 %424, %439
br i1 %440, label %462, label %441
441: ; preds = %437, %441
%442 = phi i64 [ %460, %441 ], [ %438, %437 ]
%443 = add nsw i64 %442, %8
%444 = getelementptr inbounds i8, i8* %7, i64 %443
%445 = load i8, i8* %444
%446 = zext i8 %445 to i32
%447 = shl nuw nsw i32 %446, 8
%448 = getelementptr inbounds i32, i32* %2, i64 %442
%449 = load i32, i32* %448
%450 = or i32 %447, %449
store i32 %450, i32* %448
%451 = add nuw nsw i64 %442, 1
%452 = add nsw i64 %451, %8
%453 = getelementptr inbounds i8, i8* %7, i64 %452
%454 = load i8, i8* %453
%455 = zext i8 %454 to i32
%456 = shl nuw nsw i32 %455, 8
%457 = getelementptr inbounds i32, i32* %2, i64 %451
%458 = load i32, i32* %457
%459 = or i32 %456, %458
store i32 %459, i32* %457
%460 = add nuw nsw i64 %442, 2
%461 = icmp eq i64 %460, %382
br i1 %461, label %462, label %441
462: ; preds = %437, %441, %420
br i1 %11, label %463, label %584
463: ; preds = %462
%464 = zext i32 %1 to i64
%465 = icmp ult i32 %1, 8
br i1 %465, label %537, label %466
466: ; preds = %463
%467 = getelementptr i8, i8* %7, i64 %16
%468 = getelementptr i32, i32* %0, i64 %16
%469 = bitcast i32* %468 to i8*
%470 = icmp ult i8* %7, %469
%471 = icmp ugt i8* %467, %4
%472 = and i1 %470, %471
br i1 %472, label %537, label %473
473: ; preds = %466
%474 = and i64 %16, 4294967288
%475 = add nsw i64 %474, -8
%476 = lshr exact i64 %475, 3
%477 = add nuw nsw i64 %476, 1
%478 = and i64 %477, 1
%479 = icmp eq i64 %475, 0
br i1 %479, label %517, label %480
480: ; preds = %473
%481 = and i64 %477, 4611686018427387902
br label %482
482: ; preds = %482, %480
%483 = phi i64 [ 0, %480 ], [ %514, %482 ]
%484 = phi i64 [ 0, %480 ], [ %515, %482 ]
%485 = getelementptr inbounds i32, i32* %0, i64 %483
%486 = bitcast i32* %485 to <4 x i32>*
%487 = load <4 x i32>, <4 x i32>* %486
%488 = getelementptr inbounds i32, i32* %485, i64 4
%489 = bitcast i32* %488 to <4 x i32>*
%490 = load <4 x i32>, <4 x i32>* %489
%491 = lshr <4 x i32> %487, <i32 16, i32 16, i32 16, i32 16>
%492 = lshr <4 x i32> %490, <i32 16, i32 16, i32 16, i32 16>
%493 = trunc <4 x i32> %491 to <4 x i8>
%494 = trunc <4 x i32> %492 to <4 x i8>
%495 = getelementptr inbounds i8, i8* %7, i64 %483
%496 = bitcast i8* %495 to <4 x i8>*
store <4 x i8> %493, <4 x i8>* %496
%497 = getelementptr inbounds i8, i8* %495, i64 4
%498 = bitcast i8* %497 to <4 x i8>*
store <4 x i8> %494, <4 x i8>* %498
%499 = or i64 %483, 8
%500 = getelementptr inbounds i32, i32* %0, i64 %499
%501 = bitcast i32* %500 to <4 x i32>*
%502 = load <4 x i32>, <4 x i32>* %501
%503 = getelementptr inbounds i32, i32* %500, i64 4
%504 = bitcast i32* %503 to <4 x i32>*
%505 = load <4 x i32>, <4 x i32>* %504
%506 = lshr <4 x i32> %502, <i32 16, i32 16, i32 16, i32 16>
%507 = lshr <4 x i32> %505, <i32 16, i32 16, i32 16, i32 16>
%508 = trunc <4 x i32> %506 to <4 x i8>
%509 = trunc <4 x i32> %507 to <4 x i8>
%510 = getelementptr inbounds i8, i8* %7, i64 %499
%511 = bitcast i8* %510 to <4 x i8>*
store <4 x i8> %508, <4 x i8>* %511
%512 = getelementptr inbounds i8, i8* %510, i64 4
%513 = bitcast i8* %512 to <4 x i8>*
store <4 x i8> %509, <4 x i8>* %513
%514 = add nuw i64 %483, 16
%515 = add i64 %484, 2
%516 = icmp eq i64 %515, %481
br i1 %516, label %517, label %482
517: ; preds = %482, %473
%518 = phi i64 [ 0, %473 ], [ %514, %482 ]
%519 = icmp eq i64 %478, 0
br i1 %519, label %535, label %520
520: ; preds = %517
%521 = getelementptr inbounds i32, i32* %0, i64 %518
%522 = bitcast i32* %521 to <4 x i32>*
%523 = load <4 x i32>, <4 x i32>* %522
%524 = getelementptr inbounds i32, i32* %521, i64 4
%525 = bitcast i32* %524 to <4 x i32>*
%526 = load <4 x i32>, <4 x i32>* %525
%527 = lshr <4 x i32> %523, <i32 16, i32 16, i32 16, i32 16>
%528 = lshr <4 x i32> %526, <i32 16, i32 16, i32 16, i32 16>
%529 = trunc <4 x i32> %527 to <4 x i8>
%530 = trunc <4 x i32> %528 to <4 x i8>
%531 = getelementptr inbounds i8, i8* %7, i64 %518
%532 = bitcast i8* %531 to <4 x i8>*
store <4 x i8> %529, <4 x i8>* %532
%533 = getelementptr inbounds i8, i8* %531, i64 4
%534 = bitcast i8* %533 to <4 x i8>*
store <4 x i8> %530, <4 x i8>* %534
br label %535
535: ; preds = %517, %520
%536 = icmp eq i64 %474, %16
br i1 %536, label %586, label %537
537: ; preds = %466, %463, %535
%538 = phi i64 [ 0, %466 ], [ 0, %463 ], [ %474, %535 ]
%539 = xor i64 %538, -1
%540 = add nsw i64 %539, %16
%541 = and i64 %16, 3
%542 = icmp eq i64 %541, 0
br i1 %542, label %554, label %543
543: ; preds = %537, %543
%544 = phi i64 [ %551, %543 ], [ %538, %537 ]
%545 = phi i64 [ %552, %543 ], [ 0, %537 ]
%546 = getelementptr inbounds i32, i32* %0, i64 %544
%547 = load i32, i32* %546
%548 = lshr i32 %547, 16
%549 = trunc i32 %548 to i8
%550 = getelementptr inbounds i8, i8* %7, i64 %544
store i8 %549, i8* %550
%551 = add nuw nsw i64 %544, 1
%552 = add i64 %545, 1
%553 = icmp eq i64 %552, %541
br i1 %553, label %554, label %543
554: ; preds = %543, %537
%555 = phi i64 [ %538, %537 ], [ %551, %543 ]
%556 = icmp ult i64 %540, 3
br i1 %556, label %586, label %557
557: ; preds = %554, %557
%558 = phi i64 [ %582, %557 ], [ %555, %554 ]
%559 = getelementptr inbounds i32, i32* %0, i64 %558
%560 = load i32, i32* %559
%561 = lshr i32 %560, 16
%562 = trunc i32 %561 to i8
%563 = getelementptr inbounds i8, i8* %7, i64 %558
store i8 %562, i8* %563
%564 = add nuw nsw i64 %558, 1
%565 = getelementptr inbounds i32, i32* %0, i64 %564
%566 = load i32, i32* %565
%567 = lshr i32 %566, 16
%568 = trunc i32 %567 to i8
%569 = getelementptr inbounds i8, i8* %7, i64 %564
store i8 %568, i8* %569
%570 = add nuw nsw i64 %558, 2
%571 = getelementptr inbounds i32, i32* %0, i64 %570
%572 = load i32, i32* %571
%573 = lshr i32 %572, 16
%574 = trunc i32 %573 to i8
%575 = getelementptr inbounds i8, i8* %7, i64 %570
store i8 %574, i8* %575
%576 = add nuw nsw i64 %558, 3
%577 = getelementptr inbounds i32, i32* %0, i64 %576
%578 = load i32, i32* %577
%579 = lshr i32 %578, 16
%580 = trunc i32 %579 to i8
%581 = getelementptr inbounds i8, i8* %7, i64 %576
store i8 %580, i8* %581
%582 = add nuw nsw i64 %558, 4
%583 = icmp eq i64 %582, %464
br i1 %583, label %586, label %557
584: ; preds = %462, %377, %379
%585 = tail call i32 @comp_conv_to_mtf_byte(i8* %7, i32 %1, i8* %12)
br label %669
586: ; preds = %554, %557, %535
%587 = tail call i32 @comp_conv_to_mtf_byte(i8* %7, i32 %1, i8* %12)
br i1 %11, label %588, label %669
588: ; preds = %586
%589 = zext i32 %1 to i64
%590 = icmp ult i32 %1, 8
br i1 %590, label %629, label %591
591: ; preds = %588
%592 = getelementptr i32, i32* %2, i64 %16
%593 = bitcast i32* %592 to i8*
%594 = getelementptr i8, i8* %7, i64 %8
%595 = add nsw i64 %8, %16
%596 = getelementptr i8, i8* %7, i64 %595
%597 = icmp ugt i8* %596, %5
%598 = icmp ult i8* %594, %593
%599 = and i1 %597, %598
br i1 %599, label %629, label %600
600: ; preds = %591
%601 = and i64 %16, 4294967288
br label %602
602: ; preds = %602, %600
%603 = phi i64 [ 0, %600 ], [ %625, %602 ]
%604 = add nsw i64 %603, %8
%605 = getelementptr inbounds i8, i8* %7, i64 %604
%606 = bitcast i8* %605 to <4 x i8>*
%607 = load <4 x i8>, <4 x i8>* %606
%608 = getelementptr inbounds i8, i8* %605, i64 4
%609 = bitcast i8* %608 to <4 x i8>*
%610 = load <4 x i8>, <4 x i8>* %609
%611 = zext <4 x i8> %607 to <4 x i32>
%612 = zext <4 x i8> %610 to <4 x i32>
%613 = shl nuw nsw <4 x i32> %611, <i32 16, i32 16, i32 16, i32 16>
%614 = shl nuw nsw <4 x i32> %612, <i32 16, i32 16, i32 16, i32 16>
%615 = getelementptr inbounds i32, i32* %2, i64 %603
%616 = bitcast i32* %615 to <4 x i32>*
%617 = load <4 x i32>, <4 x i32>* %616
%618 = getelementptr inbounds i32, i32* %615, i64 4
%619 = bitcast i32* %618 to <4 x i32>*
%620 = load <4 x i32>, <4 x i32>* %619
%621 = or <4 x i32> %613, %617
%622 = or <4 x i32> %614, %620
%623 = bitcast i32* %615 to <4 x i32>*
store <4 x i32> %621, <4 x i32>* %623
%624 = bitcast i32* %618 to <4 x i32>*
store <4 x i32> %622, <4 x i32>* %624
%625 = add nuw i64 %603, 8
%626 = icmp eq i64 %625, %601
br i1 %626, label %627, label %602
627: ; preds = %602
%628 = icmp eq i64 %601, %16
br i1 %628, label %669, label %629
629: ; preds = %591, %588, %627
%630 = phi i64 [ 0, %591 ], [ 0, %588 ], [ %601, %627 ]
%631 = xor i64 %630, -1
%632 = and i64 %16, 1
%633 = icmp eq i64 %632, 0
br i1 %633, label %644, label %634
634: ; preds = %629
%635 = add nsw i64 %630, %8
%636 = getelementptr inbounds i8, i8* %7, i64 %635
%637 = load i8, i8* %636
%638 = zext i8 %637 to i32
%639 = shl nuw nsw i32 %638, 16
%640 = getelementptr inbounds i32, i32* %2, i64 %630
%641 = load i32, i32* %640
%642 = or i32 %639, %641
store i32 %642, i32* %640
%643 = or i64 %630, 1
br label %644
644: ; preds = %634, %629
%645 = phi i64 [ %630, %629 ], [ %643, %634 ]
%646 = sub nsw i64 0, %16
%647 = icmp eq i64 %631, %646
br i1 %647, label %669, label %648
648: ; preds = %644, %648
%649 = phi i64 [ %667, %648 ], [ %645, %644 ]
%650 = add nsw i64 %649, %8
%651 = getelementptr inbounds i8, i8* %7, i64 %650
%652 = load i8, i8* %651
%653 = zext i8 %652 to i32
%654 = shl nuw nsw i32 %653, 16
%655 = getelementptr inbounds i32, i32* %2, i64 %649
%656 = load i32, i32* %655
%657 = or i32 %654, %656
store i32 %657, i32* %655
%658 = add nuw nsw i64 %649, 1
%659 = add nsw i64 %658, %8
%660 = getelementptr inbounds i8, i8* %7, i64 %659
%661 = load i8, i8* %660
%662 = zext i8 %661 to i32
%663 = shl nuw nsw i32 %662, 16
%664 = getelementptr inbounds i32, i32* %2, i64 %658
%665 = load i32, i32* %664
%666 = or i32 %663, %665
store i32 %666, i32* %664
%667 = add nuw nsw i64 %649, 2
%668 = icmp eq i64 %667, %589
br i1 %668, label %669, label %648
669: ; preds = %644, %648, %627, %584, %586
%670 = tail call i32 @free(i8* %7)
ret void
}