#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 */
void expand(char *source, char *target) {
  size_t i;
  int buffer[3] = {'\0', '\0', '\0'};
  size_t bufflen = 0;
  while (*source != '\0') {
    if (bufflen < 3)
      buffer[bufflen++] = *source;
    else {
      int k;
      *target++ = buffer[0];
      for (k = 1; k < 3; k++)
        buffer[k - 1] = buffer[k];
      buffer[2] = *source;
    }
    if (bufflen == 3 && buffer[1] == '-') {
      char temp;
      bool up = (buffer[0] < buffer[2]);
      for (temp = buffer[0]; (up) ? (temp < buffer[2]) : (temp > buffer[2]);
           temp += (up) ? 1 : -1)
        *target++ = temp;
      buffer[0] = buffer[2];
      bufflen = 1;
    }
    source++;
  }
  for (i = 0; i < bufflen; i++)
    *target++ = buffer[i];
  *target = '\0';
}


x86 assembly (clang, -O0):
<expand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x24(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1030 <memset@plt>
movq   $0x0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1284 <expand+0x174>
cmpq   $0x3,-0x30(%rbp)
jae    1172 <expand+0x62>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,-0x24(%rbp,%rax,4)
jmp    11c5 <expand+0xb5>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
movl   $0x1,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    11bb <expand+0xab>
movslq -0x34(%rbp),%rax
mov    -0x24(%rbp,%rax,4),%ecx
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x24(%rbp,%rax,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118f <expand+0x7f>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x1c(%rbp)
cmpq   $0x3,-0x30(%rbp)
jne    1273 <expand+0x163>
cmpl   $0x2d,-0x20(%rbp)
jne    1273 <expand+0x163>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x24(%rbp),%eax
mov    %al,-0x35(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1212 <expand+0x102>
movsbl -0x35(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x40(%rbp)
jmp    1224 <expand+0x114>
movsbl -0x35(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    $0x0,%eax
je     1265 <expand+0x155>
mov    -0x35(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x3c(%rbp),%edx
mov    $0xffffffff,%ecx
mov    $0x1,%eax
cmp    $0x0,%edx
cmovne %eax,%ecx
movsbl -0x35(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x35(%rbp)
jmp    11f1 <expand+0xe1>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
movq   $0x1,-0x30(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1138 <expand+0x28>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    12c6 <expand+0x1b6>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp,%rax,4),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    128c <expand+0x17c>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<expand>:
movl   $0x0,-0x8(%rsp)
movq   $0x0,-0x10(%rsp)
mov    (%rdi),%cl
test   %cl,%cl
je     1380 <expand+0x280>
xor    %r9d,%r9d
jmp    1139 <expand+0x39>
mov    %eax,-0x10(%rsp)
mov    $0x1,%r9d
mov    0x1(%rdi),%cl
add    $0x1,%rdi
test   %cl,%cl
je     11cf <expand+0xcf>
cmp    $0x2,%r9
ja     1160 <expand+0x60>
movsbl %cl,%ecx
mov    %ecx,-0x10(%rsp,%r9,4)
add    $0x1,%r9
cmp    $0x3,%r9
je     1181 <expand+0x81>
jmp    112a <expand+0x2a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x10(%rsp),%cl
mov    %cl,(%rsi)
mov    -0xc(%rsp),%rcx
mov    %rcx,-0x10(%rsp)
add    $0x1,%rsi
movsbl (%rdi),%ecx
mov    %ecx,-0x8(%rsp)
cmp    $0x3,%r9
jne    112a <expand+0x2a>
cmpl   $0x2d,-0xc(%rsp)
jne    112a <expand+0x2a>
mov    -0x10(%rsp),%r9d
mov    -0x8(%rsp),%r8d
mov    %r9d,%edx
jmp    11b5 <expand+0xb5>
nopw   0x0(%rax,%rax,1)
mov    $0xffffffff,%edx
cmp    %eax,%ecx
jle    1120 <expand+0x20>
mov    %cl,(%rsi)
add    $0x1,%rsi
add    %ecx,%edx
movsbl %dl,%ecx
mov    -0x8(%rsp),%eax
cmp    %r8d,%r9d
jge    11a0 <expand+0xa0>
mov    $0x1,%edx
cmp    %eax,%ecx
jl     11ad <expand+0xad>
jmp    1120 <expand+0x20>
cmp    $0x8,%r9
jb     11f8 <expand+0xf8>
lea    (%rsp,%r9,4),%rcx
add    $0xfffffffffffffff0,%rcx
cmp    %rcx,%rsi
jae    1297 <expand+0x197>
lea    (%rsi,%r9,1),%rcx
lea    -0x10(%rsp),%rdx
cmp    %rdx,%rcx
jbe    1297 <expand+0x197>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rdi
and    $0x7,%rdi
je     1225 <expand+0x125>
nopl   0x0(%rax)
movzbl -0x10(%rsp,%rcx,4),%edx
mov    %dl,(%rsi)
add    $0x1,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1210 <expand+0x110>
cmp    $0x7,%r8
jb     1380 <expand+0x280>
sub    %rcx,%r9
lea    (%rsp,%rcx,4),%rdx
add    $0xc,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl -0x1c(%rdx,%rcx,4),%eax
mov    %al,(%rsi,%rcx,1)
movzbl -0x18(%rdx,%rcx,4),%eax
mov    %al,0x1(%rsi,%rcx,1)
movzbl -0x14(%rdx,%rcx,4),%eax
mov    %al,0x2(%rsi,%rcx,1)
movzbl -0x10(%rdx,%rcx,4),%eax
mov    %al,0x3(%rsi,%rcx,1)
movzbl -0xc(%rdx,%rcx,4),%eax
mov    %al,0x4(%rsi,%rcx,1)
movzbl -0x8(%rdx,%rcx,4),%eax
mov    %al,0x5(%rsi,%rcx,1)
movzbl -0x4(%rdx,%rcx,4),%eax
mov    %al,0x6(%rsi,%rcx,1)
movzbl (%rdx,%rcx,4),%eax
mov    %al,0x7(%rsi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%r9
jne    1240 <expand+0x140>
add    %rcx,%rsi
jmp    1380 <expand+0x280>
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1384 <expand+0x284>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0xd39(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rsp,%rdx,4),%xmm1
movdqu (%rsp,%rdx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,(%rsi,%rdx,1)
movd   %xmm2,0x4(%rsi,%rdx,1)
movdqu 0x10(%rsp,%rdx,4),%xmm1
movdqu 0x20(%rsp,%rdx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%rsi,%rdx,1)
movd   %xmm2,0xc(%rsi,%rdx,1)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12d0 <expand+0x1d0>
test   $0x1,%r8b
je     1374 <expand+0x274>
movdqu -0x10(%rsp,%rdx,4),%xmm0
movdqu (%rsp,%rdx,4),%xmm1
movdqa 0xcaf(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rsi,%rdx,1)
movd   %xmm1,0x4(%rsi,%rdx,1)
add    %rcx,%rsi
cmp    %rcx,%r9
jne    11fa <expand+0xfa>
movb   $0x0,(%rsi)
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    133e <expand+0x23e>
jmp    1374 <expand+0x274>

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

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