#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 expand_byte_word(int);
void *memset(void *to, int c, size_t n) {
  unsigned long rem, chunks;
  unsigned char *tmp_to;
  chunks = n / 8;
  tmp_to = to - 4;
  c = expand_byte_word(c);
  if (!chunks)
    goto lessthan8;
  rem = (unsigned long)tmp_to % 4;
  if (rem)
    goto align;
copy_chunks:
  do {
    *(unsigned long *)(tmp_to + 4) = c;
    tmp_to += 4;
    *(unsigned long *)(tmp_to + 4) = c;
    tmp_to += 4;
  } while (--chunks);
lessthan8:
  n = n % 8;
  if (n >= 4) {
    *(unsigned long *)(tmp_to + 4) = c;
    tmp_to += 4;
    n = n - 4;
  }
  if (!n)
    return to;
  tmp_to += 3;
  do {
    *++tmp_to = c;
  } while (--n);
  return to;
align:
  rem = 4 - rem;
  n = n - rem;
  do {
    *(tmp_to + 4) = c;
    ++tmp_to;
  } while (--rem);
  chunks = n / 8;
  if (chunks)
    goto copy_chunks;
  goto lessthan8;
}


x86 assembly (clang, -O0):
<memset>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <expand_byte_word@plt>
mov    %eax,-0x14(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1156 <memset+0x46>
jmp    11c7 <memset+0xb7>
mov    -0x38(%rbp),%rax
and    $0x3,%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     1172 <memset+0x62>
jmp    1260 <memset+0x150>
jmp    1177 <memset+0x67>
jmp    117c <memset+0x6c>
movslq -0x14(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x4(%rax)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
movslq -0x14(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x4(%rax)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    117c <memset+0x6c>
jmp    11c7 <memset+0xb7>
mov    -0x20(%rbp),%rax
and    $0x7,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jb     1202 <memset+0xf2>
movslq -0x14(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x4(%rax)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
sub    $0x4,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    121a <memset+0x10a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12c8 <memset+0x1b8>
mov    -0x38(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,0x1(%rax)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    1226 <memset+0x116>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12c8 <memset+0x1b8>
mov    $0x4,%eax
sub    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jne    1279 <memset+0x169>
mov    -0x20(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
je     12c3 <memset+0x1b3>
jmp    1177 <memset+0x67>
jmp    11c7 <memset+0xb7>
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<memset>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r15
mov    %rdi,%r14
lea    -0x4(%rdi),%rbx
mov    %esi,%edi
call   1030 <expand_byte_word@plt>
cmp    $0x8,%r15
jb     11fa <memset+0xea>
mov    %rbx,%rcx
and    $0x3,%rcx
je     1174 <memset+0x64>
or     $0xfffffffffffffffc,%rbx
mov    %al,(%r14)
cmp    $0x3,%rcx
jne    114c <memset+0x3c>
lea    -0x3(%r14),%rcx
jmp    1164 <memset+0x54>
mov    %al,0x1(%r14)
cmp    $0x2,%rcx
jne    115c <memset+0x4c>
lea    -0x2(%r14),%rcx
jmp    1164 <memset+0x54>
mov    %al,0x2(%r14)
lea    -0x1(%r14),%rcx
add    %rbx,%r15
mov    %rcx,%rbx
cmp    $0x8,%r15
jb     11fa <memset+0xea>
mov    %r15,%rcx
shr    $0x3,%rcx
movslq %eax,%rdx
lea    -0x1(%rcx),%r8
mov    %rcx,%rdi
and    $0x7,%rdi
je     11a8 <memset+0x98>
xor    %esi,%esi
nopl   (%rax)
mov    %rdx,0x4(%rbx)
mov    %rdx,0x8(%rbx)
add    $0x8,%rbx
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1190 <memset+0x80>
sub    %rsi,%rcx
cmp    $0x7,%r8
jb     11fa <memset+0xea>
xchg   %ax,%ax
mov    %rdx,0x4(%rbx)
mov    %rdx,0x8(%rbx)
mov    %rdx,0xc(%rbx)
mov    %rdx,0x10(%rbx)
mov    %rdx,0x14(%rbx)
mov    %rdx,0x18(%rbx)
mov    %rdx,0x1c(%rbx)
mov    %rdx,0x20(%rbx)
mov    %rdx,0x24(%rbx)
mov    %rdx,0x28(%rbx)
mov    %rdx,0x2c(%rbx)
mov    %rdx,0x30(%rbx)
mov    %rdx,0x34(%rbx)
mov    %rdx,0x38(%rbx)
mov    %rdx,0x3c(%rbx)
mov    %rdx,0x40(%rbx)
add    $0x40,%rbx
add    $0xfffffffffffffff8,%rcx
jne    11b0 <memset+0xa0>
and    $0x7,%r15d
cmp    $0x4,%r15
jb     1213 <memset+0x103>
movslq %eax,%rcx
mov    %rcx,0x4(%rbx)
add    $0x4,%rbx
add    $0xfffffffffffffffc,%r15
test   %r15,%r15
je     139d <memset+0x28d>
lea    0x3(%rbx),%rcx
cmp    $0x8,%r15
jae    122e <memset+0x11e>
mov    %r15,%rdi
jmp    1384 <memset+0x274>
movzbl %al,%r8d
cmp    $0x20,%r15
jae    123f <memset+0x12f>
xor    %edx,%edx
jmp    134f <memset+0x23f>
mov    %r15,%rdx
and    $0xffffffffffffffe0,%rdx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x7,%r9d
cmp    $0xe0,%rsi
jae    127f <memset+0x16f>
xor    %esi,%esi
jmp    1319 <memset+0x209>
and    $0xfffffffffffffff8,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm0,0x4(%rbx,%rsi,1)
movdqu %xmm0,0x14(%rbx,%rsi,1)
movdqu %xmm0,0x24(%rbx,%rsi,1)
movdqu %xmm0,0x34(%rbx,%rsi,1)
movdqu %xmm0,0x44(%rbx,%rsi,1)
movdqu %xmm0,0x54(%rbx,%rsi,1)
movdqu %xmm0,0x64(%rbx,%rsi,1)
movdqu %xmm0,0x74(%rbx,%rsi,1)
movdqu %xmm0,0x84(%rbx,%rsi,1)
movdqu %xmm0,0x94(%rbx,%rsi,1)
movdqu %xmm0,0xa4(%rbx,%rsi,1)
movdqu %xmm0,0xb4(%rbx,%rsi,1)
movdqu %xmm0,0xc4(%rbx,%rsi,1)
movdqu %xmm0,0xd4(%rbx,%rsi,1)
movdqu %xmm0,0xe4(%rbx,%rsi,1)
movdqu %xmm0,0xf4(%rbx,%rsi,1)
add    $0x100,%rsi
add    $0xfffffffffffffff8,%rdi
jne    1290 <memset+0x180>
test   %r9,%r9
je     1344 <memset+0x234>
add    %rbx,%rsi
add    $0x14,%rsi
shl    $0x5,%r9
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1330 <memset+0x220>
cmp    %rdx,%r15
je     139d <memset+0x28d>
test   $0x18,%r15b
je     13a6 <memset+0x296>
mov    %r15,%rsi
and    $0xfffffffffffffff8,%rsi
mov    %r15d,%edi
and    $0x7,%edi
add    %rsi,%rcx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
nopl   (%rax)
movq   %xmm0,0x4(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1370 <memset+0x260>
cmp    %rsi,%r15
je     139d <memset+0x28d>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    %al,0x1(%rcx,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1390 <memset+0x280>
mov    %r14,%rax
pop    %rbx
pop    %r14
pop    %r15
ret
add    %rdx,%rcx
and    $0x1f,%r15d
jmp    1226 <memset+0x116>

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

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