#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 long mmini_huffman_compress(unsigned char *, unsigned long,
                                     unsigned char *, unsigned long, void *);
unsigned long mmini_lzl_compress(unsigned char *, unsigned long,
                                 unsigned char *, unsigned long);
unsigned long mmini_compress(unsigned char *in, unsigned long inlen,
                             unsigned char *tmp, unsigned long tmplen,
                             unsigned char *out, unsigned long outlen,
                             void *huffheap) {
  unsigned long l;
  if (outlen < (inlen + 3))
    return 0;
  if (tmplen < inlen)
    return 0;
  l = mmini_lzl_compress(in, inlen, tmp, tmplen);
  if ((l) && (l < inlen)) {
    l = mmini_huffman_compress(tmp, l, out + 3, inlen + 3, huffheap);
    if (l) {
      out[0] = (unsigned char)((inlen >> 16) & 0xff);
      out[1] = (unsigned char)((inlen >> 8) & 0xff);
      out[2] = (unsigned char)(inlen & 0xff);
      return (l + 3);
    }
  }
  out[0] = (unsigned char)0;
  out[1] = (unsigned char)0;
  out[2] = (unsigned char)0;
  for (l = 0; l < inlen; ++l)
    out[l + 3] = in[l];
  return (inlen + 3);
}


x86 assembly (clang, -O0):
<mmini_compress>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
jae    1166 <mmini_compress+0x46>
movq   $0x0,-0x8(%rbp)
jmp    129a <mmini_compress+0x17a>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1181 <mmini_compress+0x61>
movq   $0x0,-0x8(%rbp)
jmp    129a <mmini_compress+0x17a>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
call   1030 <mmini_lzl_compress@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1239 <mmini_compress+0x119>
mov    -0x40(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1239 <mmini_compress+0x119>
mov    -0x20(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x30(%rbp),%rdx
add    $0x3,%rdx
mov    -0x18(%rbp),%rcx
add    $0x3,%rcx
mov    0x10(%rbp),%r8
call   1040 <mmini_huffman_compress@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1234 <mmini_compress+0x114>
mov    -0x18(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x18(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x40(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x8(%rbp)
jmp    129a <mmini_compress+0x17a>
jmp    1239 <mmini_compress+0x119>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x30(%rbp),%rax
movb   $0x0,0x1(%rax)
mov    -0x30(%rbp),%rax
movb   $0x0,0x2(%rax)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    128e <mmini_compress+0x16e>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %dl,0x3(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1258 <mmini_compress+0x138>
mov    -0x18(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mmini_compress>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
xor    %eax,%eax
cmp    %rsi,%rcx
jb     1246 <mmini_compress+0x126>
lea    0x3(%rsi),%r14
cmp    %r9,%r14
ja     1246 <mmini_compress+0x126>
mov    %r8,%rbp
mov    %rdx,%r15
mov    %rdi,%rbx
mov    %rsi,%r12
call   1030 <mmini_lzl_compress@plt>
mov    %r12,%rdx
test   %rax,%rax
je     1196 <mmini_compress+0x76>
cmp    %rdx,%rax
jae    1196 <mmini_compress+0x76>
mov    0x30(%rsp),%r8
lea    0x3(%rbp),%rdx
mov    %r15,%rdi
mov    %rax,%rsi
mov    %r14,%rcx
call   1040 <mmini_huffman_compress@plt>
test   %rax,%rax
je     11b1 <mmini_compress+0x91>
mov    %r12,%rdx
mov    %r12,%rcx
shr    $0x10,%rcx
mov    %cl,0x0(%rbp)
mov    %dh,0x1(%rbp)
mov    %dl,0x2(%rbp)
add    $0x3,%rax
jmp    1246 <mmini_compress+0x126>
movw   $0x0,0x0(%rbp)
movb   $0x0,0x2(%rbp)
test   %rdx,%rdx
je     1241 <mmini_compress+0x121>
cmp    $0x8,%rdx
jae    11c4 <mmini_compress+0xa4>
jmp    11de <mmini_compress+0xbe>
movw   $0x0,0x0(%rbp)
movb   $0x0,0x2(%rbp)
mov    %r12,%rdx
cmp    $0x8,%rdx
jb     11de <mmini_compress+0xbe>
lea    0x3(%rbp),%rax
lea    (%rbx,%rdx,1),%rcx
cmp    %rcx,%rax
jae    124f <mmini_compress+0x12f>
lea    (%rdx,%rbp,1),%rax
add    $0x3,%rax
cmp    %rbx,%rax
jbe    124f <mmini_compress+0x12f>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rdx,%rsi
and    $0x3,%rdx
je     1202 <mmini_compress+0xe2>
nop
movzbl (%rbx,%rax,1),%ecx
mov    %cl,0x3(%rbp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11f0 <mmini_compress+0xd0>
cmp    $0x3,%rsi
jb     123c <mmini_compress+0x11c>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,1),%ecx
mov    %cl,0x3(%rbp,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
mov    %cl,0x4(%rbp,%rax,1)
movzbl 0x2(%rbx,%rax,1),%ecx
mov    %cl,0x5(%rbp,%rax,1)
movzbl 0x3(%rbx,%rax,1),%ecx
mov    %cl,0x6(%rbp,%rax,1)
add    $0x4,%rax
cmp    %rax,%r12
jne    1210 <mmini_compress+0xf0>
mov    %r14,%rax
jmp    1246 <mmini_compress+0x126>
mov    $0x3,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%rdx
jae    125c <mmini_compress+0x13c>
xor    %eax,%eax
jmp    1329 <mmini_compress+0x209>
mov    %rdx,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x60,%rdx
jae    1281 <mmini_compress+0x161>
xor    %edx,%edx
jmp    12e9 <mmini_compress+0x1c9>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rdx,1),%xmm0
movups 0x10(%rbx,%rdx,1),%xmm1
movups %xmm0,0x3(%rbp,%rdx,1)
movups %xmm1,0x13(%rbp,%rdx,1)
movups 0x20(%rbx,%rdx,1),%xmm0
movups 0x30(%rbx,%rdx,1),%xmm1
movups %xmm0,0x23(%rbp,%rdx,1)
movups %xmm1,0x33(%rbp,%rdx,1)
movups 0x40(%rbx,%rdx,1),%xmm0
movups 0x50(%rbx,%rdx,1),%xmm1
movups %xmm0,0x43(%rbp,%rdx,1)
movups %xmm1,0x53(%rbp,%rdx,1)
movups 0x60(%rbx,%rdx,1),%xmm0
movups 0x70(%rbx,%rdx,1),%xmm1
movups %xmm0,0x63(%rbp,%rdx,1)
movups %xmm1,0x73(%rbp,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1290 <mmini_compress+0x170>
test   %rcx,%rcx
je     1314 <mmini_compress+0x1f4>
xchg   %ax,%ax
movups (%rbx,%rdx,1),%xmm0
movups 0x10(%rbx,%rdx,1),%xmm1
mov    %rdx,%rsi
or     $0x3,%rsi
movups %xmm0,0x0(%rbp,%rsi,1)
movups %xmm1,0x10(%rbp,%rsi,1)
add    $0x20,%rdx
add    $0xffffffffffffffff,%rcx
jne    12f0 <mmini_compress+0x1d0>
cmp    %r12,%rax
je     123c <mmini_compress+0x11c>
mov    %r12,%rdx
test   $0x18,%dl
je     11e0 <mmini_compress+0xc0>
mov    %rax,%rcx
mov    %rdx,%rax
and    $0xfffffffffffffff8,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rcx,1),%rdx
mov    %rdx,0x3(%rbp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1340 <mmini_compress+0x220>
mov    %r12,%rdx
cmp    %r12,%rax
je     123c <mmini_compress+0x11c>
jmp    11e0 <mmini_compress+0xc0>

LLVM IR (-O0):
define i64 @mmini_compress(i8* %0, i64 %1, i8* %2, i64 %3, i8* %4, i64 %5, i8* %6) {
%8 = alloca i64
%9 = alloca i8*
%10 = alloca i64
%11 = alloca i8*
%12 = alloca i64
%13 = alloca i8*
%14 = alloca i64
%15 = alloca i8*
%16 = alloca i64
store i8* %0, i8** %9
store i64 %1, i64* %10
store i8* %2, i8** %11
store i64 %3, i64* %12
store i8* %4, i8** %13
store i64 %5, i64* %14
store i8* %6, i8** %15
%17 = load i64, i64* %14
%18 = load i64, i64* %10
%19 = add i64 %18, 3
%20 = icmp ult i64 %17, %19
br i1 %20, label %21, label %22
21: ; preds = %7
store i64 0, i64* %8
br label %97
22: ; preds = %7
%23 = load i64, i64* %12
%24 = load i64, i64* %10
%25 = icmp ult i64 %23, %24
br i1 %25, label %26, label %27
26: ; preds = %22
store i64 0, i64* %8
br label %97
27: ; preds = %22
%28 = load i8*, i8** %9
%29 = load i64, i64* %10
%30 = load i8*, i8** %11
%31 = load i64, i64* %12
%32 = call i64 @mmini_lzl_compress(i8* %28, i64 %29, i8* %30, i64 %31)
store i64 %32, i64* %16
%33 = load i64, i64* %16
%34 = icmp ne i64 %33, 0
br i1 %34, label %35, label %71
35: ; preds = %27
%36 = load i64, i64* %16
%37 = load i64, i64* %10
%38 = icmp ult i64 %36, %37
br i1 %38, label %39, label %71
39: ; preds = %35
%40 = load i8*, i8** %11
%41 = load i64, i64* %16
%42 = load i8*, i8** %13
%43 = getelementptr inbounds i8, i8* %42, i64 3
%44 = load i64, i64* %10
%45 = add i64 %44, 3
%46 = load i8*, i8** %15
%47 = call i64 @mmini_huffman_compress(i8* %40, i64 %41, i8* %43, i64 %45, i8* %46)
store i64 %47, i64* %16
%48 = load i64, i64* %16
%49 = icmp ne i64 %48, 0
br i1 %49, label %50, label %70
50: ; preds = %39
%51 = load i64, i64* %10
%52 = lshr i64 %51, 16
%53 = and i64 %52, 255
%54 = trunc i64 %53 to i8
%55 = load i8*, i8** %13
%56 = getelementptr inbounds i8, i8* %55, i64 0
store i8 %54, i8* %56
%57 = load i64, i64* %10
%58 = lshr i64 %57, 8
%59 = and i64 %58, 255
%60 = trunc i64 %59 to i8
%61 = load i8*, i8** %13
%62 = getelementptr inbounds i8, i8* %61, i64 1
store i8 %60, i8* %62
%63 = load i64, i64* %10
%64 = and i64 %63, 255
%65 = trunc i64 %64 to i8
%66 = load i8*, i8** %13
%67 = getelementptr inbounds i8, i8* %66, i64 2
store i8 %65, i8* %67
%68 = load i64, i64* %16
%69 = add i64 %68, 3
store i64 %69, i64* %8
br label %97
70: ; preds = %39
br label %71
71: ; preds = %70, %35, %27
%72 = load i8*, i8** %13
%73 = getelementptr inbounds i8, i8* %72, i64 0
store i8 0, i8* %73
%74 = load i8*, i8** %13
%75 = getelementptr inbounds i8, i8* %74, i64 1
store i8 0, i8* %75
%76 = load i8*, i8** %13
%77 = getelementptr inbounds i8, i8* %76, i64 2
store i8 0, i8* %77
store i64 0, i64* %16
br label %78
78: ; preds = %91, %71
%79 = load i64, i64* %16
%80 = load i64, i64* %10
%81 = icmp ult i64 %79, %80
br i1 %81, label %82, label %94
82: ; preds = %78
%83 = load i8*, i8** %9
%84 = load i64, i64* %16
%85 = getelementptr inbounds i8, i8* %83, i64 %84
%86 = load i8, i8* %85
%87 = load i8*, i8** %13
%88 = load i64, i64* %16
%89 = add i64 %88, 3
%90 = getelementptr inbounds i8, i8* %87, i64 %89
store i8 %86, i8* %90
br label %91
91: ; preds = %82
%92 = load i64, i64* %16
%93 = add i64 %92, 1
store i64 %93, i64* %16
br label %78
94: ; preds = %78
%95 = load i64, i64* %10
%96 = add i64 %95, 3
store i64 %96, i64* %8
br label %97
97: ; preds = %94, %50, %26, %21
%98 = load i64, i64* %8
ret i64 %98
}

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