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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
unsigned int ccnt_read();
int /*<<< orphan*/ dummy_proc_0();
int /*<<< orphan*/ dummy_proc_1(int);
int /*<<< orphan*/ dummy_proc_2(int, int);
int /*<<< orphan*/ dummy_proc_3(int, int, int);
int /*<<< orphan*/ dummy_proc_4(int, int, int, int);
int /*<<< orphan*/ dummy_proc_5(int, int, int, int, int);
int /*<<< orphan*/ dummy_proc_6(int, int, int, int, int, int);
int /*<<< orphan*/ dummy_proc_7(int, int, int, int, int, int, int);
float *cpu_proccall_overhead(float ccnt_overhead) {
  unsigned start, end;
  static float total[7 + 1];
  int a0, a1, a2, a3, a4, a5, a6;
  a0 = 0;
  a1 = 1;
  a2 = 2;
  a3 = 3;
  a4 = 4;
  a5 = 5;
  a6 = 6;
  int i;
  for (i = 0; i <= 7; i++) {
    total[i] = 0;
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_0();
    end = ccnt_read();
    total[0] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_1(a0);
    end = ccnt_read();
    total[1] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_2(a0, a1);
    end = ccnt_read();
    total[2] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_3(a0, a1, a2);
    end = ccnt_read();
    total[3] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_4(a0, a1, a2, a3);
    end = ccnt_read();
    total[4] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_5(a0, a1, a2, a3, a4);
    end = ccnt_read();
    total[5] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_6(a0, a1, a2, a3, a4, a5);
    end = ccnt_read();
    total[6] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i < 10000; i++) {
    start = ccnt_read();
    dummy_proc_7(a0, a1, a2, a3, a4, a5, a6);
    end = ccnt_read();
    total[7] += (float)(end - start - ccnt_overhead);
  }
  for (i = 0; i <= 7; i++) {
    total[i] /= (float)10000;
  }
  return total;
}


x86 assembly (clang, -O0):
<cpu_proccall_overhead>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movss  %xmm0,-0x4(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x1,-0x14(%rbp)
movl   $0x2,-0x18(%rbp)
movl   $0x3,-0x1c(%rbp)
movl   $0x4,-0x20(%rbp)
movl   $0x5,-0x24(%rbp)
movl   $0x6,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x7,-0x2c(%rbp)
jg     1200 <cpu_proccall_overhead+0x70>
movslq -0x2c(%rbp),%rcx
lea    0x2e96(%rip),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d5 <cpu_proccall_overhead+0x45>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    1266 <cpu_proccall_overhead+0xd6>
xor    %eax,%eax
mov    %al,-0x2d(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,%ecx
mov    -0x2d(%rbp),%al
mov    %ecx,-0x8(%rbp)
call   1050 <dummy_proc_0@plt>
mov    -0x2d(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2e30(%rip),%xmm0
movss  %xmm0,0x2e28(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1207 <cpu_proccall_overhead+0x77>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    12ca <cpu_proccall_overhead+0x13a>
xor    %eax,%eax
mov    %al,-0x2e(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%edi
call   10b0 <dummy_proc_1@plt>
mov    -0x2e(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2dd0(%rip),%xmm0
movss  %xmm0,0x2dc8(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    126d <cpu_proccall_overhead+0xdd>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    1331 <cpu_proccall_overhead+0x1a1>
xor    %eax,%eax
mov    %al,-0x2f(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1070 <dummy_proc_2@plt>
mov    -0x2f(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2d6d(%rip),%xmm0
movss  %xmm0,0x2d65(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12d1 <cpu_proccall_overhead+0x141>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    139b <cpu_proccall_overhead+0x20b>
xor    %eax,%eax
mov    %al,-0x30(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
call   10a0 <dummy_proc_3@plt>
mov    -0x30(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2d07(%rip),%xmm0
movss  %xmm0,0x2cff(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1338 <cpu_proccall_overhead+0x1a8>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    1408 <cpu_proccall_overhead+0x278>
xor    %eax,%eax
mov    %al,-0x31(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1060 <dummy_proc_4@plt>
mov    -0x31(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2c9e(%rip),%xmm0
movss  %xmm0,0x2c96(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13a2 <cpu_proccall_overhead+0x212>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    1479 <cpu_proccall_overhead+0x2e9>
xor    %eax,%eax
mov    %al,-0x32(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
call   1030 <dummy_proc_5@plt>
mov    -0x32(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2c31(%rip),%xmm0
movss  %xmm0,0x2c29(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    140f <cpu_proccall_overhead+0x27f>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    14ee <cpu_proccall_overhead+0x35e>
xor    %eax,%eax
mov    %al,-0x33(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    -0x24(%rbp),%r9d
call   1090 <dummy_proc_6@plt>
mov    -0x33(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2bc0(%rip),%xmm0
movss  %xmm0,0x2bb8(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1480 <cpu_proccall_overhead+0x2f0>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2710,-0x2c(%rbp)
jge    156d <cpu_proccall_overhead+0x3dd>
xor    %eax,%eax
mov    %al,-0x34(%rbp)
call   1080 <ccnt_read@plt>
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    -0x24(%rbp),%r9d
mov    -0x28(%rbp),%r10d
mov    %rsp,%rax
mov    %r10d,(%rax)
call   1040 <dummy_proc_7@plt>
mov    -0x34(%rbp),%al
call   1080 <ccnt_read@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
subss  -0x4(%rbp),%xmm0
addss  0x2b45(%rip),%xmm0
movss  %xmm0,0x2b3d(%rip)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14f5 <cpu_proccall_overhead+0x365>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x7,-0x2c(%rbp)
jg     15b4 <cpu_proccall_overhead+0x424>
movslq -0x2c(%rbp),%rcx
lea    0x2af7(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
movss  0xa6a(%rip),%xmm1
divss  %xmm1,%xmm0
lea    0x2adf(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1574 <cpu_proccall_overhead+0x3e4>
lea    0x2ac5(%rip),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cpu_proccall_overhead>:
push   %rbp
push   %rbx
sub    $0x18,%rsp
xorps  %xmm1,%xmm1
movaps %xmm1,0x2ef0(%rip)
movaps %xmm1,0x2ed9(%rip)
mov    $0x2710,%ebp
movss  %xmm0,0x14(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1050 <dummy_proc_0@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
movss  0x14(%rsp),%xmm0
sub    %ebx,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
subss  %xmm0,%xmm1
addss  0x2e8d(%rip),%xmm1
movss  %xmm1,0x2e85(%rip)
add    $0xffffffff,%ebp
jne    11c0 <cpu_proccall_overhead+0x30>
mov    $0x2710,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
xor    %edi,%edi
call   10b0 <dummy_proc_1@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
sub    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
subss  0x14(%rsp),%xmm0
addss  0x2e45(%rip),%xmm0
movss  %xmm0,0x2e3d(%rip)
add    $0xffffffff,%ebp
jne    1210 <cpu_proccall_overhead+0x80>
mov    $0x2710,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
call   1070 <dummy_proc_2@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
sub    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
subss  0x14(%rsp),%xmm0
addss  0x2df4(%rip),%xmm0
movss  %xmm0,0x2dec(%rip)
add    $0xffffffff,%ebp
jne    1260 <cpu_proccall_overhead+0xd0>
mov    $0x2710,%ebp
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
call   10a0 <dummy_proc_3@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
sub    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
subss  0x14(%rsp),%xmm0
addss  0x2da3(%rip),%xmm0
movss  %xmm0,0x2d9b(%rip)
add    $0xffffffff,%ebp
jne    12b0 <cpu_proccall_overhead+0x120>
mov    $0x2710,%ebp
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
mov    $0x3,%ecx
call   1060 <dummy_proc_4@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
sub    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
subss  0x14(%rsp),%xmm0
addss  0x2d52(%rip),%xmm0
movss  %xmm0,0x2d4a(%rip)
add    $0xffffffff,%ebp
jne    1300 <cpu_proccall_overhead+0x170>
mov    $0x2710,%ebp
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
mov    $0x3,%ecx
mov    $0x4,%r8d
call   1030 <dummy_proc_5@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
sub    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
subss  0x14(%rsp),%xmm0
addss  0x2d00(%rip),%xmm0
movss  %xmm0,0x2cf8(%rip)
add    $0xffffffff,%ebp
jne    1350 <cpu_proccall_overhead+0x1c0>
mov    $0x2710,%ebp
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
mov    $0x3,%ecx
mov    $0x4,%r8d
mov    $0x5,%r9d
call   1090 <dummy_proc_6@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
sub    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
subss  0x14(%rsp),%xmm0
addss  0x2c9e(%rip),%xmm0
movss  %xmm0,0x2c96(%rip)
add    $0xffffffff,%ebp
jne    13b0 <cpu_proccall_overhead+0x220>
mov    $0x2710,%ebp
nopl   0x0(%rax)
xor    %eax,%eax
call   1080 <ccnt_read@plt>
mov    %eax,%ebx
movl   $0x6,(%rsp)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x2,%edx
mov    $0x3,%ecx
mov    $0x4,%r8d
mov    $0x5,%r9d
call   1040 <dummy_proc_7@plt>
xor    %eax,%eax
call   1080 <ccnt_read@plt>
sub    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
subss  0x14(%rsp),%xmm0
addss  0x2c3b(%rip),%xmm0
movss  %xmm0,0x2c33(%rip)
add    $0xffffffff,%ebp
jne    1410 <cpu_proccall_overhead+0x280>
movaps 0x2c0b(%rip),%xmm1
movaps 0xb84(%rip),%xmm2
divps  %xmm2,%xmm1
movaps %xmm1,0x2bfa(%rip)
movsd  0x2c06(%rip),%xmm1
shufps $0xd4,%xmm1,%xmm0
unpcklpd 0x2bf6(%rip),%xmm1
lea    0x2bdf(%rip),%rax
shufps $0x22,%xmm0,%xmm1
divps  %xmm2,%xmm1
movaps %xmm1,0x2be1(%rip)
add    $0x18,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@cpu_proccall_overhead.total = internal global [8 x float] zeroinitializer
define float* @cpu_proccall_overhead(float %0) {
%2 = alloca float
%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
store float %0, float* %2
store i32 0, i32* %5
store i32 1, i32* %6
store i32 2, i32* %7
store i32 3, i32* %8
store i32 4, i32* %9
store i32 5, i32* %10
store i32 6, i32* %11
store i32 0, i32* %12
br label %13
13: ; preds = %20, %1
%14 = load i32, i32* %12
%15 = icmp sle i32 %14, 7
br i1 %15, label %16, label %23
16: ; preds = %13
%17 = load i32, i32* %12
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 %18
store float 0.000000e+00, float* %19
br label %20
20: ; preds = %16
%21 = load i32, i32* %12
%22 = add nsw i32 %21, 1
store i32 %22, i32* %12
br label %13
23: ; preds = %13
store i32 0, i32* %12
br label %24
24: ; preds = %39, %23
%25 = load i32, i32* %12
%26 = icmp slt i32 %25, 10000
br i1 %26, label %27, label %42
27: ; preds = %24
%28 = call i32 (...) @ccnt_read()
store i32 %28, i32* %3
%29 = call i32 (...) @dummy_proc_0()
%30 = call i32 (...) @ccnt_read()
store i32 %30, i32* %4
%31 = load i32, i32* %4
%32 = load i32, i32* %3
%33 = sub i32 %31, %32
%34 = uitofp i32 %33 to float
%35 = load float, float* %2
%36 = fsub float %34, %35
%37 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 0)
%38 = fadd float %37, %36
store float %38, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 0)
br label %39
39: ; preds = %27
%40 = load i32, i32* %12
%41 = add nsw i32 %40, 1
store i32 %41, i32* %12
br label %24
42: ; preds = %24
store i32 0, i32* %12
br label %43
43: ; preds = %59, %42
%44 = load i32, i32* %12
%45 = icmp slt i32 %44, 10000
br i1 %45, label %46, label %62
46: ; preds = %43
%47 = call i32 (...) @ccnt_read()
store i32 %47, i32* %3
%48 = load i32, i32* %5
%49 = call i32 @dummy_proc_1(i32 %48)
%50 = call i32 (...) @ccnt_read()
store i32 %50, i32* %4
%51 = load i32, i32* %4
%52 = load i32, i32* %3
%53 = sub i32 %51, %52
%54 = uitofp i32 %53 to float
%55 = load float, float* %2
%56 = fsub float %54, %55
%57 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 1)
%58 = fadd float %57, %56
store float %58, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 1)
br label %59
59: ; preds = %46
%60 = load i32, i32* %12
%61 = add nsw i32 %60, 1
store i32 %61, i32* %12
br label %43
62: ; preds = %43
store i32 0, i32* %12
br label %63
63: ; preds = %80, %62
%64 = load i32, i32* %12
%65 = icmp slt i32 %64, 10000
br i1 %65, label %66, label %83
66: ; preds = %63
%67 = call i32 (...) @ccnt_read()
store i32 %67, i32* %3
%68 = load i32, i32* %5
%69 = load i32, i32* %6
%70 = call i32 @dummy_proc_2(i32 %68, i32 %69)
%71 = call i32 (...) @ccnt_read()
store i32 %71, i32* %4
%72 = load i32, i32* %4
%73 = load i32, i32* %3
%74 = sub i32 %72, %73
%75 = uitofp i32 %74 to float
%76 = load float, float* %2
%77 = fsub float %75, %76
%78 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 2)
%79 = fadd float %78, %77
store float %79, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 2)
br label %80
80: ; preds = %66
%81 = load i32, i32* %12
%82 = add nsw i32 %81, 1
store i32 %82, i32* %12
br label %63
83: ; preds = %63
store i32 0, i32* %12
br label %84
84: ; preds = %102, %83
%85 = load i32, i32* %12
%86 = icmp slt i32 %85, 10000
br i1 %86, label %87, label %105
87: ; preds = %84
%88 = call i32 (...) @ccnt_read()
store i32 %88, i32* %3
%89 = load i32, i32* %5
%90 = load i32, i32* %6
%91 = load i32, i32* %7
%92 = call i32 @dummy_proc_3(i32 %89, i32 %90, i32 %91)
%93 = call i32 (...) @ccnt_read()
store i32 %93, i32* %4
%94 = load i32, i32* %4
%95 = load i32, i32* %3
%96 = sub i32 %94, %95
%97 = uitofp i32 %96 to float
%98 = load float, float* %2
%99 = fsub float %97, %98
%100 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 3)
%101 = fadd float %100, %99
store float %101, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 3)
br label %102
102: ; preds = %87
%103 = load i32, i32* %12
%104 = add nsw i32 %103, 1
store i32 %104, i32* %12
br label %84
105: ; preds = %84
store i32 0, i32* %12
br label %106
106: ; preds = %125, %105
%107 = load i32, i32* %12
%108 = icmp slt i32 %107, 10000
br i1 %108, label %109, label %128
109: ; preds = %106
%110 = call i32 (...) @ccnt_read()
store i32 %110, i32* %3
%111 = load i32, i32* %5
%112 = load i32, i32* %6
%113 = load i32, i32* %7
%114 = load i32, i32* %8
%115 = call i32 @dummy_proc_4(i32 %111, i32 %112, i32 %113, i32 %114)
%116 = call i32 (...) @ccnt_read()
store i32 %116, i32* %4
%117 = load i32, i32* %4
%118 = load i32, i32* %3
%119 = sub i32 %117, %118
%120 = uitofp i32 %119 to float
%121 = load float, float* %2
%122 = fsub float %120, %121
%123 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 4)
%124 = fadd float %123, %122
store float %124, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 4)
br label %125
125: ; preds = %109
%126 = load i32, i32* %12
%127 = add nsw i32 %126, 1
store i32 %127, i32* %12
br label %106
128: ; preds = %106
store i32 0, i32* %12
br label %129
129: ; preds = %149, %128
%130 = load i32, i32* %12
%131 = icmp slt i32 %130, 10000
br i1 %131, label %132, label %152
132: ; preds = %129
%133 = call i32 (...) @ccnt_read()
store i32 %133, i32* %3
%134 = load i32, i32* %5
%135 = load i32, i32* %6
%136 = load i32, i32* %7
%137 = load i32, i32* %8
%138 = load i32, i32* %9
%139 = call i32 @dummy_proc_5(i32 %134, i32 %135, i32 %136, i32 %137, i32 %138)
%140 = call i32 (...) @ccnt_read()
store i32 %140, i32* %4
%141 = load i32, i32* %4
%142 = load i32, i32* %3
%143 = sub i32 %141, %142
%144 = uitofp i32 %143 to float
%145 = load float, float* %2
%146 = fsub float %144, %145
%147 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 5)
%148 = fadd float %147, %146
store float %148, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 5)
br label %149
149: ; preds = %132
%150 = load i32, i32* %12
%151 = add nsw i32 %150, 1
store i32 %151, i32* %12
br label %129
152: ; preds = %129
store i32 0, i32* %12
br label %153
153: ; preds = %174, %152
%154 = load i32, i32* %12
%155 = icmp slt i32 %154, 10000
br i1 %155, label %156, label %177
156: ; preds = %153
%157 = call i32 (...) @ccnt_read()
store i32 %157, i32* %3
%158 = load i32, i32* %5
%159 = load i32, i32* %6
%160 = load i32, i32* %7
%161 = load i32, i32* %8
%162 = load i32, i32* %9
%163 = load i32, i32* %10
%164 = call i32 @dummy_proc_6(i32 %158, i32 %159, i32 %160, i32 %161, i32 %162, i32 %163)
%165 = call i32 (...) @ccnt_read()
store i32 %165, i32* %4
%166 = load i32, i32* %4
%167 = load i32, i32* %3
%168 = sub i32 %166, %167
%169 = uitofp i32 %168 to float
%170 = load float, float* %2
%171 = fsub float %169, %170
%172 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 6)
%173 = fadd float %172, %171
store float %173, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 6)
br label %174
174: ; preds = %156
%175 = load i32, i32* %12
%176 = add nsw i32 %175, 1
store i32 %176, i32* %12
br label %153
177: ; preds = %153
store i32 0, i32* %12
br label %178
178: ; preds = %200, %177
%179 = load i32, i32* %12
%180 = icmp slt i32 %179, 10000
br i1 %180, label %181, label %203
181: ; preds = %178
%182 = call i32 (...) @ccnt_read()
store i32 %182, i32* %3
%183 = load i32, i32* %5
%184 = load i32, i32* %6
%185 = load i32, i32* %7
%186 = load i32, i32* %8
%187 = load i32, i32* %9
%188 = load i32, i32* %10
%189 = load i32, i32* %11
%190 = call i32 @dummy_proc_7(i32 %183, i32 %184, i32 %185, i32 %186, i32 %187, i32 %188, i32 %189)
%191 = call i32 (...) @ccnt_read()
store i32 %191, i32* %4
%192 = load i32, i32* %4
%193 = load i32, i32* %3
%194 = sub i32 %192, %193
%195 = uitofp i32 %194 to float
%196 = load float, float* %2
%197 = fsub float %195, %196
%198 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 7)
%199 = fadd float %198, %197
store float %199, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 7)
br label %200
200: ; preds = %181
%201 = load i32, i32* %12
%202 = add nsw i32 %201, 1
store i32 %202, i32* %12
br label %178
203: ; preds = %178
store i32 0, i32* %12
br label %204
204: ; preds = %213, %203
%205 = load i32, i32* %12
%206 = icmp sle i32 %205, 7
br i1 %206, label %207, label %216
207: ; preds = %204
%208 = load i32, i32* %12
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 %209
%211 = load float, float* %210
%212 = fdiv float %211, 1.000000e+04
store float %212, float* %210
br label %213
213: ; preds = %207
%214 = load i32, i32* %12
%215 = add nsw i32 %214, 1
store i32 %215, i32* %12
br label %204
216: ; preds = %204
ret float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 0)
}

LLVM IR (-O2):
@cpu_proccall_overhead.total = internal global [8 x float] zeroinitializer
define float* @cpu_proccall_overhead(float %0) {
br label %2
2: ; preds = %1, %2
%3 = phi i32 [ %12, %2 ], [ 0, %1 ]
%4 = tail call i32 (...) @ccnt_read()
%5 = tail call i32 (...) @dummy_proc_0()
%6 = tail call i32 (...) @ccnt_read()
%7 = sub i32 %6, %4
%8 = uitofp i32 %7 to float
%9 = fsub float %8, %0
%10 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 0)
%11 = fadd float %10, %9
store float %11, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 0)
%12 = add nuw nsw i32 %3, 1
%13 = icmp eq i32 %12, 10000
br i1 %13, label %14, label %2
14: ; preds = %2, %14
%15 = phi i32 [ %24, %14 ], [ 0, %2 ]
%16 = tail call i32 (...) @ccnt_read()
%17 = tail call i32 @dummy_proc_1(i32 0)
%18 = tail call i32 (...) @ccnt_read()
%19 = sub i32 %18, %16
%20 = uitofp i32 %19 to float
%21 = fsub float %20, %0
%22 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 1)
%23 = fadd float %22, %21
store float %23, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 1)
%24 = add nuw nsw i32 %15, 1
%25 = icmp eq i32 %24, 10000
br i1 %25, label %26, label %14
26: ; preds = %14, %26
%27 = phi i32 [ %36, %26 ], [ 0, %14 ]
%28 = tail call i32 (...) @ccnt_read()
%29 = tail call i32 @dummy_proc_2(i32 0, i32 1)
%30 = tail call i32 (...) @ccnt_read()
%31 = sub i32 %30, %28
%32 = uitofp i32 %31 to float
%33 = fsub float %32, %0
%34 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 2)
%35 = fadd float %34, %33
store float %35, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 2)
%36 = add nuw nsw i32 %27, 1
%37 = icmp eq i32 %36, 10000
br i1 %37, label %38, label %26
38: ; preds = %26, %38
%39 = phi i32 [ %48, %38 ], [ 0, %26 ]
%40 = tail call i32 (...) @ccnt_read()
%41 = tail call i32 @dummy_proc_3(i32 0, i32 1, i32 2)
%42 = tail call i32 (...) @ccnt_read()
%43 = sub i32 %42, %40
%44 = uitofp i32 %43 to float
%45 = fsub float %44, %0
%46 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 3)
%47 = fadd float %46, %45
store float %47, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 3)
%48 = add nuw nsw i32 %39, 1
%49 = icmp eq i32 %48, 10000
br i1 %49, label %50, label %38
50: ; preds = %38, %50
%51 = phi i32 [ %60, %50 ], [ 0, %38 ]
%52 = tail call i32 (...) @ccnt_read()
%53 = tail call i32 @dummy_proc_4(i32 0, i32 1, i32 2, i32 3)
%54 = tail call i32 (...) @ccnt_read()
%55 = sub i32 %54, %52
%56 = uitofp i32 %55 to float
%57 = fsub float %56, %0
%58 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 4)
%59 = fadd float %58, %57
store float %59, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 4)
%60 = add nuw nsw i32 %51, 1
%61 = icmp eq i32 %60, 10000
br i1 %61, label %62, label %50
62: ; preds = %50, %62
%63 = phi i32 [ %72, %62 ], [ 0, %50 ]
%64 = tail call i32 (...) @ccnt_read()
%65 = tail call i32 @dummy_proc_5(i32 0, i32 1, i32 2, i32 3, i32 4)
%66 = tail call i32 (...) @ccnt_read()
%67 = sub i32 %66, %64
%68 = uitofp i32 %67 to float
%69 = fsub float %68, %0
%70 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 5)
%71 = fadd float %70, %69
store float %71, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 5)
%72 = add nuw nsw i32 %63, 1
%73 = icmp eq i32 %72, 10000
br i1 %73, label %74, label %62
74: ; preds = %62, %74
%75 = phi i32 [ %84, %74 ], [ 0, %62 ]
%76 = tail call i32 (...) @ccnt_read()
%77 = tail call i32 @dummy_proc_6(i32 0, i32 1, i32 2, i32 3, i32 4, i32 5)
%78 = tail call i32 (...) @ccnt_read()
%79 = sub i32 %78, %76
%80 = uitofp i32 %79 to float
%81 = fsub float %80, %0
%82 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 6)
%83 = fadd float %82, %81
store float %83, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 6)
%84 = add nuw nsw i32 %75, 1
%85 = icmp eq i32 %84, 10000
br i1 %85, label %86, label %74
86: ; preds = %74, %86
%87 = phi i32 [ %96, %86 ], [ 0, %74 ]
%88 = tail call i32 (...) @ccnt_read()
%89 = tail call i32 @dummy_proc_7(i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6)
%90 = tail call i32 (...) @ccnt_read()
%91 = sub i32 %90, %88
%92 = uitofp i32 %91 to float
%93 = fsub float %92, %0
%94 = load float, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 7)
%95 = fadd float %94, %93
store float %95, float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 7)
%96 = add nuw nsw i32 %87, 1
%97 = icmp eq i32 %96, 10000
br i1 %97, label %98, label %86
98: ; preds = %86
%99 = load <4 x float>, <4 x float>* bitcast ([8 x float]* @cpu_proccall_overhead.total to <4 x float>*)
%100 = fdiv <4 x float> %99, <float 1.000000e+04, float 1.000000e+04, float 1.000000e+04, float 1.000000e+04>
store <4 x float> %100, <4 x float>* bitcast ([8 x float]* @cpu_proccall_overhead.total to <4 x float>*)
%101 = load <4 x float>, <4 x float>* bitcast (float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 4) to <4 x float>*)
%102 = load <2 x float>, <2 x float>* bitcast (float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 5) to <2 x float>*)
%103 = shufflevector <2 x float> %102, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%104 = shufflevector <4 x float> %101, <4 x float> %103, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%105 = insertelement <4 x float> %104, float %95, i64 3
%106 = fdiv <4 x float> %105, <float 1.000000e+04, float 1.000000e+04, float 1.000000e+04, float 1.000000e+04>
store <4 x float> %106, <4 x float>* bitcast (float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 4) to <4 x float>*)
ret float* getelementptr inbounds ([8 x float], [8 x float]* @cpu_proccall_overhead.total, i64 0, i64 0)
}