#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 */
int ConvertBitOrder();
void ConvertBlock(unsigned char *cnv, int *pattern) {
  int i, j, k;
  int bflg;
  unsigned char *ptr;
  unsigned char tmp[8];
  bflg = ConvertBitOrder();
  if (bflg == 1)
    return;
  ptr = cnv;
  for (i = 0; pattern[i] != 0; i += 2) {
    if (pattern[i] == 1)
      ptr += pattern[i + 1];
    else
      for (j = 0; j < pattern[i + 1]; j++) {
        for (k = 0; k < pattern[i]; k++)
          tmp[pattern[i] - 1 - k] = ptr[k];
        for (k = 0; k < pattern[i]; k++)
          ptr[k] = tmp[k];
        ptr += pattern[i];
      }
  }
}


x86 assembly (clang, -O0):
<ConvertBlock>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x0,%al
call   1030 <ConvertBitOrder@plt>
mov    %eax,-0x20(%rbp)
cmpl   $0x1,-0x20(%rbp)
jne    1139 <ConvertBlock+0x29>
jmp    1275 <ConvertBlock+0x165>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1275 <ConvertBlock+0x165>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    118f <ConvertBlock+0x7f>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    1262 <ConvertBlock+0x152>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    125d <ConvertBlock+0x14d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11fa <ConvertBlock+0xea>
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
sub    $0x1,%eax
sub    -0x1c(%rbp),%eax
cltq
mov    %cl,-0x30(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b6 <ConvertBlock+0xa6>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1236 <ConvertBlock+0x126>
movslq -0x1c(%rbp),%rax
mov    -0x30(%rbp,%rax,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1201 <ConvertBlock+0xf1>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1196 <ConvertBlock+0x86>
jmp    1262 <ConvertBlock+0x152>
jmp    1267 <ConvertBlock+0x157>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1148 <ConvertBlock+0x38>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ConvertBlock>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
xor    %eax,%eax
call   1030 <ConvertBitOrder@plt>
cmp    $0x1,%eax
jne    113b <ConvertBlock+0x2b>
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x9(%rsp),%r8
xor    %r15d,%r15d
pxor   %xmm0,%xmm0
jmp    1167 <ConvertBlock+0x57>
nopl   0x0(%rax)
lea    0x0(,%r15,4),%rax
or     $0x4,%rax
movslq (%r14,%rax,1),%rax
add    %rax,%rbx
add    $0x2,%r15
mov    (%r14,%r15,4),%esi
cmp    $0x1,%esi
je     1150 <ConvertBlock+0x40>
test   %esi,%esi
je     112e <ConvertBlock+0x1e>
mov    %r15,%r9
or     $0x1,%r9
mov    (%r14,%r9,4),%r10d
test   %r10d,%r10d
jle    1390 <ConvertBlock+0x280>
xor    %r11d,%r11d
jmp    11a3 <ConvertBlock+0x93>
nopl   (%rax)
movslq %esi,%rax
add    %rax,%rbx
add    $0x1,%r11d
cmp    %r10d,%r11d
jge    1390 <ConvertBlock+0x280>
test   %esi,%esi
jle    1190 <ConvertBlock+0x80>
mov    %esi,%r12d
cmp    $0x8,%esi
jb     11f0 <ConvertBlock+0xe0>
lea    -0x1(%r12),%rax
lea    -0x1(%rsi),%edi
mov    %edi,%ecx
sub    %eax,%ecx
cmp    %edi,%ecx
jg     11f0 <ConvertBlock+0xe0>
shr    $0x20,%rax
mov    $0x0,%eax
jne    11f2 <ConvertBlock+0xe2>
lea    -0x1(%rsi),%eax
cltq
lea    (%r8,%rax,1),%rcx
cmp    %rcx,%rbx
jae    127e <ConvertBlock+0x16e>
lea    (%rbx,%r12,1),%rcx
sub    %r12,%rax
add    %r8,%rax
cmp    %rcx,%rax
jae    127e <ConvertBlock+0x16e>
nop
xor    %eax,%eax
mov    %rax,%rcx
test   $0x1,%r12b
je     1212 <ConvertBlock+0x102>
mov    (%rbx,%rax,1),%cl
mov    %eax,%edi
not    %edi
add    %esi,%edi
movslq %edi,%rdi
mov    %cl,0x8(%rsp,%rdi,1)
mov    %rax,%rcx
or     $0x1,%rcx
not    %rax
add    %r12,%rax
je     1255 <ConvertBlock+0x145>
sub    %rcx,%r12
mov    %ecx,%eax
not    %eax
add    %esi,%eax
add    %rbx,%rcx
add    $0x1,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
movzbl -0x1(%rcx,%rdi,1),%edx
cltq
mov    %dl,0x8(%rsp,%rax,1)
movzbl (%rcx,%rdi,1),%edx
lea    -0x1(%rax),%ebp
movslq %ebp,%rbp
mov    %dl,0x8(%rsp,%rbp,1)
add    $0x2,%rdi
add    $0xfffffffe,%eax
cmp    %rdi,%r12
jne    1230 <ConvertBlock+0x120>
test   %esi,%esi
jle    1190 <ConvertBlock+0x80>
xor    %eax,%eax
nop
movzbl 0x8(%rsp,%rax,1),%ecx
mov    %cl,(%rbx,%rax,1)
add    $0x1,%rax
movslq (%r14,%r15,4),%rsi
cmp    %rsi,%rax
jl     1260 <ConvertBlock+0x150>
mov    (%r14,%r9,4),%r10d
jmp    1190 <ConvertBlock+0x80>
cmp    $0x20,%esi
jae    128a <ConvertBlock+0x17a>
xor    %eax,%eax
jmp    1339 <ConvertBlock+0x229>
mov    %r12d,%eax
and    $0xffffffe0,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rbx,%rcx,1),%xmm1
movdqu 0x10(%rbx,%rcx,1),%xmm2
movslq %edi,%rdi
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm1,-0x7(%rsp,%rdi,1)
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
movdqu %xmm2,-0x17(%rsp,%rdi,1)
add    $0x20,%rcx
add    $0xffffffe0,%edi
cmp    %rcx,%rax
jne    12a0 <ConvertBlock+0x190>
cmp    %r12,%rax
je     1255 <ConvertBlock+0x145>
test   $0x18,%r12b
je     11f2 <ConvertBlock+0xe2>
mov    %rax,%rcx
mov    %r12d,%eax
and    $0xfffffff8,%eax
mov    %ecx,%edi
not    %edi
add    %esi,%edi
nopl   0x0(%rax,%rax,1)
movq   (%rbx,%rcx,1),%xmm1
movslq %edi,%rdi
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x1(%rsp,%rdi,1)
add    $0x8,%rcx
add    $0xfffffff8,%edi
cmp    %rcx,%rax
jne    1350 <ConvertBlock+0x240>
cmp    %r12,%rax
je     1255 <ConvertBlock+0x145>
jmp    11f2 <ConvertBlock+0xe2>
nop
add    $0x2,%r15
jmp    1167 <ConvertBlock+0x57>

LLVM IR (-O0):
define void @ConvertBlock(i8* %0, i32* %1) {
%3 = alloca i8*
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca [8 x i8]
store i8* %0, i8** %3
store i32* %1, i32** %4
%11 = call i32 (...) @ConvertBitOrder()
store i32 %11, i32* %8
%12 = load i32, i32* %8
%13 = icmp eq i32 %12, 1
br i1 %13, label %14, label %15
14: ; preds = %2
br label %117
15: ; preds = %2
%16 = load i8*, i8** %3
store i8* %16, i8** %9
store i32 0, i32* %5
br label %17
17: ; preds = %114, %15
%18 = load i32*, i32** %4
%19 = load i32, i32* %5
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i32, i32* %18, i64 %20
%22 = load i32, i32* %21
%23 = icmp ne i32 %22, 0
br i1 %23, label %24, label %117
24: ; preds = %17
%25 = load i32*, i32** %4
%26 = load i32, i32* %5
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i32, i32* %25, i64 %27
%29 = load i32, i32* %28
%30 = icmp eq i32 %29, 1
br i1 %30, label %31, label %41
31: ; preds = %24
%32 = load i32*, i32** %4
%33 = load i32, i32* %5
%34 = add nsw i32 %33, 1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32, i32* %32, i64 %35
%37 = load i32, i32* %36
%38 = load i8*, i8** %9
%39 = sext i32 %37 to i64
%40 = getelementptr inbounds i8, i8* %38, i64 %39
store i8* %40, i8** %9
br label %113
41: ; preds = %24
store i32 0, i32* %6
br label %42
42: ; preds = %109, %41
%43 = load i32, i32* %6
%44 = load i32*, i32** %4
%45 = load i32, i32* %5
%46 = add nsw i32 %45, 1
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %44, i64 %47
%49 = load i32, i32* %48
%50 = icmp slt i32 %43, %49
br i1 %50, label %51, label %112
51: ; preds = %42
store i32 0, i32* %7
br label %52
52: ; preds = %76, %51
%53 = load i32, i32* %7
%54 = load i32*, i32** %4
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %54, i64 %56
%58 = load i32, i32* %57
%59 = icmp slt i32 %53, %58
br i1 %59, label %60, label %79
60: ; preds = %52
%61 = load i8*, i8** %9
%62 = load i32, i32* %7
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %61, i64 %63
%65 = load i8, i8* %64
%66 = load i32*, i32** %4
%67 = load i32, i32* %5
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
%70 = load i32, i32* %69
%71 = sub nsw i32 %70, 1
%72 = load i32, i32* %7
%73 = sub nsw i32 %71, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [8 x i8], [8 x i8]* %10, i64 0, i64 %74
store i8 %65, i8* %75
br label %76
76: ; preds = %60
%77 = load i32, i32* %7
%78 = add nsw i32 %77, 1
store i32 %78, i32* %7
br label %52
79: ; preds = %52
store i32 0, i32* %7
br label %80
80: ; preds = %97, %79
%81 = load i32, i32* %7
%82 = load i32*, i32** %4
%83 = load i32, i32* %5
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %82, i64 %84
%86 = load i32, i32* %85
%87 = icmp slt i32 %81, %86
br i1 %87, label %88, label %100
88: ; preds = %80
%89 = load i32, i32* %7
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [8 x i8], [8 x i8]* %10, i64 0, i64 %90
%92 = load i8, i8* %91
%93 = load i8*, i8** %9
%94 = load i32, i32* %7
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %93, i64 %95
store i8 %92, i8* %96
br label %97
97: ; preds = %88
%98 = load i32, i32* %7
%99 = add nsw i32 %98, 1
store i32 %99, i32* %7
br label %80
100: ; preds = %80
%101 = load i32*, i32** %4
%102 = load i32, i32* %5
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %101, i64 %103
%105 = load i32, i32* %104
%106 = load i8*, i8** %9
%107 = sext i32 %105 to i64
%108 = getelementptr inbounds i8, i8* %106, i64 %107
store i8* %108, i8** %9
br label %109
109: ; preds = %100
%110 = load i32, i32* %6
%111 = add nsw i32 %110, 1
store i32 %111, i32* %6
br label %42
112: ; preds = %42
br label %113
113: ; preds = %112, %31
br label %114
114: ; preds = %113
%115 = load i32, i32* %5
%116 = add nsw i32 %115, 2
store i32 %116, i32* %5
br label %17
117: ; preds = %14, %17
ret void
}

LLVM IR (-O2):
define void @ConvertBlock(i8* nocapture %0, i32* nocapture %1) {
%3 = alloca [8 x i8]
%4 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 0
%5 = tail call i32 (...) @ConvertBitOrder()
%6 = icmp eq i32 %5, 1
br i1 %6, label %163, label %7
7: ; preds = %2
%8 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 1
%9 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 1
br label %10
10: ; preds = %7, %160
%11 = phi i64 [ %162, %160 ], [ 0, %7 ]
%12 = phi i8* [ %161, %160 ], [ %0, %7 ]
%13 = getelementptr inbounds i32, i32* %1, i64 %11
%14 = load i32, i32* %13
switch i32 %14, label %15 [
i32 0, label %163
i32 1, label %20
]
15: ; preds = %10
%16 = or i64 %11, 1
%17 = getelementptr inbounds i32, i32* %1, i64 %16
%18 = load i32, i32* %17
%19 = icmp sgt i32 %18, 0
br i1 %19, label %26, label %160
20: ; preds = %10
%21 = or i64 %11, 1
%22 = getelementptr inbounds i32, i32* %1, i64 %21
%23 = load i32, i32* %22
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %12, i64 %24
br label %160
26: ; preds = %15, %153
%27 = phi i32 [ %154, %153 ], [ %18, %15 ]
%28 = phi i32 [ %155, %153 ], [ %14, %15 ]
%29 = phi i8* [ %157, %153 ], [ %12, %15 ]
%30 = phi i32 [ %158, %153 ], [ 0, %15 ]
%31 = icmp sgt i32 %28, 0
br i1 %31, label %32, label %153
32: ; preds = %26
%33 = zext i32 %28 to i64
%34 = icmp ult i32 %28, 8
br i1 %34, label %104, label %35
35: ; preds = %32
%36 = add nsw i64 %33, -1
%37 = add i32 %28, -1
%38 = trunc i64 %36 to i32
%39 = sub i32 %37, %38
%40 = icmp sgt i32 %39, %37
%41 = icmp ugt i64 %36, 4294967295
%42 = or i1 %40, %41
br i1 %42, label %104, label %43
43: ; preds = %35
%44 = getelementptr i8, i8* %29, i64 %33
%45 = add i32 %28, -1
%46 = sext i32 %45 to i64
%47 = sub nsw i64 %46, %33
%48 = getelementptr i8, i8* %8, i64 %47
%49 = getelementptr i8, i8* %9, i64 %46
%50 = icmp ult i8* %29, %49
%51 = icmp ult i8* %48, %44
%52 = and i1 %50, %51
br i1 %52, label %104, label %53
53: ; preds = %43
%54 = icmp ult i32 %28, 32
br i1 %54, label %83, label %55
55: ; preds = %53
%56 = and i64 %33, 4294967264
br label %57
57: ; preds = %57, %55
%58 = phi i64 [ 0, %55 ], [ %76, %57 ]
%59 = trunc i64 %58 to i32
%60 = getelementptr inbounds i8, i8* %29, i64 %58
%61 = bitcast i8* %60 to <16 x i8>*
%62 = load <16 x i8>, <16 x i8>* %61
%63 = getelementptr inbounds i8, i8* %60, i64 16
%64 = bitcast i8* %63 to <16 x i8>*
%65 = load <16 x i8>, <16 x i8>* %64
%66 = xor i32 %59, -1
%67 = add i32 %28, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 %68
%70 = shufflevector <16 x i8> %62, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%71 = getelementptr inbounds i8, i8* %69, i64 -15
%72 = bitcast i8* %71 to <16 x i8>*
store <16 x i8> %70, <16 x i8>* %72
%73 = shufflevector <16 x i8> %65, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%74 = getelementptr inbounds i8, i8* %69, i64 -31
%75 = bitcast i8* %74 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %75
%76 = add nuw i64 %58, 32
%77 = icmp eq i64 %76, %56
br i1 %77, label %78, label %57
78: ; preds = %57
%79 = icmp eq i64 %56, %33
br i1 %79, label %122, label %80
80: ; preds = %78
%81 = and i64 %33, 24
%82 = icmp eq i64 %81, 0
br i1 %82, label %104, label %83
83: ; preds = %53, %80
%84 = phi i64 [ %56, %80 ], [ 0, %53 ]
%85 = zext i32 %28 to i64
%86 = and i64 %85, 4294967288
br label %87
87: ; preds = %87, %83
%88 = phi i64 [ %84, %83 ], [ %100, %87 ]
%89 = trunc i64 %88 to i32
%90 = getelementptr inbounds i8, i8* %29, i64 %88
%91 = bitcast i8* %90 to <8 x i8>*
%92 = load <8 x i8>, <8 x i8>* %91
%93 = xor i32 %89, -1
%94 = add i32 %28, %93
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 %95
%97 = shufflevector <8 x i8> %92, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%98 = getelementptr inbounds i8, i8* %96, i64 -7
%99 = bitcast i8* %98 to <8 x i8>*
store <8 x i8> %97, <8 x i8>* %99
%100 = add nuw i64 %88, 8
%101 = icmp eq i64 %100, %86
br i1 %101, label %102, label %87
102: ; preds = %87
%103 = icmp eq i64 %86, %85
br i1 %103, label %122, label %104
104: ; preds = %43, %35, %32, %80, %102
%105 = phi i64 [ 0, %32 ], [ 0, %43 ], [ 0, %35 ], [ %56, %80 ], [ %86, %102 ]
%106 = xor i64 %105, -1
%107 = and i64 %33, 1
%108 = icmp eq i64 %107, 0
br i1 %108, label %118, label %109
109: ; preds = %104
%110 = getelementptr inbounds i8, i8* %29, i64 %105
%111 = load i8, i8* %110
%112 = trunc i64 %105 to i32
%113 = xor i32 %112, -1
%114 = add i32 %28, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 %115
store i8 %111, i8* %116
%117 = or i64 %105, 1
br label %118
118: ; preds = %109, %104
%119 = phi i64 [ %105, %104 ], [ %117, %109 ]
%120 = sub nsw i64 0, %33
%121 = icmp eq i64 %106, %120
br i1 %121, label %122, label %123
122: ; preds = %118, %123, %102, %78
br i1 %31, label %142, label %153
123: ; preds = %118, %123
%124 = phi i64 [ %140, %123 ], [ %119, %118 ]
%125 = getelementptr inbounds i8, i8* %29, i64 %124
%126 = load i8, i8* %125
%127 = trunc i64 %124 to i32
%128 = xor i32 %127, -1
%129 = add i32 %28, %128
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 %130
store i8 %126, i8* %131
%132 = add nuw nsw i64 %124, 1
%133 = getelementptr inbounds i8, i8* %29, i64 %132
%134 = load i8, i8* %133
%135 = trunc i64 %132 to i32
%136 = xor i32 %135, -1
%137 = add i32 %28, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 %138
store i8 %134, i8* %139
%140 = add nuw nsw i64 %124, 2
%141 = icmp eq i64 %140, %33
br i1 %141, label %122, label %123
142: ; preds = %122, %142
%143 = phi i64 [ %147, %142 ], [ 0, %122 ]
%144 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 %143
%145 = load i8, i8* %144
%146 = getelementptr inbounds i8, i8* %29, i64 %143
store i8 %145, i8* %146
%147 = add nuw nsw i64 %143, 1
%148 = load i32, i32* %13
%149 = sext i32 %148 to i64
%150 = icmp slt i64 %147, %149
br i1 %150, label %142, label %151
151: ; preds = %142
%152 = load i32, i32* %17
br label %153
153: ; preds = %122, %26, %151
%154 = phi i32 [ %152, %151 ], [ %27, %26 ], [ %27, %122 ]
%155 = phi i32 [ %148, %151 ], [ %28, %26 ], [ %28, %122 ]
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %29, i64 %156
%158 = add nuw nsw i32 %30, 1
%159 = icmp slt i32 %158, %154
br i1 %159, label %26, label %160
160: ; preds = %153, %15, %20
%161 = phi i8* [ %25, %20 ], [ %12, %15 ], [ %157, %153 ]
%162 = add nuw i64 %11, 2
br label %10
163: ; preds = %10, %2
ret void
}