#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 product, known_product;
  int NI, NJ, NK;
  int error;
  int *input;
  struct timeval tim;
  double start, end;
  NK = 1 << 7;
  NJ = 1 << 7;
  NI = 1 << 7;
  error = 0;
  input = (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;
      }
    }
  }
  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 (product != known_product) {
    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    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x80,-0x24(%rbp)
movl   $0x80,-0x20(%rbp)
movl   $0x80,-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    0x2e12(%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    1283 <main+0x103>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1270 <main+0xf0>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    125d <main+0xdd>
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    1210 <main+0x90>
jmp    1262 <main+0xe2>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11fd <main+0x7d>
jmp    1275 <main+0xf5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11ea <main+0x6a>
movl   $0x1,-0x14(%rbp)
lea    -0x40(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
imul   $0x3e8,-0x40(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  0xd51(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1351 <main+0x1d1>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    133e <main+0x1be>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    132b <main+0x1ab>
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),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12e9 <main+0x169>
jmp    1330 <main+0x1b0>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12d6 <main+0x156>
jmp    1343 <main+0x1c3>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12c3 <main+0x143>
lea    -0x40(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
imul   $0x3e8,-0x40(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  0xc8a(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x1,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    141f <main+0x29f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    140c <main+0x28c>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13f9 <main+0x279>
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),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13b7 <main+0x237>
jmp    13fe <main+0x27e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13a4 <main+0x224>
jmp    1411 <main+0x291>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1391 <main+0x211>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1448 <main+0x2c8>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xbc7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
lea    0xbea(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x28(%rbp)
jne    1478 <main+0x2f8>
lea    0xc05(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x50,%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    $0x800000,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
mov    0x2e2e(%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    %r14,%r15
xor    %r12d,%r12d
nopl   (%rax)
mov    %r15,%rbx
xor    %r13d,%r13d
cs 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    $0x80,%rbp
jne    11f0 <main+0x60>
add    $0x1,%r13
add    $0x200,%rbx
cmp    $0x80,%r13
jne    11e0 <main+0x50>
add    $0x1,%r12
add    $0x10000,%r15
cmp    $0x80,%r12
jne    11d0 <main+0x40>
xor    %ebx,%ebx
lea    0x18(%rsp),%rdi
xor    %esi,%esi
call   1060 <gettimeofday@plt>
imul   $0x3e8,0x18(%rsp),%eax
movsd  0x20(%rsp),%xmm0
divsd  0xd8d(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
lea    0x1f0(%r14),%rcx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   %ebp,%xmm1
shufpd $0x2,0xd63(%rip),%xmm1
movdqu -0x1f0(%rcx,%rdx,1),%xmm2
ff ff
movdqu -0x1e0(%rcx,%rdx,1),%xmm3
ff ff
movdqu -0x1d0(%rcx,%rdx,1),%xmm4
ff ff
movdqu -0x1c0(%rcx,%rdx,1),%xmm0
ff ff
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm2,%xmm2
pmuludq 0xd3e(%rip),%xmm2
pmuludq %xmm4,%xmm1
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
pshufd $0xf5,%xmm3,%xmm2
pshufd $0xf5,%xmm0,%xmm5
pmuludq %xmm2,%xmm5
pmuludq %xmm3,%xmm0
movdqu -0x1b0(%rcx,%rdx,1),%xmm2
ff ff
movdqu -0x1a0(%rcx,%rdx,1),%xmm3
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm4,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm3,%xmm2
pmuludq %xmm5,%xmm2
pmuludq %xmm3,%xmm0
movdqu -0x190(%rcx,%rdx,1),%xmm3
ff ff
movdqu -0x180(%rcx,%rdx,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x170(%rcx,%rdx,1),%xmm2
ff ff
movdqu -0x160(%rcx,%rdx,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm0
movdqu -0x150(%rcx,%rdx,1),%xmm3
ff ff
movdqu -0x140(%rcx,%rdx,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x130(%rcx,%rdx,1),%xmm2
ff ff
movdqu -0x120(%rcx,%rdx,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm0
movdqu -0x110(%rcx,%rdx,1),%xmm3
ff ff
movdqu -0x100(%rcx,%rdx,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0xf0(%rcx,%rdx,1),%xmm2
ff ff
movdqu -0xe0(%rcx,%rdx,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm0
movdqu -0xd0(%rcx,%rdx,1),%xmm3
ff ff
movdqu -0xc0(%rcx,%rdx,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0xb0(%rcx,%rdx,1),%xmm2
ff ff
movdqu -0xa0(%rcx,%rdx,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm0
movdqu -0x90(%rcx,%rdx,1),%xmm3
ff ff
movdqu -0x80(%rcx,%rdx,1),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x70(%rcx,%rdx,1),%xmm2
movdqu -0x60(%rcx,%rdx,1),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm0
movdqu -0x50(%rcx,%rdx,1),%xmm3
movdqu -0x40(%rcx,%rdx,1),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x30(%rcx,%rdx,1),%xmm2
movdqu -0x20(%rcx,%rdx,1),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm0
movdqu -0x10(%rcx,%rdx,1),%xmm3
movdqu (%rcx,%rdx,1),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pmuludq %xmm1,%xmm0
pshufd $0xf5,%xmm4,%xmm1
pmuludq %xmm2,%xmm1
pmuludq %xmm3,%xmm1
pshufd $0xee,%xmm0,%xmm2
pshufd $0xaa,%xmm1,%xmm3
pmuludq %xmm1,%xmm3
pmuludq %xmm0,%xmm2
pmuludq %xmm3,%xmm2
movd   %xmm2,%ebp
add    $0x200,%rdx
cmp    $0x10000,%rdx
jne    12a0 <main+0x110>
add    $0x1,%rbx
add    $0x10000,%rcx
cmp    $0x80,%rbx
jne    1290 <main+0x100>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebx,%ebx
lea    0x18(%rsp),%rdi
xor    %esi,%esi
call   1060 <gettimeofday@plt>
movdqa 0xa61(%rip),%xmm8
movaps 0xa49(%rip),%xmm9
imul   $0x3e8,0x18(%rsp),%eax
movsd  0x20(%rsp),%xmm0
divsd  0xa23(%rip),%xmm0
mov    %r14,%rcx
add    $0x1f0,%rcx
mov    $0x1,%edx
nopl   0x0(%rax)
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   %edx,%xmm1
shufps $0xe4,%xmm9,%xmm1
movdqu -0x1f0(%rcx,%rsi,1),%xmm2
ff ff
movdqu -0x1e0(%rcx,%rsi,1),%xmm3
ff ff
movdqu -0x1d0(%rcx,%rsi,1),%xmm4
ff ff
movdqu -0x1c0(%rcx,%rsi,1),%xmm7
ff ff
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm8,%xmm2
pmuludq %xmm4,%xmm1
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
pshufd $0xf5,%xmm3,%xmm2
pshufd $0xf5,%xmm7,%xmm5
pmuludq %xmm2,%xmm5
pmuludq %xmm3,%xmm7
movdqu -0x1b0(%rcx,%rsi,1),%xmm2
ff ff
movdqu -0x1a0(%rcx,%rsi,1),%xmm3
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm4,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm3,%xmm2
pmuludq %xmm5,%xmm2
pmuludq %xmm3,%xmm7
movdqu -0x190(%rcx,%rsi,1),%xmm3
ff ff
movdqu -0x180(%rcx,%rsi,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x170(%rcx,%rsi,1),%xmm2
ff ff
movdqu -0x160(%rcx,%rsi,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm7
movdqu -0x150(%rcx,%rsi,1),%xmm3
ff ff
movdqu -0x140(%rcx,%rsi,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x130(%rcx,%rsi,1),%xmm2
ff ff
movdqu -0x120(%rcx,%rsi,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm7
movdqu -0x110(%rcx,%rsi,1),%xmm3
ff ff
movdqu -0x100(%rcx,%rsi,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0xf0(%rcx,%rsi,1),%xmm2
ff ff
movdqu -0xe0(%rcx,%rsi,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm7
movdqu -0xd0(%rcx,%rsi,1),%xmm3
ff ff
movdqu -0xc0(%rcx,%rsi,1),%xmm4
ff ff
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0xb0(%rcx,%rsi,1),%xmm2
ff ff
movdqu -0xa0(%rcx,%rsi,1),%xmm5
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm7
movdqu -0x90(%rcx,%rsi,1),%xmm3
ff ff
movdqu -0x80(%rcx,%rsi,1),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x70(%rcx,%rsi,1),%xmm2
movdqu -0x60(%rcx,%rsi,1),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm7
movdqu -0x50(%rcx,%rsi,1),%xmm3
movdqu -0x40(%rcx,%rsi,1),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqu -0x30(%rcx,%rsi,1),%xmm2
movdqu -0x20(%rcx,%rsi,1),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pmuludq %xmm5,%xmm7
movdqu -0x10(%rcx,%rsi,1),%xmm3
movdqu (%rcx,%rsi,1),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm7
pmuludq %xmm1,%xmm7
pshufd $0xf5,%xmm4,%xmm1
pmuludq %xmm2,%xmm1
pmuludq %xmm3,%xmm1
pshufd $0xee,%xmm7,%xmm2
pshufd $0xaa,%xmm1,%xmm3
pmuludq %xmm1,%xmm3
pmuludq %xmm7,%xmm2
pmuludq %xmm3,%xmm2
movd   %xmm2,%edx
add    $0x200,%rsi
cmp    $0x10000,%rsi
jne    1600 <main+0x470>
add    $0x1,%rbx
add    $0x10000,%rcx
cmp    $0x80,%rbx
jne    15f0 <main+0x460>
movsd  0x10(%rsp),%xmm1
addsd  0x8(%rsp),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
addsd  %xmm2,%xmm0
cmp    %edx,%ebp
jne    192f <main+0x79f>
subsd  %xmm1,%xmm0
lea    0x751(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x776(%rip),%rdi
call   1040 <puts@plt>
jmp    1965 <main+0x7d5>
lea    0x6fa(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
movsd  %xmm1,0x10(%rsp)
movsd  %xmm0,0x8(%rsp)
call   1050 <printf@plt>
movsd  0x8(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
lea    0x70d(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    $0x1,%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 = [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 i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca %struct.timeval
%13 = alloca double
%14 = alloca double
store i32 0, i32* %1
store i32 128, i32* %9
store i32 128, i32* %8
store i32 128, i32* %7
store i32 0, i32* %10
%15 = load i32, i32* %9
%16 = load i32, i32* %8
%17 = mul nsw i32 %15, %16
%18 = load i32, i32* %7
%19 = mul nsw i32 %17, %18
%20 = sext i32 %19 to i64
%21 = mul i64 %20, 4
%22 = trunc i64 %21 to i32
%23 = call i64 @malloc(i32 %22)
%24 = inttoptr i64 %23 to i32*
store i32* %24, i32** %11
%25 = load i32, i32* @acc_device_default
%26 = call i32 @acc_init(i32 %25)
%27 = call i64 @time(i32 0)
%28 = trunc i64 %27 to i32
%29 = call i32 @srand(i32 %28)
store i32 0, i32* %4
br label %30
30: ; preds = %70, %0
%31 = load i32, i32* %4
%32 = load i32, i32* %9
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %73
34: ; preds = %30
store i32 0, i32* %3
br label %35
35: ; preds = %66, %34
%36 = load i32, i32* %3
%37 = load i32, i32* %8
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %69
39: ; preds = %35
store i32 0, i32* %2
br label %40
40: ; preds = %62, %39
%41 = load i32, i32* %2
%42 = load i32, i32* %7
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %65
44: ; preds = %40
%45 = call i32 (...) @rand()
%46 = srem i32 %45, 5
%47 = add nsw i32 %46, 1
%48 = load i32*, i32** %11
%49 = load i32, i32* %4
%50 = load i32, i32* %8
%51 = mul nsw i32 %49, %50
%52 = load i32, i32* %7
%53 = mul nsw i32 %51, %52
%54 = load i32, i32* %3
%55 = load i32, i32* %7
%56 = mul nsw i32 %54, %55
%57 = add nsw i32 %53, %56
%58 = load i32, i32* %2
%59 = add nsw i32 %57, %58
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %48, i64 %60
store i32 %47, i32* %61
br label %62
62: ; preds = %44
%63 = load i32, i32* %2
%64 = add nsw i32 %63, 1
store i32 %64, i32* %2
br label %40
65: ; preds = %40
br label %66
66: ; preds = %65
%67 = load i32, i32* %3
%68 = add nsw i32 %67, 1
store i32 %68, i32* %3
br label %35
69: ; preds = %35
br label %70
70: ; preds = %69
%71 = load i32, i32* %4
%72 = add nsw i32 %71, 1
store i32 %72, i32* %4
br label %30
73: ; preds = %30
store i32 1, i32* %5
%74 = call i32 @gettimeofday(%struct.timeval* %12, i32* null)
%75 = getelementptr inbounds %struct.timeval, %struct.timeval* %12, i32 0, i32 0
%76 = load i32, i32* %75
%77 = mul nsw i32 %76, 1000
%78 = sitofp i32 %77 to double
%79 = getelementptr inbounds %struct.timeval, %struct.timeval* %12, i32 0, i32 1
%80 = load double, double* %79
%81 = fdiv double %80, 1.000000e+03
%82 = fadd double %78, %81
store double %82, double* %13
store i32 0, i32* %4
br label %83
83: ; preds = %123, %73
%84 = load i32, i32* %4
%85 = load i32, i32* %9
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %126
87: ; preds = %83
store i32 0, i32* %3
br label %88
88: ; preds = %119, %87
%89 = load i32, i32* %3
%90 = load i32, i32* %8
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %122
92: ; preds = %88
store i32 0, i32* %2
br label %93
93: ; preds = %115, %92
%94 = load i32, i32* %2
%95 = load i32, i32* %7
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %118
97: ; preds = %93
%98 = load i32*, i32** %11
%99 = load i32, i32* %4
%100 = load i32, i32* %8
%101 = mul nsw i32 %99, %100
%102 = load i32, i32* %7
%103 = mul nsw i32 %101, %102
%104 = load i32, i32* %3
%105 = load i32, i32* %7
%106 = mul nsw i32 %104, %105
%107 = add nsw i32 %103, %106
%108 = load i32, i32* %2
%109 = add nsw i32 %107, %108
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %98, i64 %110
%112 = load i32, i32* %111
%113 = load i32, i32* %5
%114 = mul nsw i32 %113, %112
store i32 %114, i32* %5
br label %115
115: ; preds = %97
%116 = load i32, i32* %2
%117 = add nsw i32 %116, 1
store i32 %117, i32* %2
br label %93
118: ; preds = %93
br label %119
119: ; preds = %118
%120 = load i32, i32* %3
%121 = add nsw i32 %120, 1
store i32 %121, i32* %3
br label %88
122: ; preds = %88
br label %123
123: ; preds = %122
%124 = load i32, i32* %4
%125 = add nsw i32 %124, 1
store i32 %125, i32* %4
br label %83
126: ; preds = %83
%127 = call i32 @gettimeofday(%struct.timeval* %12, i32* null)
%128 = getelementptr inbounds %struct.timeval, %struct.timeval* %12, i32 0, i32 0
%129 = load i32, i32* %128
%130 = mul nsw i32 %129, 1000
%131 = sitofp i32 %130 to double
%132 = getelementptr inbounds %struct.timeval, %struct.timeval* %12, i32 0, i32 1
%133 = load double, double* %132
%134 = fdiv double %133, 1.000000e+03
%135 = fadd double %131, %134
store double %135, double* %14
store i32 1, i32* %6
store i32 0, i32* %4
br label %136
136: ; preds = %176, %126
%137 = load i32, i32* %4
%138 = load i32, i32* %9
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %179
140: ; preds = %136
store i32 0, i32* %3
br label %141
141: ; preds = %172, %140
%142 = load i32, i32* %3
%143 = load i32, i32* %8
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %175
145: ; preds = %141
store i32 0, i32* %2
br label %146
146: ; preds = %168, %145
%147 = load i32, i32* %2
%148 = load i32, i32* %7
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %171
150: ; preds = %146
%151 = load i32*, i32** %11
%152 = load i32, i32* %4
%153 = load i32, i32* %8
%154 = mul nsw i32 %152, %153
%155 = load i32, i32* %7
%156 = mul nsw i32 %154, %155
%157 = load i32, i32* %3
%158 = load i32, i32* %7
%159 = mul nsw i32 %157, %158
%160 = add nsw i32 %156, %159
%161 = load i32, i32* %2
%162 = add nsw i32 %160, %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32, i32* %151, i64 %163
%165 = load i32, i32* %164
%166 = load i32, i32* %6
%167 = mul nsw i32 %166, %165
store i32 %167, i32* %6
br label %168
168: ; preds = %150
%169 = load i32, i32* %2
%170 = add nsw i32 %169, 1
store i32 %170, i32* %2
br label %146
171: ; preds = %146
br label %172
172: ; preds = %171
%173 = load i32, i32* %3
%174 = add nsw i32 %173, 1
store i32 %174, i32* %3
br label %141
175: ; preds = %141
br label %176
176: ; preds = %175
%177 = load i32, i32* %4
%178 = add nsw i32 %177, 1
store i32 %178, i32* %4
br label %136
179: ; preds = %136
%180 = load i32, i32* %5
%181 = load i32, i32* %6
%182 = icmp ne i32 %180, %181
br i1 %182, label %183, label %189
183: ; preds = %179
%184 = load i32, i32* %10
%185 = add nsw i32 %184, 1
store i32 %185, i32* %10
%186 = load i32, i32* %5
%187 = load i32, i32* %6
%188 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0), i32 %186, i32 %187)
br label %189
189: ; preds = %183, %179
%190 = load double, double* %14
%191 = load double, double* %13
%192 = fsub double %190, %191
%193 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.1, i64 0, i64 0), double %192)
%194 = load i32, i32* %10
%195 = icmp eq i32 %194, 0
br i1 %195, label %196, label %198
196: ; preds = %189
%197 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0))
br label %198
198: ; preds = %196, %189
%199 = load i32*, i32** %11
%200 = call i32 @free(i32* %199)
ret i32 1
}

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