#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 *memset(void *_dest, int value, unsigned int length) {
  char *dest = (char *)_dest;
  value &= 0xff;
  if ((((unsigned int)dest) & 3) == 0) {
    unsigned wideVal = value | (value << 8) | (value << 16) | (value << 24);
    while (length > 4) {
      *((unsigned int *)dest) = wideVal;
      dest += 4;
      length -= 4;
    }
  }
  while (length > 0) {
    *dest++ = value;
    length--;
  }
  return _dest;
}


x86 assembly (clang, -O0):
<memset>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0xc(%rbp)
mov    -0x18(%rbp),%rax
and    $0x3,%eax
cmp    $0x0,%eax
jne    1181 <memset+0x81>
mov    -0xc(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0xc(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0xc(%rbp),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x4,-0x10(%rbp)
jbe    117c <memset+0x7c>
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    114f <memset+0x4f>
jmp    1181 <memset+0x81>
jmp    1186 <memset+0x86>
cmpl   $0x0,-0x10(%rbp)
jbe    11b4 <memset+0xb4>
mov    -0xc(%rbp),%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1186 <memset+0x86>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memset>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rax
test   $0x3,%al
jne    1134 <memset+0x34>
cmp    $0x5,%edx
jb     1134 <memset+0x34>
movzbl %sil,%ecx
imul   $0x10101,%ecx,%ecx
mov    %esi,%edi
shl    $0x18,%edi
or     %ecx,%edi
lea    -0x5(%rdx),%r8d
cmp    $0x1c,%r8d
jae    1144 <memset+0x44>
mov    %rax,%rcx
jmp    1210 <memset+0x110>
mov    %rax,%rcx
test   %edx,%edx
jne    121e <memset+0x11e>
jmp    13bc <memset+0x2bc>
shr    $0x2,%r8d
add    $0x1,%r8d
mov    %r8d,%r9d
and    $0xfffffff8,%r9d
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r9),%rbx
mov    %rbx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0x18,%rbx
jae    117c <memset+0x7c>
xor    %ebx,%ebx
jmp    11c9 <memset+0xc9>
and    $0xfffffffffffffffc,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,(%rax,%rbx,4)
movdqu %xmm0,0x10(%rax,%rbx,4)
movdqu %xmm0,0x20(%rax,%rbx,4)
movdqu %xmm0,0x30(%rax,%rbx,4)
movdqu %xmm0,0x40(%rax,%rbx,4)
movdqu %xmm0,0x50(%rax,%rbx,4)
movdqu %xmm0,0x60(%rax,%rbx,4)
movdqu %xmm0,0x70(%rax,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1190 <memset+0x90>
lea    0x0(,%r9,4),%r11d
test   %r10,%r10
je     1204 <memset+0x104>
lea    (%rax,%rbx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu %xmm0,-0x10(%rcx,%rbx,1)
movdqu %xmm0,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    11f0 <memset+0xf0>
lea    (%rax,%r9,4),%rcx
sub    %r11d,%edx
cmp    %r8,%r9
je     121e <memset+0x11e>
mov    %edi,(%rcx)
add    $0x4,%rcx
add    $0xfffffffc,%edx
cmp    $0x4,%edx
ja     1210 <memset+0x110>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jae    1230 <memset+0x130>
mov    %rcx,%rbx
jmp    13a3 <memset+0x2a3>
movabs $0x1ffffffe0,%r9
movzbl %sil,%r10d
cmp    $0x1f,%r8d
jae    124b <memset+0x14b>
xor    %edi,%edi
jmp    1361 <memset+0x261>
lea    0x1(%r8),%r11
mov    %r11,%rdi
and    %r9,%rdi
movd   %r10d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rdi),%rbx
mov    %rbx,%r15
shr    $0x5,%r15
add    $0x1,%r15
mov    %r15d,%r14d
and    $0x7,%r14d
cmp    $0xe0,%rbx
jae    128e <memset+0x18e>
xor    %ebx,%ebx
jmp    1328 <memset+0x228>
and    $0xfffffffffffffff8,%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu %xmm0,(%rcx,%rbx,1)
movdqu %xmm0,0x10(%rcx,%rbx,1)
movdqu %xmm0,0x20(%rcx,%rbx,1)
movdqu %xmm0,0x30(%rcx,%rbx,1)
movdqu %xmm0,0x40(%rcx,%rbx,1)
movdqu %xmm0,0x50(%rcx,%rbx,1)
movdqu %xmm0,0x60(%rcx,%rbx,1)
movdqu %xmm0,0x70(%rcx,%rbx,1)
movdqu %xmm0,0x80(%rcx,%rbx,1)
movdqu %xmm0,0x90(%rcx,%rbx,1)
movdqu %xmm0,0xa0(%rcx,%rbx,1)
movdqu %xmm0,0xb0(%rcx,%rbx,1)
movdqu %xmm0,0xc0(%rcx,%rbx,1)
movdqu %xmm0,0xd0(%rcx,%rbx,1)
movdqu %xmm0,0xe0(%rcx,%rbx,1)
movdqu %xmm0,0xf0(%rcx,%rbx,1)
add    $0x100,%rbx
add    $0xfffffffffffffff8,%r15
jne    12a0 <memset+0x1a0>
test   %r14,%r14
je     1356 <memset+0x256>
lea    (%rbx,%rcx,1),%r15
add    $0x10,%r15
shl    $0x5,%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%r15,%rbx,1)
movdqu %xmm0,(%r15,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    1340 <memset+0x240>
cmp    %rdi,%r11
je     13bc <memset+0x2bc>
test   $0x18,%r11b
je     13c2 <memset+0x2c2>
add    $0x1,%r8
add    $0x18,%r9
and    %r8,%r9
lea    (%rcx,%r9,1),%rbx
sub    %r9d,%edx
movd   %r10d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   %xmm0,(%rcx,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r9
jne    1390 <memset+0x290>
cmp    %r9,%r8
je     13bc <memset+0x2bc>
mov    %edx,%ecx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %sil,(%rbx,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    13b0 <memset+0x2b0>
pop    %rbx
pop    %r14
pop    %r15
ret
sub    %edi,%edx
add    %rdi,%rcx
jmp    1228 <memset+0x128>

LLVM IR (-O0):
define i8* @memset(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%9 = load i8*, i8** %4
store i8* %9, i8** %7
%10 = load i32, i32* %5
%11 = and i32 %10, 255
store i32 %11, i32* %5
%12 = load i8*, i8** %7
%13 = ptrtoint i8* %12 to i32
%14 = and i32 %13, 3
%15 = icmp eq i32 %14, 0
br i1 %15, label %16, label %39
16: ; preds = %3
%17 = load i32, i32* %5
%18 = load i32, i32* %5
%19 = shl i32 %18, 8
%20 = or i32 %17, %19
%21 = load i32, i32* %5
%22 = shl i32 %21, 16
%23 = or i32 %20, %22
%24 = load i32, i32* %5
%25 = shl i32 %24, 24
%26 = or i32 %23, %25
store i32 %26, i32* %8
br label %27
27: ; preds = %30, %16
%28 = load i32, i32* %6
%29 = icmp ugt i32 %28, 4
br i1 %29, label %30, label %38
30: ; preds = %27
%31 = load i32, i32* %8
%32 = load i8*, i8** %7
%33 = bitcast i8* %32 to i32*
store i32 %31, i32* %33
%34 = load i8*, i8** %7
%35 = getelementptr inbounds i8, i8* %34, i64 4
store i8* %35, i8** %7
%36 = load i32, i32* %6
%37 = sub i32 %36, 4
store i32 %37, i32* %6
br label %27
38: ; preds = %27
br label %39
39: ; preds = %38, %3
br label %40
40: ; preds = %43, %39
%41 = load i32, i32* %6
%42 = icmp ugt i32 %41, 0
br i1 %42, label %43, label %50
43: ; preds = %40
%44 = load i32, i32* %5
%45 = trunc i32 %44 to i8
%46 = load i8*, i8** %7
%47 = getelementptr inbounds i8, i8* %46, i32 1
store i8* %47, i8** %7
store i8 %45, i8* %46
%48 = load i32, i32* %6
%49 = add i32 %48, -1
store i32 %49, i32* %6
br label %40
50: ; preds = %40
%51 = load i8*, i8** %4
ret i8* %51
}

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