#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 int /*<<< orphan*/ FILE;

/* Variables and functions */
float delta_n_step(float, float, float);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, float, float);
float *malloc(int);
void single_decay(float N0, float lambda, float dt) {
  float t_total = 5.0 / lambda;
  int n_points = (int)t_total / dt;
  int i;
  int j;
  int k;
  float M = 5.0;
  float t = 0.0;
  float n = N0;
  float *array_n = malloc(n_points * sizeof(float));
  float *array_t = malloc(n_points * sizeof(float));
  FILE *out = fopen("data_rand_average.txt", "w+");
  fprintf(out, "%f %f\n", t, n);
  array_n[0] = n;
  array_t[0] = t;
  float *array_n_temp = malloc(n_points * sizeof(float));
  float *array_t_temp = malloc(n_points * sizeof(float));
  for (j = 0; j < M; j++) {
    array_n_temp[0] = N0;
    array_t_temp[0] = 0.0;
    n = N0;
    t = 0.0;
    for (i = 1; i < (n_points); i++) {
      t += dt;
      float delta_n = delta_n_step(n, lambda, dt);
      n += delta_n;
      array_n_temp[i] = n;
      array_t_temp[i] = t;
    }
    for (i = 1; i < (n_points); i++) {
      array_n[i] = array_n[i] + array_n_temp[i];
      array_t[i] = array_t[i] + array_t_temp[i];
    }
  }
  for (k = 1; k < (n_points); k++) {
    array_n[k] = array_n[k] / M;
    array_t[k] = array_t[k] / M;
    fprintf(out, "%f %f\n", array_t[k], array_n[k]);
  }
  fclose(out);
}


x86 assembly (clang, -O0):
<single_decay>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe90(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
cvttss2si -0x10(%rbp),%eax
cvtsi2ss %eax,%xmm0
divss  -0xc(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x14(%rbp)
movss  0xe5e(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
lea    0xe2a(%rip),%rdi
lea    0xe39(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
movss  -0x28(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
lea    0xe1e(%rip),%rsi
call   1040 <fprintf@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x1c(%rbp)
cvtsi2ssl -0x1c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1392 <single_decay+0x242>
movss  -0x4(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1310 <single_decay+0x1c0>
movss  -0xc(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x8(%rbp),%xmm1
movss  -0xc(%rbp),%xmm2
call   1060 <delta_n_step@plt>
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    129b <single_decay+0x14b>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    137f <single_decay+0x22f>
mov    -0x38(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1317 <single_decay+0x1c7>
jmp    1384 <single_decay+0x234>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1257 <single_decay+0x107>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    141b <single_decay+0x2cb>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0xc21(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1399 <single_decay+0x249>
mov    -0x48(%rbp),%rdi
call   1030 <fclose@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<single_decay>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movss  %xmm0,0x4(%rsp)
movss  0xe94(%rip),%xmm0
movss  %xmm1,0x8(%rsp)
divss  %xmm1,%xmm0
cvttps2dq %xmm0,%xmm0
cvtdq2ps %xmm0,%xmm0
movss  %xmm2,0xc(%rsp)
divss  %xmm2,%xmm0
cvttss2si %xmm0,%ebp
lea    0x0(,%rbp,4),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
lea    0xe57(%rip),%rdi
lea    0xe66(%rip),%rsi
call   1070 <fopen@plt>
lea    0xe5d(%rip),%rsi
xorps  %xmm0,%xmm0
mov    %rax,0x18(%rsp)
mov    %rax,%rdi
movss  0x4(%rsp),%xmm1
call   1040 <fprintf@plt>
movss  0x4(%rsp),%xmm0
movss  %xmm0,(%r14)
movl   $0x0,(%r12)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1050 <malloc@plt>
movss  0x4(%rsp),%xmm2
mov    %rax,%rbx
lea    -0x1(%rbp),%rax
lea    -0x5(%rbp),%rcx
mov    %rcx,0x48(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rax,0x20(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rsp)
add    $0x1,%rax
mov    %rax,0x30(%rsp)
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x28(%rsp)
xor    %edx,%edx
jmp    125c <single_decay+0x10c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%edx
cmp    $0x5,%edx
je     143e <single_decay+0x2ee>
movss  %xmm2,0x0(%r13)
movl   $0x0,(%rbx)
cmp    $0x2,%ebp
jl     1250 <single_decay+0x100>
mov    %rdx,0x50(%rsp)
xorps  %xmm0,%xmm0
mov    $0x1,%r15d
movaps %xmm2,%xmm1
xchg   %ax,%ax
movss  %xmm1,0x10(%rsp)
movss  0xc(%rsp),%xmm2
addss  %xmm2,%xmm0
movss  %xmm0,0x14(%rsp)
movaps %xmm1,%xmm0
movss  0x8(%rsp),%xmm1
call   1060 <delta_n_step@plt>
movss  0x10(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  0x14(%rsp),%xmm0
movss  %xmm1,0x0(%r13,%r15,4)
movss  %xmm0,(%rbx,%r15,4)
add    $0x1,%r15
cmp    %r15,%rbp
jne    1280 <single_decay+0x130>
cmp    $0x2,%ebp
movss  0x4(%rsp),%xmm2
mov    0x50(%rsp),%rdx
jl     1250 <single_decay+0x100>
mov    $0x1,%eax
cmpq   $0x4,0x20(%rsp)
jb     13b0 <single_decay+0x260>
cmpq   $0x4,0x48(%rsp)
jae    12fb <single_decay+0x1ab>
xor    %eax,%eax
jmp    136c <single_decay+0x21c>
mov    0x28(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x4(%r14,%rax,4),%xmm0
movups 0x4(%r13,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x4(%r14,%rax,4)
movups 0x4(%r12,%rax,4),%xmm0
movups 0x4(%rbx,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x4(%r12,%rax,4)
movups 0x14(%r14,%rax,4),%xmm0
movups 0x14(%r13,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x14(%r14,%rax,4)
movups 0x14(%r12,%rax,4),%xmm0
movups 0x14(%rbx,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x14(%r12,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1310 <single_decay+0x1c0>
testb  $0x1,0x40(%rsp)
je     139f <single_decay+0x24f>
shl    $0x2,%rax
or     $0x4,%rax
movups (%r14,%rax,1),%xmm0
movups 0x0(%r13,%rax,1),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r14,%rax,1)
movups (%r12,%rax,1),%xmm0
movups (%rbx,%rax,1),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r12,%rax,1)
mov    0x30(%rsp),%rax
mov    0x38(%rsp),%rcx
cmp    %rcx,0x20(%rsp)
je     13dd <single_decay+0x28d>
movss  (%r14,%rax,4),%xmm0
addss  0x0(%r13,%rax,4),%xmm0
movss  (%r12,%rax,4),%xmm1
addss  (%rbx,%rax,4),%xmm1
movss  %xmm0,(%r14,%rax,4)
movss  %xmm1,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    13b0 <single_decay+0x260>
add    $0x1,%edx
cmp    $0x5,%edx
jne    125c <single_decay+0x10c>
cmp    $0x2,%ebp
jl     143e <single_decay+0x2ee>
mov    $0x1,%ebx
lea    0xc23(%rip),%r15
nopw   0x0(%rax,%rax,1)
movss  (%r14,%rbx,4),%xmm1
movss  0xbf2(%rip),%xmm2
divss  %xmm2,%xmm1
movss  %xmm1,(%r14,%rbx,4)
movss  (%r12,%rbx,4),%xmm0
divss  %xmm2,%xmm0
movss  %xmm0,(%r12,%rbx,4)
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
call   1040 <fprintf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1400 <single_decay+0x2b0>
mov    0x18(%rsp),%rdi
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <fclose@plt>

LLVM IR (-O0):
@.str = [22 x i8] c"data_rand_average.txt\00"
@.str.1 = [3 x i8] c"w+\00"
@.str.2 = [7 x i8] c"%f %f\0A\00"
define void @single_decay(float %0, float %1, float %2) {
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float*
%16 = alloca float*
%17 = alloca i32*
%18 = alloca float*
%19 = alloca float*
%20 = alloca float
store float %0, float* %4
store float %1, float* %5
store float %2, float* %6
%21 = load float, float* %5
%22 = fpext float %21 to double
%23 = fdiv double 5.000000e+00, %22
%24 = fptrunc double %23 to float
store float %24, float* %7
%25 = load float, float* %7
%26 = fptosi float %25 to i32
%27 = sitofp i32 %26 to float
%28 = load float, float* %6
%29 = fdiv float %27, %28
%30 = fptosi float %29 to i32
store i32 %30, i32* %8
store float 5.000000e+00, float* %12
store float 0.000000e+00, float* %13
%31 = load float, float* %4
store float %31, float* %14
%32 = load i32, i32* %8
%33 = sext i32 %32 to i64
%34 = mul i64 %33, 4
%35 = trunc i64 %34 to i32
%36 = call float* @malloc(i32 %35)
store float* %36, float** %15
%37 = load i32, i32* %8
%38 = sext i32 %37 to i64
%39 = mul i64 %38, 4
%40 = trunc i64 %39 to i32
%41 = call float* @malloc(i32 %40)
store float* %41, float** %16
%42 = call i32* @fopen(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i32* %42, i32** %17
%43 = load i32*, i32** %17
%44 = load float, float* %13
%45 = load float, float* %14
%46 = call i32 @fprintf(i32* %43, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), float %44, float %45)
%47 = load float, float* %14
%48 = load float*, float** %15
%49 = getelementptr inbounds float, float* %48, i64 0
store float %47, float* %49
%50 = load float, float* %13
%51 = load float*, float** %16
%52 = getelementptr inbounds float, float* %51, i64 0
store float %50, float* %52
%53 = load i32, i32* %8
%54 = sext i32 %53 to i64
%55 = mul i64 %54, 4
%56 = trunc i64 %55 to i32
%57 = call float* @malloc(i32 %56)
store float* %57, float** %18
%58 = load i32, i32* %8
%59 = sext i32 %58 to i64
%60 = mul i64 %59, 4
%61 = trunc i64 %60 to i32
%62 = call float* @malloc(i32 %61)
store float* %62, float** %19
store i32 0, i32* %10
br label %63
63: ; preds = %143, %3
%64 = load i32, i32* %10
%65 = sitofp i32 %64 to float
%66 = load float, float* %12
%67 = fcmp olt float %65, %66
br i1 %67, label %68, label %146
68: ; preds = %63
%69 = load float, float* %4
%70 = load float*, float** %18
%71 = getelementptr inbounds float, float* %70, i64 0
store float %69, float* %71
%72 = load float*, float** %19
%73 = getelementptr inbounds float, float* %72, i64 0
store float 0.000000e+00, float* %73
%74 = load float, float* %4
store float %74, float* %14
store float 0.000000e+00, float* %13
store i32 1, i32* %9
br label %75
75: ; preds = %100, %68
%76 = load i32, i32* %9
%77 = load i32, i32* %8
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %103
79: ; preds = %75
%80 = load float, float* %6
%81 = load float, float* %13
%82 = fadd float %81, %80
store float %82, float* %13
%83 = load float, float* %14
%84 = load float, float* %5
%85 = load float, float* %6
%86 = call float @delta_n_step(float %83, float %84, float %85)
store float %86, float* %20
%87 = load float, float* %20
%88 = load float, float* %14
%89 = fadd float %88, %87
store float %89, float* %14
%90 = load float, float* %14
%91 = load float*, float** %18
%92 = load i32, i32* %9
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %91, i64 %93
store float %90, float* %94
%95 = load float, float* %13
%96 = load float*, float** %19
%97 = load i32, i32* %9
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %96, i64 %98
store float %95, float* %99
br label %100
100: ; preds = %79
%101 = load i32, i32* %9
%102 = add nsw i32 %101, 1
store i32 %102, i32* %9
br label %75
103: ; preds = %75
store i32 1, i32* %9
br label %104
104: ; preds = %139, %103
%105 = load i32, i32* %9
%106 = load i32, i32* %8
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %142
108: ; preds = %104
%109 = load float*, float** %15
%110 = load i32, i32* %9
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = load float, float* %112
%114 = load float*, float** %18
%115 = load i32, i32* %9
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %114, i64 %116
%118 = load float, float* %117
%119 = fadd float %113, %118
%120 = load float*, float** %15
%121 = load i32, i32* %9
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %120, i64 %122
store float %119, float* %123
%124 = load float*, float** %16
%125 = load i32, i32* %9
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %124, i64 %126
%128 = load float, float* %127
%129 = load float*, float** %19
%130 = load i32, i32* %9
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %129, i64 %131
%133 = load float, float* %132
%134 = fadd float %128, %133
%135 = load float*, float** %16
%136 = load i32, i32* %9
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
store float %134, float* %138
br label %139
139: ; preds = %108
%140 = load i32, i32* %9
%141 = add nsw i32 %140, 1
store i32 %141, i32* %9
br label %104
142: ; preds = %104
br label %143
143: ; preds = %142
%144 = load i32, i32* %10
%145 = add nsw i32 %144, 1
store i32 %145, i32* %10
br label %63
146: ; preds = %63
store i32 1, i32* %11
br label %147
147: ; preds = %186, %146
%148 = load i32, i32* %11
%149 = load i32, i32* %8
%150 = icmp slt i32 %148, %149
br i1 %150, label %151, label %189
151: ; preds = %147
%152 = load float*, float** %15
%153 = load i32, i32* %11
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = load float, float* %12
%158 = fdiv float %156, %157
%159 = load float*, float** %15
%160 = load i32, i32* %11
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float, float* %159, i64 %161
store float %158, float* %162
%163 = load float*, float** %16
%164 = load i32, i32* %11
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %163, i64 %165
%167 = load float, float* %166
%168 = load float, float* %12
%169 = fdiv float %167, %168
%170 = load float*, float** %16
%171 = load i32, i32* %11
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %170, i64 %172
store float %169, float* %173
%174 = load i32*, i32** %17
%175 = load float*, float** %16
%176 = load i32, i32* %11
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %175, i64 %177
%179 = load float, float* %178
%180 = load float*, float** %15
%181 = load i32, i32* %11
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
%184 = load float, float* %183
%185 = call i32 @fprintf(i32* %174, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), float %179, float %184)
br label %186
186: ; preds = %151
%187 = load i32, i32* %11
%188 = add nsw i32 %187, 1
store i32 %188, i32* %11
br label %147
189: ; preds = %147
%190 = load i32*, i32** %17
%191 = call i32 @fclose(i32* %190)
ret void
}

LLVM IR (-O2):
@.str = [22 x i8] c"data_rand_average.txt\00"
@.str.1 = [3 x i8] c"w+\00"
@.str.2 = [7 x i8] c"%f %f\0A\00"
define void @single_decay(float %0, float %1, float %2) {
%4 = fdiv float 5.000000e+00, %1
%5 = fptosi float %4 to i32
%6 = sitofp i32 %5 to float
%7 = fdiv float %6, %2
%8 = fptosi float %7 to i32
%9 = shl i32 %8, 2
%10 = tail call float* @malloc(i32 %9)
%11 = tail call float* @malloc(i32 %9)
%12 = tail call i32* @fopen(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%13 = tail call i32 @fprintf(i32* %12, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), float 0.000000e+00, float %0)
store float %0, float* %10
store float 0.000000e+00, float* %11
%14 = tail call float* @malloc(i32 %9)
%15 = tail call float* @malloc(i32 %9)
%16 = icmp sgt i32 %8, 1
%17 = zext i32 %8 to i64
%18 = zext i32 %8 to i64
%19 = add nsw i64 %17, -1
%20 = add nsw i64 %17, -5
%21 = lshr i64 %20, 2
%22 = add nuw nsw i64 %21, 1
%23 = icmp ult i64 %19, 4
%24 = and i64 %19, -4
%25 = or i64 %24, 1
%26 = and i64 %22, 1
%27 = icmp ult i64 %20, 4
%28 = and i64 %22, 9223372036854775806
%29 = icmp eq i64 %26, 0
%30 = icmp eq i64 %19, %24
br label %34
31: ; preds = %127
br i1 %16, label %32, label %146
32: ; preds = %31
%33 = zext i32 %8 to i64
br label %135
34: ; preds = %130, %3
%35 = phi i32 [ 0, %3 ], [ %131, %130 ]
store float %0, float* %14
store float 0.000000e+00, float* %15
br i1 %16, label %102, label %132
36: ; preds = %102
br i1 %16, label %37, label %132
37: ; preds = %36
br i1 %23, label %100, label %38
38: ; preds = %37
br i1 %27, label %79, label %39
39: ; preds = %38, %39
%40 = phi i64 [ %76, %39 ], [ 0, %38 ]
%41 = phi i64 [ %77, %39 ], [ 0, %38 ]
%42 = or i64 %40, 1
%43 = getelementptr inbounds float, float* %10, i64 %42
%44 = bitcast float* %43 to <4 x float>*
%45 = load <4 x float>, <4 x float>* %44
%46 = getelementptr inbounds float, float* %14, i64 %42
%47 = bitcast float* %46 to <4 x float>*
%48 = load <4 x float>, <4 x float>* %47
%49 = fadd <4 x float> %45, %48
%50 = bitcast float* %43 to <4 x float>*
store <4 x float> %49, <4 x float>* %50
%51 = getelementptr inbounds float, float* %11, i64 %42
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = getelementptr inbounds float, float* %15, i64 %42
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = fadd <4 x float> %53, %56
%58 = bitcast float* %51 to <4 x float>*
store <4 x float> %57, <4 x float>* %58
%59 = or i64 %40, 5
%60 = getelementptr inbounds float, float* %10, i64 %59
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = getelementptr inbounds float, float* %14, i64 %59
%64 = bitcast float* %63 to <4 x float>*
%65 = load <4 x float>, <4 x float>* %64
%66 = fadd <4 x float> %62, %65
%67 = bitcast float* %60 to <4 x float>*
store <4 x float> %66, <4 x float>* %67
%68 = getelementptr inbounds float, float* %11, i64 %59
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = getelementptr inbounds float, float* %15, i64 %59
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = fadd <4 x float> %70, %73
%75 = bitcast float* %68 to <4 x float>*
store <4 x float> %74, <4 x float>* %75
%76 = add nuw i64 %40, 8
%77 = add i64 %41, 2
%78 = icmp eq i64 %77, %28
br i1 %78, label %79, label %39
79: ; preds = %39, %38
%80 = phi i64 [ 0, %38 ], [ %76, %39 ]
br i1 %29, label %99, label %81
81: ; preds = %79
%82 = or i64 %80, 1
%83 = getelementptr inbounds float, float* %10, i64 %82
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = getelementptr inbounds float, float* %14, i64 %82
%87 = bitcast float* %86 to <4 x float>*
%88 = load <4 x float>, <4 x float>* %87
%89 = fadd <4 x float> %85, %88
%90 = bitcast float* %83 to <4 x float>*
store <4 x float> %89, <4 x float>* %90
%91 = getelementptr inbounds float, float* %11, i64 %82
%92 = bitcast float* %91 to <4 x float>*
%93 = load <4 x float>, <4 x float>* %92
%94 = getelementptr inbounds float, float* %15, i64 %82
%95 = bitcast float* %94 to <4 x float>*
%96 = load <4 x float>, <4 x float>* %95
%97 = fadd <4 x float> %93, %96
%98 = bitcast float* %91 to <4 x float>*
store <4 x float> %97, <4 x float>* %98
br label %99
99: ; preds = %79, %81
br i1 %30, label %127, label %100
100: ; preds = %37, %99
%101 = phi i64 [ 1, %37 ], [ %25, %99 ]
br label %113
102: ; preds = %34, %102
%103 = phi i64 [ %111, %102 ], [ 1, %34 ]
%104 = phi float [ %106, %102 ], [ 0.000000e+00, %34 ]
%105 = phi float [ %108, %102 ], [ %0, %34 ]
%106 = fadd float %104, %2
%107 = tail call float @delta_n_step(float %105, float %1, float %2)
%108 = fadd float %105, %107
%109 = getelementptr inbounds float, float* %14, i64 %103
store float %108, float* %109
%110 = getelementptr inbounds float, float* %15, i64 %103
store float %106, float* %110
%111 = add nuw nsw i64 %103, 1
%112 = icmp eq i64 %111, %17
br i1 %112, label %36, label %102
113: ; preds = %100, %113
%114 = phi i64 [ %125, %113 ], [ %101, %100 ]
%115 = getelementptr inbounds float, float* %10, i64 %114
%116 = load float, float* %115
%117 = getelementptr inbounds float, float* %14, i64 %114
%118 = load float, float* %117
%119 = fadd float %116, %118
store float %119, float* %115
%120 = getelementptr inbounds float, float* %11, i64 %114
%121 = load float, float* %120
%122 = getelementptr inbounds float, float* %15, i64 %114
%123 = load float, float* %122
%124 = fadd float %121, %123
store float %124, float* %120
%125 = add nuw nsw i64 %114, 1
%126 = icmp eq i64 %125, %18
br i1 %126, label %127, label %113
127: ; preds = %113, %99
%128 = add nuw nsw i32 %35, 1
%129 = icmp eq i32 %128, 5
br i1 %129, label %31, label %130
130: ; preds = %127, %132
%131 = phi i32 [ %128, %127 ], [ %133, %132 ]
br label %34
132: ; preds = %34, %36
%133 = add nuw nsw i32 %35, 1
%134 = icmp eq i32 %133, 5
br i1 %134, label %146, label %130
135: ; preds = %32, %135
%136 = phi i64 [ 1, %32 ], [ %144, %135 ]
%137 = getelementptr inbounds float, float* %10, i64 %136
%138 = load float, float* %137
%139 = fdiv float %138, 5.000000e+00
store float %139, float* %137
%140 = getelementptr inbounds float, float* %11, i64 %136
%141 = load float, float* %140
%142 = fdiv float %141, 5.000000e+00
store float %142, float* %140
%143 = tail call i32 @fprintf(i32* %12, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), float %142, float %139)
%144 = add nuw nsw i64 %136, 1
%145 = icmp eq i64 %144, %33
br i1 %145, label %146, label %135
146: ; preds = %132, %135, %31
%147 = tail call i32 @fclose(i32* %12)
ret void
}