#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 */
double fabs(double);
scalar_t__ pow(double, int);
double sqrt(double);
double wirth_median(double *, int);
void compute_sigma_clipped_bounds(double data_buffer[], int count,
                                  int use_median, int use_mad_std, int maxiters,
                                  double sigma_lower, double sigma_upper,
                                  double *lower_bound, double *upper_bound,
                                  double mad_buffer[]) {
  double mean, std, median, cen;
  int i, new_count, iteration = 0;
  while (1) {
    if (use_median || use_mad_std) {
      median = wirth_median(data_buffer, count);
    }
    if (!use_median || !use_mad_std) {
      mean = 0;
      for (i = 0; i < count; i++) {
        mean += data_buffer[i];
      }
      mean /= count;
    }
    if (use_median) {
      cen = median;
    } else {
      cen = mean;
    }
    if (use_mad_std) {
      for (i = 0; i < count; i++) {
        mad_buffer[i] = fabs(data_buffer[i] - median);
      }
      std = wirth_median(mad_buffer, count) * 1.482602218505602;
    } else {
      std = 0;
      for (i = 0; i < count; i++) {
        std += pow(mean - data_buffer[i], 2);
      }
      std = sqrt(std / count);
    }
    *lower_bound = cen - sigma_lower * std;
    *upper_bound = cen + sigma_upper * std;
    new_count = 0;
    for (i = 0; i < count; i++) {
      if (data_buffer[i] >= *lower_bound && data_buffer[i] <= *upper_bound) {
        data_buffer[new_count] = data_buffer[i];
        new_count += 1;
      }
    }
    if (new_count == count)
      return;
    count = new_count;
    iteration += 1;
    if (maxiters != -1 && iteration >= maxiters)
      return;
  }
}


x86 assembly (clang, -O0):
<compute_sigma_clipped_bounds>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x0,-0x10(%rbp)
jne    117a <compute_sigma_clipped_bounds+0x4a>
cmpl   $0x0,-0x14(%rbp)
je     118b <compute_sigma_clipped_bounds+0x5b>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <wirth_median@plt>
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     119f <compute_sigma_clipped_bounds+0x6f>
cmpl   $0x0,-0x14(%rbp)
jne    11f2 <compute_sigma_clipped_bounds+0xc2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11df <compute_sigma_clipped_bounds+0xaf>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11ae <compute_sigma_clipped_bounds+0x7e>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     120b <compute_sigma_clipped_bounds+0xdb>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1215 <compute_sigma_clipped_bounds+0xe5>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     128c <compute_sigma_clipped_bounds+0x15c>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    126a <compute_sigma_clipped_bounds+0x13a>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
movaps 0xdc5(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1226 <compute_sigma_clipped_bounds+0xf6>
mov    0x18(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <wirth_median@plt>
movsd  0xd82(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    12f8 <compute_sigma_clipped_bounds+0x1c8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12e0 <compute_sigma_clipped_bounds+0x1b0>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    129b <compute_sigma_clipped_bounds+0x16b>
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13d7 <compute_sigma_clipped_bounds+0x2a7>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
ucomisd (%rax),%xmm0
jb     13c4 <compute_sigma_clipped_bounds+0x294>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     13c4 <compute_sigma_clipped_bounds+0x294>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    13c9 <compute_sigma_clipped_bounds+0x299>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    135b <compute_sigma_clipped_bounds+0x22b>
mov    -0x58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    13e8 <compute_sigma_clipped_bounds+0x2b8>
jmp    1417 <compute_sigma_clipped_bounds+0x2e7>
mov    -0x58(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0xffffffff,-0x18(%rbp)
je     1412 <compute_sigma_clipped_bounds+0x2e2>
mov    -0x5c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jl     1412 <compute_sigma_clipped_bounds+0x2e2>
jmp    1417 <compute_sigma_clipped_bounds+0x2e7>
jmp    1166 <compute_sigma_clipped_bounds+0x36>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_sigma_clipped_bounds>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%r14
movsd  %xmm1,0x58(%rsp)
mov    %r8d,%r13d
mov    %ecx,%r15d
mov    %edx,%r12d
mov    %rdi,%rbp
mov    0xb8(%rsp),%rbx
test   %edx,%edx
setne  %al
test   %ecx,%ecx
setne  %cl
mov    %r15d,%edx
or     %r12d,%edx
mov    %edx,0x3c(%rsp)
and    %al,%cl
mov    %cl,0x7(%rsp)
xorpd  0xe83(%rip),%xmm0
movapd %xmm0,0x60(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
movapd 0xe7e(%rip),%xmm3
movapd 0xe76(%rip),%xmm4
mov    %r8d,0x24(%rsp)
mov    %r15d,0x20(%rsp)
mov    %r12d,0x1c(%rsp)
nopl   0x0(%rax)
cmpl   $0x0,0x3c(%rsp)
mov    %esi,0x18(%rsp)
je     11e7 <compute_sigma_clipped_bounds+0xb7>
mov    %rbp,%rdi
movsd  %xmm2,0x10(%rsp)
call   1030 <wirth_median@plt>
movsd  0x10(%rsp),%xmm2
movapd 0xe39(%rip),%xmm4
movapd 0xe31(%rip),%xmm3
mov    0x18(%rsp),%esi
movapd %xmm0,%xmm5
cmpb   $0x0,0x7(%rsp)
jne    1289 <compute_sigma_clipped_bounds+0x159>
test   %esi,%esi
jle    120f <compute_sigma_clipped_bounds+0xdf>
mov    %esi,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x7,%eax
cmp    $0x7,%rdx
jae    1215 <compute_sigma_clipped_bounds+0xe5>
xorpd  %xmm2,%xmm2
xor    %edx,%edx
jmp    1259 <compute_sigma_clipped_bounds+0x129>
xorpd  %xmm2,%xmm2
jmp    127e <compute_sigma_clipped_bounds+0x14e>
and    $0xfffffff8,%ecx
xorpd  %xmm2,%xmm2
xor    %edx,%edx
xchg   %ax,%ax
addsd  0x0(%rbp,%rdx,8),%xmm2
addsd  0x8(%rbp,%rdx,8),%xmm2
addsd  0x10(%rbp,%rdx,8),%xmm2
addsd  0x18(%rbp,%rdx,8),%xmm2
addsd  0x20(%rbp,%rdx,8),%xmm2
addsd  0x28(%rbp,%rdx,8),%xmm2
addsd  0x30(%rbp,%rdx,8),%xmm2
addsd  0x38(%rbp,%rdx,8),%xmm2
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1220 <compute_sigma_clipped_bounds+0xf0>
test   %rax,%rax
je     127e <compute_sigma_clipped_bounds+0x14e>
lea    0x0(,%rdx,8),%rcx
add    %rbp,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addsd  (%rcx,%rdx,8),%xmm2
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1270 <compute_sigma_clipped_bounds+0x140>
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
divsd  %xmm0,%xmm2
movapd %xmm5,%xmm0
test   %r12d,%r12d
jne    1296 <compute_sigma_clipped_bounds+0x166>
movapd %xmm2,%xmm0
test   %r15d,%r15d
movsd  %xmm2,0x10(%rsp)
movapd %xmm5,0x40(%rsp)
movsd  %xmm0,0x28(%rsp)
je     1350 <compute_sigma_clipped_bounds+0x220>
test   %esi,%esi
jle    15d0 <compute_sigma_clipped_bounds+0x4a0>
mov    %esi,%eax
cmp    $0x4,%esi
jb     12e1 <compute_sigma_clipped_bounds+0x1b1>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    1503 <compute_sigma_clipped_bounds+0x3d3>
lea    (%rbx,%rax,8),%rcx
cmp    %rbp,%rcx
jbe    1503 <compute_sigma_clipped_bounds+0x3d3>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     1304 <compute_sigma_clipped_bounds+0x1d4>
movsd  0x0(%rbp,%rcx,8),%xmm0
subsd  %xmm5,%xmm0
andpd  %xmm4,%xmm0
movlpd %xmm0,(%rbx,%rcx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
je     15d0 <compute_sigma_clipped_bounds+0x4a0>
movsd  0x0(%rbp,%rdx,8),%xmm0
subsd  %xmm5,%xmm0
andpd  %xmm3,%xmm0
movlpd %xmm0,(%rbx,%rdx,8)
movsd  0x8(%rbp,%rdx,8),%xmm0
subsd  %xmm5,%xmm0
andpd  %xmm3,%xmm0
movlpd %xmm0,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1310 <compute_sigma_clipped_bounds+0x1e0>
jmp    15d0 <compute_sigma_clipped_bounds+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nop
test   %esi,%esi
jle    1375 <compute_sigma_clipped_bounds+0x245>
mov    %esi,%r12d
lea    -0x1(%r12),%rax
mov    %r12d,%r15d
and    $0x3,%r15d
cmp    $0x3,%rax
jae    137e <compute_sigma_clipped_bounds+0x24e>
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
jmp    144d <compute_sigma_clipped_bounds+0x31d>
xorpd  %xmm0,%xmm0
jmp    149b <compute_sigma_clipped_bounds+0x36b>
and    $0xfffffffc,%r12d
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
nopl   0x0(%rax)
movsd  %xmm0,0x8(%rsp)
movapd %xmm2,%xmm0
subsd  0x0(%rbp,%r13,8),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
subsd  0x8(%rbp,%r13,8),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
subsd  0x10(%rbp,%r13,8),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
subsd  0x18(%rbp,%r13,8),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
movsd  0x10(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
add    $0x4,%r13
cmp    %r13,%r12
jne    1390 <compute_sigma_clipped_bounds+0x260>
test   %r15,%r15
je     149b <compute_sigma_clipped_bounds+0x36b>
lea    0x0(,%r13,8),%r12
add    %rbp,%r12
xor    %ebx,%ebx
nop
movsd  %xmm0,0x8(%rsp)
movapd %xmm2,%xmm0
subsd  (%r12,%rbx,8),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm2
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1460 <compute_sigma_clipped_bounds+0x330>
mov    0x18(%rsp),%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
ucomisd 0xb76(%rip),%xmm0
jb     14ba <compute_sigma_clipped_bounds+0x38a>
sqrtsd %xmm0,%xmm0
jmp    14c9 <compute_sigma_clipped_bounds+0x399>
call   1050 <sqrt@plt>
movsd  0x10(%rsp),%xmm2
mov    0x18(%rsp),%ecx
mov    0x24(%rsp),%r13d
mov    0x20(%rsp),%r15d
mov    0x1c(%rsp),%r12d
mov    0xb8(%rsp),%rbx
mov    0xb0(%rsp),%rdi
movapd 0xb20(%rip),%xmm3
movapd 0xb18(%rip),%xmm4
movapd 0x40(%rsp),%xmm5
jmp    1608 <compute_sigma_clipped_bounds+0x4d8>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
lea    -0x4(%rcx),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     170f <compute_sigma_clipped_bounds+0x5df>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd 0x10(%rbp,%rdx,8),%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
andpd  %xmm4,%xmm1
andpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rdx,8)
movupd %xmm2,0x10(%rbx,%rdx,8)
movupd 0x20(%rbp,%rdx,8),%xmm1
movupd 0x30(%rbp,%rdx,8),%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
andpd  %xmm4,%xmm1
andpd  %xmm4,%xmm2
movupd %xmm1,0x20(%rbx,%rdx,8)
movupd %xmm2,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1540 <compute_sigma_clipped_bounds+0x410>
test   $0x1,%r8b
je     15c6 <compute_sigma_clipped_bounds+0x496>
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd 0x10(%rbp,%rdx,8),%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
andpd  %xmm4,%xmm1
andpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rdx,8)
movupd %xmm2,0x10(%rbx,%rdx,8)
cmp    %rax,%rcx
jne    12e3 <compute_sigma_clipped_bounds+0x1b3>
nop
mov    %rbx,%rdi
call   1030 <wirth_median@plt>
movsd  0x10(%rsp),%xmm2
movapd 0x40(%rsp),%xmm5
movapd 0xa24(%rip),%xmm4
movapd 0xa1c(%rip),%xmm3
mov    0x18(%rsp),%ecx
mulsd  0xa20(%rip),%xmm0
mov    0xb0(%rsp),%rdi
movsd  0x28(%rsp),%xmm6
movapd 0x60(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,(%r14)
mulsd  0x58(%rsp),%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm0,(%rdi)
xor    %eax,%eax
test   %ecx,%ecx
jg     1670 <compute_sigma_clipped_bounds+0x540>
cmp    %ecx,%eax
je     1720 <compute_sigma_clipped_bounds+0x5f0>
mov    0x30(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x30(%rsp)
mov    %eax,%esi
cmp    $0xffffffff,%r13d
je     11b0 <compute_sigma_clipped_bounds+0x80>
mov    %eax,%esi
cmp    %r13d,0x30(%rsp)
jl     11b0 <compute_sigma_clipped_bounds+0x80>
jmp    1720 <compute_sigma_clipped_bounds+0x5f0>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%r8d
cmp    $0x1,%ecx
jne    16a6 <compute_sigma_clipped_bounds+0x576>
xor    %edx,%edx
xor    %eax,%eax
test   $0x1,%r8b
je     1635 <compute_sigma_clipped_bounds+0x505>
movsd  0x0(%rbp,%rdx,8),%xmm0
ucomisd (%r14),%xmm0
jb     1635 <compute_sigma_clipped_bounds+0x505>
movsd  (%rdi),%xmm1
ucomisd %xmm0,%xmm1
jb     1635 <compute_sigma_clipped_bounds+0x505>
cltq
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%eax
jmp    1635 <compute_sigma_clipped_bounds+0x505>
mov    %r8d,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
xor    %eax,%eax
jmp    16c9 <compute_sigma_clipped_bounds+0x599>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rdx
cmp    %rdx,%rsi
je     167c <compute_sigma_clipped_bounds+0x54c>
movsd  0x0(%rbp,%rdx,8),%xmm0
ucomisd (%r14),%xmm0
jb     16eb <compute_sigma_clipped_bounds+0x5bb>
movsd  (%rdi),%xmm1
ucomisd %xmm0,%xmm1
jb     16eb <compute_sigma_clipped_bounds+0x5bb>
cltq
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%eax
movsd  0x8(%rbp,%rdx,8),%xmm0
ucomisd (%r14),%xmm0
jb     16c0 <compute_sigma_clipped_bounds+0x590>
movsd  (%rdi),%xmm1
ucomisd %xmm0,%xmm1
jb     16c0 <compute_sigma_clipped_bounds+0x590>
cltq
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%eax
jmp    16c0 <compute_sigma_clipped_bounds+0x590>
xor    %edx,%edx
test   $0x1,%r8b
jne    159f <compute_sigma_clipped_bounds+0x46f>
jmp    15c6 <compute_sigma_clipped_bounds+0x496>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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