#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, const int filler, size_t size) {
  char *destc = (char *)dest;
  while ((uintptr_t)destc % sizeof(size_t) && size--) {
    *destc++ = filler;
  }
  for (; size >= sizeof(size_t);
       size -= sizeof(size_t), destc += sizeof(size_t)) {
    *(size_t *)destc = filler;
  }
  while (size--) {
    *destc++ = filler;
  }
}


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,-0x20(%rbp)
mov    -0x20(%rbp),%rcx
and    $0x7,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x21(%rbp)
je     1147 <memset+0x47>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
test   $0x1,%al
jne    1157 <memset+0x57>
jmp    1172 <memset+0x72>
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    1117 <memset+0x17>
jmp    1177 <memset+0x77>
cmpq   $0x8,-0x18(%rbp)
jb     11aa <memset+0xaa>
movslq -0xc(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
jmp    1177 <memset+0x77>
jmp    11af <memset+0xaf>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11e3 <memset+0xe3>
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    11af <memset+0xaf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<memset>:
push   %rbx
test   $0x7,%dil
je     11dc <memset+0xdc>
mov    $0xffffffffffffffff,%r8
test   %rdx,%rdx
je     11ed <memset+0xed>
lea    -0x1(%rdx),%rax
lea    0x1(%rdi),%rcx
mov    %sil,(%rdi)
test   $0x7,%cl
je     11d6 <memset+0xd6>
test   %rax,%rax
je     11f0 <memset+0xf0>
lea    -0x2(%rdx),%rax
lea    0x2(%rdi),%rcx
mov    %sil,0x1(%rdi)
test   $0x7,%cl
je     11d6 <memset+0xd6>
test   %rax,%rax
je     11f0 <memset+0xf0>
lea    -0x3(%rdx),%rax
lea    0x3(%rdi),%rcx
mov    %sil,0x2(%rdi)
test   $0x7,%cl
je     11d6 <memset+0xd6>
test   %rax,%rax
je     11f0 <memset+0xf0>
lea    -0x4(%rdx),%rax
lea    0x4(%rdi),%rcx
mov    %sil,0x3(%rdi)
test   $0x7,%cl
je     11d6 <memset+0xd6>
test   %rax,%rax
je     11f0 <memset+0xf0>
lea    -0x5(%rdx),%rax
lea    0x5(%rdi),%rcx
mov    %sil,0x4(%rdi)
test   $0x7,%cl
je     11d6 <memset+0xd6>
test   %rax,%rax
je     11f0 <memset+0xf0>
lea    -0x6(%rdx),%rax
lea    0x6(%rdi),%rcx
mov    %sil,0x5(%rdi)
test   $0x7,%cl
je     11d6 <memset+0xd6>
test   %rax,%rax
je     11f0 <memset+0xf0>
lea    -0x7(%rdx),%rax
lea    0x7(%rdi),%rcx
mov    %sil,0x6(%rdi)
test   $0x7,%cl
je     11d6 <memset+0xd6>
test   %rax,%rax
je     11f0 <memset+0xf0>
add    $0xfffffffffffffff8,%rdx
mov    %sil,0x7(%rdi)
add    $0x8,%rdi
jmp    11dc <memset+0xdc>
mov    %rcx,%rdi
mov    %rax,%rdx
mov    %rdx,%r8
mov    %rdi,%rcx
cmp    $0x8,%rdx
jae    11f0 <memset+0xf0>
jmp    1301 <memset+0x201>
mov    %rdi,%rcx
movslq %esi,%rax
mov    $0x7,%edx
sub    %r8,%rdx
cmp    $0xfffffffffffffff9,%rdx
mov    $0xfffffffffffffff8,%r9
cmovae %rdx,%r9
add    %r8,%r9
cmp    $0x18,%r9
jb     12e6 <memset+0x1e6>
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9,%r10
and    $0xfffffffffffffffc,%r10
movq   %rax,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%r10),%rdx
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r11d
and    $0x3,%r11d
cmp    $0xc,%rdx
jae    1250 <memset+0x150>
xor    %edx,%edx
jmp    1299 <memset+0x199>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movdqu %xmm0,(%rcx,%rdx,8)
movdqu %xmm0,0x10(%rcx,%rdx,8)
movdqu %xmm0,0x20(%rcx,%rdx,8)
movdqu %xmm0,0x30(%rcx,%rdx,8)
movdqu %xmm0,0x40(%rcx,%rdx,8)
movdqu %xmm0,0x50(%rcx,%rdx,8)
movdqu %xmm0,0x60(%rcx,%rdx,8)
movdqu %xmm0,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1260 <memset+0x160>
lea    0x0(,%r10,8),%rdi
test   %r11,%r11
je     12d4 <memset+0x1d4>
lea    (%rcx,%rdx,8),%rdx
add    $0x10,%rdx
shl    $0x5,%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu %xmm0,-0x10(%rdx,%rbx,1)
movdqu %xmm0,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r11
jne    12c0 <memset+0x1c0>
lea    (%rcx,%r10,8),%rcx
sub    %rdi,%r8
mov    %r8,%rdx
mov    %rcx,%rdi
cmp    %r10,%r9
je     1301 <memset+0x201>
mov    %rcx,%rdi
mov    %r8,%rdx
nopl   0x0(%rax)
mov    %rax,(%rdi)
add    $0xfffffffffffffff8,%rdx
add    $0x8,%rdi
cmp    $0x7,%rdx
ja     12f0 <memset+0x1f0>
test   %rdx,%rdx
je     148d <memset+0x38d>
cmp    $0x8,%rdx
jae    131b <memset+0x21b>
mov    %rdi,%r9
mov    %rdx,%rcx
jmp    1473 <memset+0x373>
movzbl %sil,%r8d
cmp    $0x20,%rdx
jae    132c <memset+0x22c>
xor    %eax,%eax
jmp    143e <memset+0x33e>
mov    %rdx,%rax
and    $0xffffffffffffffe0,%rax
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rax),%rcx
mov    %rcx,%r10
shr    $0x5,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x7,%r9d
cmp    $0xe0,%rcx
jae    136c <memset+0x26c>
xor    %ecx,%ecx
jmp    1408 <memset+0x308>
and    $0xfffffffffffffff8,%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,(%rdi,%rcx,1)
movdqu %xmm0,0x10(%rdi,%rcx,1)
movdqu %xmm0,0x20(%rdi,%rcx,1)
movdqu %xmm0,0x30(%rdi,%rcx,1)
movdqu %xmm0,0x40(%rdi,%rcx,1)
movdqu %xmm0,0x50(%rdi,%rcx,1)
movdqu %xmm0,0x60(%rdi,%rcx,1)
movdqu %xmm0,0x70(%rdi,%rcx,1)
movdqu %xmm0,0x80(%rdi,%rcx,1)
movdqu %xmm0,0x90(%rdi,%rcx,1)
movdqu %xmm0,0xa0(%rdi,%rcx,1)
movdqu %xmm0,0xb0(%rdi,%rcx,1)
movdqu %xmm0,0xc0(%rdi,%rcx,1)
movdqu %xmm0,0xd0(%rdi,%rcx,1)
movdqu %xmm0,0xe0(%rdi,%rcx,1)
movdqu %xmm0,0xf0(%rdi,%rcx,1)
add    $0x100,%rcx
add    $0xfffffffffffffff8,%r10
jne    1380 <memset+0x280>
test   %r9,%r9
je     1434 <memset+0x334>
add    %rdi,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rcx,%rbx,1)
movdqu %xmm0,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1420 <memset+0x320>
cmp    %rax,%rdx
je     148d <memset+0x38d>
test   $0x18,%dl
je     148f <memset+0x38f>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rdi,%r10,1),%r9
mov    %edx,%ecx
and    $0x7,%ecx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
nopl   0x0(%rax)
movq   %xmm0,(%rdi,%rax,1)
add    $0x8,%rax
cmp    %rax,%r10
jne    1460 <memset+0x360>
cmp    %r10,%rdx
je     148d <memset+0x38d>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %sil,(%r9,%rax,1)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1480 <memset+0x380>
pop    %rbx
ret
and    $0x1f,%edx
add    %rax,%rdi
jmp    1310 <memset+0x210>

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

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