#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 */
typedef int uint8_t;
typedef int uint32_t;

/* Variables and functions */
scalar_t__ malloc(int);
char *escape_data(const uint8_t *packet, uint32_t start, uint32_t end) {
  int i, o;
  uint8_t c;
  unsigned int length = 1;
  char *outstr;
  for (i = start; i < end; i++) {
    c = packet[i];
    if (c < 0x20 || c == 0x5c || c >= 0x75)
      length += 4;
    else
      length += 1;
  }
  outstr = (char *)malloc(sizeof(char) * length);
  if (outstr == 0)
    return (char *)0;
  o = 0;
  for (i = start; i < end; i++) {
    c = packet[i];
    if (c < 0x20 || c == 0x5c || c >= 0x7f) {
      outstr[o] = '\\';
      outstr[o + 1] = 'x';
      outstr[o + 2] = c / 16 + 0x30;
      outstr[o + 3] = c % 16 + 0x30;
      if (outstr[o + 2] > 0x39)
        outstr[o + 2] += 0x27;
      if (outstr[o + 3] > 0x39)
        outstr[o + 3] += 0x27;
      o += 4;
    } else {
      outstr[o] = c;
      o++;
    }
  }
  outstr[o] = 0;
  return outstr;
}


x86 assembly (clang, -O0):
<escape_data>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1191 <escape_data+0x81>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x20,-0x24(%rbp)
jl     1167 <escape_data+0x57>
cmpl   $0x5c,-0x24(%rbp)
je     1167 <escape_data+0x57>
cmpl   $0x75,-0x24(%rbp)
jl     1175 <escape_data+0x65>
mov    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    117e <escape_data+0x6e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1183 <escape_data+0x73>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112f <escape_data+0x1f>
mov    -0x28(%rbp),%eax
shl    $0x0,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    11bb <escape_data+0xab>
movq   $0x0,-0x8(%rbp)
jmp    130b <escape_data+0x1fb>
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12f7 <escape_data+0x1e7>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x20,-0x24(%rbp)
jl     1200 <escape_data+0xf0>
cmpl   $0x5c,-0x24(%rbp)
je     1200 <escape_data+0xf0>
cmpl   $0x7f,-0x24(%rbp)
jl     12cb <escape_data+0x1bb>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x78,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jle    128c <escape_data+0x17c>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
add    $0x27,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jle    12bd <escape_data+0x1ad>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
add    $0x27,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x20(%rbp)
jmp    12e4 <escape_data+0x1d4>
mov    -0x24(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12e9 <escape_data+0x1d9>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c8 <escape_data+0xb8>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<escape_data>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmp    %edx,%esi
jge    1147 <escape_data+0x37>
mov    %edx,%r14d
mov    %esi,%r15d
mov    %rdi,%r12
movslq %esi,%rsi
movslq %edx,%r13
mov    %r13,%rcx
sub    %rsi,%rcx
mov    $0x1,%edi
cmp    $0x8,%rcx
jae    1161 <escape_data+0x51>
mov    %rsi,%rax
jmp    1255 <escape_data+0x145>
mov    $0x1,%edi
call   1030 <malloc@plt>
xor    %ecx,%ecx
test   %rax,%rax
jne    1329 <escape_data+0x219>
jmp    1323 <escape_data+0x213>
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rdx,%rsi,1),%rax
lea    (%r12,%rsi,4),%rsi
add    $0x10,%rsi
pxor   %xmm0,%xmm0
movdqa 0xe80(%rip),%xmm1
xor    %edi,%edi
movdqa 0xe85(%rip),%xmm8
movdqa 0xe8c(%rip),%xmm9
movdqa 0xe93(%rip),%xmm10
movdqa 0xe9a(%rip),%xmm11
movdqa 0xea1(%rip),%xmm12
pcmpeqd %xmm7,%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rsi,%rdi,4),%xmm2
movdqu (%rsi,%rdi,4),%xmm3
movdqa %xmm2,%xmm4
pcmpeqd %xmm8,%xmm4
movdqa %xmm3,%xmm5
pcmpeqd %xmm8,%xmm5
paddd  %xmm9,%xmm2
paddd  %xmm9,%xmm3
pxor   %xmm10,%xmm2
movdqa %xmm11,%xmm6
pcmpgtd %xmm2,%xmm6
por    %xmm4,%xmm6
pxor   %xmm10,%xmm3
movdqa %xmm11,%xmm2
pcmpgtd %xmm3,%xmm2
por    %xmm5,%xmm2
paddd  %xmm6,%xmm1
pand   %xmm12,%xmm6
paddd  %xmm6,%xmm1
paddd  %xmm2,%xmm0
pand   %xmm12,%xmm2
paddd  %xmm2,%xmm0
psubd  %xmm7,%xmm1
psubd  %xmm7,%xmm0
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    11c0 <escape_data+0xb0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
cmp    %rdx,%rcx
je     1285 <escape_data+0x175>
mov    $0x4,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rax,4),%edx
lea    -0x75(%rdx),%esi
xor    %ebp,%ebp
cmp    $0xffffffab,%esi
setb   %bpl
cmp    $0x5c,%edx
lea    0x1(%rbp,%rbp,2),%edx
cmove  %ecx,%edx
add    %edx,%edi
add    $0x1,%rax
cmp    %rax,%r13
jne    1260 <escape_data+0x150>
call   1030 <malloc@plt>
test   %rax,%rax
je     1323 <escape_data+0x213>
xor    %ecx,%ecx
cmp    %r14d,%r15d
jge    1329 <escape_data+0x219>
movslq %r15d,%rdx
jmp    12c4 <escape_data+0x1b4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %sil,(%rax,%rdi,1)
mov    $0x1,%ebx
add    %ebx,%ecx
add    $0x1,%rdx
cmp    %rdx,%r13
je     1327 <escape_data+0x217>
mov    (%r12,%rdx,4),%esi
mov    %ecx,%edi
cmp    $0x5c,%esi
je     12d7 <escape_data+0x1c7>
lea    -0x7f(%rsi),%ebp
cmp    $0xffffffa0,%ebp
ja     12b0 <escape_data+0x1a0>
movw   $0x785c,(%rax,%rdi,1)
lea    0xf(%rsi),%ebp
test   %esi,%esi
cmovns %esi,%ebp
mov    %ebp,%ebx
sar    $0x4,%ebx
lea    0x30(%rbx),%r8d
mov    %r8b,0x2(%rax,%rdi,1)
and    $0xfffffff0,%ebp
sub    %ebp,%esi
lea    0x30(%rsi),%ebp
mov    %bpl,0x3(%rax,%rdi,1)
cmp    $0x3a,%r8b
jl     130d <escape_data+0x1fd>
add    $0x57,%bl
mov    %bl,0x2(%rax,%rdi,1)
mov    $0x4,%ebx
cmp    $0x3a,%bpl
jb     12b9 <escape_data+0x1a9>
add    $0x57,%sil
mov    %sil,0x3(%rax,%rdi,1)
jmp    12b9 <escape_data+0x1a9>
xor    %eax,%eax
jmp    132d <escape_data+0x21d>
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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