#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 */
struct timeval {
  int tv_sec;
  double tv_usec;
};

/* Variables and functions */
int /*<<< orphan*/ acc_device_default;
int /*<<< orphan*/ acc_init(int /*<<< orphan*/);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ gettimeofday(struct timeval *, int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int rand();
int /*<<< orphan*/ srand(unsigned int);
scalar_t__ time(int /*<<< orphan*/);
int main() {
  int i, j, k;
  int sum, known_sum;
  int NI, NJ, NK;
  int error;
  int *input, *temp;
  struct timeval tim;
  double start, end;
  NK = 1 << 20;
  NJ = 2;
  NI = 32;
  error = 0;
  input = (int *)malloc(NK * NJ * NI * sizeof(int));
  temp = (int *)malloc(NK * NJ * NI * sizeof(int));
  acc_init(acc_device_default);
  srand((unsigned)time(0));
  for (k = 0; k < NK; k++) {
    for (j = 0; j < NJ; j++) {
      for (i = 0; i < NI; i++) {
        input[k * NJ * NI + j * NI + i] = rand() % 5 + 1;
      }
    }
  }
  sum = 0;
  gettimeofday(&tim, NULL);
  start = tim.tv_sec * 1000 + (tim.tv_usec / 1000.0);
#pragma acc parallel copyin(input [0:NK * NJ * NI])                            \
    create(temp [0:NK * NJ * NI]) num_gangs(192) num_workers(8)                \
        vector_length(128)
  {
#pragma acc loop gang reduction(+ : sum)
    for (k = 0; k < NK; k++) {
#pragma acc loop worker
      for (j = 0; j < NJ; j++) {
#pragma acc loop vector
        for (i = 0; i < NI; i++)
          temp[k * NJ * NI + j * NI + i] = input[k * NJ * NI + j * NI + i];
      }
      sum += temp[k * NJ * NI];
    }
  }
  gettimeofday(&tim, NULL);
  end = tim.tv_sec * 1000 + (tim.tv_usec / 1000.0);
  known_sum = 0;
  for (k = 0; k < NK; k++) {
    known_sum += input[k * NJ * NI];
  }
  if (sum != known_sum) {
    error++;
    printf("Int + FAILED! sum=%d, known_sum=%d\n", sum, known_sum);
  }
  printf("gang + execution time is :%.2lf: ms\n", end - start);
  if (error == 0)
    printf("gang + SUCCESS!\n");
  free(input);
  free(temp);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x100000,-0x24(%rbp)
movl   $0x2,-0x20(%rbp)
movl   $0x20,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    0x2df6(%rip),%rax
mov    (%rax),%edi
call   1090 <acc_init@plt>
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    129f <main+0x11f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    128c <main+0x10c>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1279 <main+0xf9>
mov    $0x0,%al
call   10a0 <rand@plt>
mov    $0x5,%ecx
cltd
idiv   %ecx
add    $0x1,%edx
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0xc(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
add    -0x8(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    122c <main+0xac>
jmp    127e <main+0xfe>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1219 <main+0x99>
jmp    1291 <main+0x111>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1206 <main+0x86>
movl   $0x0,-0x14(%rbp)
lea    -0x48(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
imul   $0x3e8,-0x48(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  0xd35(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    139d <main+0x21d>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1374 <main+0x1f4>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1361 <main+0x1e1>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
add    -0x8(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    -0xc(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
add    -0x8(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1305 <main+0x185>
jmp    1366 <main+0x1e6>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12f2 <main+0x172>
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12df <main+0x15f>
lea    -0x48(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
imul   $0x3e8,-0x48(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  0xc3e(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1412 <main+0x292>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x20(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13dd <main+0x25d>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     143b <main+0x2bb>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xbd4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
lea    0xbe0(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x28(%rbp)
jne    146b <main+0x2eb>
lea    0xbed(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    $0x10000000,%edi
call   1090 <malloc@plt>
mov    %rax,%r12
mov    $0x10000000,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
mov    0x2e21(%rip),%rax
mov    (%rax),%edi
call   10a0 <acc_init@plt>
xor    %edi,%edi
call   1080 <time@plt>
mov    %eax,%edi
call   1070 <srand@plt>
mov    %r12,%rbx
xor    %r15d,%r15d
nopw   0x0(%rax,%rax,1)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   10b0 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    $0x20,%rbp
jne    11f0 <main+0x60>
mov    $0x20,%ebp
nopl   0x0(%rax)
xor    %eax,%eax
call   10b0 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x21,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    $0x40,%rbp
jne    1230 <main+0xa0>
add    $0x1,%r15
add    $0x100,%rbx
cmp    $0x100000,%r15
jne    11e0 <main+0x50>
xor    %r13d,%r13d
lea    0x18(%rsp),%rdi
xor    %esi,%esi
call   1060 <gettimeofday@plt>
imul   $0x3e8,0x18(%rsp),%r8d
movsd  0x20(%rsp),%xmm1
divsd  0xd5e(%rip),%xmm1
lea    0xc(%r14),%rcx
lea    0xc(%r12),%rdx
lea    0x8c(%r14),%rsi
lea    0x8c(%r12),%rdi
xor    %r15d,%r15d
jmp    13a2 <main+0x212>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,%rax
or     $0x20,%rax
movups (%r12,%rax,4),%xmm0
movups %xmm0,(%r14,%rax,4)
lea    0x0(,%r11,4),%rax
mov    %rax,%rbp
or     $0x90,%rbp
movups (%r12,%rbp,1),%xmm0
movups %xmm0,(%r14,%rbp,1)
mov    %rax,%rbp
or     $0xa0,%rbp
movups (%r12,%rbp,1),%xmm0
movups %xmm0,(%r14,%rbp,1)
mov    %rax,%rbp
or     $0xb0,%rbp
movups (%r12,%rbp,1),%xmm0
movups %xmm0,(%r14,%rbp,1)
mov    %rax,%rbp
or     $0xc0,%rbp
movups (%r12,%rbp,1),%xmm0
movups %xmm0,(%r14,%rbp,1)
mov    %rax,%rbp
or     $0xd0,%rbp
movups (%r12,%rbp,1),%xmm0
movups %xmm0,(%r14,%rbp,1)
mov    %rax,%rbp
or     $0xe0,%rbp
movups (%r12,%rbp,1),%xmm0
movups %xmm0,(%r14,%rbp,1)
or     $0xf0,%rax
movups (%r12,%rax,1),%xmm0
movups %xmm0,(%r14,%rax,1)
add    (%r14,%r11,4),%r15d
add    $0x1,%r13
add    $0x100,%rcx
add    $0x100,%rdx
add    $0x100,%rsi
add    $0x100,%rdi
cmp    $0x100000,%r13
je     14ed <main+0x35d>
mov    %r13,%r11
shl    $0x6,%r11
mov    %r13,%rbp
shl    $0x8,%rbp
lea    (%r14,%rbp,1),%r10
add    $0x80,%r10
lea    (%r12,%rbp,1),%r9
add    $0x80,%r9
lea    (%r14,%rbp,1),%rax
cmp    %r9,%rax
jae    1410 <main+0x280>
lea    (%r12,%rbp,1),%rax
cmp    %r10,%rax
jae    1410 <main+0x280>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    -0xc(%rdx,%rax,4),%ebx
mov    %ebx,-0xc(%rcx,%rax,4)
mov    -0x8(%rdx,%rax,4),%ebx
mov    %ebx,-0x8(%rcx,%rax,4)
mov    -0x4(%rdx,%rax,4),%ebx
mov    %ebx,-0x4(%rcx,%rax,4)
mov    (%rdx,%rax,4),%ebx
mov    %ebx,(%rcx,%rax,4)
add    $0x4,%rax
cmp    $0x20,%rax
jne    13e0 <main+0x250>
jmp    1496 <main+0x306>
nopl   (%rax)
lea    0x0(,%r11,4),%rax
movups (%r12,%r11,4),%xmm0
movups %xmm0,(%r14,%r11,4)
mov    %rax,%rbx
or     $0x10,%rbx
movups (%r12,%rbx,1),%xmm0
movups %xmm0,(%r14,%rbx,1)
mov    %rax,%rbx
or     $0x20,%rbx
movups (%r12,%rbx,1),%xmm0
movups %xmm0,(%r14,%rbx,1)
mov    %rax,%rbx
or     $0x30,%rbx
movups (%r12,%rbx,1),%xmm0
movups %xmm0,(%r14,%rbx,1)
mov    %rax,%rbx
or     $0x40,%rbx
movups (%r12,%rbx,1),%xmm0
movups %xmm0,(%r14,%rbx,1)
mov    %rax,%rbx
or     $0x50,%rbx
movups (%r12,%rbx,1),%xmm0
movups %xmm0,(%r14,%rbx,1)
mov    %rax,%rbx
or     $0x60,%rbx
movups (%r12,%rbx,1),%xmm0
movups %xmm0,(%r14,%rbx,1)
or     $0x70,%rax
movups (%r12,%rax,1),%xmm0
movups %xmm0,(%r14,%rax,1)
lea    (%r12,%rbp,1),%rax
add    $0x100,%rax
cmp    %rax,%r10
jae    12d0 <main+0x140>
lea    (%r14,%rbp,1),%rax
add    $0x100,%rax
cmp    %rax,%r9
jae    12d0 <main+0x140>
xor    %eax,%eax
xchg   %ax,%ax
mov    -0xc(%rdi,%rax,4),%ebp
mov    %ebp,-0xc(%rsi,%rax,4)
mov    -0x8(%rdi,%rax,4),%ebp
mov    %ebp,-0x8(%rsi,%rax,4)
mov    -0x4(%rdi,%rax,4),%ebp
mov    %ebp,-0x4(%rsi,%rax,4)
mov    (%rdi,%rax,4),%ebp
mov    %ebp,(%rsi,%rax,4)
add    $0x4,%rax
cmp    $0x20,%rax
jne    14c0 <main+0x330>
jmp    1371 <main+0x1e1>
movsd  %xmm1,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
lea    0x18(%rsp),%rdi
xor    %esi,%esi
call   1060 <gettimeofday@plt>
imul   $0x3e8,0x18(%rsp),%eax
movsd  0x20(%rsp),%xmm0
divsd  0xadb(%rip),%xmm0
mov    $0x300,%ecx
nopw   0x0(%rax,%rax,1)
add    -0x300(%r12,%rcx,1),%ebp
ff
add    -0x200(%r12,%rcx,1),%ebp
ff
add    -0x100(%r12,%rcx,1),%ebp
ff
add    (%r12,%rcx,1),%ebp
add    $0x400,%rcx
cmp    $0x10000300,%rcx
jne    1530 <main+0x3a0>
movsd  0x10(%rsp),%xmm1
addsd  0x8(%rsp),%xmm1
cvtsi2sd %eax,%xmm2
addsd  %xmm2,%xmm0
cmp    %ebp,%r15d
jne    1595 <main+0x405>
subsd  %xmm1,%xmm0
lea    0xaac(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0xac3(%rip),%rdi
call   1040 <puts@plt>
jmp    15ce <main+0x43e>
lea    0xa6c(%rip),%rdi
mov    %r15d,%esi
mov    %ebp,%edx
xor    %eax,%eax
movsd  %xmm1,0x10(%rsp)
movsd  %xmm0,0x8(%rsp)
call   1050 <printf@plt>
movsd  0x8(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
lea    0xa65(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timeval = type { i32, double }
@acc_device_default = global i32 0
@.str = [36 x i8] c"Int + FAILED! sum=%d, known_sum=%d\0A\00"
@.str.1 = [37 x i8] c"gang + execution time is :%.2lf: ms\0A\00"
@.str.2 = [17 x i8] c"gang + SUCCESS!\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca %struct.timeval
%14 = alloca double
%15 = alloca double
store i32 0, i32* %1
store i32 1048576, i32* %9
store i32 2, i32* %8
store i32 32, i32* %7
store i32 0, i32* %10
%16 = load i32, i32* %9
%17 = load i32, i32* %8
%18 = mul nsw i32 %16, %17
%19 = load i32, i32* %7
%20 = mul nsw i32 %18, %19
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 4
%23 = trunc i64 %22 to i32
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to i32*
store i32* %25, i32** %11
%26 = load i32, i32* %9
%27 = load i32, i32* %8
%28 = mul nsw i32 %26, %27
%29 = load i32, i32* %7
%30 = mul nsw i32 %28, %29
%31 = sext i32 %30 to i64
%32 = mul i64 %31, 4
%33 = trunc i64 %32 to i32
%34 = call i64 @malloc(i32 %33)
%35 = inttoptr i64 %34 to i32*
store i32* %35, i32** %12
%36 = load i32, i32* @acc_device_default
%37 = call i32 @acc_init(i32 %36)
%38 = call i64 @time(i32 0)
%39 = trunc i64 %38 to i32
%40 = call i32 @srand(i32 %39)
store i32 0, i32* %4
br label %41
41: ; preds = %81, %0
%42 = load i32, i32* %4
%43 = load i32, i32* %9
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %84
45: ; preds = %41
store i32 0, i32* %3
br label %46
46: ; preds = %77, %45
%47 = load i32, i32* %3
%48 = load i32, i32* %8
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %80
50: ; preds = %46
store i32 0, i32* %2
br label %51
51: ; preds = %73, %50
%52 = load i32, i32* %2
%53 = load i32, i32* %7
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %76
55: ; preds = %51
%56 = call i32 (...) @rand()
%57 = srem i32 %56, 5
%58 = add nsw i32 %57, 1
%59 = load i32*, i32** %11
%60 = load i32, i32* %4
%61 = load i32, i32* %8
%62 = mul nsw i32 %60, %61
%63 = load i32, i32* %7
%64 = mul nsw i32 %62, %63
%65 = load i32, i32* %3
%66 = load i32, i32* %7
%67 = mul nsw i32 %65, %66
%68 = add nsw i32 %64, %67
%69 = load i32, i32* %2
%70 = add nsw i32 %68, %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %59, i64 %71
store i32 %58, i32* %72
br label %73
73: ; preds = %55
%74 = load i32, i32* %2
%75 = add nsw i32 %74, 1
store i32 %75, i32* %2
br label %51
76: ; preds = %51
br label %77
77: ; preds = %76
%78 = load i32, i32* %3
%79 = add nsw i32 %78, 1
store i32 %79, i32* %3
br label %46
80: ; preds = %46
br label %81
81: ; preds = %80
%82 = load i32, i32* %4
%83 = add nsw i32 %82, 1
store i32 %83, i32* %4
br label %41
84: ; preds = %41
store i32 0, i32* %5
%85 = call i32 @gettimeofday(%struct.timeval* %13, i32* null)
%86 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 0
%87 = load i32, i32* %86
%88 = mul nsw i32 %87, 1000
%89 = sitofp i32 %88 to double
%90 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 1
%91 = load double, double* %90
%92 = fdiv double %91, 1.000000e+03
%93 = fadd double %89, %92
store double %93, double* %14
store i32 0, i32* %4
br label %94
94: ; preds = %157, %84
%95 = load i32, i32* %4
%96 = load i32, i32* %9
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %160
98: ; preds = %94
store i32 0, i32* %3
br label %99
99: ; preds = %142, %98
%100 = load i32, i32* %3
%101 = load i32, i32* %8
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %145
103: ; preds = %99
store i32 0, i32* %2
br label %104
104: ; preds = %138, %103
%105 = load i32, i32* %2
%106 = load i32, i32* %7
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %141
108: ; preds = %104
%109 = load i32*, i32** %11
%110 = load i32, i32* %4
%111 = load i32, i32* %8
%112 = mul nsw i32 %110, %111
%113 = load i32, i32* %7
%114 = mul nsw i32 %112, %113
%115 = load i32, i32* %3
%116 = load i32, i32* %7
%117 = mul nsw i32 %115, %116
%118 = add nsw i32 %114, %117
%119 = load i32, i32* %2
%120 = add nsw i32 %118, %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %109, i64 %121
%123 = load i32, i32* %122
%124 = load i32*, i32** %12
%125 = load i32, i32* %4
%126 = load i32, i32* %8
%127 = mul nsw i32 %125, %126
%128 = load i32, i32* %7
%129 = mul nsw i32 %127, %128
%130 = load i32, i32* %3
%131 = load i32, i32* %7
%132 = mul nsw i32 %130, %131
%133 = add nsw i32 %129, %132
%134 = load i32, i32* %2
%135 = add nsw i32 %133, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %124, i64 %136
store i32 %123, i32* %137
br label %138
138: ; preds = %108
%139 = load i32, i32* %2
%140 = add nsw i32 %139, 1
store i32 %140, i32* %2
br label %104
141: ; preds = %104
br label %142
142: ; preds = %141
%143 = load i32, i32* %3
%144 = add nsw i32 %143, 1
store i32 %144, i32* %3
br label %99
145: ; preds = %99
%146 = load i32*, i32** %12
%147 = load i32, i32* %4
%148 = load i32, i32* %8
%149 = mul nsw i32 %147, %148
%150 = load i32, i32* %7
%151 = mul nsw i32 %149, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i32, i32* %146, i64 %152
%154 = load i32, i32* %153
%155 = load i32, i32* %5
%156 = add nsw i32 %155, %154
store i32 %156, i32* %5
br label %157
157: ; preds = %145
%158 = load i32, i32* %4
%159 = add nsw i32 %158, 1
store i32 %159, i32* %4
br label %94
160: ; preds = %94
%161 = call i32 @gettimeofday(%struct.timeval* %13, i32* null)
%162 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 0
%163 = load i32, i32* %162
%164 = mul nsw i32 %163, 1000
%165 = sitofp i32 %164 to double
%166 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 1
%167 = load double, double* %166
%168 = fdiv double %167, 1.000000e+03
%169 = fadd double %165, %168
store double %169, double* %15
store i32 0, i32* %6
store i32 0, i32* %4
br label %170
170: ; preds = %186, %160
%171 = load i32, i32* %4
%172 = load i32, i32* %9
%173 = icmp slt i32 %171, %172
br i1 %173, label %174, label %189
174: ; preds = %170
%175 = load i32*, i32** %11
%176 = load i32, i32* %4
%177 = load i32, i32* %8
%178 = mul nsw i32 %176, %177
%179 = load i32, i32* %7
%180 = mul nsw i32 %178, %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %175, i64 %181
%183 = load i32, i32* %182
%184 = load i32, i32* %6
%185 = add nsw i32 %184, %183
store i32 %185, i32* %6
br label %186
186: ; preds = %174
%187 = load i32, i32* %4
%188 = add nsw i32 %187, 1
store i32 %188, i32* %4
br label %170
189: ; preds = %170
%190 = load i32, i32* %5
%191 = load i32, i32* %6
%192 = icmp ne i32 %190, %191
br i1 %192, label %193, label %199
193: ; preds = %189
%194 = load i32, i32* %10
%195 = add nsw i32 %194, 1
store i32 %195, i32* %10
%196 = load i32, i32* %5
%197 = load i32, i32* %6
%198 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0), i32 %196, i32 %197)
br label %199
199: ; preds = %193, %189
%200 = load double, double* %15
%201 = load double, double* %14
%202 = fsub double %200, %201
%203 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), double %202)
%204 = load i32, i32* %10
%205 = icmp eq i32 %204, 0
br i1 %205, label %206, label %208
206: ; preds = %199
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0))
br label %208
208: ; preds = %206, %199
%209 = load i32*, i32** %11
%210 = call i32 @free(i32* %209)
%211 = load i32*, i32** %12
%212 = call i32 @free(i32* %211)
ret i32 0
}

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