#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 */
float RAND_MAX;
scalar_t__ rand();
void detect_noise_spike_creation(int x, int y, int ***spikes,
                                 int **spikes_created, int **stim_matrix,
                                 int t) {
  int sim_sec = t / 20000;
  int window_spikes_left = spikes[x][y][sim_sec] - spikes_created[x][y];
  if ((spikes[x][y][sim_sec] == 0) || (window_spikes_left == 0)) {
    stim_matrix[x][y] = 0;
    return;
  }
  int spike_frame_beginning =
      (sim_sec + (((float)(spikes_created[x][y])) / spikes[x][y][sim_sec])) *
      20000;
  int spike_frame_ending = (sim_sec + (((float)(spikes_created[x][y] + 1)) /
                                       spikes[x][y][sim_sec])) *
                               20000 -
                           1;
  if (t < spike_frame_beginning) {
    stim_matrix[x][y] = 0;
    return;
  }
  if (t >= (spike_frame_ending - 501)) {
    stim_matrix[x][y] = 500;
    spikes_created[x][y]++;
    return;
  }
  float random_number = ((float)rand()) / RAND_MAX;
  float chance_to_get_spike =
      ((float)(t - spike_frame_beginning)) /
      ((float)(spike_frame_ending - 500 - spike_frame_beginning));
  if (random_number < chance_to_get_spike) {
    stim_matrix[x][y] = 500;
    spikes_created[x][y]++;
  } else {
    stim_matrix[x][y] = 0;
  }
  return;
}


x86 assembly (clang, -O0):
<detect_noise_spike_creation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x4e20,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x4(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x8(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1199 <detect_noise_spike_creation+0x89>
cmpl   $0x0,-0x2c(%rbp)
jne    11b5 <detect_noise_spike_creation+0xa5>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    137d <detect_noise_spike_creation+0x26d>
cvtsi2ssl -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  0xe04(%rip),%xmm1
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
cvtsi2ssl -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  0xdad(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0xda5(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x34(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1292 <detect_noise_spike_creation+0x182>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    137d <detect_noise_spike_creation+0x26d>
mov    -0x24(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1f5,%ecx
cmp    %ecx,%eax
jl     12db <detect_noise_spike_creation+0x1cb>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movl   $0x1f4,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    137d <detect_noise_spike_creation+0x26d>
mov    $0x0,%al
call   1030 <rand@plt>
cvtsi2ss %rax,%xmm0
mov    0x2cfa(%rip),%rax
divss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x30(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov    -0x34(%rbp),%eax
sub    $0x1f4,%eax
sub    -0x30(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1361 <detect_noise_spike_creation+0x251>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movl   $0x1f4,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1378 <detect_noise_spike_creation+0x268>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    137d <detect_noise_spike_creation+0x26d>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<detect_noise_spike_creation>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r8,%r15
movslq %r9d,%rax
imul   $0x68db8bad,%rax,%rax
mov    %rax,%rbp
shr    $0x3f,%rbp
sar    $0x2d,%rax
add    %ebp,%eax
movslq %edi,%rbp
mov    (%rdx,%rbp,8),%rdx
movslq %esi,%rbx
mov    (%rdx,%rbx,8),%rsi
movslq %eax,%rdx
mov    (%rsi,%rdx,4),%esi
test   %esi,%esi
je     1185 <detect_noise_spike_creation+0x75>
mov    (%rcx,%rbp,8),%rdi
mov    (%rdi,%rbx,4),%edx
cmp    %edx,%esi
je     1185 <detect_noise_spike_creation+0x75>
mov    %r9d,%r12d
cvtsi2ss %eax,%xmm0
cvtsi2ss %edx,%xmm3
cvtsi2ss %esi,%xmm1
divss  %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  0xe89(%rip),%xmm2
mulss  %xmm2,%xmm3
cvttss2si %xmm3,%r13d
cmp    %r9d,%r13d
jle    119f <detect_noise_spike_creation+0x8f>
mov    (%r15,%rbp,8),%rax
movl   $0x0,(%rax,%rbx,4)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
divss  %xmm1,%xmm3
addss  %xmm0,%xmm3
mulss  %xmm2,%xmm3
addss  0xe47(%rip),%xmm3
cvttss2si %xmm3,%r14d
lea    -0x1f5(%r14),%eax
cmp    %r12d,%eax
jle    123e <detect_noise_spike_creation+0x12e>
mov    %rcx,(%rsp)
xor    %eax,%eax
call   1030 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x2e00(%rip),%rax
sub    %r13d,%r12d
xorps  %xmm1,%xmm1
cvtsi2ss %r12d,%xmm1
sub    %r13d,%r14d
add    $0xfffffe0c,%r14d
xorps  %xmm2,%xmm2
cvtsi2ss %r14d,%xmm2
unpcklps %xmm1,%xmm0
movss  (%rax),%xmm1
unpcklps %xmm2,%xmm1
divps  %xmm1,%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
ucomiss %xmm0,%xmm1
mov    (%r15,%rbp,8),%rax
jbe    1189 <detect_noise_spike_creation+0x79>
movl   $0x1f4,(%rax,%rbx,4)
mov    (%rsp),%rax
mov    (%rax,%rbp,8),%rax
addl   $0x1,(%rax,%rbx,4)
jmp    1190 <detect_noise_spike_creation+0x80>
mov    (%r15,%rbp,8),%rcx
movl   $0x1f4,(%rcx,%rbx,4)
addl   $0x1,(%rdi,%rbx,4)
jmp    1190 <detect_noise_spike_creation+0x80>

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

LLVM IR (-O2):
@RAND_MAX = global float 0.000000e+00
define void @detect_noise_spike_creation(i32 %0, i32 %1, i32*** nocapture %2, i32** nocapture %3, i32** nocapture %4, i32 %5) {
%7 = sdiv i32 %5, 20000
%8 = sext i32 %0 to i64
%9 = getelementptr inbounds i32**, i32*** %2, i64 %8
%10 = load i32**, i32*** %9
%11 = sext i32 %1 to i64
%12 = getelementptr inbounds i32*, i32** %10, i64 %11
%13 = load i32*, i32** %12
%14 = sext i32 %7 to i64
%15 = getelementptr inbounds i32, i32* %13, i64 %14
%16 = load i32, i32* %15
%17 = getelementptr inbounds i32*, i32** %3, i64 %8
%18 = load i32*, i32** %17
%19 = getelementptr inbounds i32, i32* %18, i64 %11
%20 = load i32, i32* %19
%21 = icmp eq i32 %16, 0
%22 = icmp eq i32 %16, %20
%23 = select i1 %21, i1 true, i1 %22
br i1 %23, label %24, label %28
24: ; preds = %6
%25 = getelementptr inbounds i32*, i32** %4, i64 %8
%26 = load i32*, i32** %25
%27 = getelementptr inbounds i32, i32* %26, i64 %11
store i32 0, i32* %27
br label %82
28: ; preds = %6
%29 = sitofp i32 %7 to float
%30 = sitofp i32 %20 to float
%31 = sitofp i32 %16 to float
%32 = fdiv float %30, %31
%33 = fadd float %32, %29
%34 = fmul float %33, 2.000000e+04
%35 = fptosi float %34 to i32
%36 = add nsw i32 %20, 1
%37 = sitofp i32 %36 to float
%38 = fdiv float %37, %31
%39 = fadd float %38, %29
%40 = tail call float @llvm.fmuladd.f32(float %39, float 2.000000e+04, float -1.000000e+00)
%41 = fptosi float %40 to i32
%42 = icmp sgt i32 %35, %5
br i1 %42, label %43, label %47
43: ; preds = %28
%44 = getelementptr inbounds i32*, i32** %4, i64 %8
%45 = load i32*, i32** %44
%46 = getelementptr inbounds i32, i32* %45, i64 %11
store i32 0, i32* %46
br label %82
47: ; preds = %28
%48 = add nsw i32 %41, -501
%49 = icmp sgt i32 %48, %5
br i1 %49, label %56, label %50
50: ; preds = %47
%51 = getelementptr inbounds i32*, i32** %4, i64 %8
%52 = load i32*, i32** %51
%53 = getelementptr inbounds i32, i32* %52, i64 %11
store i32 500, i32* %53
%54 = load i32, i32* %19
%55 = add nsw i32 %54, 1
store i32 %55, i32* %19
br label %82
56: ; preds = %47
%57 = tail call i64 (...) @rand()
%58 = sitofp i64 %57 to float
%59 = load float, float* @RAND_MAX
%60 = sub nsw i32 %5, %35
%61 = sitofp i32 %60 to float
%62 = sub i32 -500, %35
%63 = add i32 %62, %41
%64 = sitofp i32 %63 to float
%65 = insertelement <2 x float> poison, float %58, i64 0
%66 = insertelement <2 x float> %65, float %61, i64 1
%67 = insertelement <2 x float> poison, float %59, i64 0
%68 = insertelement <2 x float> %67, float %64, i64 1
%69 = fdiv <2 x float> %66, %68
%70 = extractelement <2 x float> %69, i64 0
%71 = extractelement <2 x float> %69, i64 1
%72 = fcmp olt float %70, %71
%73 = getelementptr inbounds i32*, i32** %4, i64 %8
%74 = load i32*, i32** %73
%75 = getelementptr inbounds i32, i32* %74, i64 %11
br i1 %72, label %76, label %81
76: ; preds = %56
store i32 500, i32* %75
%77 = load i32*, i32** %17
%78 = getelementptr inbounds i32, i32* %77, i64 %11
%79 = load i32, i32* %78
%80 = add nsw i32 %79, 1
store i32 %80, i32* %78
br label %82
81: ; preds = %56
store i32 0, i32* %75
br label %82
82: ; preds = %43, %50, %81, %76, %24
ret void
}