int regulateAsync(int conc_count, double concs[conc_count], int rows, int cols,
                  double weights[rows][cols], int tf_count,
                  int tf_genes[tf_count], int p_count, int p_genes[p_count],
                  int delta, double e_total) {
  double updates[rows];
  double gene_count = rows - p_count;
  double signal;
  int below_zero = 0;
  int debug = 0;
  for (int i = 0; i < cols; i++) {
    signal = 0;
    for (int j = 0; j < rows; j++) {
      signal += (concs[j] * weights[j][i]);
    }
    updates[i] = signal / gene_count;
    for (int x = 0; x < tf_count; x++) {
      if (i == tf_genes[x]) {
        concs[tf_genes[x]] += (concs[tf_genes[x]] * updates[i]) * delta;
        if (concs[tf_genes[x]] < 0) {
          below_zero = 1;
        }
        if (concs[tf_genes[x]] < 1e-10) {
          concs[tf_genes[x]] = 1e-10;
        }
      }
    }
    for (int x = 0; x < p_count; x++) {
      if (i == p_genes[x]) {
        concs[p_genes[x]] += delta * updates[i];
        if (concs[p_genes[x]] < 1e-10) {
          concs[p_genes[x]] = 1e-10;
        }
      }
    }
  }
  double tf_total = 0;
  for (int i = 0; i < tf_count; i++) {
    tf_total += concs[tf_genes[i]];
  }
  for (int i = 0; i < tf_count; i++) {
    concs[tf_genes[i]] *= 1 - e_total;
    concs[tf_genes[i]] = concs[tf_genes[i]] / tf_total;
  }
  double p_total = 0;
  for (int i = 0; i < p_count; i++) {
    p_total += concs[p_genes[i]];
  }
  for (int i = 0; i < p_count; i++) {
    concs[p_genes[i]] = concs[p_genes[i]] / p_total;
  }
  return below_zero;
}


x86 assembly (clang, -O0):
<regulateAsync>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    %rcx,-0x98(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x90(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
sub    0x18(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13d5 <regulateAsync+0x2d5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1202 <regulateAsync+0x102>
mov    -0x98(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11a6 <regulateAsync+0xa6>
mov    -0x90(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    130c <regulateAsync+0x20c>
mov    -0x5c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x64(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    12f9 <regulateAsync+0x1f9>
mov    -0x90(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x10(%rbp),%rdx
movslq -0x64(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x5c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl 0x28(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    12b4 <regulateAsync+0x1b4>
movl   $0x1,-0x54(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  0xd3c(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    12f4 <regulateAsync+0x1f4>
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  0xd19(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12f9 <regulateAsync+0x1f9>
jmp    12fe <regulateAsync+0x1fe>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1223 <regulateAsync+0x123>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    13c2 <regulateAsync+0x2c2>
mov    -0x5c(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x68(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    13af <regulateAsync+0x2af>
mov    -0x90(%rbp),%rax
cvtsi2sdl 0x28(%rbp),%xmm0
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  0xc86(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    13aa <regulateAsync+0x2aa>
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  0xc63(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    13af <regulateAsync+0x2af>
jmp    13b4 <regulateAsync+0x2b4>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1313 <regulateAsync+0x213>
jmp    13c7 <regulateAsync+0x2c7>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    118b <regulateAsync+0x8b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    141d <regulateAsync+0x31d>
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x74(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13e4 <regulateAsync+0x2e4>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1494 <regulateAsync+0x394>
movsd  0xbc8(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1424 <regulateAsync+0x324>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    14eb <regulateAsync+0x3eb>
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x84(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    14a6 <regulateAsync+0x3a6>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    154d <regulateAsync+0x44d>
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x88(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x88(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    14f5 <regulateAsync+0x3f5>
mov    -0x54(%rbp),%eax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<regulateAsync>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,-0x38(%rsp)
mov    0x48(%rsp),%r10
mov    0x40(%rsp),%ebp
mov    %r9d,-0x3c(%rsp)
mov    %r9d,%r13d
mov    %ebp,%edi
test   %ecx,%ecx
mov    %rdi,-0x28(%rsp)
jle    1341 <regulateAsync+0x241>
mov    %ecx,%r14d
mov    %edx,%eax
sub    %ebp,%eax
cvtsi2sd %eax,%xmm1
cvtsi2sdl 0x50(%rsp),%xmm2
mov    %edx,%eax
lea    -0x1(%rax),%rcx
mov    %rcx,-0x8(%rsp)
mov    %eax,%r15d
and    $0x3,%r15d
and    $0xfffffffc,%eax
mov    %rax,-0x10(%rsp)
mov    %r14,%rax
shl    $0x4,%rax
mov    %rax,-0x18(%rsp)
mov    %r14,%r11
shl    $0x5,%r11
lea    0x0(,%r14,8),%r12
lea    (%r12,%r12,2),%rax
mov    %rax,-0x20(%rsp)
xor    %r9d,%r9d
xorpd  %xmm3,%xmm3
movsd  0xe73(%rip),%xmm4
xor    %eax,%eax
mov    %edx,-0x2c(%rsp)
movabs $0x3ddb7cdfd9d7bdbb,%rbx
7c db 3d
jmp    11b7 <regulateAsync+0xb7>
nop
add    $0x1,%r9
addq   $0x8,-0x38(%rsp)
cmp    %r14,%r9
mov    -0x2c(%rsp),%edx
je     1343 <regulateAsync+0x243>
xorpd  %xmm5,%xmm5
test   %edx,%edx
jle    128a <regulateAsync+0x18a>
cmpq   $0x3,-0x8(%rsp)
jae    11e0 <regulateAsync+0xe0>
xorpd  %xmm5,%xmm5
xor    %edx,%edx
jmp    124a <regulateAsync+0x14a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm5,%xmm5
mov    -0x38(%rsp),%r8
xor    %edx,%edx
mov    -0x10(%rsp),%rcx
mov    -0x18(%rsp),%rdi
mov    -0x20(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rdx,8),%xmm6
mulsd  (%r8),%xmm6
movsd  0x8(%rsi,%rdx,8),%xmm7
addsd  %xmm5,%xmm6
mulsd  (%r8,%r14,8),%xmm7
addsd  %xmm6,%xmm7
movsd  0x10(%rsi,%rdx,8),%xmm6
mulsd  (%r8,%rdi,1),%xmm6
addsd  %xmm7,%xmm6
movsd  0x18(%rsi,%rdx,8),%xmm5
mulsd  (%r8,%rbp,1),%xmm5
addsd  %xmm6,%xmm5
add    $0x4,%rdx
add    %r11,%r8
cmp    %rdx,%rcx
jne    1200 <regulateAsync+0x100>
test   %r15,%r15
mov    0x48(%rsp),%r10
mov    -0x28(%rsp),%rdi
je     128a <regulateAsync+0x18a>
mov    %r14,%rcx
imul   %rdx,%rcx
mov    -0x38(%rsp),%rbp
lea    0x0(%rbp,%rcx,8),%rbp
lea    (%rsi,%rdx,8),%rdx
xor    %ecx,%ecx
movsd  (%rdx,%rcx,8),%xmm6
mulsd  0x0(%rbp),%xmm6
addsd  %xmm6,%xmm5
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r15
jne    1270 <regulateAsync+0x170>
divsd  %xmm1,%xmm5
cmpl   $0x0,-0x3c(%rsp)
jle    12f0 <regulateAsync+0x1f0>
xor    %edx,%edx
mov    0x38(%rsp),%rbp
jmp    12a9 <regulateAsync+0x1a9>
xchg   %ax,%ax
add    $0x1,%rdx
cmp    %rdx,%r13
je     12f0 <regulateAsync+0x1f0>
mov    0x0(%rbp,%rdx,4),%ecx
cmp    %rcx,%r9
jne    12a0 <regulateAsync+0x1a0>
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm6
movapd %xmm5,%xmm7
mulsd  %xmm6,%xmm7
mulsd  %xmm2,%xmm7
addsd  %xmm6,%xmm7
ucomisd %xmm7,%xmm3
mov    $0x1,%r8d
cmova  %r8d,%eax
movsd  %xmm7,(%rsi,%rcx,8)
ucomisd %xmm7,%xmm4
jbe    12a0 <regulateAsync+0x1a0>
mov    %rbx,(%rsi,%rcx,8)
jmp    12a0 <regulateAsync+0x1a0>
nopl   0x0(%rax)
cmpl   $0x0,0x40(%rsp)
jle    11a0 <regulateAsync+0xa0>
xor    %edx,%edx
jmp    130d <regulateAsync+0x20d>
nop
add    $0x1,%rdx
cmp    %rdx,%rdi
je     11a0 <regulateAsync+0xa0>
mov    (%r10,%rdx,4),%ecx
cmp    %rcx,%r9
jne    1300 <regulateAsync+0x200>
movslq %ecx,%rcx
movapd %xmm2,%xmm6
mulsd  %xmm5,%xmm6
addsd  (%rsi,%rcx,8),%xmm6
movsd  %xmm6,(%rsi,%rcx,8)
ucomisd %xmm6,%xmm4
jbe    1300 <regulateAsync+0x200>
movabs $0x3ddb7cdfd9d7bdbb,%rbp
7c db 3d
mov    %rbp,(%rsi,%rcx,8)
jmp    1300 <regulateAsync+0x200>
xor    %eax,%eax
mov    %eax,%r9d
cmpl   $0x0,-0x3c(%rsp)
jle    144e <regulateAsync+0x34e>
lea    -0x1(%r13),%r8
mov    %r13d,%edx
and    $0x3,%edx
cmp    $0x3,%r8
jae    1369 <regulateAsync+0x269>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
jmp    13b0 <regulateAsync+0x2b0>
mov    %r13d,%ebp
and    $0xfffffffc,%ebp
xorpd  %xmm1,%xmm1
xor    %edi,%edi
mov    0x38(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movslq (%rax,%rdi,4),%rcx
addsd  (%rsi,%rcx,8),%xmm1
movslq 0x4(%rax,%rdi,4),%rcx
addsd  (%rsi,%rcx,8),%xmm1
movslq 0x8(%rax,%rdi,4),%rcx
addsd  (%rsi,%rcx,8),%xmm1
movslq 0xc(%rax,%rdi,4),%rcx
addsd  (%rsi,%rcx,8),%xmm1
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1380 <regulateAsync+0x280>
test   %rdx,%rdx
je     13d2 <regulateAsync+0x2d2>
mov    0x38(%rsp),%rax
lea    (%rax,%rdi,4),%rdi
xor    %ebp,%ebp
movslq (%rdi,%rbp,4),%rcx
addsd  (%rsi,%rcx,8),%xmm1
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    13c0 <regulateAsync+0x2c0>
cmpl   $0x0,-0x3c(%rsp)
mov    0x38(%rsp),%rax
jle    144e <regulateAsync+0x34e>
movsd  0xc22(%rip),%xmm2
subsd  %xmm0,%xmm2
test   %r8,%r8
je     1554 <regulateAsync+0x454>
mov    %r13d,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movslq (%rax,%rcx,4),%rdi
movsd  (%rsi,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movslq 0x4(%rax,%rcx,4),%rdi
movsd  (%rsi,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1400 <regulateAsync+0x300>
test   $0x1,%r13b
je     144e <regulateAsync+0x34e>
movslq (%rax,%rcx,4),%rcx
mulsd  (%rsi,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rcx,8)
cmpl   $0x0,0x40(%rsp)
mov    0x48(%rsp),%rax
mov    -0x28(%rsp),%r8
jle    1546 <regulateAsync+0x446>
lea    -0x1(%r8),%rcx
mov    %r8d,%edx
and    $0x3,%edx
cmp    $0x3,%rcx
jae    147b <regulateAsync+0x37b>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    14c0 <regulateAsync+0x3c0>
mov    %r8d,%ebp
and    $0xfffffffc,%ebp
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movslq (%rax,%rdi,4),%rbx
addsd  (%rsi,%rbx,8),%xmm0
movslq 0x4(%rax,%rdi,4),%rbx
addsd  (%rsi,%rbx,8),%xmm0
movslq 0x8(%rax,%rdi,4),%rbx
addsd  (%rsi,%rbx,8),%xmm0
movslq 0xc(%rax,%rdi,4),%rbx
addsd  (%rsi,%rbx,8),%xmm0
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1490 <regulateAsync+0x390>
test   %rdx,%rdx
je     14e2 <regulateAsync+0x3e2>
lea    (%rax,%rdi,4),%rdi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movslq (%rdi,%rbp,4),%rbx
addsd  (%rsi,%rbx,8),%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    14d0 <regulateAsync+0x3d0>
cmpl   $0x0,0x40(%rsp)
jle    1546 <regulateAsync+0x446>
test   %rcx,%rcx
je     1565 <regulateAsync+0x465>
mov    %r8d,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movslq (%rax,%rcx,4),%rdi
movsd  (%rsi,%rdi,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
movslq 0x4(%rax,%rcx,4),%rdi
movsd  (%rsi,%rdi,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1500 <regulateAsync+0x400>
test   $0x1,%r8b
je     1546 <regulateAsync+0x446>
movslq (%rax,%rcx,4),%rcx
movsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
mov    %r9d,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%r13b
jne    143c <regulateAsync+0x33c>
jmp    144e <regulateAsync+0x34e>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1534 <regulateAsync+0x434>
jmp    1546 <regulateAsync+0x446>

LLVM IR (-O0):
define i32 @regulateAsync(i32 %0, double* %1, i32 %2, i32 %3, double* %4, i32 %5, i32* %6, i32 %7, i32* %8, i32 %9, double %10) {
%12 = alloca i32
%13 = alloca double*
%14 = alloca i32
%15 = alloca i32
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32*
%19 = alloca i32
%20 = alloca i32*
%21 = alloca i32
%22 = alloca double
%23 = alloca i8*
%24 = alloca i64
%25 = alloca double
%26 = alloca double
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca double
%34 = alloca i32
%35 = alloca i32
%36 = alloca double
%37 = alloca i32
%38 = alloca i32
store i32 %0, i32* %12
store double* %1, double** %13
store i32 %2, i32* %14
store i32 %3, i32* %15
store double* %4, double** %16
store i32 %5, i32* %17
store i32* %6, i32** %18
store i32 %7, i32* %19
store i32* %8, i32** %20
store i32 %9, i32* %21
store double %10, double* %22
%39 = load i32, i32* %12
%40 = zext i32 %39 to i64
%41 = load i32, i32* %14
%42 = zext i32 %41 to i64
%43 = load i32, i32* %15
%44 = zext i32 %43 to i64
%45 = load i32, i32* %17
%46 = zext i32 %45 to i64
%47 = load i32, i32* %19
%48 = zext i32 %47 to i64
%49 = load i32, i32* %14
%50 = zext i32 %49 to i64
%51 = call i8* @llvm.stacksave()
store i8* %51, i8** %23
%52 = alloca double, i64 %50
store i64 %50, i64* %24
%53 = load i32, i32* %14
%54 = load i32, i32* %19
%55 = sub nsw i32 %53, %54
%56 = sitofp i32 %55 to double
store double %56, double* %25
store i32 0, i32* %27
store i32 0, i32* %28
store i32 0, i32* %29
br label %57
57: ; preds = %223, %11
%58 = load i32, i32* %29
%59 = load i32, i32* %15
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %226
61: ; preds = %57
store double 0.000000e+00, double* %26
store i32 0, i32* %30
br label %62
62: ; preds = %83, %61
%63 = load i32, i32* %30
%64 = load i32, i32* %14
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %86
66: ; preds = %62
%67 = load double*, double** %13
%68 = load i32, i32* %30
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %67, i64 %69
%71 = load double, double* %70
%72 = load double*, double** %16
%73 = load i32, i32* %30
%74 = sext i32 %73 to i64
%75 = mul nsw i64 %74, %44
%76 = getelementptr inbounds double, double* %72, i64 %75
%77 = load i32, i32* %29
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %76, i64 %78
%80 = load double, double* %79
%81 = load double, double* %26
%82 = call double @llvm.fmuladd.f64(double %71, double %80, double %81)
store double %82, double* %26
br label %83
83: ; preds = %66
%84 = load i32, i32* %30
%85 = add nsw i32 %84, 1
store i32 %85, i32* %30
br label %62
86: ; preds = %62
%87 = load double, double* %26
%88 = load double, double* %25
%89 = fdiv double %87, %88
%90 = load i32, i32* %29
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %52, i64 %91
store double %89, double* %92
store i32 0, i32* %31
br label %93
93: ; preds = %165, %86
%94 = load i32, i32* %31
%95 = load i32, i32* %17
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %168
97: ; preds = %93
%98 = load i32, i32* %29
%99 = load i32*, i32** %18
%100 = load i32, i32* %31
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %99, i64 %101
%103 = load i32, i32* %102
%104 = icmp eq i32 %98, %103
br i1 %104, label %105, label %164
105: ; preds = %97
%106 = load double*, double** %13
%107 = load i32*, i32** %18
%108 = load i32, i32* %31
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %107, i64 %109
%111 = load i32, i32* %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %106, i64 %112
%114 = load double, double* %113
%115 = load i32, i32* %29
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %52, i64 %116
%118 = load double, double* %117
%119 = fmul double %114, %118
%120 = load i32, i32* %21
%121 = sitofp i32 %120 to double
%122 = load double*, double** %13
%123 = load i32*, i32** %18
%124 = load i32, i32* %31
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %123, i64 %125
%127 = load i32, i32* %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %122, i64 %128
%130 = load double, double* %129
%131 = call double @llvm.fmuladd.f64(double %119, double %121, double %130)
store double %131, double* %129
%132 = load double*, double** %13
%133 = load i32*, i32** %18
%134 = load i32, i32* %31
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %133, i64 %135
%137 = load i32, i32* %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %132, i64 %138
%140 = load double, double* %139
%141 = fcmp olt double %140, 0.000000e+00
br i1 %141, label %142, label %143
142: ; preds = %105
store i32 1, i32* %27
br label %143
143: ; preds = %142, %105
%144 = load double*, double** %13
%145 = load i32*, i32** %18
%146 = load i32, i32* %31
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
%149 = load i32, i32* %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %144, i64 %150
%152 = load double, double* %151
%153 = fcmp olt double %152, 1.000000e-10
br i1 %153, label %154, label %163
154: ; preds = %143
%155 = load double*, double** %13
%156 = load i32*, i32** %18
%157 = load i32, i32* %31
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %156, i64 %158
%160 = load i32, i32* %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %155, i64 %161
store double 1.000000e-10, double* %162
br label %163
163: ; preds = %154, %143
br label %164
164: ; preds = %163, %97
br label %165
165: ; preds = %164
%166 = load i32, i32* %31
%167 = add nsw i32 %166, 1
store i32 %167, i32* %31
br label %93
168: ; preds = %93
store i32 0, i32* %32
br label %169
169: ; preds = %219, %168
%170 = load i32, i32* %32
%171 = load i32, i32* %19
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %222
173: ; preds = %169
%174 = load i32, i32* %29
%175 = load i32*, i32** %20
%176 = load i32, i32* %32
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i32, i32* %175, i64 %177
%179 = load i32, i32* %178
%180 = icmp eq i32 %174, %179
br i1 %180, label %181, label %218
181: ; preds = %173
%182 = load i32, i32* %21
%183 = sitofp i32 %182 to double
%184 = load i32, i32* %29
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %52, i64 %185
%187 = load double, double* %186
%188 = load double*, double** %13
%189 = load i32*, i32** %20
%190 = load i32, i32* %32
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %189, i64 %191
%193 = load i32, i32* %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %188, i64 %194
%196 = load double, double* %195
%197 = call double @llvm.fmuladd.f64(double %183, double %187, double %196)
store double %197, double* %195
%198 = load double*, double** %13
%199 = load i32*, i32** %20
%200 = load i32, i32* %32
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i32, i32* %199, i64 %201
%203 = load i32, i32* %202
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double, double* %198, i64 %204
%206 = load double, double* %205
%207 = fcmp olt double %206, 1.000000e-10
br i1 %207, label %208, label %217
208: ; preds = %181
%209 = load double*, double** %13
%210 = load i32*, i32** %20
%211 = load i32, i32* %32
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i32, i32* %210, i64 %212
%214 = load i32, i32* %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %209, i64 %215
store double 1.000000e-10, double* %216
br label %217
217: ; preds = %208, %181
br label %218
218: ; preds = %217, %173
br label %219
219: ; preds = %218
%220 = load i32, i32* %32
%221 = add nsw i32 %220, 1
store i32 %221, i32* %32
br label %169
222: ; preds = %169
br label %223
223: ; preds = %222
%224 = load i32, i32* %29
%225 = add nsw i32 %224, 1
store i32 %225, i32* %29
br label %57
226: ; preds = %57
store double 0.000000e+00, double* %33
store i32 0, i32* %34
br label %227
227: ; preds = %243, %226
%228 = load i32, i32* %34
%229 = load i32, i32* %17
%230 = icmp slt i32 %228, %229
br i1 %230, label %231, label %246
231: ; preds = %227
%232 = load double*, double** %13
%233 = load i32*, i32** %18
%234 = load i32, i32* %34
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %233, i64 %235
%237 = load i32, i32* %236
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %232, i64 %238
%240 = load double, double* %239
%241 = load double, double* %33
%242 = fadd double %241, %240
store double %242, double* %33
br label %243
243: ; preds = %231
%244 = load i32, i32* %34
%245 = add nsw i32 %244, 1
store i32 %245, i32* %34
br label %227
246: ; preds = %227
store i32 0, i32* %35
br label %247
247: ; preds = %283, %246
%248 = load i32, i32* %35
%249 = load i32, i32* %17
%250 = icmp slt i32 %248, %249
br i1 %250, label %251, label %286
251: ; preds = %247
%252 = load double, double* %22
%253 = fsub double 1.000000e+00, %252
%254 = load double*, double** %13
%255 = load i32*, i32** %18
%256 = load i32, i32* %35
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i32, i32* %255, i64 %257
%259 = load i32, i32* %258
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %254, i64 %260
%262 = load double, double* %261
%263 = fmul double %262, %253
store double %263, double* %261
%264 = load double*, double** %13
%265 = load i32*, i32** %18
%266 = load i32, i32* %35
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %265, i64 %267
%269 = load i32, i32* %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %264, i64 %270
%272 = load double, double* %271
%273 = load double, double* %33
%274 = fdiv double %272, %273
%275 = load double*, double** %13
%276 = load i32*, i32** %18
%277 = load i32, i32* %35
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %276, i64 %278
%280 = load i32, i32* %279
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds double, double* %275, i64 %281
store double %274, double* %282
br label %283
283: ; preds = %251
%284 = load i32, i32* %35
%285 = add nsw i32 %284, 1
store i32 %285, i32* %35
br label %247
286: ; preds = %247
store double 0.000000e+00, double* %36
store i32 0, i32* %37
br label %287
287: ; preds = %303, %286
%288 = load i32, i32* %37
%289 = load i32, i32* %19
%290 = icmp slt i32 %288, %289
br i1 %290, label %291, label %306
291: ; preds = %287
%292 = load double*, double** %13
%293 = load i32*, i32** %20
%294 = load i32, i32* %37
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i32, i32* %293, i64 %295
%297 = load i32, i32* %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %292, i64 %298
%300 = load double, double* %299
%301 = load double, double* %36
%302 = fadd double %301, %300
store double %302, double* %36
br label %303
303: ; preds = %291
%304 = load i32, i32* %37
%305 = add nsw i32 %304, 1
store i32 %305, i32* %37
br label %287
306: ; preds = %287
store i32 0, i32* %38
br label %307
307: ; preds = %331, %306
%308 = load i32, i32* %38
%309 = load i32, i32* %19
%310 = icmp slt i32 %308, %309
br i1 %310, label %311, label %334
311: ; preds = %307
%312 = load double*, double** %13
%313 = load i32*, i32** %20
%314 = load i32, i32* %38
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i32, i32* %313, i64 %315
%317 = load i32, i32* %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %312, i64 %318
%320 = load double, double* %319
%321 = load double, double* %36
%322 = fdiv double %320, %321
%323 = load double*, double** %13
%324 = load i32*, i32** %20
%325 = load i32, i32* %38
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %324, i64 %326
%328 = load i32, i32* %327
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %323, i64 %329
store double %322, double* %330
br label %331
331: ; preds = %311
%332 = load i32, i32* %38
%333 = add nsw i32 %332, 1
store i32 %333, i32* %38
br label %307
334: ; preds = %307
%335 = load i32, i32* %27
%336 = load i8*, i8** %23
ret i32 %335
}

LLVM IR (-O2):
define i32 @regulateAsync(i32 %0, double* nocapture %1, i32 %2, i32 %3, double* nocapture %4, i32 %5, i32* nocapture %6, i32 %7, i32* nocapture %8, i32 %9, double %10) {
%12 = zext i32 %3 to i64
%13 = sub nsw i32 %2, %7
%14 = sitofp i32 %13 to double
%15 = icmp sgt i32 %3, 0
br i1 %15, label %16, label %34
16: ; preds = %11
%17 = icmp sgt i32 %2, 0
%18 = icmp sgt i32 %5, 0
%19 = sitofp i32 %9 to double
%20 = icmp sgt i32 %7, 0
%21 = zext i32 %2 to i64
%22 = zext i32 %5 to i64
%23 = zext i32 %7 to i64
%24 = add nsw i64 %21, -1
%25 = and i64 %21, 3
%26 = icmp ult i64 %24, 3
%27 = and i64 %21, 4294967292
%28 = icmp eq i64 %25, 0
br label %29
29: ; preds = %16, %121
%30 = phi i64 [ 0, %16 ], [ %122, %121 ]
%31 = phi i32 [ 0, %16 ], [ %99, %121 ]
br i1 %17, label %32, label %61
32: ; preds = %29
%33 = getelementptr inbounds double, double* %4, i64 %30
br i1 %26, label %44, label %64
34: ; preds = %121, %11
%35 = phi i32 [ 0, %11 ], [ %99, %121 ]
%36 = icmp sgt i32 %5, 0
br i1 %36, label %37, label %211
37: ; preds = %34
%38 = zext i32 %5 to i64
%39 = add nsw i64 %38, -1
%40 = and i64 %38, 3
%41 = icmp ult i64 %39, 3
br i1 %41, label %140, label %42
42: ; preds = %37
%43 = and i64 %38, 4294967292
br label %166
44: ; preds = %64, %32
%45 = phi double [ undef, %32 ], [ %94, %64 ]
%46 = phi i64 [ 0, %32 ], [ %95, %64 ]
%47 = phi double [ 0.000000e+00, %32 ], [ %94, %64 ]
br i1 %28, label %61, label %48
48: ; preds = %44, %48
%49 = phi i64 [ %58, %48 ], [ %46, %44 ]
%50 = phi double [ %57, %48 ], [ %47, %44 ]
%51 = phi i64 [ %59, %48 ], [ 0, %44 ]
%52 = getelementptr inbounds double, double* %1, i64 %49
%53 = load double, double* %52
%54 = mul nuw nsw i64 %49, %12
%55 = getelementptr inbounds double, double* %33, i64 %54
%56 = load double, double* %55
%57 = tail call double @llvm.fmuladd.f64(double %53, double %56, double %50)
%58 = add nuw nsw i64 %49, 1
%59 = add i64 %51, 1
%60 = icmp eq i64 %59, %25
br i1 %60, label %61, label %48
61: ; preds = %44, %48, %29
%62 = phi double [ 0.000000e+00, %29 ], [ %45, %44 ], [ %57, %48 ]
%63 = fdiv double %62, %14
br i1 %18, label %100, label %98
64: ; preds = %32, %64
%65 = phi i64 [ %95, %64 ], [ 0, %32 ]
%66 = phi double [ %94, %64 ], [ 0.000000e+00, %32 ]
%67 = phi i64 [ %96, %64 ], [ 0, %32 ]
%68 = getelementptr inbounds double, double* %1, i64 %65
%69 = load double, double* %68
%70 = mul nuw nsw i64 %65, %12
%71 = getelementptr inbounds double, double* %33, i64 %70
%72 = load double, double* %71
%73 = tail call double @llvm.fmuladd.f64(double %69, double %72, double %66)
%74 = or i64 %65, 1
%75 = getelementptr inbounds double, double* %1, i64 %74
%76 = load double, double* %75
%77 = mul nuw nsw i64 %74, %12
%78 = getelementptr inbounds double, double* %33, i64 %77
%79 = load double, double* %78
%80 = tail call double @llvm.fmuladd.f64(double %76, double %79, double %73)
%81 = or i64 %65, 2
%82 = getelementptr inbounds double, double* %1, i64 %81
%83 = load double, double* %82
%84 = mul nuw nsw i64 %81, %12
%85 = getelementptr inbounds double, double* %33, i64 %84
%86 = load double, double* %85
%87 = tail call double @llvm.fmuladd.f64(double %83, double %86, double %80)
%88 = or i64 %65, 3
%89 = getelementptr inbounds double, double* %1, i64 %88
%90 = load double, double* %89
%91 = mul nuw nsw i64 %88, %12
%92 = getelementptr inbounds double, double* %33, i64 %91
%93 = load double, double* %92
%94 = tail call double @llvm.fmuladd.f64(double %90, double %93, double %87)
%95 = add nuw nsw i64 %65, 4
%96 = add i64 %67, 4
%97 = icmp eq i64 %96, %27
br i1 %97, label %44, label %64
98: ; preds = %117, %61
%99 = phi i32 [ %31, %61 ], [ %118, %117 ]
br i1 %20, label %124, label %121
100: ; preds = %61, %117
%101 = phi i64 [ %119, %117 ], [ 0, %61 ]
%102 = phi i32 [ %118, %117 ], [ %31, %61 ]
%103 = getelementptr inbounds i32, i32* %6, i64 %101
%104 = load i32, i32* %103
%105 = zext i32 %104 to i64
%106 = icmp eq i64 %30, %105
br i1 %106, label %107, label %117
107: ; preds = %100
%108 = sext i32 %104 to i64
%109 = getelementptr inbounds double, double* %1, i64 %108
%110 = load double, double* %109
%111 = fmul double %63, %110
%112 = tail call double @llvm.fmuladd.f64(double %111, double %19, double %110)
store double %112, double* %109
%113 = fcmp olt double %112, 0.000000e+00
%114 = select i1 %113, i32 1, i32 %102
%115 = fcmp olt double %112, 1.000000e-10
br i1 %115, label %116, label %117
116: ; preds = %107
store double 1.000000e-10, double* %109
br label %117
117: ; preds = %100, %116, %107
%118 = phi i32 [ %114, %116 ], [ %114, %107 ], [ %102, %100 ]
%119 = add nuw nsw i64 %101, 1
%120 = icmp eq i64 %119, %22
br i1 %120, label %98, label %100
121: ; preds = %137, %98
%122 = add nuw nsw i64 %30, 1
%123 = icmp eq i64 %122, %12
br i1 %123, label %34, label %29
124: ; preds = %98, %137
%125 = phi i64 [ %138, %137 ], [ 0, %98 ]
%126 = getelementptr inbounds i32, i32* %8, i64 %125
%127 = load i32, i32* %126
%128 = zext i32 %127 to i64
%129 = icmp eq i64 %30, %128
br i1 %129, label %130, label %137
130: ; preds = %124
%131 = sext i32 %127 to i64
%132 = getelementptr inbounds double, double* %1, i64 %131
%133 = load double, double* %132
%134 = tail call double @llvm.fmuladd.f64(double %19, double %63, double %133)
store double %134, double* %132
%135 = fcmp olt double %134, 1.000000e-10
br i1 %135, label %136, label %137
136: ; preds = %130
store double 1.000000e-10, double* %132
br label %137
137: ; preds = %124, %136, %130
%138 = add nuw nsw i64 %125, 1
%139 = icmp eq i64 %138, %23
br i1 %139, label %121, label %124
140: ; preds = %166, %37
%141 = phi double [ undef, %37 ], [ %196, %166 ]
%142 = phi i64 [ 0, %37 ], [ %197, %166 ]
%143 = phi double [ 0.000000e+00, %37 ], [ %196, %166 ]
%144 = icmp eq i64 %40, 0
br i1 %144, label %158, label %145
145: ; preds = %140, %145
%146 = phi i64 [ %155, %145 ], [ %142, %140 ]
%147 = phi double [ %154, %145 ], [ %143, %140 ]
%148 = phi i64 [ %156, %145 ], [ 0, %140 ]
%149 = getelementptr inbounds i32, i32* %6, i64 %146
%150 = load i32, i32* %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %1, i64 %151
%153 = load double, double* %152
%154 = fadd double %147, %153
%155 = add nuw nsw i64 %146, 1
%156 = add i64 %148, 1
%157 = icmp eq i64 %156, %40
br i1 %157, label %158, label %145
158: ; preds = %145, %140
%159 = phi double [ %141, %140 ], [ %154, %145 ]
br i1 %36, label %160, label %211
160: ; preds = %158
%161 = fsub double 1.000000e+00, %10
%162 = and i64 %38, 1
%163 = icmp eq i64 %39, 0
br i1 %163, label %200, label %164
164: ; preds = %160
%165 = and i64 %38, 4294967294
br label %220
166: ; preds = %166, %42
%167 = phi i64 [ 0, %42 ], [ %197, %166 ]
%168 = phi double [ 0.000000e+00, %42 ], [ %196, %166 ]
%169 = phi i64 [ 0, %42 ], [ %198, %166 ]
%170 = getelementptr inbounds i32, i32* %6, i64 %167
%171 = load i32, i32* %170
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %1, i64 %172
%174 = load double, double* %173
%175 = fadd double %168, %174
%176 = or i64 %167, 1
%177 = getelementptr inbounds i32, i32* %6, i64 %176
%178 = load i32, i32* %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %1, i64 %179
%181 = load double, double* %180
%182 = fadd double %175, %181
%183 = or i64 %167, 2
%184 = getelementptr inbounds i32, i32* %6, i64 %183
%185 = load i32, i32* %184
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %1, i64 %186
%188 = load double, double* %187
%189 = fadd double %182, %188
%190 = or i64 %167, 3
%191 = getelementptr inbounds i32, i32* %6, i64 %190
%192 = load i32, i32* %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %1, i64 %193
%195 = load double, double* %194
%196 = fadd double %189, %195
%197 = add nuw nsw i64 %167, 4
%198 = add i64 %169, 4
%199 = icmp eq i64 %198, %43
br i1 %199, label %140, label %166
200: ; preds = %220, %160
%201 = phi i64 [ 0, %160 ], [ %238, %220 ]
%202 = icmp eq i64 %162, 0
br i1 %202, label %211, label %203
203: ; preds = %200
%204 = getelementptr inbounds i32, i32* %6, i64 %201
%205 = load i32, i32* %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %1, i64 %206
%208 = load double, double* %207
%209 = fmul double %161, %208
%210 = fdiv double %209, %159
store double %210, double* %207
br label %211
211: ; preds = %203, %200, %34, %158
%212 = icmp sgt i32 %7, 0
br i1 %212, label %213, label %310
213: ; preds = %211
%214 = zext i32 %7 to i64
%215 = add nsw i64 %214, -1
%216 = and i64 %214, 3
%217 = icmp ult i64 %215, 3
br i1 %217, label %241, label %218
218: ; preds = %213
%219 = and i64 %214, 4294967292
br label %266
220: ; preds = %220, %164
%221 = phi i64 [ 0, %164 ], [ %238, %220 ]
%222 = phi i64 [ 0, %164 ], [ %239, %220 ]
%223 = getelementptr inbounds i32, i32* %6, i64 %221
%224 = load i32, i32* %223
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %1, i64 %225
%227 = load double, double* %226
%228 = fmul double %161, %227
%229 = fdiv double %228, %159
store double %229, double* %226
%230 = or i64 %221, 1
%231 = getelementptr inbounds i32, i32* %6, i64 %230
%232 = load i32, i32* %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %1, i64 %233
%235 = load double, double* %234
%236 = fmul double %161, %235
%237 = fdiv double %236, %159
store double %237, double* %234
%238 = add nuw nsw i64 %221, 2
%239 = add i64 %222, 2
%240 = icmp eq i64 %239, %165
br i1 %240, label %200, label %220
241: ; preds = %266, %213
%242 = phi double [ undef, %213 ], [ %296, %266 ]
%243 = phi i64 [ 0, %213 ], [ %297, %266 ]
%244 = phi double [ 0.000000e+00, %213 ], [ %296, %266 ]
%245 = icmp eq i64 %216, 0
br i1 %245, label %259, label %246
246: ; preds = %241, %246
%247 = phi i64 [ %256, %246 ], [ %243, %241 ]
%248 = phi double [ %255, %246 ], [ %244, %241 ]
%249 = phi i64 [ %257, %246 ], [ 0, %241 ]
%250 = getelementptr inbounds i32, i32* %8, i64 %247
%251 = load i32, i32* %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %1, i64 %252
%254 = load double, double* %253
%255 = fadd double %248, %254
%256 = add nuw nsw i64 %247, 1
%257 = add i64 %249, 1
%258 = icmp eq i64 %257, %216
br i1 %258, label %259, label %246
259: ; preds = %246, %241
%260 = phi double [ %242, %241 ], [ %255, %246 ]
br i1 %212, label %261, label %310
261: ; preds = %259
%262 = and i64 %214, 1
%263 = icmp eq i64 %215, 0
br i1 %263, label %300, label %264
264: ; preds = %261
%265 = and i64 %214, 4294967294
br label %311
266: ; preds = %266, %218
%267 = phi i64 [ 0, %218 ], [ %297, %266 ]
%268 = phi double [ 0.000000e+00, %218 ], [ %296, %266 ]
%269 = phi i64 [ 0, %218 ], [ %298, %266 ]
%270 = getelementptr inbounds i32, i32* %8, i64 %267
%271 = load i32, i32* %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %1, i64 %272
%274 = load double, double* %273
%275 = fadd double %268, %274
%276 = or i64 %267, 1
%277 = getelementptr inbounds i32, i32* %8, i64 %276
%278 = load i32, i32* %277
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %1, i64 %279
%281 = load double, double* %280
%282 = fadd double %275, %281
%283 = or i64 %267, 2
%284 = getelementptr inbounds i32, i32* %8, i64 %283
%285 = load i32, i32* %284
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double, double* %1, i64 %286
%288 = load double, double* %287
%289 = fadd double %282, %288
%290 = or i64 %267, 3
%291 = getelementptr inbounds i32, i32* %8, i64 %290
%292 = load i32, i32* %291
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %1, i64 %293
%295 = load double, double* %294
%296 = fadd double %289, %295
%297 = add nuw nsw i64 %267, 4
%298 = add i64 %269, 4
%299 = icmp eq i64 %298, %219
br i1 %299, label %241, label %266
300: ; preds = %311, %261
%301 = phi i64 [ 0, %261 ], [ %327, %311 ]
%302 = icmp eq i64 %262, 0
br i1 %302, label %310, label %303
303: ; preds = %300
%304 = getelementptr inbounds i32, i32* %8, i64 %301
%305 = load i32, i32* %304
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %1, i64 %306
%308 = load double, double* %307
%309 = fdiv double %308, %260
store double %309, double* %307
br label %310
310: ; preds = %303, %300, %211, %259
ret i32 %35
311: ; preds = %311, %264
%312 = phi i64 [ 0, %264 ], [ %327, %311 ]
%313 = phi i64 [ 0, %264 ], [ %328, %311 ]
%314 = getelementptr inbounds i32, i32* %8, i64 %312
%315 = load i32, i32* %314
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %1, i64 %316
%318 = load double, double* %317
%319 = fdiv double %318, %260
store double %319, double* %317
%320 = or i64 %312, 1
%321 = getelementptr inbounds i32, i32* %8, i64 %320
%322 = load i32, i32* %321
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %1, i64 %323
%325 = load double, double* %324
%326 = fdiv double %325, %260
store double %326, double* %324
%327 = add nuw nsw i64 %312, 2
%328 = add i64 %313, 2
%329 = icmp eq i64 %328, %265
br i1 %329, label %300, label %311
}