#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 *m, int c, size_t n) {
  char *s = (char *)m;
  unsigned int i;
  unsigned long buffer;
  unsigned long *aligned_addr;
  if (!((n) < (sizeof(long))) && !((long)m & ((sizeof(long)) - 1))) {
    aligned_addr = (unsigned long *)m;
    c &= 0xff;
    if ((sizeof(long)) == 4) {
      buffer = (c << 8) | c;
      buffer |= (buffer << 16);
    } else {
      buffer = 0;
      for (i = 0; i < (sizeof(long)); i++)
        buffer = (buffer << 8) | c;
    }
    while (n >= (sizeof(long)) * 4) {
      *aligned_addr++ = buffer;
      *aligned_addr++ = buffer;
      *aligned_addr++ = buffer;
      *aligned_addr++ = buffer;
      n -= 4 * (sizeof(long));
    }
    while (n >= (sizeof(long))) {
      *aligned_addr++ = buffer;
      n -= (sizeof(long));
    }
    s = (char *)aligned_addr;
  }
  while (n--) {
    *s++ = (char)c;
  }
  return m;
}


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)
cmpq   $0x8,-0x18(%rbp)
jb     123c <memset+0x13c>
mov    -0x8(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    123c <memset+0x13c>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0xc(%rbp)
movq   $0x0,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    $0x8,%rax
jae    1184 <memset+0x84>
mov    -0x30(%rbp),%rax
shl    $0x8,%rax
movslq -0xc(%rbp),%rcx
or     %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1156 <memset+0x56>
jmp    1189 <memset+0x89>
cmpq   $0x20,-0x18(%rbp)
jb     11fd <memset+0xfd>
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x20,%rax
mov    %rax,-0x18(%rbp)
jmp    1189 <memset+0x89>
jmp    1202 <memset+0x102>
cmpq   $0x8,-0x18(%rbp)
jb     1234 <memset+0x134>
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x18(%rbp)
jmp    1202 <memset+0x102>
mov    -0x38(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1241 <memset+0x141>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     1275 <memset+0x175>
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    1241 <memset+0x141>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memset>:
push   %r14
push   %rbx
mov    %rdi,%rax
cmp    $0x8,%rdx
jb     1208 <memset+0x108>
mov    %eax,%ecx
and    $0x7,%ecx
test   %rcx,%rcx
jne    1208 <memset+0x108>
movzbl %sil,%esi
mov    %esi,%ecx
shl    $0x10,%ecx
mov    %rsi,%rbx
shl    $0x8,%rbx
lea    (%rbx,%rcx,1),%edi
or     %esi,%edi
shl    $0x10,%rdi
or     %rbx,%rdi
or     %rsi,%rdi
shl    $0x10,%rdi
or     %rbx,%rdi
or     %rsi,%rdi
shl    $0x8,%rdi
or     %rsi,%rdi
cmp    $0x20,%rdx
jb     1210 <memset+0x110>
lea    -0x20(%rdx),%r8
mov    %r8d,%ecx
shr    $0x5,%ecx
add    $0x1,%ecx
and    $0x3,%rcx
je     1273 <memset+0x173>
shl    $0x5,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdi,(%rax,%rbx,1)
mov    %rdi,0x8(%rax,%rbx,1)
mov    %rdi,0x10(%rax,%rbx,1)
mov    %rdi,0x18(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rcx
jne    1180 <memset+0x80>
lea    (%rax,%rbx,1),%rcx
sub    %rbx,%rdx
cmp    $0x60,%r8
jb     11fd <memset+0xfd>
nopl   0x0(%rax)
mov    %rdi,(%rcx)
mov    %rdi,0x8(%rcx)
mov    %rdi,0x10(%rcx)
mov    %rdi,0x18(%rcx)
mov    %rdi,0x20(%rcx)
mov    %rdi,0x28(%rcx)
mov    %rdi,0x30(%rcx)
mov    %rdi,0x38(%rcx)
mov    %rdi,0x40(%rcx)
mov    %rdi,0x48(%rcx)
mov    %rdi,0x50(%rcx)
mov    %rdi,0x58(%rcx)
mov    %rdi,0x60(%rcx)
mov    %rdi,0x68(%rcx)
mov    %rdi,0x70(%rcx)
mov    %rdi,0x78(%rcx)
sub    $0xffffffffffffff80,%rcx
add    $0xffffffffffffff80,%rdx
cmp    $0x1f,%rdx
ja     11b0 <memset+0xb0>
cmp    $0x8,%rdx
jae    1213 <memset+0x113>
jmp    1371 <memset+0x271>
mov    %rax,%rcx
jmp    1371 <memset+0x271>
mov    %rax,%rcx
mov    $0x7,%ebx
sub    %rdx,%rbx
cmp    $0xfffffffffffffff9,%rbx
mov    $0xfffffffffffffff8,%r8
cmovae %rbx,%r8
add    %rdx,%r8
cmp    $0x18,%r8
jb     1360 <memset+0x260>
shr    $0x3,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
movq   %rdi,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%r9),%rbx
mov    %rbx,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x7,%r10d
cmp    $0x1c,%rbx
jae    1285 <memset+0x185>
xor    %ebx,%ebx
jmp    1315 <memset+0x215>
mov    %rax,%rcx
cmp    $0x60,%r8
jae    11b0 <memset+0xb0>
jmp    11fd <memset+0xfd>
and    $0xfffffffffffffff8,%r11
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,(%rcx,%rbx,8)
movdqu %xmm0,0x10(%rcx,%rbx,8)
movdqu %xmm0,0x20(%rcx,%rbx,8)
movdqu %xmm0,0x30(%rcx,%rbx,8)
movdqu %xmm0,0x40(%rcx,%rbx,8)
movdqu %xmm0,0x50(%rcx,%rbx,8)
movdqu %xmm0,0x60(%rcx,%rbx,8)
movdqu %xmm0,0x70(%rcx,%rbx,8)
movdqu %xmm0,0x80(%rcx,%rbx,8)
movdqu %xmm0,0x90(%rcx,%rbx,8)
movdqu %xmm0,0xa0(%rcx,%rbx,8)
movdqu %xmm0,0xb0(%rcx,%rbx,8)
movdqu %xmm0,0xc0(%rcx,%rbx,8)
movdqu %xmm0,0xd0(%rcx,%rbx,8)
movdqu %xmm0,0xe0(%rcx,%rbx,8)
movdqu %xmm0,0xf0(%rcx,%rbx,8)
add    $0x20,%rbx
add    $0xfffffffffffffff8,%r11
jne    1290 <memset+0x190>
lea    0x0(,%r9,8),%r11
test   %r10,%r10
je     1346 <memset+0x246>
lea    (%rcx,%rbx,8),%r14
add    $0x10,%r14
shl    $0x5,%r10
xor    %ebx,%ebx
movdqu %xmm0,-0x10(%r14,%rbx,1)
movdqu %xmm0,(%r14,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1330 <memset+0x230>
lea    (%rcx,%r9,8),%rcx
sub    %r11,%rdx
cmp    %r9,%r8
je     1371 <memset+0x271>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdi,(%rcx)
add    $0x8,%rcx
add    $0xfffffffffffffff8,%rdx
cmp    $0x7,%rdx
ja     1360 <memset+0x260>
test   %rdx,%rdx
je     14fd <memset+0x3fd>
cmp    $0x8,%rdx
jae    138b <memset+0x28b>
mov    %rcx,%r9
mov    %rdx,%rbx
jmp    14e3 <memset+0x3e3>
movzbl %sil,%r8d
cmp    $0x20,%rdx
jae    139c <memset+0x29c>
xor    %edi,%edi
jmp    14b0 <memset+0x3b0>
mov    %rdx,%rdi
and    $0xffffffffffffffe0,%rdi
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rdi),%rbx
mov    %rbx,%r10
shr    $0x5,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x7,%r9d
cmp    $0xe0,%rbx
jae    13dc <memset+0x2dc>
xor    %ebx,%ebx
jmp    1478 <memset+0x378>
and    $0xfffffffffffffff8,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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,%r10
jne    13f0 <memset+0x2f0>
test   %r9,%r9
je     14a6 <memset+0x3a6>
lea    (%rbx,%rcx,1),%r10
add    $0x10,%r10
shl    $0x5,%r9
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%r10,%rbx,1)
movdqu %xmm0,(%r10,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1490 <memset+0x390>
cmp    %rdi,%rdx
je     14fd <memset+0x3fd>
test   $0x18,%dl
je     1501 <memset+0x401>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rcx,%r10,1),%r9
mov    %edx,%ebx
and    $0x7,%ebx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
xchg   %ax,%ax
movq   %xmm0,(%rcx,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r10
jne    14d0 <memset+0x3d0>
cmp    %r10,%rdx
je     14fd <memset+0x3fd>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %sil,(%r9,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    14f0 <memset+0x3f0>
pop    %rbx
pop    %r14
ret
and    $0x1f,%edx
add    %rdi,%rcx
jmp    1380 <memset+0x280>

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 i64
%10 = alloca i64*
store i8* %0, i8** %4
store i32 %1, i32* %5
store i64 %2, i64* %6
%11 = load i8*, i8** %4
store i8* %11, i8** %7
%12 = load i64, i64* %6
%13 = icmp ult i64 %12, 8
br i1 %13, label %69, label %14
14: ; preds = %3
%15 = load i8*, i8** %4
%16 = ptrtoint i8* %15 to i64
%17 = and i64 %16, 7
%18 = icmp ne i64 %17, 0
br i1 %18, label %69, label %19
19: ; preds = %14
%20 = load i8*, i8** %4
%21 = bitcast i8* %20 to i64*
store i64* %21, i64** %10
%22 = load i32, i32* %5
%23 = and i32 %22, 255
store i32 %23, i32* %5
store i64 0, i64* %9
store i32 0, i32* %8
br label %24
24: ; preds = %34, %19
%25 = load i32, i32* %8
%26 = zext i32 %25 to i64
%27 = icmp ult i64 %26, 8
br i1 %27, label %28, label %37
28: ; preds = %24
%29 = load i64, i64* %9
%30 = shl i64 %29, 8
%31 = load i32, i32* %5
%32 = sext i32 %31 to i64
%33 = or i64 %30, %32
store i64 %33, i64* %9
br label %34
34: ; preds = %28
%35 = load i32, i32* %8
%36 = add i32 %35, 1
store i32 %36, i32* %8
br label %24
37: ; preds = %24
br label %38
38: ; preds = %41, %37
%39 = load i64, i64* %6
%40 = icmp uge i64 %39, 32
br i1 %40, label %41, label %56
41: ; preds = %38
%42 = load i64, i64* %9
%43 = load i64*, i64** %10
%44 = getelementptr inbounds i64, i64* %43, i32 1
store i64* %44, i64** %10
store i64 %42, i64* %43
%45 = load i64, i64* %9
%46 = load i64*, i64** %10
%47 = getelementptr inbounds i64, i64* %46, i32 1
store i64* %47, i64** %10
store i64 %45, i64* %46
%48 = load i64, i64* %9
%49 = load i64*, i64** %10
%50 = getelementptr inbounds i64, i64* %49, i32 1
store i64* %50, i64** %10
store i64 %48, i64* %49
%51 = load i64, i64* %9
%52 = load i64*, i64** %10
%53 = getelementptr inbounds i64, i64* %52, i32 1
store i64* %53, i64** %10
store i64 %51, i64* %52
%54 = load i64, i64* %6
%55 = sub i64 %54, 32
store i64 %55, i64* %6
br label %38
56: ; preds = %38
br label %57
57: ; preds = %60, %56
%58 = load i64, i64* %6
%59 = icmp uge i64 %58, 8
br i1 %59, label %60, label %66
60: ; preds = %57
%61 = load i64, i64* %9
%62 = load i64*, i64** %10
%63 = getelementptr inbounds i64, i64* %62, i32 1
store i64* %63, i64** %10
store i64 %61, i64* %62
%64 = load i64, i64* %6
%65 = sub i64 %64, 8
store i64 %65, i64* %6
br label %57
66: ; preds = %57
%67 = load i64*, i64** %10
%68 = bitcast i64* %67 to i8*
store i8* %68, i8** %7
br label %69
69: ; preds = %66, %14, %3
br label %70
70: ; preds = %74, %69
%71 = load i64, i64* %6
%72 = add i64 %71, -1
store i64 %72, i64* %6
%73 = icmp ne i64 %71, 0
br i1 %73, label %74, label %79
74: ; preds = %70
%75 = load i32, i32* %5
%76 = trunc i32 %75 to i8
%77 = load i8*, i8** %7
%78 = getelementptr inbounds i8, i8* %77, i32 1
store i8* %78, i8** %7
store i8 %76, i8* %77
br label %70
79: ; preds = %70
%80 = load i8*, i8** %4
ret i8* %80
}

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