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


x86 assembly (clang, -O0):
<memset>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
je     117a <memset+0x7a>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
je     1168 <memset+0x68>
mov    -0x14(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1175 <memset+0x75>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12ca <memset+0x1ca>
jmp    1122 <memset+0x22>
cmpq   $0x8,-0x20(%rbp)
jb     1289 <memset+0x189>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x8,%eax
or     -0x3c(%rbp),%eax
mov    %eax,%eax
mov    %rax,-0x38(%rbp)
movl   $0x10,-0x40(%rbp)
movslq -0x40(%rbp),%rax
cmp    $0x40,%rax
jae    11d1 <memset+0xd1>
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    %cl,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11a3 <memset+0xa3>
jmp    11d6 <memset+0xd6>
cmpq   $0x20,-0x20(%rbp)
jb     124a <memset+0x14a>
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
sub    $0x20,%rax
mov    %rax,-0x20(%rbp)
jmp    11d6 <memset+0xd6>
jmp    124f <memset+0x14f>
cmpq   $0x8,-0x20(%rbp)
jb     1281 <memset+0x181>
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x20(%rbp)
jmp    124f <memset+0x14f>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    128e <memset+0x18e>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
je     12c2 <memset+0x1c2>
mov    -0x14(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    128e <memset+0x18e>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memset>:
push   %r14
push   %rbx
mov    %rdi,%rax
test   $0x7,%al
je     11f0 <memset+0xf0>
test   %rdx,%rdx
je     15ad <memset+0x4ad>
lea    -0x1(%rdx),%rdi
lea    0x1(%rax),%rcx
mov    %sil,(%rax)
test   $0x7,%cl
je     11ff <memset+0xff>
test   %rdi,%rdi
je     15ad <memset+0x4ad>
lea    -0x2(%rdx),%rdi
lea    0x2(%rax),%rcx
mov    %sil,0x1(%rax)
test   $0x7,%cl
je     11ff <memset+0xff>
test   %rdi,%rdi
je     15ad <memset+0x4ad>
lea    -0x3(%rdx),%rdi
lea    0x3(%rax),%rcx
mov    %sil,0x2(%rax)
test   $0x7,%cl
je     11ff <memset+0xff>
test   %rdi,%rdi
je     15ad <memset+0x4ad>
lea    -0x4(%rdx),%rdi
lea    0x4(%rax),%rcx
mov    %sil,0x3(%rax)
test   $0x7,%cl
je     11ff <memset+0xff>
test   %rdi,%rdi
je     15ad <memset+0x4ad>
lea    -0x5(%rdx),%rdi
lea    0x5(%rax),%rcx
mov    %sil,0x4(%rax)
test   $0x7,%cl
je     11ff <memset+0xff>
test   %rdi,%rdi
je     15ad <memset+0x4ad>
lea    -0x6(%rdx),%rdi
lea    0x6(%rax),%rcx
mov    %sil,0x5(%rax)
test   $0x7,%cl
je     11ff <memset+0xff>
test   %rdi,%rdi
je     15ad <memset+0x4ad>
lea    -0x7(%rdx),%rdi
lea    0x7(%rax),%rcx
mov    %sil,0x6(%rax)
test   $0x7,%cl
je     11ff <memset+0xff>
test   %rdi,%rdi
je     15ad <memset+0x4ad>
add    $0xfffffffffffffff8,%rdx
lea    0x8(%rax),%rcx
mov    %sil,0x7(%rax)
cmp    $0x8,%rdx
jb     1421 <memset+0x321>
jmp    120c <memset+0x10c>
mov    %rax,%rcx
cmp    $0x8,%rdx
jb     1421 <memset+0x321>
jmp    120c <memset+0x10c>
mov    %rdi,%rdx
cmp    $0x8,%rdx
jb     1421 <memset+0x321>
movzbl %sil,%ebx
mov    %ebx,%edi
shl    $0x8,%edi
or     %ebx,%edi
mov    %rdi,%rbx
shl    $0x10,%rbx
or     %rdi,%rbx
mov    %rbx,%rdi
shl    $0x20,%rdi
or     %rbx,%rdi
cmp    $0x20,%rdx
jb     12d7 <memset+0x1d7>
lea    -0x20(%rdx),%r8
mov    %r8d,%r9d
shr    $0x5,%r9d
add    $0x1,%r9d
and    $0x3,%r9
je     1272 <memset+0x172>
shl    $0x5,%r9
xor    %ebx,%ebx
mov    %rdi,(%rcx,%rbx,1)
mov    %rdi,0x8(%rcx,%rbx,1)
mov    %rdi,0x10(%rcx,%rbx,1)
mov    %rdi,0x18(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1250 <memset+0x150>
add    %rbx,%rcx
sub    %rbx,%rdx
cmp    $0x60,%r8
jb     12cd <memset+0x1cd>
nopl   0x0(%rax,%rax,1)
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     1280 <memset+0x180>
cmp    $0x8,%rdx
jb     1421 <memset+0x321>
mov    $0x7,%ebx
sub    %rdx,%rbx
cmp    $0xfffffffffffffff9,%rbx
mov    $0xfffffffffffffff8,%r8
cmovae %rbx,%r8
add    %rdx,%r8
cmp    $0x18,%r8
jb     1410 <memset+0x310>
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    1337 <memset+0x237>
xor    %ebx,%ebx
jmp    13c5 <memset+0x2c5>
and    $0xfffffffffffffff8,%r11
xor    %ebx,%ebx
nopl   (%rax)
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    1340 <memset+0x240>
lea    0x0(,%r9,8),%r11
test   %r10,%r10
je     13f6 <memset+0x2f6>
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    13e0 <memset+0x2e0>
lea    (%rcx,%r9,8),%rcx
sub    %r11,%rdx
cmp    %r9,%r8
je     1421 <memset+0x321>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdi,(%rcx)
add    $0x8,%rcx
add    $0xfffffffffffffff8,%rdx
cmp    $0x7,%rdx
ja     1410 <memset+0x310>
test   %rdx,%rdx
je     15ad <memset+0x4ad>
cmp    $0x8,%rdx
jae    143b <memset+0x33b>
mov    %rcx,%r9
mov    %rdx,%rbx
jmp    1593 <memset+0x493>
movzbl %sil,%r8d
cmp    $0x20,%rdx
jae    144c <memset+0x34c>
xor    %edi,%edi
jmp    1560 <memset+0x460>
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    148c <memset+0x38c>
xor    %ebx,%ebx
jmp    1528 <memset+0x428>
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    14a0 <memset+0x3a0>
test   %r9,%r9
je     1556 <memset+0x456>
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    1540 <memset+0x440>
cmp    %rdi,%rdx
je     15ad <memset+0x4ad>
test   $0x18,%dl
je     15b1 <memset+0x4b1>
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    1580 <memset+0x480>
cmp    %r10,%rdx
je     15ad <memset+0x4ad>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %sil,(%r9,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    15a0 <memset+0x4a0>
pop    %rbx
pop    %r14
ret
and    $0x1f,%edx
add    %rdi,%rcx
jmp    1430 <memset+0x330>

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

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