#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 */
typedef unsigned int uint8_t;

/* Variables and functions */
int /*<<< orphan*/ free(unsigned int *);
scalar_t__ malloc(unsigned int);
double omp_get_wtime();
double parallel_combined() {
  extern unsigned int datasize;
  unsigned int n = (int)(datasize / sizeof(uint8_t));
  uint8_t *a = NULL;
  unsigned int i = 0;
  double t1_start = 0;
  double t1_end = 0;
  double t2_start = 0;
  double t2_end = 0;
  a = (uint8_t *)malloc(n * sizeof(uint8_t));
  if (a == NULL) {
    return (-10000);
  }
  t1_start = omp_get_wtime();
#pragma acc parallel loop create(a [0:n])
  for (i = 0; i < n; i++) {
    a[i] = i;
  }
  t1_end = omp_get_wtime();
  t2_start = omp_get_wtime();
#pragma acc parallel create(a [0:n])
#pragma acc loop
  for (i = 0; i < n; i++) {
    a[i] = i;
  }
  t2_end = omp_get_wtime();
  free(a);
  return ((t2_end - t2_start) - (t1_end - t1_start));
}


x86 assembly (clang, -O0):
<parallel_combined>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x2ea9(%rip),%rax
mov    (%rax),%eax
shr    $0x2,%rax
mov    %eax,-0xc(%rbp)
movq   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    11a6 <parallel_combined+0x76>
movsd  0xe64(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1258 <parallel_combined+0x128>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    11e0 <parallel_combined+0xb0>
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b9 <parallel_combined+0x89>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x30(%rbp)
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1226 <parallel_combined+0xf6>
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ff <parallel_combined+0xcf>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parallel_combined>:
push   %rbp
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    0x2ea9(%rip),%rax
mov    (%rax),%ebp
mov    %ebp,%edi
and    $0xfffffffc,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     1189 <parallel_combined+0x59>
mov    %rax,%rbx
mov    %ebp,%r14d
shr    $0x2,%r14d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movq   %xmm0,0x18(%rsp)
cmp    $0x4,%ebp
jb     12fc <parallel_combined+0x1cc>
cmp    $0x2,%r14d
mov    $0x1,%eax
cmovae %r14d,%eax
cmp    $0x8,%eax
jae    1196 <parallel_combined+0x66>
xor    %ecx,%ecx
jmp    12f0 <parallel_combined+0x1c0>
movsd  0xe6f(%rip),%xmm0
jmp    14cf <parallel_combined+0x39f>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    11c4 <parallel_combined+0x94>
movdqa 0xe53(%rip),%xmm0
xor    %edi,%edi
jmp    1298 <parallel_combined+0x168>
and    $0xfffffffffffffffc,%rsi
movdqa 0xe40(%rip),%xmm0
xor    %edi,%edi
movdqa 0xe45(%rip),%xmm8
movdqa 0xe4c(%rip),%xmm9
movdqa 0xe53(%rip),%xmm10
movdqa 0xe5b(%rip),%xmm4
movdqa 0xe63(%rip),%xmm5
movdqa 0xe6b(%rip),%xmm6
movdqa 0xe73(%rip),%xmm7
movdqa 0xe7b(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rdi,4)
movdqu %xmm3,0x30(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rdi,4)
movdqu %xmm3,0x50(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rdi,4)
movdqu %xmm3,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1220 <parallel_combined+0xf0>
test   %rdx,%rdx
je     12e0 <parallel_combined+0x1b0>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xd6d(%rip),%xmm1
movdqa 0xd75(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    12c0 <parallel_combined+0x190>
cmp    %rax,%rcx
je     12fc <parallel_combined+0x1cc>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12f0 <parallel_combined+0x1c0>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movq   %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movq   %xmm0,0x8(%rsp)
cmp    $0x4,%ebp
jb     149c <parallel_combined+0x36c>
cmp    $0x2,%r14d
mov    $0x1,%eax
cmovae %r14d,%eax
cmp    $0x8,%eax
jae    1338 <parallel_combined+0x208>
xor    %ecx,%ecx
jmp    1490 <parallel_combined+0x360>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1366 <parallel_combined+0x236>
movdqa 0xcb1(%rip),%xmm0
xor    %edi,%edi
jmp    1438 <parallel_combined+0x308>
and    $0xfffffffffffffffc,%rsi
movdqa 0xc9e(%rip),%xmm0
xor    %edi,%edi
movdqa 0xca3(%rip),%xmm8
movdqa 0xcaa(%rip),%xmm9
movdqa 0xcb1(%rip),%xmm10
movdqa 0xcb9(%rip),%xmm4
movdqa 0xcc1(%rip),%xmm5
movdqa 0xcc9(%rip),%xmm6
movdqa 0xcd1(%rip),%xmm7
movdqa 0xcd9(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rdi,4)
movdqu %xmm3,0x30(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rdi,4)
movdqu %xmm3,0x50(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rdi,4)
movdqu %xmm3,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    13c0 <parallel_combined+0x290>
test   %rdx,%rdx
je     1480 <parallel_combined+0x350>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xbcd(%rip),%xmm1
movdqa 0xbd5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1460 <parallel_combined+0x330>
cmp    %rax,%rcx
je     149c <parallel_combined+0x36c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1490 <parallel_combined+0x360>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movq   %xmm0,(%rsp)
mov    %rbx,%rdi
call   1030 <free@plt>
movsd  (%rsp),%xmm1
subsd  0x8(%rsp),%xmm1
movsd  0x10(%rsp),%xmm0
subsd  0x18(%rsp),%xmm0
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
@datasize = external global i32
define double @parallel_combined() {
%1 = alloca double
%2 = alloca i32
%3 = alloca i32*
%4 = alloca i32
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = load i32, i32* @datasize
%10 = zext i32 %9 to i64
%11 = udiv i64 %10, 4
%12 = trunc i64 %11 to i32
store i32 %12, i32* %2
store i32* null, i32** %3
store i32 0, i32* %4
store double 0.000000e+00, double* %5
store double 0.000000e+00, double* %6
store double 0.000000e+00, double* %7
store double 0.000000e+00, double* %8
%13 = load i32, i32* %2
%14 = zext i32 %13 to i64
%15 = mul i64 %14, 4
%16 = trunc i64 %15 to i32
%17 = call i64 @malloc(i32 %16)
%18 = inttoptr i64 %17 to i32*
store i32* %18, i32** %3
%19 = load i32*, i32** %3
%20 = icmp eq i32* %19, null
br i1 %20, label %21, label %22
21: ; preds = %0
store double -1.000000e+04, double* %1
br label %64
22: ; preds = %0
%23 = call double (...) @omp_get_wtime()
store double %23, double* %5
store i32 0, i32* %4
br label %24
24: ; preds = %34, %22
%25 = load i32, i32* %4
%26 = load i32, i32* %2
%27 = icmp ult i32 %25, %26
br i1 %27, label %28, label %37
28: ; preds = %24
%29 = load i32, i32* %4
%30 = load i32*, i32** %3
%31 = load i32, i32* %4
%32 = zext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %30, i64 %32
store i32 %29, i32* %33
br label %34
34: ; preds = %28
%35 = load i32, i32* %4
%36 = add i32 %35, 1
store i32 %36, i32* %4
br label %24
37: ; preds = %24
%38 = call double (...) @omp_get_wtime()
store double %38, double* %6
%39 = call double (...) @omp_get_wtime()
store double %39, double* %7
store i32 0, i32* %4
br label %40
40: ; preds = %50, %37
%41 = load i32, i32* %4
%42 = load i32, i32* %2
%43 = icmp ult i32 %41, %42
br i1 %43, label %44, label %53
44: ; preds = %40
%45 = load i32, i32* %4
%46 = load i32*, i32** %3
%47 = load i32, i32* %4
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %46, i64 %48
store i32 %45, i32* %49
br label %50
50: ; preds = %44
%51 = load i32, i32* %4
%52 = add i32 %51, 1
store i32 %52, i32* %4
br label %40
53: ; preds = %40
%54 = call double (...) @omp_get_wtime()
store double %54, double* %8
%55 = load i32*, i32** %3
%56 = call i32 @free(i32* %55)
%57 = load double, double* %8
%58 = load double, double* %7
%59 = fsub double %57, %58
%60 = load double, double* %6
%61 = load double, double* %5
%62 = fsub double %60, %61
%63 = fsub double %59, %62
store double %63, double* %1
br label %64
64: ; preds = %53, %21
%65 = load double, double* %1
ret double %65
}

LLVM IR (-O2):
@datasize = external global i32
define double @parallel_combined() {
%1 = load i32, i32* @datasize
%2 = lshr i32 %1, 2
%3 = and i32 %1, -4
%4 = tail call i64 @malloc(i32 %3)
%5 = inttoptr i64 %4 to i32*
%6 = icmp eq i64 %4, 0
br i1 %6, label %167, label %7
7: ; preds = %0
%8 = tail call double (...) @omp_get_wtime()
%9 = icmp ult i32 %1, 4
br i1 %9, label %84, label %10
10: ; preds = %7
%11 = call i32 @llvm.umax.i32(i32 %2, i32 1)
%12 = zext i32 %11 to i64
%13 = icmp ult i32 %11, 8
br i1 %13, label %76, label %14
14: ; preds = %10
%15 = and i64 %12, 1073741816
%16 = add nsw i64 %15, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 3
%20 = icmp ult i64 %16, 24
br i1 %20, label %57, label %21
21: ; preds = %14
%22 = and i64 %18, 4611686018427387900
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %53, %23 ]
%25 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %21 ], [ %54, %23 ]
%26 = phi i64 [ 0, %21 ], [ %55, %23 ]
%27 = add <4 x i32> %25, <i32 4, i32 4, i32 4, i32 4>
%28 = getelementptr inbounds i32, i32* %5, i64 %24
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> %25, <4 x i32>* %29
%30 = getelementptr inbounds i32, i32* %28, i64 4
%31 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %31
%32 = or i64 %24, 8
%33 = add <4 x i32> %25, <i32 8, i32 8, i32 8, i32 8>
%34 = add <4 x i32> %25, <i32 12, i32 12, i32 12, i32 12>
%35 = getelementptr inbounds i32, i32* %5, i64 %32
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> %33, <4 x i32>* %36
%37 = getelementptr inbounds i32, i32* %35, i64 4
%38 = bitcast i32* %37 to <4 x i32>*
store <4 x i32> %34, <4 x i32>* %38
%39 = or i64 %24, 16
%40 = add <4 x i32> %25, <i32 16, i32 16, i32 16, i32 16>
%41 = add <4 x i32> %25, <i32 20, i32 20, i32 20, i32 20>
%42 = getelementptr inbounds i32, i32* %5, i64 %39
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %43
%44 = getelementptr inbounds i32, i32* %42, i64 4
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %45
%46 = or i64 %24, 24
%47 = add <4 x i32> %25, <i32 24, i32 24, i32 24, i32 24>
%48 = add <4 x i32> %25, <i32 28, i32 28, i32 28, i32 28>
%49 = getelementptr inbounds i32, i32* %5, i64 %46
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %50
%51 = getelementptr inbounds i32, i32* %49, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %52
%53 = add nuw i64 %24, 32
%54 = add <4 x i32> %25, <i32 32, i32 32, i32 32, i32 32>
%55 = add i64 %26, 4
%56 = icmp eq i64 %55, %22
br i1 %56, label %57, label %23
57: ; preds = %23, %14
%58 = phi i64 [ 0, %14 ], [ %53, %23 ]
%59 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %14 ], [ %54, %23 ]
%60 = icmp eq i64 %19, 0
br i1 %60, label %74, label %61
61: ; preds = %57, %61
%62 = phi i64 [ %70, %61 ], [ %58, %57 ]
%63 = phi <4 x i32> [ %71, %61 ], [ %59, %57 ]
%64 = phi i64 [ %72, %61 ], [ 0, %57 ]
%65 = add <4 x i32> %63, <i32 4, i32 4, i32 4, i32 4>
%66 = getelementptr inbounds i32, i32* %5, i64 %62
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> %63, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %66, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %69
%70 = add nuw i64 %62, 8
%71 = add <4 x i32> %63, <i32 8, i32 8, i32 8, i32 8>
%72 = add i64 %64, 1
%73 = icmp eq i64 %72, %19
br i1 %73, label %74, label %61
74: ; preds = %61, %57
%75 = icmp eq i64 %15, %12
br i1 %75, label %84, label %76
76: ; preds = %10, %74
%77 = phi i64 [ 0, %10 ], [ %15, %74 ]
br label %78
78: ; preds = %76, %78
%79 = phi i64 [ %82, %78 ], [ %77, %76 ]
%80 = getelementptr inbounds i32, i32* %5, i64 %79
%81 = trunc i64 %79 to i32
store i32 %81, i32* %80
%82 = add nuw nsw i64 %79, 1
%83 = icmp eq i64 %82, %12
br i1 %83, label %84, label %78
84: ; preds = %78, %74, %7
%85 = tail call double (...) @omp_get_wtime()
%86 = tail call double (...) @omp_get_wtime()
br i1 %9, label %161, label %87
87: ; preds = %84
%88 = call i32 @llvm.umax.i32(i32 %2, i32 1)
%89 = zext i32 %88 to i64
%90 = icmp ult i32 %88, 8
br i1 %90, label %153, label %91
91: ; preds = %87
%92 = and i64 %89, 1073741816
%93 = add nsw i64 %92, -8
%94 = lshr exact i64 %93, 3
%95 = add nuw nsw i64 %94, 1
%96 = and i64 %95, 3
%97 = icmp ult i64 %93, 24
br i1 %97, label %134, label %98
98: ; preds = %91
%99 = and i64 %95, 4611686018427387900
br label %100
100: ; preds = %100, %98
%101 = phi i64 [ 0, %98 ], [ %130, %100 ]
%102 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %98 ], [ %131, %100 ]
%103 = phi i64 [ 0, %98 ], [ %132, %100 ]
%104 = add <4 x i32> %102, <i32 4, i32 4, i32 4, i32 4>
%105 = getelementptr inbounds i32, i32* %5, i64 %101
%106 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> %102, <4 x i32>* %106
%107 = getelementptr inbounds i32, i32* %105, i64 4
%108 = bitcast i32* %107 to <4 x i32>*
store <4 x i32> %104, <4 x i32>* %108
%109 = or i64 %101, 8
%110 = add <4 x i32> %102, <i32 8, i32 8, i32 8, i32 8>
%111 = add <4 x i32> %102, <i32 12, i32 12, i32 12, i32 12>
%112 = getelementptr inbounds i32, i32* %5, i64 %109
%113 = bitcast i32* %112 to <4 x i32>*
store <4 x i32> %110, <4 x i32>* %113
%114 = getelementptr inbounds i32, i32* %112, i64 4
%115 = bitcast i32* %114 to <4 x i32>*
store <4 x i32> %111, <4 x i32>* %115
%116 = or i64 %101, 16
%117 = add <4 x i32> %102, <i32 16, i32 16, i32 16, i32 16>
%118 = add <4 x i32> %102, <i32 20, i32 20, i32 20, i32 20>
%119 = getelementptr inbounds i32, i32* %5, i64 %116
%120 = bitcast i32* %119 to <4 x i32>*
store <4 x i32> %117, <4 x i32>* %120
%121 = getelementptr inbounds i32, i32* %119, i64 4
%122 = bitcast i32* %121 to <4 x i32>*
store <4 x i32> %118, <4 x i32>* %122
%123 = or i64 %101, 24
%124 = add <4 x i32> %102, <i32 24, i32 24, i32 24, i32 24>
%125 = add <4 x i32> %102, <i32 28, i32 28, i32 28, i32 28>
%126 = getelementptr inbounds i32, i32* %5, i64 %123
%127 = bitcast i32* %126 to <4 x i32>*
store <4 x i32> %124, <4 x i32>* %127
%128 = getelementptr inbounds i32, i32* %126, i64 4
%129 = bitcast i32* %128 to <4 x i32>*
store <4 x i32> %125, <4 x i32>* %129
%130 = add nuw i64 %101, 32
%131 = add <4 x i32> %102, <i32 32, i32 32, i32 32, i32 32>
%132 = add i64 %103, 4
%133 = icmp eq i64 %132, %99
br i1 %133, label %134, label %100
134: ; preds = %100, %91
%135 = phi i64 [ 0, %91 ], [ %130, %100 ]
%136 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %91 ], [ %131, %100 ]
%137 = icmp eq i64 %96, 0
br i1 %137, label %151, label %138
138: ; preds = %134, %138
%139 = phi i64 [ %147, %138 ], [ %135, %134 ]
%140 = phi <4 x i32> [ %148, %138 ], [ %136, %134 ]
%141 = phi i64 [ %149, %138 ], [ 0, %134 ]
%142 = add <4 x i32> %140, <i32 4, i32 4, i32 4, i32 4>
%143 = getelementptr inbounds i32, i32* %5, i64 %139
%144 = bitcast i32* %143 to <4 x i32>*
store <4 x i32> %140, <4 x i32>* %144
%145 = getelementptr inbounds i32, i32* %143, i64 4
%146 = bitcast i32* %145 to <4 x i32>*
store <4 x i32> %142, <4 x i32>* %146
%147 = add nuw i64 %139, 8
%148 = add <4 x i32> %140, <i32 8, i32 8, i32 8, i32 8>
%149 = add i64 %141, 1
%150 = icmp eq i64 %149, %96
br i1 %150, label %151, label %138
151: ; preds = %138, %134
%152 = icmp eq i64 %92, %89
br i1 %152, label %161, label %153
153: ; preds = %87, %151
%154 = phi i64 [ 0, %87 ], [ %92, %151 ]
br label %155
155: ; preds = %153, %155
%156 = phi i64 [ %159, %155 ], [ %154, %153 ]
%157 = getelementptr inbounds i32, i32* %5, i64 %156
%158 = trunc i64 %156 to i32
store i32 %158, i32* %157
%159 = add nuw nsw i64 %156, 1
%160 = icmp eq i64 %159, %89
br i1 %160, label %161, label %155
161: ; preds = %155, %151, %84
%162 = tail call double (...) @omp_get_wtime()
%163 = tail call i32 @free(i32* %5)
%164 = fsub double %162, %86
%165 = fsub double %85, %8
%166 = fsub double %164, %165
br label %167
167: ; preds = %0, %161
%168 = phi double [ %166, %161 ], [ -1.000000e+04, %0 ]
ret double %168
}