#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 */
scalar_t__ RAND_MAX;
int /*<<< orphan*/ acc_device_default;
int /*<<< orphan*/ acc_init(int /*<<< orphan*/);
float fabsf(float);
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ gettimeofday(struct timeval *, int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ rand();
int /*<<< orphan*/ srand(unsigned int);
scalar_t__ time(int /*<<< orphan*/);
int main() {
  int i, j, k;
  float product, known_product;
  int NI, NJ, NK;
  int error;
  float *input;
  float rounding_error = 1.E-9;
  struct timeval tim;
  double start, end;
  NK = 1 << 5;
  NJ = 1 << 5;
  NI = 1 << 5;
  error = 0;
  input = (float *)malloc(NK * NJ * NI * sizeof(float));
  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] = (float)rand() / (float)RAND_MAX + 0.1;
      }
    }
  }
  product = 1;
  gettimeofday(&tim, NULL);
  start = tim.tv_sec * 1000 + (tim.tv_usec / 1000.0);
#pragma acc parallel copyin(input [0:NK * NJ * NI]) num_gangs(192)             \
    num_workers(8) vector_length(128)
  {
#pragma acc loop gang reduction(* : product)
    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++)
          product *= input[k * NJ * NI + j * NI + i];
      }
    }
  }
  gettimeofday(&tim, NULL);
  end = tim.tv_sec * 1000 + (tim.tv_usec / 1000.0);
  known_product = 1;
  for (k = 0; k < NK; k++) {
    for (j = 0; j < NJ; j++) {
      for (i = 0; i < NI; i++)
        known_product *= input[k * NJ * NI + j * NI + i];
    }
  }
  if (fabsf(product - known_product) > rounding_error) {
    error++;
    printf("gang_worker_vector + FAILED! product=%d, known_product=%d\n",
           product, known_product);
  }
  printf("gang_worker_vector + execution time is :%.2lf: ms\n", end - start);
  if (error == 0)
    printf("gang_worker_vector + SUCCESS!\n");
  free(input);
  return 1;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
movss  0xe69(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x20,-0x24(%rbp)
movl   $0x20,-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    0x2dfd(%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    12b0 <main+0x130>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    129d <main+0x11d>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128a <main+0x10a>
mov    $0x0,%al
call   10a0 <rand@plt>
cvtsi2ss %rax,%xmm0
mov    0x2dac(%rip),%rax
cvtsi2ssq (%rax),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdbf(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    121d <main+0x9d>
jmp    128f <main+0x10f>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    120a <main+0x8a>
jmp    12a2 <main+0x122>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11f7 <main+0x77>
movss  0xd4c(%rip),%xmm0
movss  %xmm0,-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  0xd26(%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    1389 <main+0x209>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1376 <main+0x1f6>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1363 <main+0x1e3>
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
movss  (%rax,%rcx,4),%xmm0
mulss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    131c <main+0x19c>
jmp    1368 <main+0x1e8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1309 <main+0x189>
jmp    137b <main+0x1fb>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12f6 <main+0x176>
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  0xc5a(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  0xc41(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1462 <main+0x2e2>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    144f <main+0x2cf>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    143c <main+0x2bc>
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
movss  (%rax,%rcx,4),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13f5 <main+0x275>
jmp    1441 <main+0x2c1>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13e2 <main+0x262>
jmp    1454 <main+0x2d4>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13cf <main+0x24f>
movss  -0x14(%rbp),%xmm0
subss  -0x18(%rbp),%xmm0
movaps 0xbad(%rip),%xmm1
pand   %xmm1,%xmm0
ucomiss -0x34(%rbp),%xmm0
jbe    14aa <main+0x32a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xb8d(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
lea    0xbb0(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x28(%rbp)
jne    14da <main+0x35a>
lea    0xbcb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%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    $0x38,%rsp
mov    $0x20000,%edi
call   1090 <malloc@plt>
mov    %rax,%r15
mov    0x2e26(%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    0x2e1a(%rip),%r13
mov    %r15,0x30(%rsp)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
call   10b0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ssq 0x0(%r13),%xmm1
divss  %xmm1,%xmm0
movsd  0xddc(%rip),%xmm1
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%r14,4)
add    $0x1,%r14
cmp    $0x20,%r14
jne    1200 <main+0x70>
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rbx
cmp    $0x20,%rbp
jne    11f0 <main+0x60>
add    $0x1,%r12
add    $0x1000,%r15
cmp    $0x20,%r12
jne    11e0 <main+0x50>
xor    %ebx,%ebx
lea    0x18(%rsp),%rdi
xor    %esi,%esi
call   1060 <gettimeofday@plt>
imul   $0x3e8,0x18(%rsp),%eax
movsd  0x20(%rsp),%xmm0
divsd  0xd85(%rip),%xmm0
mov    0x30(%rsp),%rbp
lea    0x7c(%rbp),%rcx
movss  0xd7c(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mulss  -0x7c(%rcx,%rdx,1),%xmm1
mulss  -0x78(%rcx,%rdx,1),%xmm1
mulss  -0x74(%rcx,%rdx,1),%xmm1
mulss  -0x70(%rcx,%rdx,1),%xmm1
mulss  -0x6c(%rcx,%rdx,1),%xmm1
mulss  -0x68(%rcx,%rdx,1),%xmm1
mulss  -0x64(%rcx,%rdx,1),%xmm1
mulss  -0x60(%rcx,%rdx,1),%xmm1
mulss  -0x5c(%rcx,%rdx,1),%xmm1
mulss  -0x58(%rcx,%rdx,1),%xmm1
mulss  -0x54(%rcx,%rdx,1),%xmm1
mulss  -0x50(%rcx,%rdx,1),%xmm1
mulss  -0x4c(%rcx,%rdx,1),%xmm1
mulss  -0x48(%rcx,%rdx,1),%xmm1
mulss  -0x44(%rcx,%rdx,1),%xmm1
mulss  -0x40(%rcx,%rdx,1),%xmm1
mulss  -0x3c(%rcx,%rdx,1),%xmm1
mulss  -0x38(%rcx,%rdx,1),%xmm1
mulss  -0x34(%rcx,%rdx,1),%xmm1
mulss  -0x30(%rcx,%rdx,1),%xmm1
mulss  -0x2c(%rcx,%rdx,1),%xmm1
mulss  -0x28(%rcx,%rdx,1),%xmm1
mulss  -0x24(%rcx,%rdx,1),%xmm1
mulss  -0x20(%rcx,%rdx,1),%xmm1
mulss  -0x1c(%rcx,%rdx,1),%xmm1
mulss  -0x18(%rcx,%rdx,1),%xmm1
mulss  -0x14(%rcx,%rdx,1),%xmm1
mulss  -0x10(%rcx,%rdx,1),%xmm1
mulss  -0xc(%rcx,%rdx,1),%xmm1
mulss  -0x8(%rcx,%rdx,1),%xmm1
mulss  -0x4(%rcx,%rdx,1),%xmm1
mulss  (%rcx,%rdx,1),%xmm1
sub    $0xffffffffffffff80,%rdx
cmp    $0x1000,%rdx
jne    12b0 <main+0x120>
add    $0x1,%rbx
add    $0x1000,%rcx
cmp    $0x20,%rbx
jne    12a0 <main+0x110>
cvtsi2sd %eax,%xmm2
movsd  %xmm2,0x28(%rsp)
xor    %ebx,%ebx
lea    0x18(%rsp),%rdi
xor    %esi,%esi
movsd  %xmm0,0x10(%rsp)
movss  %xmm1,0x8(%rsp)
call   1060 <gettimeofday@plt>
movss  0x8(%rsp),%xmm4
movsd  0x10(%rsp),%xmm3
imul   $0x3e8,0x18(%rsp),%eax
movsd  0x20(%rsp),%xmm5
divsd  0xc2d(%rip),%xmm5
mov    %rbp,%rcx
add    $0x7c,%rcx
movss  0xc26(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mulss  -0x7c(%rcx,%rdx,1),%xmm1
mulss  -0x78(%rcx,%rdx,1),%xmm1
mulss  -0x74(%rcx,%rdx,1),%xmm1
mulss  -0x70(%rcx,%rdx,1),%xmm1
mulss  -0x6c(%rcx,%rdx,1),%xmm1
mulss  -0x68(%rcx,%rdx,1),%xmm1
mulss  -0x64(%rcx,%rdx,1),%xmm1
mulss  -0x60(%rcx,%rdx,1),%xmm1
mulss  -0x5c(%rcx,%rdx,1),%xmm1
mulss  -0x58(%rcx,%rdx,1),%xmm1
mulss  -0x54(%rcx,%rdx,1),%xmm1
mulss  -0x50(%rcx,%rdx,1),%xmm1
mulss  -0x4c(%rcx,%rdx,1),%xmm1
mulss  -0x48(%rcx,%rdx,1),%xmm1
mulss  -0x44(%rcx,%rdx,1),%xmm1
mulss  -0x40(%rcx,%rdx,1),%xmm1
mulss  -0x3c(%rcx,%rdx,1),%xmm1
mulss  -0x38(%rcx,%rdx,1),%xmm1
mulss  -0x34(%rcx,%rdx,1),%xmm1
mulss  -0x30(%rcx,%rdx,1),%xmm1
mulss  -0x2c(%rcx,%rdx,1),%xmm1
mulss  -0x28(%rcx,%rdx,1),%xmm1
mulss  -0x24(%rcx,%rdx,1),%xmm1
mulss  -0x20(%rcx,%rdx,1),%xmm1
mulss  -0x1c(%rcx,%rdx,1),%xmm1
mulss  -0x18(%rcx,%rdx,1),%xmm1
mulss  -0x14(%rcx,%rdx,1),%xmm1
mulss  -0x10(%rcx,%rdx,1),%xmm1
mulss  -0xc(%rcx,%rdx,1),%xmm1
mulss  -0x8(%rcx,%rdx,1),%xmm1
mulss  -0x4(%rcx,%rdx,1),%xmm1
mulss  (%rcx,%rdx,1),%xmm1
sub    $0xffffffffffffff80,%rdx
cmp    $0x1000,%rdx
jne    1400 <main+0x270>
add    $0x1,%rbx
add    $0x1000,%rcx
cmp    $0x20,%rbx
jne    13f0 <main+0x260>
cvtsi2sd %eax,%xmm0
addsd  0x28(%rsp),%xmm3
movaps %xmm4,%xmm2
subss  %xmm1,%xmm2
andps  0xb23(%rip),%xmm2
addsd  %xmm0,%xmm5
ucomiss 0xb0c(%rip),%xmm2
jbe    154b <main+0x3bb>
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
cvtss2sd %xmm1,%xmm1
lea    0xb14(%rip),%rdi
mov    $0x2,%al
movsd  %xmm3,0x10(%rsp)
movsd  %xmm5,0x8(%rsp)
call   1050 <printf@plt>
movsd  0x8(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
lea    0xb29(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    156d <main+0x3dd>
subsd  %xmm3,%xmm5
lea    0xb15(%rip),%rdi
movapd %xmm5,%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
lea    0xb36(%rip),%rdi
call   1040 <puts@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x38,%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
@RAND_MAX = global i64 0
@.str = [59 x i8] c"gang_worker_vector + FAILED! product=%d, known_product=%d\0A\00"
@.str.1 = [51 x i8] c"gang_worker_vector + execution time is :%.2lf: ms\0A\00"
@.str.2 = [31 x i8] c"gang_worker_vector + SUCCESS!\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca float
%6 = alloca float
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca float*
%12 = alloca float
%13 = alloca %struct.timeval
%14 = alloca double
%15 = alloca double
store i32 0, i32* %1
store float 0x3E112E0BE0000000, float* %12
store i32 32, i32* %9
store i32 32, 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 float*
store float* %25, float** %11
%26 = load i32, i32* @acc_device_default
%27 = call i32 @acc_init(i32 %26)
%28 = call i64 @time(i32 0)
%29 = trunc i64 %28 to i32
%30 = call i32 @srand(i32 %29)
store i32 0, i32* %4
br label %31
31: ; preds = %76, %0
%32 = load i32, i32* %4
%33 = load i32, i32* %9
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %79
35: ; preds = %31
store i32 0, i32* %3
br label %36
36: ; preds = %72, %35
%37 = load i32, i32* %3
%38 = load i32, i32* %8
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %75
40: ; preds = %36
store i32 0, i32* %2
br label %41
41: ; preds = %68, %40
%42 = load i32, i32* %2
%43 = load i32, i32* %7
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %71
45: ; preds = %41
%46 = call i64 (...) @rand()
%47 = sitofp i64 %46 to float
%48 = load i64, i64* @RAND_MAX
%49 = sitofp i64 %48 to float
%50 = fdiv float %47, %49
%51 = fpext float %50 to double
%52 = fadd double %51, 1.000000e-01
%53 = fptrunc double %52 to float
%54 = load float*, float** %11
%55 = load i32, i32* %4
%56 = load i32, i32* %8
%57 = mul nsw i32 %55, %56
%58 = load i32, i32* %7
%59 = mul nsw i32 %57, %58
%60 = load i32, i32* %3
%61 = load i32, i32* %7
%62 = mul nsw i32 %60, %61
%63 = add nsw i32 %59, %62
%64 = load i32, i32* %2
%65 = add nsw i32 %63, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %54, i64 %66
store float %53, float* %67
br label %68
68: ; preds = %45
%69 = load i32, i32* %2
%70 = add nsw i32 %69, 1
store i32 %70, i32* %2
br label %41
71: ; preds = %41
br label %72
72: ; preds = %71
%73 = load i32, i32* %3
%74 = add nsw i32 %73, 1
store i32 %74, i32* %3
br label %36
75: ; preds = %36
br label %76
76: ; preds = %75
%77 = load i32, i32* %4
%78 = add nsw i32 %77, 1
store i32 %78, i32* %4
br label %31
79: ; preds = %31
store float 1.000000e+00, float* %5
%80 = call i32 @gettimeofday(%struct.timeval* %13, i32* null)
%81 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 0
%82 = load i32, i32* %81
%83 = mul nsw i32 %82, 1000
%84 = sitofp i32 %83 to double
%85 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 1
%86 = load double, double* %85
%87 = fdiv double %86, 1.000000e+03
%88 = fadd double %84, %87
store double %88, double* %14
store i32 0, i32* %4
br label %89
89: ; preds = %129, %79
%90 = load i32, i32* %4
%91 = load i32, i32* %9
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %132
93: ; preds = %89
store i32 0, i32* %3
br label %94
94: ; preds = %125, %93
%95 = load i32, i32* %3
%96 = load i32, i32* %8
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %128
98: ; preds = %94
store i32 0, i32* %2
br label %99
99: ; preds = %121, %98
%100 = load i32, i32* %2
%101 = load i32, i32* %7
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %124
103: ; preds = %99
%104 = load float*, float** %11
%105 = load i32, i32* %4
%106 = load i32, i32* %8
%107 = mul nsw i32 %105, %106
%108 = load i32, i32* %7
%109 = mul nsw i32 %107, %108
%110 = load i32, i32* %3
%111 = load i32, i32* %7
%112 = mul nsw i32 %110, %111
%113 = add nsw i32 %109, %112
%114 = load i32, i32* %2
%115 = add nsw i32 %113, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %104, i64 %116
%118 = load float, float* %117
%119 = load float, float* %5
%120 = fmul float %119, %118
store float %120, float* %5
br label %121
121: ; preds = %103
%122 = load i32, i32* %2
%123 = add nsw i32 %122, 1
store i32 %123, i32* %2
br label %99
124: ; preds = %99
br label %125
125: ; preds = %124
%126 = load i32, i32* %3
%127 = add nsw i32 %126, 1
store i32 %127, i32* %3
br label %94
128: ; preds = %94
br label %129
129: ; preds = %128
%130 = load i32, i32* %4
%131 = add nsw i32 %130, 1
store i32 %131, i32* %4
br label %89
132: ; preds = %89
%133 = call i32 @gettimeofday(%struct.timeval* %13, i32* null)
%134 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 0
%135 = load i32, i32* %134
%136 = mul nsw i32 %135, 1000
%137 = sitofp i32 %136 to double
%138 = getelementptr inbounds %struct.timeval, %struct.timeval* %13, i32 0, i32 1
%139 = load double, double* %138
%140 = fdiv double %139, 1.000000e+03
%141 = fadd double %137, %140
store double %141, double* %15
store float 1.000000e+00, float* %6
store i32 0, i32* %4
br label %142
142: ; preds = %182, %132
%143 = load i32, i32* %4
%144 = load i32, i32* %9
%145 = icmp slt i32 %143, %144
br i1 %145, label %146, label %185
146: ; preds = %142
store i32 0, i32* %3
br label %147
147: ; preds = %178, %146
%148 = load i32, i32* %3
%149 = load i32, i32* %8
%150 = icmp slt i32 %148, %149
br i1 %150, label %151, label %181
151: ; preds = %147
store i32 0, i32* %2
br label %152
152: ; preds = %174, %151
%153 = load i32, i32* %2
%154 = load i32, i32* %7
%155 = icmp slt i32 %153, %154
br i1 %155, label %156, label %177
156: ; preds = %152
%157 = load float*, float** %11
%158 = load i32, i32* %4
%159 = load i32, i32* %8
%160 = mul nsw i32 %158, %159
%161 = load i32, i32* %7
%162 = mul nsw i32 %160, %161
%163 = load i32, i32* %3
%164 = load i32, i32* %7
%165 = mul nsw i32 %163, %164
%166 = add nsw i32 %162, %165
%167 = load i32, i32* %2
%168 = add nsw i32 %166, %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %157, i64 %169
%171 = load float, float* %170
%172 = load float, float* %6
%173 = fmul float %172, %171
store float %173, float* %6
br label %174
174: ; preds = %156
%175 = load i32, i32* %2
%176 = add nsw i32 %175, 1
store i32 %176, i32* %2
br label %152
177: ; preds = %152
br label %178
178: ; preds = %177
%179 = load i32, i32* %3
%180 = add nsw i32 %179, 1
store i32 %180, i32* %3
br label %147
181: ; preds = %147
br label %182
182: ; preds = %181
%183 = load i32, i32* %4
%184 = add nsw i32 %183, 1
store i32 %184, i32* %4
br label %142
185: ; preds = %142
%186 = load float, float* %5
%187 = load float, float* %6
%188 = fsub float %186, %187
%189 = call float @llvm.fabs.f32(float %188)
%190 = load float, float* %12
%191 = fcmp ogt float %189, %190
br i1 %191, label %192, label %200
192: ; preds = %185
%193 = load i32, i32* %10
%194 = add nsw i32 %193, 1
store i32 %194, i32* %10
%195 = load float, float* %5
%196 = fpext float %195 to double
%197 = load float, float* %6
%198 = fpext float %197 to double
%199 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0), double %196, double %198)
br label %200
200: ; preds = %192, %185
%201 = load double, double* %15
%202 = load double, double* %14
%203 = fsub double %201, %202
%204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.1, i64 0, i64 0), double %203)
%205 = load i32, i32* %10
%206 = icmp eq i32 %205, 0
br i1 %206, label %207, label %209
207: ; preds = %200
%208 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0))
br label %209
209: ; preds = %207, %200
%210 = load float*, float** %11
%211 = call i32 @free(float* %210)
ret i32 1
}

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