#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 */
scalar_t__ chk_calloc(unsigned int, int);
int /*<<< orphan*/ free(double *);
double SHOKcumulative(double *cumulative, unsigned int w, unsigned int s,
                      double epsShok) {
  double m = 0;
  double *omega_shok = NULL;
  double *omega_shok_norm = NULL;
  double avgDeg = 0.0;
  unsigned int i = 0;
  unsigned int ref = 0;
  unsigned int wvirt = (2 * w - s);
  unsigned int D = (unsigned int)(4.0 * (1.0 + epsShok) / epsShok + 0.5);
  m = epsShok * (2.0 + epsShok) / 4.0;
  if (wvirt > D) {
    ref = D;
  } else {
    ref = (double)wvirt;
  }
  omega_shok = (double *)chk_calloc(wvirt, sizeof(double));
  omega_shok_norm = (double *)chk_calloc(wvirt, sizeof(double));
  omega_shok[0] = ((double)m / (m + 1.0));
  for (i = 1; i < (ref - 1); i++) {
    omega_shok[i] = 1.0 / (((i + 1.0) * i) * (m + 1.0));
  }
  omega_shok[ref] = 1.0 / (ref * (m + 1.0));
  double normfact = 0.0;
  for (i = 0; i < w; i++) {
    normfact += omega_shok[i];
  }
  for (i = 0; i < w; i++) {
    omega_shok_norm[i] = omega_shok[i] / normfact;
    avgDeg += omega_shok_norm[i] * (i + 1);
  }
  cumulative[0] = omega_shok_norm[0];
  for (i = 1; i < w; i++) {
    cumulative[i] = (double)(cumulative[i - 1] + omega_shok_norm[i]);
  }
  free(omega_shok);
  free(omega_shok_norm);
  return avgDeg;
}


x86 assembly (clang, -O0):
<SHOKcumulative>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0xc(%rbp),%eax
add    %eax,%eax
mov    -0x10(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  0xe91(%rip),%xmm2
movaps %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  0xe72(%rip),%xmm2
mulsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  0xe7a(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
mov    %eax,-0x48(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  0xe51(%rip),%xmm1
addsd  -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe38(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jbe    11e8 <SHOKcumulative+0xc8>
mov    -0x48(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    11ee <SHOKcumulative+0xce>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%edi
mov    $0x8,%esi
call   1040 <chk_calloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x44(%rbp),%edi
mov    $0x8,%esi
call   1040 <chk_calloc@plt>
mov    %rax,-0x30(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xdf3(%rip),%xmm1
addsd  -0x20(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    1298 <SHOKcumulative+0x178>
mov    -0x3c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0xdba(%rip),%xmm2
movaps %xmm0,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm1
movsd  0xda7(%rip),%xmm0
addsd  -0x20(%rbp),%xmm0
mulsd  %xmm0,%xmm1
movsd  0xd96(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1235 <SHOKcumulative+0x115>
mov    -0x40(%rbp),%eax
cvtsi2sd %rax,%xmm1
movsd  0xd68(%rip),%xmm0
addsd  -0x20(%rbp),%xmm0
mulsd  %xmm0,%xmm1
movsd  0xd57(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1308 <SHOKcumulative+0x1e8>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12d8 <SHOKcumulative+0x1b8>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1371 <SHOKcumulative+0x251>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rcx
mov    -0x3c(%rbp),%eax
mov    %eax,%edx
mov    %edx,%eax
movsd  (%rcx,%rdx,8),%xmm0
add    $0x1,%eax
cvtsi2sd %rax,%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    130f <SHOKcumulative+0x1ef>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    13cb <SHOKcumulative+0x2ab>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1388 <SHOKcumulative+0x268>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x38(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SHOKcumulative>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r12d
mov    %rdi,%r14
movapd %xmm0,%xmm1
addsd  0xec3(%rip),%xmm1
mulsd  0xec3(%rip),%xmm1
lea    (%r12,%r12,1),%ebp
divsd  %xmm0,%xmm1
addsd  0xebb(%rip),%xmm1
sub    %edx,%ebp
cvttsd2si %xmm1,%r13
movsd  0xeb4(%rip),%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  0xeac(%rip),%xmm1
movsd  %xmm1,(%rsp)
cmp    %r13d,%ebp
cmovbe %ebp,%r13d
mov    %ebp,%edi
mov    $0x8,%esi
call   1040 <chk_calloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
mov    $0x8,%esi
call   1040 <chk_calloc@plt>
movsd  0xe5d(%rip),%xmm0
mov    %rax,%r15
movsd  (%rsp),%xmm1
movapd %xmm1,%xmm10
addsd  %xmm0,%xmm10
divsd  %xmm10,%xmm1
movsd  %xmm1,(%rbx)
lea    -0x1(%r13),%eax
cmp    $0x2,%eax
jb     1341 <SHOKcumulative+0x221>
mov    %eax,%eax
lea    -0x1(%rax),%rcx
mov    $0x1,%edx
cmp    $0x2,%rcx
jb     1310 <SHOKcumulative+0x1f0>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
lea    -0x2(%rdx),%rsi
mov    %rsi,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1580 <SHOKcumulative+0x460>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
movapd 0xe19(%rip),%xmm6
xor    %esi,%esi
xorpd  %xmm3,%xmm3
movapd 0xe1b(%rip),%xmm4
movapd 0xe23(%rip),%xmm5
movdqa 0xe2a(%rip),%xmm8
movdqa 0xe31(%rip),%xmm9
nop
movapd %xmm6,%xmm2
unpcklps %xmm3,%xmm2
orpd   %xmm4,%xmm2
subpd  %xmm4,%xmm2
movapd %xmm2,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm1,%xmm7
movapd %xmm5,%xmm2
divpd  %xmm7,%xmm2
movupd %xmm2,0x8(%rbx,%rsi,8)
movapd %xmm6,%xmm2
paddd  %xmm8,%xmm2
punpckldq %xmm3,%xmm2
por    %xmm4,%xmm2
subpd  %xmm4,%xmm2
movapd %xmm2,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm1,%xmm7
movapd %xmm5,%xmm2
divpd  %xmm7,%xmm2
movupd %xmm2,0x18(%rbx,%rsi,8)
add    $0x4,%rsi
paddd  %xmm9,%xmm6
add    $0xfffffffffffffffe,%rdi
jne    1240 <SHOKcumulative+0x120>
test   $0x1,%bpl
je     12f5 <SHOKcumulative+0x1d5>
shl    $0x3,%rsi
xorpd  %xmm2,%xmm2
unpcklps %xmm2,%xmm6
movapd 0xd78(%rip),%xmm2
orpd   %xmm2,%xmm6
subpd  %xmm2,%xmm6
movapd 0xd78(%rip),%xmm2
movapd %xmm6,%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm6,%xmm3
mulpd  %xmm3,%xmm1
divpd  %xmm1,%xmm2
or     $0x8,%rsi
movupd %xmm2,(%rbx,%rsi,1)
cmp    %rdx,%rcx
je     1341 <SHOKcumulative+0x221>
or     $0x1,%rcx
mov    %rcx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %rcx,%xmm1
movapd %xmm1,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm10,%xmm2
movapd %xmm0,%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1310 <SHOKcumulative+0x1f0>
mov    %r13d,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
mulsd  %xmm1,%xmm10
divsd  %xmm10,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
test   %r12d,%r12d
je     1535 <SHOKcumulative+0x415>
mov    %r12d,%ecx
lea    -0x1(%rcx),%rax
mov    %ecx,%edx
and    $0x7,%edx
cmp    $0x7,%rax
jae    137e <SHOKcumulative+0x25e>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
jmp    13c8 <SHOKcumulative+0x2a8>
mov    %ecx,%edi
and    $0xfffffff8,%edi
xorpd  %xmm0,%xmm0
xor    %esi,%esi
nopl   0x0(%rax)
addsd  (%rbx,%rsi,8),%xmm0
addsd  0x8(%rbx,%rsi,8),%xmm0
addsd  0x10(%rbx,%rsi,8),%xmm0
addsd  0x18(%rbx,%rsi,8),%xmm0
addsd  0x20(%rbx,%rsi,8),%xmm0
addsd  0x28(%rbx,%rsi,8),%xmm0
addsd  0x30(%rbx,%rsi,8),%xmm0
addsd  0x38(%rbx,%rsi,8),%xmm0
add    $0x8,%rsi
cmp    %rsi,%rdi
jne    1390 <SHOKcumulative+0x270>
test   %rdx,%rdx
je     13ee <SHOKcumulative+0x2ce>
lea    (%rbx,%rsi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rsi,%rdi,8),%xmm0
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    13e0 <SHOKcumulative+0x2c0>
test   %r12d,%r12d
je     1535 <SHOKcumulative+0x415>
test   %rax,%rax
je     156c <SHOKcumulative+0x44c>
mov    %ecx,%esi
and    $0xfffffffe,%esi
xorpd  %xmm3,%xmm3
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
lea    0x1(%rdx),%edi
xorps  %xmm2,%xmm2
cvtsi2sd %rdi,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movsd  0x8(%rbx,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rdx,8)
add    $0x2,%rdx
mov    %edx,%edi
xorps  %xmm3,%xmm3
cvtsi2sd %rdi,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
cmp    %rdx,%rsi
jne    1410 <SHOKcumulative+0x2f0>
test   $0x1,%cl
je     1485 <SHOKcumulative+0x365>
movsd  (%rbx,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
add    $0x1,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %rdx,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm0,%xmm3
movsd  (%r15),%xmm0
movsd  %xmm0,(%r14)
cmp    $0x2,%r12d
movsd  %xmm3,(%rsp)
jb     1548 <SHOKcumulative+0x428>
add    $0xfffffffffffffffe,%rcx
mov    %eax,%edx
and    $0x3,%edx
mov    $0x1,%esi
cmp    $0x3,%rcx
jb     1505 <SHOKcumulative+0x3e5>
and    $0xfffffffffffffffc,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
addsd  0x8(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r14,%rsi,8)
addsd  0x10(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x10(%r14,%rsi,8)
addsd  0x18(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x18(%r14,%rsi,8)
addsd  0x20(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x20(%r14,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    14c0 <SHOKcumulative+0x3a0>
add    $0x1,%rsi
test   %rdx,%rdx
je     1548 <SHOKcumulative+0x428>
lea    (%r14,%rsi,8),%rax
lea    (%r15,%rsi,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1520 <SHOKcumulative+0x400>
jmp    1548 <SHOKcumulative+0x428>
movsd  (%r15),%xmm0
movsd  %xmm0,(%r14)
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
movsd  (%rsp),%xmm0
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xorpd  %xmm3,%xmm3
xor    %edx,%edx
test   $0x1,%cl
jne    1463 <SHOKcumulative+0x343>
jmp    1485 <SHOKcumulative+0x365>
movapd 0xaa8(%rip),%xmm6
xor    %esi,%esi
test   $0x1,%bpl
jne    12b5 <SHOKcumulative+0x195>
jmp    12f5 <SHOKcumulative+0x1d5>

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

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