int main(int argc, char **argv) {
  char *p;
  int x;
  int i;
  x = 0;
  p = malloc(20000000);
  if (p == ((void *)0)) {
    printf("out of memory\n");
    return (1);
  }
  printf("addr %p approx %d MB location\n", p, ((int)p) / 1024 / 1024);
  memset(p, 'M', 20000000);
  (__builtin_memcpy((p), ("ABC"), (3)));
  (__builtin_memcpy((p + 20000000 - 3 - 1), ("XYZ"), (3)));
  for (i = 0; i < 20000000; i++) {
    x += p[i];
  }
  printf("checksum is %d\n", x);
  x = 0;
  p = malloc(9000000);
  if (p == ((void *)0)) {
    printf("out of memory\n");
    return (1);
  }
  printf("addr %p approx %d MB location\n", p, ((int)p) / 1024 / 1024);
  memset(p, 'M', 9000000);
  (__builtin_memcpy((p), ("ABC"), (3)));
  (__builtin_memcpy((p + 9000000 - 3 - 1), ("XYZ"), (3)));
  for (i = 0; i < 9000000; i++) {
    x += p[i];
  }
  printf("checksum is %d\n", x);
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    $0x1312d00,%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1180 <main+0x50>
lea    0xe93(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    132b <main+0x1fb>
mov    -0x18(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0xe6e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%rdi
mov    $0x4d,%esi
mov    $0x1312d00,%edx
call   1040 <memset@plt>
mov    -0x18(%rbp),%rax
mov    0xe68(%rip),%cx
mov    %cx,(%rax)
mov    0xe61(%rip),%cl
mov    %cl,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0xe55(%rip),%cx
mov    %cx,0x1312cfc(%rax)
mov    0xe4a(%rip),%cl
mov    %cl,0x1312cfe(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x1312d00,-0x20(%rbp)
jge    1224 <main+0xf4>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11f7 <main+0xc7>
mov    -0x1c(%rbp),%esi
lea    0xe08(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1c(%rbp)
mov    $0x895440,%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    126f <main+0x13f>
lea    0xda4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    132b <main+0x1fb>
mov    -0x18(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0xd7f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%rdi
mov    $0x4d,%esi
mov    $0x895440,%edx
call   1040 <memset@plt>
mov    -0x18(%rbp),%rax
mov    0xd79(%rip),%cx
mov    %cx,(%rax)
mov    0xd72(%rip),%cl
mov    %cl,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0xd66(%rip),%cx
mov    %cx,0x89543c(%rax)
mov    0xd5b(%rip),%cl
mov    %cl,0x89543e(%rax)
movl   $0x0,-0x20(%rbp)
cmpl   $0x895440,-0x20(%rbp)
jge    1313 <main+0x1e3>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12e6 <main+0x1b6>
mov    -0x1c(%rbp),%esi
lea    0xd19(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
mov    $0x1312d00,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     13b1 <main+0x271>
mov    %rax,%rbx
lea    0xfffff(%rax),%edx
test   %ebx,%ebx
cmovns %ebx,%edx
sar    $0x14,%edx
lea    0xea4(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
add    $0x3,%rdi
mov    $0x1312cfd,%edx
mov    $0x4d,%esi
call   1050 <memset@plt>
movw   $0x4241,(%rbx)
movb   $0x43,0x2(%rbx)
movw   $0x5958,0x1312cfc(%rbx)
58 59
movb   $0x5a,0x1312cfe(%rbx)
pxor   %xmm0,%xmm0
movdqa 0xe4f(%rip),%xmm1
mov    $0x15,%eax
cs nopw 0x0(%rax,%rax,1)
movd   -0x14(%rbx,%rax,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm3
movd   -0x10(%rbx,%rax,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm3
paddd  %xmm1,%xmm3
psrad  $0x18,%xmm2
paddd  %xmm0,%xmm2
movd   -0xc(%rbx,%rax,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm4
movd   -0x8(%rbx,%rax,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm5
psrad  $0x18,%xmm4
psrad  $0x18,%xmm5
movd   -0x4(%rbx,%rax,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm1
movd   (%rbx,%rax,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm1
paddd  %xmm4,%xmm1
paddd  %xmm3,%xmm1
psrad  $0x18,%xmm0
paddd  %xmm5,%xmm0
paddd  %xmm2,%xmm0
add    $0x18,%rax
cmp    $0x1312d0d,%rax
jne    11c0 <main+0x80>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
movsbl 0x1312cf9(%rbx),%ecx
add    %eax,%ecx
movsbl 0x1312cfa(%rbx),%eax
add    %ecx,%eax
movsbl 0x1312cfb(%rbx),%ecx
add    %eax,%ecx
movsbl 0x1312cfc(%rbx),%eax
add    %ecx,%eax
movsbl 0x1312cfd(%rbx),%ecx
add    %eax,%ecx
movsbl 0x1312cfe(%rbx),%eax
add    %ecx,%eax
movsbl 0x1312cff(%rbx),%esi
add    %eax,%esi
lea    0xd7e(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x895440,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     13b1 <main+0x271>
mov    %rax,%rbx
lea    0xfffff(%rax),%edx
test   %ebx,%ebx
cmovns %ebx,%edx
sar    $0x14,%edx
lea    0xd25(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
add    $0x3,%rdi
mov    $0x89543d,%edx
mov    $0x4d,%esi
call   1050 <memset@plt>
movw   $0x4241,(%rbx)
movb   $0x43,0x2(%rbx)
movw   $0x5958,0x89543c(%rbx)
58 59
movb   $0x5a,0x89543e(%rbx)
pxor   %xmm2,%xmm2
movdqa 0xcd0(%rip),%xmm3
mov    $0xd,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movd   -0xc(%rbx,%rax,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm1
movd   -0x8(%rbx,%rax,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm1
paddd  %xmm3,%xmm1
psrad  $0x18,%xmm0
paddd  %xmm2,%xmm0
cmp    $0x89543d,%rax
je     13c4 <main+0x284>
movd   -0x4(%rbx,%rax,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
movd   (%rbx,%rax,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
psrad  $0x18,%xmm2
psrad  $0x18,%xmm3
paddd  %xmm2,%xmm1
paddd  %xmm3,%xmm0
add    $0x10,%rax
movdqa %xmm1,%xmm3
movdqa %xmm0,%xmm2
jmp    1340 <main+0x200>
lea    0xc8f(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%ebx
jmp    142d <main+0x2ed>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
movsbl 0x895439(%rbx),%ecx
add    %eax,%ecx
movsbl 0x89543a(%rbx),%eax
add    %ecx,%eax
movsbl 0x89543b(%rbx),%ecx
add    %eax,%ecx
movsbl 0x89543c(%rbx),%eax
add    %ecx,%eax
movsbl 0x89543d(%rbx),%ecx
add    %eax,%ecx
movsbl 0x89543e(%rbx),%eax
add    %ecx,%eax
movsbl 0x89543f(%rbx),%esi
add    %eax,%esi
lea    0xc13(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebx,%eax
pop    %rbx
ret

LLVM IR (-O0):
@.str = [15 x i8] c"out of memory\0A\00"
@.str.1 = [31 x i8] c"addr %p approx %d MB location\0A\00"
@.str.2 = [4 x i8] c"ABC\00"
@.str.3 = [4 x i8] c"XYZ\00"
@.str.4 = [16 x i8] c"checksum is %d\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %7
%9 = call i8* @malloc(i64 20000000)
store i8* %9, i8** %6
%10 = load i8*, i8** %6
%11 = icmp eq i8* %10, null
br i1 %11, label %12, label %14
12: ; preds = %2
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %3
br label %81
14: ; preds = %2
%15 = load i8*, i8** %6
%16 = load i8*, i8** %6
%17 = ptrtoint i8* %16 to i32
%18 = sdiv i32 %17, 1024
%19 = sdiv i32 %18, 1024
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i8* %15, i32 %19)
%21 = load i8*, i8** %6
%22 = load i8*, i8** %6
%23 = load i8*, i8** %6
%24 = getelementptr inbounds i8, i8* %23, i64 20000000
%25 = getelementptr inbounds i8, i8* %24, i64 -3
%26 = getelementptr inbounds i8, i8* %25, i64 -1
store i32 0, i32* %8
br label %27
27: ; preds = %39, %14
%28 = load i32, i32* %8
%29 = icmp slt i32 %28, 20000000
br i1 %29, label %30, label %42
30: ; preds = %27
%31 = load i8*, i8** %6
%32 = load i32, i32* %8
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = load i32, i32* %7
%38 = add nsw i32 %37, %36
store i32 %38, i32* %7
br label %39
39: ; preds = %30
%40 = load i32, i32* %8
%41 = add nsw i32 %40, 1
store i32 %41, i32* %8
br label %27
42: ; preds = %27
%43 = load i32, i32* %7
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %43)
store i32 0, i32* %7
%45 = call i8* @malloc(i64 9000000)
store i8* %45, i8** %6
%46 = load i8*, i8** %6
%47 = icmp eq i8* %46, null
br i1 %47, label %48, label %50
48: ; preds = %42
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %3
br label %81
50: ; preds = %42
%51 = load i8*, i8** %6
%52 = load i8*, i8** %6
%53 = ptrtoint i8* %52 to i32
%54 = sdiv i32 %53, 1024
%55 = sdiv i32 %54, 1024
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i8* %51, i32 %55)
%57 = load i8*, i8** %6
%58 = load i8*, i8** %6
%59 = load i8*, i8** %6
%60 = getelementptr inbounds i8, i8* %59, i64 9000000
%61 = getelementptr inbounds i8, i8* %60, i64 -3
%62 = getelementptr inbounds i8, i8* %61, i64 -1
store i32 0, i32* %8
br label %63
63: ; preds = %75, %50
%64 = load i32, i32* %8
%65 = icmp slt i32 %64, 9000000
br i1 %65, label %66, label %78
66: ; preds = %63
%67 = load i8*, i8** %6
%68 = load i32, i32* %8
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %67, i64 %69
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = load i32, i32* %7
%74 = add nsw i32 %73, %72
store i32 %74, i32* %7
br label %75
75: ; preds = %66
%76 = load i32, i32* %8
%77 = add nsw i32 %76, 1
store i32 %77, i32* %8
br label %63
78: ; preds = %63
%79 = load i32, i32* %7
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %79)
store i32 0, i32* %3
br label %81
81: ; preds = %78, %48, %12
%82 = load i32, i32* %3
ret i32 %82
}

LLVM IR (-O2):
@.str.1 = [31 x i8] c"addr %p approx %d MB location\0A\00"
@.str.2 = [4 x i8] c"ABC\00"
@.str.3 = [4 x i8] c"XYZ\00"
@.str.4 = [16 x i8] c"checksum is %d\0A\00"
@str.5 = [14 x i8] c"out of memory\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call dereferenceable_or_null(20000000) i8* @malloc(i64 20000000)
%4 = icmp eq i8* %3, null
br i1 %4, label %5, label %7
5: ; preds = %2
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.5, i64 0, i64 0))
br label %159
7: ; preds = %2
%8 = ptrtoint i8* %3 to i64
%9 = trunc i64 %8 to i32
%10 = sdiv i32 %9, 1048576
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i8* %3, i32 %10)
%12 = getelementptr i8, i8* %3, i64 3
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %3, i8* align 1 dereferenceable(3) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i64 3, i1 false)
%13 = getelementptr inbounds i8, i8* %3, i64 19999996
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %13, i8* align 1 dereferenceable(3) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i64 3, i1 false)
br label %14
14: ; preds = %14, %7
%15 = phi i64 [ 0, %7 ], [ %53, %14 ]
%16 = phi <4 x i32> [ <i32 65, i32 0, i32 0, i32 0>, %7 ], [ %51, %14 ]
%17 = phi <4 x i32> [ zeroinitializer, %7 ], [ %52, %14 ]
%18 = or i64 %15, 1
%19 = getelementptr inbounds i8, i8* %3, i64 %18
%20 = bitcast i8* %19 to <4 x i8>*
%21 = load <4 x i8>, <4 x i8>* %20
%22 = getelementptr inbounds i8, i8* %19, i64 4
%23 = bitcast i8* %22 to <4 x i8>*
%24 = load <4 x i8>, <4 x i8>* %23
%25 = sext <4 x i8> %21 to <4 x i32>
%26 = sext <4 x i8> %24 to <4 x i32>
%27 = add <4 x i32> %16, %25
%28 = add <4 x i32> %17, %26
%29 = add nuw nsw i64 %15, 8
%30 = or i64 %29, 1
%31 = getelementptr inbounds i8, i8* %3, i64 %30
%32 = bitcast i8* %31 to <4 x i8>*
%33 = load <4 x i8>, <4 x i8>* %32
%34 = getelementptr inbounds i8, i8* %31, i64 4
%35 = bitcast i8* %34 to <4 x i8>*
%36 = load <4 x i8>, <4 x i8>* %35
%37 = sext <4 x i8> %33 to <4 x i32>
%38 = sext <4 x i8> %36 to <4 x i32>
%39 = add <4 x i32> %27, %37
%40 = add <4 x i32> %28, %38
%41 = add nuw nsw i64 %15, 16
%42 = or i64 %41, 1
%43 = getelementptr inbounds i8, i8* %3, i64 %42
%44 = bitcast i8* %43 to <4 x i8>*
%45 = load <4 x i8>, <4 x i8>* %44
%46 = getelementptr inbounds i8, i8* %43, i64 4
%47 = bitcast i8* %46 to <4 x i8>*
%48 = load <4 x i8>, <4 x i8>* %47
%49 = sext <4 x i8> %45 to <4 x i32>
%50 = sext <4 x i8> %48 to <4 x i32>
%51 = add <4 x i32> %39, %49
%52 = add <4 x i32> %40, %50
%53 = add nuw nsw i64 %15, 24
%54 = icmp eq i64 %53, 19999992
br i1 %54, label %55, label %14
55: ; preds = %14
%56 = add <4 x i32> %52, %51
%57 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %56)
%58 = getelementptr inbounds i8, i8* %3, i64 19999993
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = add nsw i32 %57, %60
%62 = getelementptr inbounds i8, i8* %3, i64 19999994
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = add nsw i32 %61, %64
%66 = getelementptr inbounds i8, i8* %3, i64 19999995
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = add nsw i32 %65, %68
%70 = getelementptr inbounds i8, i8* %3, i64 19999996
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = add nsw i32 %69, %72
%74 = getelementptr inbounds i8, i8* %3, i64 19999997
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = add nsw i32 %73, %76
%78 = getelementptr inbounds i8, i8* %3, i64 19999998
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = add nsw i32 %77, %80
%82 = getelementptr inbounds i8, i8* %3, i64 19999999
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
%85 = add nsw i32 %81, %84
%86 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %85)
%87 = tail call dereferenceable_or_null(9000000) i8* @malloc(i64 9000000)
%88 = icmp eq i8* %87, null
br i1 %88, label %89, label %91
89: ; preds = %55
%90 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.5, i64 0, i64 0))
br label %159
91: ; preds = %55
%92 = ptrtoint i8* %87 to i64
%93 = trunc i64 %92 to i32
%94 = sdiv i32 %93, 1048576
%95 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i8* %87, i32 %94)
%96 = getelementptr i8, i8* %87, i64 3
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %87, i8* align 1 dereferenceable(3) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i64 3, i1 false)
%97 = getelementptr inbounds i8, i8* %87, i64 8999996
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %97, i8* align 1 dereferenceable(3) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i64 3, i1 false)
br label %98
98: ; preds = %114, %91
%99 = phi i64 [ 0, %91 ], [ %126, %114 ]
%100 = phi <4 x i32> [ <i32 65, i32 0, i32 0, i32 0>, %91 ], [ %124, %114 ]
%101 = phi <4 x i32> [ zeroinitializer, %91 ], [ %125, %114 ]
%102 = or i64 %99, 1
%103 = getelementptr inbounds i8, i8* %87, i64 %102
%104 = bitcast i8* %103 to <4 x i8>*
%105 = load <4 x i8>, <4 x i8>* %104
%106 = getelementptr inbounds i8, i8* %103, i64 4
%107 = bitcast i8* %106 to <4 x i8>*
%108 = load <4 x i8>, <4 x i8>* %107
%109 = sext <4 x i8> %105 to <4 x i32>
%110 = sext <4 x i8> %108 to <4 x i32>
%111 = add <4 x i32> %100, %109
%112 = add <4 x i32> %101, %110
%113 = icmp eq i64 %99, 8999984
br i1 %113, label %127, label %114
114: ; preds = %98
%115 = or i64 %99, 9
%116 = getelementptr inbounds i8, i8* %87, i64 %115
%117 = bitcast i8* %116 to <4 x i8>*
%118 = load <4 x i8>, <4 x i8>* %117
%119 = getelementptr inbounds i8, i8* %116, i64 4
%120 = bitcast i8* %119 to <4 x i8>*
%121 = load <4 x i8>, <4 x i8>* %120
%122 = sext <4 x i8> %118 to <4 x i32>
%123 = sext <4 x i8> %121 to <4 x i32>
%124 = add <4 x i32> %111, %122
%125 = add <4 x i32> %112, %123
%126 = add nuw nsw i64 %99, 16
br label %98
127: ; preds = %98
%128 = add <4 x i32> %112, %111
%129 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %128)
%130 = getelementptr inbounds i8, i8* %87, i64 8999993
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = add nsw i32 %129, %132
%134 = getelementptr inbounds i8, i8* %87, i64 8999994
%135 = load i8, i8* %134
%136 = sext i8 %135 to i32
%137 = add nsw i32 %133, %136
%138 = getelementptr inbounds i8, i8* %87, i64 8999995
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = add nsw i32 %137, %140
%142 = getelementptr inbounds i8, i8* %87, i64 8999996
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = add nsw i32 %141, %144
%146 = getelementptr inbounds i8, i8* %87, i64 8999997
%147 = load i8, i8* %146
%148 = sext i8 %147 to i32
%149 = add nsw i32 %145, %148
%150 = getelementptr inbounds i8, i8* %87, i64 8999998
%151 = load i8, i8* %150
%152 = sext i8 %151 to i32
%153 = add nsw i32 %149, %152
%154 = getelementptr inbounds i8, i8* %87, i64 8999999
%155 = load i8, i8* %154
%156 = sext i8 %155 to i32
%157 = add nsw i32 %153, %156
%158 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %157)
br label %159
159: ; preds = %127, %89, %5
%160 = phi i32 [ 1, %5 ], [ 1, %89 ], [ 0, %127 ]
ret i32 %160
}