#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 *pBuffer, int value, size_t num) {
  unsigned char *pByteDestination;
  unsigned int *pAlignedDestination = (unsigned int *)pBuffer;
  unsigned int alignedValue =
      (value << 24) | (value << 16) | (value << 8) | value;
  if ((((unsigned int)pAlignedDestination & 0x3) == 0) && (num >= 4)) {
    while (num >= 4) {
      *pAlignedDestination++ = alignedValue;
      num -= 4;
    }
  }
  pByteDestination = (unsigned char *)pAlignedDestination;
  while (num--) {
    *pByteDestination++ = value;
  }
  return pBuffer;
}


x86 assembly (clang, -O0):
<memset>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x18,%eax
mov    -0xc(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0xc(%rbp),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
or     -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
and    $0x3,%eax
cmp    $0x0,%eax
jne    1188 <memset+0x88>
cmpq   $0x4,-0x18(%rbp)
jb     1188 <memset+0x88>
jmp    1153 <memset+0x53>
cmpq   $0x4,-0x18(%rbp)
jb     1183 <memset+0x83>
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x4,%rax
mov    %rax,-0x18(%rbp)
jmp    1153 <memset+0x53>
jmp    1188 <memset+0x88>
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11c4 <memset+0xc4>
mov    -0xc(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    1190 <memset+0x90>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memset>:
push   %rbx
mov    %rdi,%rax
test   $0x3,%al
jne    1139 <memset+0x39>
cmp    $0x4,%rdx
jb     1139 <memset+0x39>
mov    %esi,%ecx
shl    $0x18,%ecx
mov    %esi,%r11d
shl    $0x10,%r11d
mov    %esi,%edi
shl    $0x8,%edi
or     %ecx,%edi
or     %esi,%r11d
or     %edi,%r11d
lea    -0x4(%rdx),%r8
cmp    $0x1c,%r8
jae    1141 <memset+0x41>
mov    %rax,%rcx
jmp    1250 <memset+0x150>
mov    %rax,%rcx
jmp    1261 <memset+0x161>
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r9),%rdi
mov    %rdi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x7,%r10d
cmp    $0x38,%rdi
jae    117d <memset+0x7d>
xor    %edi,%edi
jmp    1215 <memset+0x115>
and    $0xfffffffffffffff8,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm0,0x10(%rax,%rdi,4)
movdqu %xmm0,0x20(%rax,%rdi,4)
movdqu %xmm0,0x30(%rax,%rdi,4)
movdqu %xmm0,0x40(%rax,%rdi,4)
movdqu %xmm0,0x50(%rax,%rdi,4)
movdqu %xmm0,0x60(%rax,%rdi,4)
movdqu %xmm0,0x70(%rax,%rdi,4)
movdqu %xmm0,0x80(%rax,%rdi,4)
movdqu %xmm0,0x90(%rax,%rdi,4)
movdqu %xmm0,0xa0(%rax,%rdi,4)
movdqu %xmm0,0xb0(%rax,%rdi,4)
movdqu %xmm0,0xc0(%rax,%rdi,4)
movdqu %xmm0,0xd0(%rax,%rdi,4)
movdqu %xmm0,0xe0(%rax,%rdi,4)
movdqu %xmm0,0xf0(%rax,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rcx
jne    1190 <memset+0x90>
lea    0x0(,%r9,4),%rbx
test   %r10,%r10
je     1244 <memset+0x144>
lea    (%rax,%rdi,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %edi,%edi
movdqu %xmm0,-0x10(%rcx,%rdi,1)
movdqu %xmm0,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    1230 <memset+0x130>
lea    (%rax,%r9,4),%rcx
sub    %rbx,%rdx
cmp    %r9,%r8
je     1261 <memset+0x161>
mov    %r11d,(%rcx)
add    $0x4,%rcx
add    $0xfffffffffffffffc,%rdx
cmp    $0x3,%rdx
ja     1250 <memset+0x150>
test   %rdx,%rdx
je     13ed <memset+0x2ed>
cmp    $0x8,%rdx
jae    127b <memset+0x17b>
mov    %rdx,%r9
mov    %rcx,%rdi
jmp    13d4 <memset+0x2d4>
movzbl %sil,%r8d
cmp    $0x20,%rdx
jae    128d <memset+0x18d>
xor    %r11d,%r11d
jmp    139e <memset+0x29e>
mov    %rdx,%r11
and    $0xffffffffffffffe0,%r11
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%r11),%rdi
mov    %rdi,%r10
shr    $0x5,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x7,%r9d
cmp    $0xe0,%rdi
jae    12cd <memset+0x1cd>
xor    %edi,%edi
jmp    1368 <memset+0x268>
and    $0xfffffffffffffff8,%r10
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu %xmm0,(%rcx,%rdi,1)
movdqu %xmm0,0x10(%rcx,%rdi,1)
movdqu %xmm0,0x20(%rcx,%rdi,1)
movdqu %xmm0,0x30(%rcx,%rdi,1)
movdqu %xmm0,0x40(%rcx,%rdi,1)
movdqu %xmm0,0x50(%rcx,%rdi,1)
movdqu %xmm0,0x60(%rcx,%rdi,1)
movdqu %xmm0,0x70(%rcx,%rdi,1)
movdqu %xmm0,0x80(%rcx,%rdi,1)
movdqu %xmm0,0x90(%rcx,%rdi,1)
movdqu %xmm0,0xa0(%rcx,%rdi,1)
movdqu %xmm0,0xb0(%rcx,%rdi,1)
movdqu %xmm0,0xc0(%rcx,%rdi,1)
movdqu %xmm0,0xd0(%rcx,%rdi,1)
movdqu %xmm0,0xe0(%rcx,%rdi,1)
movdqu %xmm0,0xf0(%rcx,%rdi,1)
add    $0x100,%rdi
add    $0xfffffffffffffff8,%r10
jne    12e0 <memset+0x1e0>
test   %r9,%r9
je     1394 <memset+0x294>
add    %rcx,%rdi
add    $0x10,%rdi
shl    $0x5,%r9
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rdi,%rbx,1)
movdqu %xmm0,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1380 <memset+0x280>
cmp    %r11,%rdx
je     13ed <memset+0x2ed>
test   $0x18,%dl
je     13ef <memset+0x2ef>
mov    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %edx,%r9d
and    $0x7,%r9d
lea    (%rcx,%rbx,1),%rdi
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
xchg   %ax,%ax
movq   %xmm0,(%rcx,%r11,1)
add    $0x8,%r11
cmp    %r11,%rbx
jne    13c0 <memset+0x2c0>
cmp    %rbx,%rdx
je     13ed <memset+0x2ed>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    %sil,(%rdi,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    13e0 <memset+0x2e0>
pop    %rbx
ret
add    %r11,%rcx
and    $0x1f,%edx
jmp    1270 <memset+0x170>

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

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