#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ bar();
int main() {
  int i, j;
  int sum = 0;
  int A[8192 * 8192];
  int B[8192 * 8192];
  bar();
  for (i = 0; i < 8192; i++)
    for (j = 0; j < 8192; j++) {
      A[i * 8192 + j] = j;
      B[i * 8192 + j] = j;
    }
  for (i = 0; i < 8192; i++)
    for (j = 0; j < 8192; j++)
      A[i * 8192 + j] += B[j * 8192 + i];
  bar();
  for (i = 0; i < 8192; i++)
    for (j = 0; j < 8192; j++)
      sum += A[i * 8192 + j];
  return sum;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20000010,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x10(%rbp)
mov    $0x0,%al
call   1030 <bar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x2000,-0x8(%rbp)
jge    11a3 <main+0x93>
movl   $0x0,-0xc(%rbp)
cmpl   $0x2000,-0xc(%rbp)
jge    1190 <main+0x80>
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%eax
shl    $0xd,%eax
add    -0xc(%rbp),%eax
cltq
mov    %ecx,-0x10000010(%rbp,%rax,4)
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%eax
shl    $0xd,%eax
add    -0xc(%rbp),%eax
cltq
mov    %ecx,-0x20000010(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    114b <main+0x3b>
jmp    1195 <main+0x85>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1137 <main+0x27>
movl   $0x0,-0x8(%rbp)
cmpl   $0x2000,-0x8(%rbp)
jge    1217 <main+0x107>
movl   $0x0,-0xc(%rbp)
cmpl   $0x2000,-0xc(%rbp)
jge    1204 <main+0xf4>
mov    -0xc(%rbp),%eax
shl    $0xd,%eax
add    -0x8(%rbp),%eax
cltq
mov    -0x20000010(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%eax
shl    $0xd,%eax
add    -0xc(%rbp),%eax
cltq
add    -0x10000010(%rbp,%rax,4),%ecx
mov    %ecx,-0x10000010(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11be <main+0xae>
jmp    1209 <main+0xf9>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11aa <main+0x9a>
mov    $0x0,%al
call   1030 <bar@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x2000,-0x8(%rbp)
jge    127f <main+0x16f>
movl   $0x0,-0xc(%rbp)
cmpl   $0x2000,-0xc(%rbp)
jge    126c <main+0x15c>
mov    -0x8(%rbp),%eax
shl    $0xd,%eax
add    -0xc(%rbp),%eax
cltq
mov    -0x10000010(%rbp,%rax,4),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1239 <main+0x129>
jmp    1271 <main+0x161>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1225 <main+0x115>
mov    -0x10(%rbp),%eax
add    $0x20000010,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x20000000,%rsp
xor    %ebx,%ebx
xor    %eax,%eax
call   1030 <bar@plt>
lea    0x10000030(%rsp),%rax
10
lea    0x30(%rsp),%rcx
movdqa 0xeca(%rip),%xmm0
movdqa 0xed2(%rip),%xmm1
movdqa 0xeda(%rip),%xmm2
movdqa 0xee2(%rip),%xmm3
movdqa 0xeea(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
xor    %edx,%edx
movdqa %xmm0,%xmm5
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm5,-0x30(%rcx,%rdx,4)
movdqa %xmm6,-0x20(%rcx,%rdx,4)
movdqa %xmm5,-0x30(%rax,%rdx,4)
movdqa %xmm6,-0x20(%rax,%rdx,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqa %xmm6,-0x10(%rcx,%rdx,4)
movdqa %xmm7,(%rcx,%rdx,4)
movdqa %xmm6,-0x10(%rax,%rdx,4)
movdqa %xmm7,(%rax,%rdx,4)
add    $0x10,%rdx
paddd  %xmm4,%xmm5
cmp    $0x2000,%rdx
jne    1170 <main+0x60>
add    $0x1,%rbx
add    $0x8000,%rax
add    $0x8000,%rcx
cmp    $0x2000,%rbx
jne    1160 <main+0x50>
lea    0x10008000(%rsp),%rax
10
lea    0x4(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x8000(%rsi),%ebx
add    %ebx,-0x4(%rcx,%rdi,4)
mov    (%rsi),%ebx
add    %ebx,(%rcx,%rdi,4)
add    $0x2,%rdi
add    $0x10000,%rsi
cmp    $0x2000,%rdi
jne    1210 <main+0x100>
add    $0x1,%rdx
add    $0x4,%rax
add    $0x8000,%rcx
cmp    $0x2000,%rdx
jne    1200 <main+0xf0>
xor    %ebx,%ebx
xor    %eax,%eax
call   1030 <bar@plt>
lea    0x70(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movd   %eax,%xmm1
pxor   %xmm0,%xmm0
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
paddd  -0x70(%rcx,%rax,4),%xmm1
paddd  -0x60(%rcx,%rax,4),%xmm0
paddd  -0x50(%rcx,%rax,4),%xmm1
paddd  -0x40(%rcx,%rax,4),%xmm0
paddd  -0x30(%rcx,%rax,4),%xmm1
paddd  -0x20(%rcx,%rax,4),%xmm0
paddd  -0x10(%rcx,%rax,4),%xmm1
paddd  (%rcx,%rax,4),%xmm0
add    $0x20,%rax
cmp    $0x2000,%rax
jne    1270 <main+0x160>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
add    $0x1,%rbx
add    $0x8000,%rcx
cmp    $0x2000,%rbx
jne    1260 <main+0x150>
add    $0x20000000,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [67108864 x i32]
%6 = alloca [67108864 x i32]
store i32 0, i32* %1
store i32 0, i32* %4
%7 = call i32 (...) @bar()
store i32 0, i32* %2
br label %8
8: ; preds = %34, %0
%9 = load i32, i32* %2
%10 = icmp slt i32 %9, 8192
br i1 %10, label %11, label %37
11: ; preds = %8
store i32 0, i32* %3
br label %12
12: ; preds = %30, %11
%13 = load i32, i32* %3
%14 = icmp slt i32 %13, 8192
br i1 %14, label %15, label %33
15: ; preds = %12
%16 = load i32, i32* %3
%17 = load i32, i32* %2
%18 = mul nsw i32 %17, 8192
%19 = load i32, i32* %3
%20 = add nsw i32 %18, %19
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %5, i64 0, i64 %21
store i32 %16, i32* %22
%23 = load i32, i32* %3
%24 = load i32, i32* %2
%25 = mul nsw i32 %24, 8192
%26 = load i32, i32* %3
%27 = add nsw i32 %25, %26
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %6, i64 0, i64 %28
store i32 %23, i32* %29
br label %30
30: ; preds = %15
%31 = load i32, i32* %3
%32 = add nsw i32 %31, 1
store i32 %32, i32* %3
br label %12
33: ; preds = %12
br label %34
34: ; preds = %33
%35 = load i32, i32* %2
%36 = add nsw i32 %35, 1
store i32 %36, i32* %2
br label %8
37: ; preds = %8
store i32 0, i32* %2
br label %38
38: ; preds = %65, %37
%39 = load i32, i32* %2
%40 = icmp slt i32 %39, 8192
br i1 %40, label %41, label %68
41: ; preds = %38
store i32 0, i32* %3
br label %42
42: ; preds = %61, %41
%43 = load i32, i32* %3
%44 = icmp slt i32 %43, 8192
br i1 %44, label %45, label %64
45: ; preds = %42
%46 = load i32, i32* %3
%47 = mul nsw i32 %46, 8192
%48 = load i32, i32* %2
%49 = add nsw i32 %47, %48
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %6, i64 0, i64 %50
%52 = load i32, i32* %51
%53 = load i32, i32* %2
%54 = mul nsw i32 %53, 8192
%55 = load i32, i32* %3
%56 = add nsw i32 %54, %55
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %5, i64 0, i64 %57
%59 = load i32, i32* %58
%60 = add nsw i32 %59, %52
store i32 %60, i32* %58
br label %61
61: ; preds = %45
%62 = load i32, i32* %3
%63 = add nsw i32 %62, 1
store i32 %63, i32* %3
br label %42
64: ; preds = %42
br label %65
65: ; preds = %64
%66 = load i32, i32* %2
%67 = add nsw i32 %66, 1
store i32 %67, i32* %2
br label %38
68: ; preds = %38
%69 = call i32 (...) @bar()
store i32 0, i32* %2
br label %70
70: ; preds = %91, %68
%71 = load i32, i32* %2
%72 = icmp slt i32 %71, 8192
br i1 %72, label %73, label %94
73: ; preds = %70
store i32 0, i32* %3
br label %74
74: ; preds = %87, %73
%75 = load i32, i32* %3
%76 = icmp slt i32 %75, 8192
br i1 %76, label %77, label %90
77: ; preds = %74
%78 = load i32, i32* %2
%79 = mul nsw i32 %78, 8192
%80 = load i32, i32* %3
%81 = add nsw i32 %79, %80
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %5, i64 0, i64 %82
%84 = load i32, i32* %83
%85 = load i32, i32* %4
%86 = add nsw i32 %85, %84
store i32 %86, i32* %4
br label %87
87: ; preds = %77
%88 = load i32, i32* %3
%89 = add nsw i32 %88, 1
store i32 %89, i32* %3
br label %74
90: ; preds = %74
br label %91
91: ; preds = %90
%92 = load i32, i32* %2
%93 = add nsw i32 %92, 1
store i32 %93, i32* %2
br label %70
94: ; preds = %70
%95 = load i32, i32* %4
ret i32 %95
}

LLVM IR (-O2):
define i32 @main() {
%1 = alloca [67108864 x i32]
%2 = alloca [67108864 x i32]
%3 = bitcast [67108864 x i32]* %1 to i8*
%4 = bitcast [67108864 x i32]* %2 to i8*
%5 = tail call i32 (...) @bar()
br label %6
6: ; preds = %0, %37
%7 = phi i64 [ 0, %0 ], [ %38, %37 ]
%8 = shl nsw i64 %7, 13
br label %9
9: ; preds = %9, %6
%10 = phi i64 [ 0, %6 ], [ %34, %9 ]
%11 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %6 ], [ %35, %9 ]
%12 = add <4 x i32> %11, <i32 4, i32 4, i32 4, i32 4>
%13 = add nuw nsw i64 %10, %8
%14 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %13
%15 = bitcast i32* %14 to <4 x i32>*
store <4 x i32> %11, <4 x i32>* %15
%16 = getelementptr inbounds i32, i32* %14, i64 4
%17 = bitcast i32* %16 to <4 x i32>*
store <4 x i32> %12, <4 x i32>* %17
%18 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %2, i64 0, i64 %13
%19 = bitcast i32* %18 to <4 x i32>*
store <4 x i32> %11, <4 x i32>* %19
%20 = getelementptr inbounds i32, i32* %18, i64 4
%21 = bitcast i32* %20 to <4 x i32>*
store <4 x i32> %12, <4 x i32>* %21
%22 = or i64 %10, 8
%23 = add <4 x i32> %11, <i32 8, i32 8, i32 8, i32 8>
%24 = add <4 x i32> %11, <i32 12, i32 12, i32 12, i32 12>
%25 = add nuw nsw i64 %22, %8
%26 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %25
%27 = bitcast i32* %26 to <4 x i32>*
store <4 x i32> %23, <4 x i32>* %27
%28 = getelementptr inbounds i32, i32* %26, i64 4
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> %24, <4 x i32>* %29
%30 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %2, i64 0, i64 %25
%31 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %23, <4 x i32>* %31
%32 = getelementptr inbounds i32, i32* %30, i64 4
%33 = bitcast i32* %32 to <4 x i32>*
store <4 x i32> %24, <4 x i32>* %33
%34 = add nuw nsw i64 %10, 16
%35 = add <4 x i32> %11, <i32 16, i32 16, i32 16, i32 16>
%36 = icmp eq i64 %34, 8192
br i1 %36, label %37, label %9
37: ; preds = %9
%38 = add nuw nsw i64 %7, 1
%39 = icmp eq i64 %38, 8192
br i1 %39, label %40, label %6
40: ; preds = %37, %64
%41 = phi i64 [ %65, %64 ], [ 0, %37 ]
%42 = shl nsw i64 %41, 13
br label %43
43: ; preds = %43, %40
%44 = phi i64 [ 0, %40 ], [ %62, %43 ]
%45 = shl nuw nsw i64 %44, 13
%46 = add nuw nsw i64 %45, %41
%47 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %2, i64 0, i64 %46
%48 = load i32, i32* %47
%49 = add nuw nsw i64 %44, %42
%50 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %49
%51 = load i32, i32* %50
%52 = add nsw i32 %51, %48
store i32 %52, i32* %50
%53 = or i64 %44, 1
%54 = shl nuw nsw i64 %53, 13
%55 = add nuw nsw i64 %54, %41
%56 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %2, i64 0, i64 %55
%57 = load i32, i32* %56
%58 = add nuw nsw i64 %53, %42
%59 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %58
%60 = load i32, i32* %59
%61 = add nsw i32 %60, %57
store i32 %61, i32* %59
%62 = add nuw nsw i64 %44, 2
%63 = icmp eq i64 %62, 8192
br i1 %63, label %64, label %43
64: ; preds = %43
%65 = add nuw nsw i64 %41, 1
%66 = icmp eq i64 %65, 8192
br i1 %66, label %67, label %40
67: ; preds = %64
%68 = tail call i32 (...) @bar()
br label %69
69: ; preds = %67, %119
%70 = phi i64 [ 0, %67 ], [ %122, %119 ]
%71 = phi i32 [ 0, %67 ], [ %121, %119 ]
%72 = shl nsw i64 %70, 13
%73 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %71, i64 0
br label %74
74: ; preds = %74, %69
%75 = phi i64 [ 0, %69 ], [ %117, %74 ]
%76 = phi <4 x i32> [ %73, %69 ], [ %115, %74 ]
%77 = phi <4 x i32> [ zeroinitializer, %69 ], [ %116, %74 ]
%78 = add nuw nsw i64 %75, %72
%79 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %78
%80 = bitcast i32* %79 to <4 x i32>*
%81 = load <4 x i32>, <4 x i32>* %80
%82 = getelementptr inbounds i32, i32* %79, i64 4
%83 = bitcast i32* %82 to <4 x i32>*
%84 = load <4 x i32>, <4 x i32>* %83
%85 = add <4 x i32> %81, %76
%86 = add <4 x i32> %84, %77
%87 = or i64 %75, 8
%88 = add nuw nsw i64 %87, %72
%89 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %88
%90 = bitcast i32* %89 to <4 x i32>*
%91 = load <4 x i32>, <4 x i32>* %90
%92 = getelementptr inbounds i32, i32* %89, i64 4
%93 = bitcast i32* %92 to <4 x i32>*
%94 = load <4 x i32>, <4 x i32>* %93
%95 = add <4 x i32> %91, %85
%96 = add <4 x i32> %94, %86
%97 = or i64 %75, 16
%98 = add nuw nsw i64 %97, %72
%99 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %98
%100 = bitcast i32* %99 to <4 x i32>*
%101 = load <4 x i32>, <4 x i32>* %100
%102 = getelementptr inbounds i32, i32* %99, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = add <4 x i32> %101, %95
%106 = add <4 x i32> %104, %96
%107 = or i64 %75, 24
%108 = add nuw nsw i64 %107, %72
%109 = getelementptr inbounds [67108864 x i32], [67108864 x i32]* %1, i64 0, i64 %108
%110 = bitcast i32* %109 to <4 x i32>*
%111 = load <4 x i32>, <4 x i32>* %110
%112 = getelementptr inbounds i32, i32* %109, i64 4
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = add <4 x i32> %111, %105
%116 = add <4 x i32> %114, %106
%117 = add nuw nsw i64 %75, 32
%118 = icmp eq i64 %117, 8192
br i1 %118, label %119, label %74
119: ; preds = %74
%120 = add <4 x i32> %116, %115
%121 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %120)
%122 = add nuw nsw i64 %70, 1
%123 = icmp eq i64 %122, 8192
br i1 %123, label %124, label %69
124: ; preds = %119
ret i32 %121
}