#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 /*<<< orphan*/ memcpy(unsigned char *, unsigned char const *, int);
int /*<<< orphan*/ memset(unsigned char *, unsigned char, int);
size_t sas_rle_decompress(void *output_buf, size_t output_len,
                          const void *input_buf, size_t input_len) {
  unsigned char *buffer = (unsigned char *)output_buf;
  unsigned char *output = buffer;
  const unsigned char *input = (const unsigned char *)input_buf;
  while (input < (const unsigned char *)input_buf + input_len) {
    unsigned char control = *input++;
    unsigned char command = (control & 0xF0) >> 4;
    unsigned char length = (control & 0x0F);
    int copy_len = 0;
    int insert_len = 0;
    unsigned char insert_byte = '\0';
    switch (command) {
    case 0:
      copy_len = (*input++) + 64 + length * 256;
      break;
    case 4:
      insert_len = (*input++) + 18 + length * 16;
      insert_byte = *input++;
      break;
    case 5:
      insert_len = (*input++) + 17 + length * 256;
      insert_byte = '@';
      break;
    case 6:
      insert_len = (*input++) + 17 + length * 256;
      insert_byte = ' ';
      break;
    case 7:
      insert_len = (*input++) + 17 + length * 256;
      insert_byte = '\0';
      break;
    case 8:
      copy_len = length + 1;
      break;
    case 9:
      copy_len = length + 17;
      break;
    case 10:
      copy_len = length + 33;
      break;
    case 11:
      copy_len = length + 49;
      break;
    case 12:
      insert_byte = *input++;
      insert_len = length + 3;
      break;
    case 13:
      insert_byte = '@';
      insert_len = length + 2;
      break;
    case 14:
      insert_byte = ' ';
      insert_len = length + 2;
      break;
    case 15:
      insert_byte = '\0';
      insert_len = length + 2;
      break;
    default:
      break;
    }
    if (copy_len) {
      memcpy(output, input, copy_len);
      input += copy_len;
      output += copy_len;
    }
    if (insert_len) {
      memset(output, insert_byte, insert_len);
      output += insert_len;
    }
  }
  return output - buffer;
}


x86 assembly (clang, -O0):
<sas_rle_decompress>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    13ac <sas_rle_decompress+0x28c>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%al
mov    %al,-0x39(%rbp)
movzbl -0x39(%rbp),%eax
shr    $0x4,%eax
mov    %al,-0x3a(%rbp)
mov    -0x39(%rbp),%al
and    $0xf,%al
mov    %al,-0x3b(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movb   $0x0,-0x45(%rbp)
movzbl -0x3a(%rbp),%eax
mov    %rax,-0x50(%rbp)
sub    $0xf,%rax
ja     1339 <sas_rle_decompress+0x219>
mov    -0x50(%rbp),%rax
lea    0xe46(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    $0x40,%eax
movzbl -0x3b(%rbp),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    $0x12,%eax
movzbl -0x3b(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%al
mov    %al,-0x45(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    $0x11,%eax
movzbl -0x3b(%rbp),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
movb   $0x40,-0x45(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    $0x11,%eax
movzbl -0x3b(%rbp),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
movb   $0x20,-0x45(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    $0x11,%eax
movzbl -0x3b(%rbp),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
movb   $0x0,-0x45(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
movzbl -0x3b(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
movzbl -0x3b(%rbp),%eax
add    $0x11,%eax
mov    %eax,-0x40(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
movzbl -0x3b(%rbp),%eax
add    $0x21,%eax
mov    %eax,-0x40(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
movzbl -0x3b(%rbp),%eax
add    $0x31,%eax
mov    %eax,-0x40(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%al
mov    %al,-0x45(%rbp)
movzbl -0x3b(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x44(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
movb   $0x40,-0x45(%rbp)
movzbl -0x3b(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
movb   $0x20,-0x45(%rbp)
movzbl -0x3b(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
movb   $0x0,-0x45(%rbp)
movzbl -0x3b(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
jmp    133e <sas_rle_decompress+0x21e>
jmp    133e <sas_rle_decompress+0x21e>
cmpl   $0x0,-0x40(%rbp)
je     137a <sas_rle_decompress+0x25a>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x40(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     13a7 <sas_rle_decompress+0x287>
mov    -0x30(%rbp),%rdi
mov    -0x45(%rbp),%al
mov    -0x44(%rbp),%edx
movzbl %al,%esi
call   1030 <memset@plt>
mov    -0x44(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
jmp    1150 <sas_rle_decompress+0x30>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sas_rle_decompress>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r14
mov    %rdi,%r12
test   %rcx,%rcx
jle    1271 <sas_rle_decompress+0x151>
mov    %rcx,%r15
add    %rdx,%r15
lea    0xeb9(%rip),%r13
mov    %r14,%r12
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rbx
movzbl (%rdx),%ecx
mov    %ecx,%esi
shr    $0x4,%esi
cmp    $0xf,%esi
ja     1245 <sas_rle_decompress+0x125>
mov    %ecx,%eax
and    $0xf,%eax
movslq 0x0(%r13,%rsi,4),%rsi
add    %r13,%rsi
jmp    *%rsi
movzbl 0x1(%rdx),%ecx
add    $0x2,%rdx
shl    $0x8,%eax
lea    (%rcx,%rax,1),%ebp
add    $0x40,%ebp
mov    %rdx,%rbx
jmp    1204 <sas_rle_decompress+0xe4>
movzbl 0x1(%rdx),%eax
shl    $0x4,%cl
movzbl %cl,%ecx
lea    (%rcx,%rax,1),%ebp
add    $0x12,%ebp
movzbl 0x2(%rdx),%ecx
add    $0x3,%rdx
jmp    1230 <sas_rle_decompress+0x110>
movzbl 0x1(%rdx),%ecx
add    $0x2,%rdx
movzbl %al,%eax
shl    $0x8,%eax
lea    (%rcx,%rax,1),%ebp
add    $0x11,%ebp
mov    $0x40,%cl
jmp    1230 <sas_rle_decompress+0x110>
movzbl 0x1(%rdx),%ecx
add    $0x2,%rdx
movzbl %al,%eax
shl    $0x8,%eax
lea    (%rcx,%rax,1),%ebp
add    $0x11,%ebp
mov    $0x20,%cl
jmp    1230 <sas_rle_decompress+0x110>
movzbl 0x1(%rdx),%ecx
add    $0x2,%rdx
movzbl %al,%eax
shl    $0x8,%eax
lea    (%rcx,%rax,1),%ebp
add    $0x11,%ebp
xor    %ecx,%ecx
jmp    1230 <sas_rle_decompress+0x110>
add    $0x1,%eax
jmp    1201 <sas_rle_decompress+0xe1>
add    $0x11,%eax
jmp    1201 <sas_rle_decompress+0xe1>
add    $0x21,%eax
jmp    1201 <sas_rle_decompress+0xe1>
add    $0x31,%eax
movzbl %al,%ebp
mov    %r12,%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
call   1040 <memcpy@plt>
mov    %ebp,%eax
add    %rax,%rbx
jmp    1242 <sas_rle_decompress+0x122>
movzbl 0x1(%rdx),%ecx
add    $0x2,%rdx
add    $0x3,%eax
movzbl %al,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    %rdx,%rbx
movzbl %cl,%esi
mov    %r12,%rdi
mov    %ebp,%edx
call   1030 <memset@plt>
mov    %ebp,%eax
add    %rax,%r12
mov    %rbx,%rdx
cmp    %r15,%rbx
jb     1150 <sas_rle_decompress+0x30>
jmp    1271 <sas_rle_decompress+0x151>
add    $0x2,%eax
movzbl %al,%ebp
mov    $0x40,%cl
jmp    1233 <sas_rle_decompress+0x113>
add    $0x2,%eax
movzbl %al,%ebp
mov    $0x20,%cl
jmp    1233 <sas_rle_decompress+0x113>
add    $0x2,%eax
movzbl %al,%ebp
xor    %ecx,%ecx
jmp    1233 <sas_rle_decompress+0x113>
sub    %r14,%r12
mov    %r12,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i64 @sas_rle_decompress(i8* %0, i64 %1, i8* %2, i64 %3) {
%5 = getelementptr inbounds i8, i8* %2, i64 %3
%6 = icmp sgt i64 %3, 0
br i1 %6, label %7, label %101
7: ; preds = %4, %97
%8 = phi i8* [ %99, %97 ], [ %0, %4 ]
%9 = phi i8* [ %98, %97 ], [ %2, %4 ]
%10 = getelementptr inbounds i8, i8* %9, i64 1
%11 = load i8, i8* %9
%12 = lshr i8 %11, 4
%13 = and i8 %11, 15
%14 = zext i8 %12 to i32
switch i32 %14, label %97 [
i32 0, label %15
i32 4, label %23
i32 5, label %33
i32 6, label %41
i32 7, label %49
i32 8, label %57
i32 9, label %60
i32 10, label %63
i32 11, label %66
i32 12, label %69
i32 13, label %74
i32 14, label %77
i32 15, label %80
]
15: ; preds = %7
%16 = getelementptr inbounds i8, i8* %9, i64 2
%17 = load i8, i8* %10
%18 = zext i8 %17 to i32
%19 = zext i8 %13 to i32
%20 = shl nuw nsw i32 %19, 8
%21 = or i32 %20, 64
%22 = add nuw nsw i32 %21, %18
br label %83
23: ; preds = %7
%24 = getelementptr inbounds i8, i8* %9, i64 2
%25 = load i8, i8* %10
%26 = zext i8 %25 to i32
%27 = shl i8 %11, 4
%28 = zext i8 %27 to i32
%29 = add nuw nsw i32 %28, 18
%30 = add nuw nsw i32 %29, %26
%31 = getelementptr inbounds i8, i8* %9, i64 3
%32 = load i8, i8* %24
br label %90
33: ; preds = %7
%34 = getelementptr inbounds i8, i8* %9, i64 2
%35 = load i8, i8* %10
%36 = zext i8 %35 to i32
%37 = zext i8 %13 to i32
%38 = shl nuw nsw i32 %37, 8
%39 = or i32 %38, 17
%40 = add nuw nsw i32 %39, %36
br label %90
41: ; preds = %7
%42 = getelementptr inbounds i8, i8* %9, i64 2
%43 = load i8, i8* %10
%44 = zext i8 %43 to i32
%45 = zext i8 %13 to i32
%46 = shl nuw nsw i32 %45, 8
%47 = or i32 %46, 17
%48 = add nuw nsw i32 %47, %44
br label %90
49: ; preds = %7
%50 = getelementptr inbounds i8, i8* %9, i64 2
%51 = load i8, i8* %10
%52 = zext i8 %51 to i32
%53 = zext i8 %13 to i32
%54 = shl nuw nsw i32 %53, 8
%55 = or i32 %54, 17
%56 = add nuw nsw i32 %55, %52
br label %90
57: ; preds = %7
%58 = add nuw nsw i8 %13, 1
%59 = zext i8 %58 to i32
br label %83
60: ; preds = %7
%61 = add nuw nsw i8 %13, 17
%62 = zext i8 %61 to i32
br label %83
63: ; preds = %7
%64 = add nuw nsw i8 %13, 33
%65 = zext i8 %64 to i32
br label %83
66: ; preds = %7
%67 = add nuw nsw i8 %13, 49
%68 = zext i8 %67 to i32
br label %83
69: ; preds = %7
%70 = getelementptr inbounds i8, i8* %9, i64 2
%71 = load i8, i8* %10
%72 = add nuw nsw i8 %13, 3
%73 = zext i8 %72 to i32
br label %90
74: ; preds = %7
%75 = add nuw nsw i8 %13, 2
%76 = zext i8 %75 to i32
br label %90
77: ; preds = %7
%78 = add nuw nsw i8 %13, 2
%79 = zext i8 %78 to i32
br label %90
80: ; preds = %7
%81 = add nuw nsw i8 %13, 2
%82 = zext i8 %81 to i32
br label %90
83: ; preds = %66, %63, %60, %57, %15
%84 = phi i8* [ %10, %66 ], [ %10, %63 ], [ %10, %60 ], [ %10, %57 ], [ %16, %15 ]
%85 = phi i32 [ %68, %66 ], [ %65, %63 ], [ %62, %60 ], [ %59, %57 ], [ %22, %15 ]
%86 = tail call i32 @memcpy(i8* %8, i8* %84, i32 %85)
%87 = zext i32 %85 to i64
%88 = getelementptr inbounds i8, i8* %84, i64 %87
%89 = getelementptr inbounds i8, i8* %8, i64 %87
br label %97
90: ; preds = %23, %33, %41, %49, %69, %74, %77, %80
%91 = phi i8* [ %10, %80 ], [ %10, %77 ], [ %10, %74 ], [ %70, %69 ], [ %50, %49 ], [ %42, %41 ], [ %34, %33 ], [ %31, %23 ]
%92 = phi i32 [ %82, %80 ], [ %79, %77 ], [ %76, %74 ], [ %73, %69 ], [ %56, %49 ], [ %48, %41 ], [ %40, %33 ], [ %30, %23 ]
%93 = phi i8 [ 0, %80 ], [ 32, %77 ], [ 64, %74 ], [ %71, %69 ], [ 0, %49 ], [ 32, %41 ], [ 64, %33 ], [ %32, %23 ]
%94 = tail call i32 @memset(i8* %8, i8 zeroext %93, i32 %92)
%95 = zext i32 %92 to i64
%96 = getelementptr inbounds i8, i8* %8, i64 %95
br label %97
97: ; preds = %7, %83, %90
%98 = phi i8* [ %91, %90 ], [ %88, %83 ], [ %10, %7 ]
%99 = phi i8* [ %96, %90 ], [ %89, %83 ], [ %8, %7 ]
%100 = icmp ult i8* %98, %5
br i1 %100, label %7, label %101
101: ; preds = %97, %4
%102 = phi i8* [ %0, %4 ], [ %99, %97 ]
%103 = ptrtoint i8* %102 to i64
%104 = ptrtoint i8* %0 to i64
%105 = sub i64 %103, %104
ret i64 %105
}