long quick_pileup_simple(int *ret_poss, float *ret_values, int *start_poss,
                         int *end_poss, long length_poss, float scale_factor,
                         float baseline_value) {
  long i_s, i_e, i, I;
  int p, pre_p, pileup;
  int *ptr_ret_poss;
  int *ptr_start_poss, *ptr_end_poss;
  float *ptr_ret_values;
  long l = length_poss;
  ptr_ret_poss = ret_poss;
  ptr_ret_values = ret_values;
  ptr_start_poss = start_poss;
  ptr_end_poss = end_poss;
  i_s = 0;
  i_e = 0;
  pileup = 0;
  pre_p = ((*ptr_start_poss) > (*ptr_end_poss) ? (*ptr_end_poss)
                                               : (*ptr_start_poss));
  ptr_start_poss++;
  ptr_end_poss++;
  I = 0;
  if (pre_p != 0) {
    *ptr_ret_poss = pre_p;
    *ptr_ret_values = ((0) > (baseline_value) ? (0) : (baseline_value));
    ptr_ret_poss++;
    ptr_ret_values++;
    I++;
  }
  while (i_s < l && i_e < l) {
    if (*ptr_start_poss < *ptr_end_poss) {
      p = *ptr_start_poss;
      if (p != pre_p) {
        *ptr_ret_poss = p;
        *ptr_ret_values = ((pileup * scale_factor) > (baseline_value)
                               ? (pileup * scale_factor)
                               : (baseline_value));
        ptr_ret_poss++;
        ptr_ret_values++;
        I++;
        pre_p = p;
      }
      pileup += 1;
      i_s += 1;
      ptr_start_poss++;
    } else if (*ptr_start_poss > *ptr_end_poss) {
      p = *ptr_end_poss;
      if (p != pre_p) {
        *ptr_ret_poss = p;
        *ptr_ret_values = ((pileup * scale_factor) > (baseline_value)
                               ? (pileup * scale_factor)
                               : (baseline_value));
        ptr_ret_poss++;
        ptr_ret_values++;
        I++;
        pre_p = p;
      }
      pileup -= 1;
      i_e += 1;
      ptr_end_poss++;
    } else {
      i_s += 1;
      i_e += 1;
      ptr_start_poss++;
      ptr_end_poss++;
    }
  }
  if (i_e < l) {
    for (i = i_e; i < l; i++) {
      p = *ptr_end_poss;
      if (p != pre_p) {
        *ptr_ret_poss = p;
        *ptr_ret_values = ((pileup * scale_factor) > (baseline_value)
                               ? (pileup * scale_factor)
                               : (baseline_value));
        ptr_ret_poss++;
        ptr_ret_values++;
        I++;
        pre_p = p;
      }
      pileup -= 1;
      ptr_end_poss++;
    }
  }
  return I;
}


x86 assembly (clang, -O0):
<quick_pileup_simple>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x78(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    -0x78(%rbp),%rcx
cmp    (%rcx),%eax
jle    118b <quick_pileup_simple+0x8b>
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x8c(%rbp)
jmp    1197 <quick_pileup_simple+0x97>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
movq   $0x0,-0x50(%rbp)
cmpl   $0x0,-0x58(%rbp)
je     1231 <quick_pileup_simple+0x131>
mov    -0x58(%rbp),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
xorps  %xmm0,%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    11f0 <quick_pileup_simple+0xf0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
jmp    11fd <quick_pileup_simple+0xfd>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1236 <quick_pileup_simple+0x136>
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x88(%rbp),%rcx
mov    %al,-0x91(%rbp)
jge    1263 <quick_pileup_simple+0x163>
mov    -0x40(%rbp),%rax
cmp    -0x88(%rbp),%rax
setl   %al
mov    %al,-0x91(%rbp)
mov    -0x91(%rbp),%al
test   $0x1,%al
jne    1276 <quick_pileup_simple+0x176>
jmp    1440 <quick_pileup_simple+0x340>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    -0x78(%rbp),%rcx
cmp    (%rcx),%eax
jge    133e <quick_pileup_simple+0x23e>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     1318 <quick_pileup_simple+0x218>
mov    -0x54(%rbp),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    12d1 <quick_pileup_simple+0x1d1>
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    12de <quick_pileup_simple+0x1de>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
jmp    143b <quick_pileup_simple+0x33b>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    -0x78(%rbp),%rcx
cmp    (%rcx),%eax
jle    1406 <quick_pileup_simple+0x306>
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     13e0 <quick_pileup_simple+0x2e0>
mov    -0x54(%rbp),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    1399 <quick_pileup_simple+0x299>
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
jmp    13a6 <quick_pileup_simple+0x2a6>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
jmp    1436 <quick_pileup_simple+0x336>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
jmp    143b <quick_pileup_simple+0x33b>
jmp    1236 <quick_pileup_simple+0x136>
mov    -0x40(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    1525 <quick_pileup_simple+0x425>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x88(%rbp),%rax
jge    1520 <quick_pileup_simple+0x420>
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     14fa <quick_pileup_simple+0x3fa>
mov    -0x54(%rbp),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    14b3 <quick_pileup_simple+0x3b3>
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    14c0 <quick_pileup_simple+0x3c0>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1459 <quick_pileup_simple+0x359>
jmp    1525 <quick_pileup_simple+0x425>
mov    -0x50(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quick_pileup_simple>:
push   %rbp
push   %r14
push   %rbx
mov    (%rdx),%r10d
mov    (%rcx),%eax
cmp    %eax,%r10d
cmovg  %eax,%r10d
test   %r10d,%r10d
je     113a <quick_pileup_simple+0x3a>
mov    %r10d,(%rdi)
xorps  %xmm2,%xmm2
maxss  %xmm1,%xmm2
movss  %xmm2,(%rsi)
add    $0x4,%rdi
add    $0x4,%rsi
mov    $0x1,%eax
test   %r8,%r8
jg     1145 <quick_pileup_simple+0x45>
jmp    1261 <quick_pileup_simple+0x161>
xor    %eax,%eax
test   %r8,%r8
jle    1261 <quick_pileup_simple+0x161>
add    $0x4,%rdx
add    $0x4,%rcx
xor    %r14d,%r14d
xor    %r9d,%r9d
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
mov    (%rdx),%ebx
mov    (%rcx),%ebp
cmp    %ebp,%ebx
jge    11b0 <quick_pileup_simple+0xb0>
cmp    %r10d,%ebx
je     1192 <quick_pileup_simple+0x92>
xorps  %xmm2,%xmm2
cvtsi2ss %r9d,%xmm2
mov    %ebx,(%rdi)
mulss  %xmm0,%xmm2
maxss  %xmm1,%xmm2
movss  %xmm2,(%rsi)
add    $0x4,%rdi
add    $0x4,%rsi
add    $0x1,%rax
mov    %ebx,%r10d
add    $0x1,%r9d
add    $0x1,%r14
add    $0x4,%rdx
cmp    %r8,%r14
jl     1205 <quick_pileup_simple+0x105>
jmp    120e <quick_pileup_simple+0x10e>
cs nopw 0x0(%rax,%rax,1)
nop
jle    11f0 <quick_pileup_simple+0xf0>
cmp    %r10d,%ebp
je     11dc <quick_pileup_simple+0xdc>
xorps  %xmm2,%xmm2
cvtsi2ss %r9d,%xmm2
mov    %ebp,(%rdi)
mulss  %xmm0,%xmm2
maxss  %xmm1,%xmm2
movss  %xmm2,(%rsi)
add    $0x4,%rdi
add    $0x4,%rsi
add    $0x1,%rax
mov    %ebp,%r10d
add    $0xffffffff,%r9d
add    $0x1,%r11
jmp    11fc <quick_pileup_simple+0xfc>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
add    $0x1,%r11
add    $0x4,%rdx
add    $0x4,%rcx
cmp    %r8,%r14
jge    120e <quick_pileup_simple+0x10e>
cmp    %r8,%r11
jl     1160 <quick_pileup_simple+0x60>
cmp    %r8,%r11
jge    1261 <quick_pileup_simple+0x161>
mov    %r8d,%ebx
sub    %r11d,%ebx
mov    %r11,%rdx
not    %rdx
test   $0x1,%bl
je     125c <quick_pileup_simple+0x15c>
mov    (%rcx),%ebx
cmp    %r10d,%ebx
je     1250 <quick_pileup_simple+0x150>
xorps  %xmm2,%xmm2
cvtsi2ss %r9d,%xmm2
mov    %ebx,(%rdi)
mulss  %xmm0,%xmm2
maxss  %xmm1,%xmm2
movss  %xmm2,(%rsi)
add    $0x4,%rdi
add    $0x4,%rsi
add    $0x1,%rax
mov    %ebx,%r10d
add    $0xffffffff,%r9d
add    $0x4,%rcx
add    $0x1,%r11
add    %r8,%rdx
jne    1266 <quick_pileup_simple+0x166>
pop    %rbx
pop    %r14
pop    %rbp
ret
sub    %r11,%r8
xor    %edx,%edx
jmp    12a3 <quick_pileup_simple+0x1a3>
nopl   (%rax)
lea    -0x1(%r9),%ebp
xorps  %xmm2,%xmm2
cvtsi2ss %ebp,%xmm2
mov    %r10d,(%rdi)
mulss  %xmm0,%xmm2
maxss  %xmm1,%xmm2
movss  %xmm2,(%rsi)
add    $0x4,%rdi
add    $0x4,%rsi
add    $0x1,%rax
add    $0xfffffffe,%r9d
add    $0x2,%rdx
cmp    %rdx,%r8
je     1261 <quick_pileup_simple+0x161>
mov    (%rcx,%rdx,4),%ebx
cmp    %r10d,%ebx
jne    12b0 <quick_pileup_simple+0x1b0>
mov    %r10d,%ebx
jmp    12d2 <quick_pileup_simple+0x1d2>
xorps  %xmm2,%xmm2
cvtsi2ss %r9d,%xmm2
mov    %ebx,(%rdi)
mulss  %xmm0,%xmm2
maxss  %xmm1,%xmm2
movss  %xmm2,(%rsi)
add    $0x4,%rdi
add    $0x4,%rsi
add    $0x1,%rax
mov    0x4(%rcx,%rdx,4),%r10d
cmp    %ebx,%r10d
jne    1270 <quick_pileup_simple+0x170>
mov    %ebx,%r10d
jmp    1296 <quick_pileup_simple+0x196>

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

LLVM IR (-O2):
define i64 @quick_pileup_simple(i32* nocapture writeonly %0, float* nocapture writeonly %1, i32* nocapture %2, i32* nocapture %3, i64 %4, float %5, float %6) {
%8 = load i32, i32* %2
%9 = load i32, i32* %3
%10 = icmp sgt i32 %8, %9
%11 = select i1 %10, i32 %9, i32 %8
%12 = getelementptr inbounds i32, i32* %2, i64 1
%13 = getelementptr inbounds i32, i32* %3, i64 1
%14 = icmp eq i32 %11, 0
br i1 %14, label %20, label %15
15: ; preds = %7
store i32 %11, i32* %0
%16 = fcmp olt float %6, 0.000000e+00
%17 = select i1 %16, float 0.000000e+00, float %6
store float %17, float* %1
%18 = getelementptr inbounds i32, i32* %0, i64 1
%19 = getelementptr inbounds float, float* %1, i64 1
br label %20
20: ; preds = %15, %7
%21 = phi i64 [ 1, %15 ], [ 0, %7 ]
%22 = phi i32* [ %18, %15 ], [ %0, %7 ]
%23 = phi float* [ %19, %15 ], [ %1, %7 ]
%24 = icmp sgt i64 %4, 0
br i1 %24, label %25, label %174
25: ; preds = %20, %81
%26 = phi i64 [ %90, %81 ], [ 0, %20 ]
%27 = phi float* [ %89, %81 ], [ %23, %20 ]
%28 = phi i32* [ %88, %81 ], [ %13, %20 ]
%29 = phi i32* [ %87, %81 ], [ %12, %20 ]
%30 = phi i32* [ %86, %81 ], [ %22, %20 ]
%31 = phi i32 [ %85, %81 ], [ 0, %20 ]
%32 = phi i32 [ %84, %81 ], [ %11, %20 ]
%33 = phi i64 [ %83, %81 ], [ %21, %20 ]
%34 = phi i64 [ %82, %81 ], [ 0, %20 ]
%35 = load i32, i32* %29
%36 = load i32, i32* %28
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %56
38: ; preds = %25
%39 = icmp eq i32 %35, %32
br i1 %39, label %48, label %40
40: ; preds = %38
store i32 %35, i32* %30
%41 = sitofp i32 %31 to float
%42 = fmul float %41, %5
%43 = fcmp ogt float %42, %6
%44 = select i1 %43, float %42, float %6
store float %44, float* %27
%45 = getelementptr inbounds i32, i32* %30, i64 1
%46 = getelementptr inbounds float, float* %27, i64 1
%47 = add nsw i64 %33, 1
br label %48
48: ; preds = %40, %38
%49 = phi i64 [ %47, %40 ], [ %33, %38 ]
%50 = phi i32 [ %35, %40 ], [ %32, %38 ]
%51 = phi i32* [ %45, %40 ], [ %30, %38 ]
%52 = phi float* [ %46, %40 ], [ %27, %38 ]
%53 = add nsw i32 %31, 1
%54 = add nsw i64 %26, 1
%55 = getelementptr inbounds i32, i32* %29, i64 1
br label %81
56: ; preds = %25
%57 = icmp sgt i32 %35, %36
br i1 %57, label %58, label %76
58: ; preds = %56
%59 = icmp eq i32 %36, %32
br i1 %59, label %68, label %60
60: ; preds = %58
store i32 %36, i32* %30
%61 = sitofp i32 %31 to float
%62 = fmul float %61, %5
%63 = fcmp ogt float %62, %6
%64 = select i1 %63, float %62, float %6
store float %64, float* %27
%65 = getelementptr inbounds i32, i32* %30, i64 1
%66 = getelementptr inbounds float, float* %27, i64 1
%67 = add nsw i64 %33, 1
br label %68
68: ; preds = %60, %58
%69 = phi i64 [ %67, %60 ], [ %33, %58 ]
%70 = phi i32 [ %36, %60 ], [ %32, %58 ]
%71 = phi i32* [ %65, %60 ], [ %30, %58 ]
%72 = phi float* [ %66, %60 ], [ %27, %58 ]
%73 = add nsw i32 %31, -1
%74 = add nsw i64 %34, 1
%75 = getelementptr inbounds i32, i32* %28, i64 1
br label %81
76: ; preds = %56
%77 = add nsw i64 %26, 1
%78 = add nsw i64 %34, 1
%79 = getelementptr inbounds i32, i32* %29, i64 1
%80 = getelementptr inbounds i32, i32* %28, i64 1
br label %81
81: ; preds = %68, %76, %48
%82 = phi i64 [ %34, %48 ], [ %74, %68 ], [ %78, %76 ]
%83 = phi i64 [ %49, %48 ], [ %69, %68 ], [ %33, %76 ]
%84 = phi i32 [ %50, %48 ], [ %70, %68 ], [ %32, %76 ]
%85 = phi i32 [ %53, %48 ], [ %73, %68 ], [ %31, %76 ]
%86 = phi i32* [ %51, %48 ], [ %71, %68 ], [ %30, %76 ]
%87 = phi i32* [ %55, %48 ], [ %29, %68 ], [ %79, %76 ]
%88 = phi i32* [ %28, %48 ], [ %75, %68 ], [ %80, %76 ]
%89 = phi float* [ %52, %48 ], [ %72, %68 ], [ %27, %76 ]
%90 = phi i64 [ %54, %48 ], [ %26, %68 ], [ %77, %76 ]
%91 = icmp slt i64 %90, %4
%92 = icmp slt i64 %82, %4
%93 = select i1 %91, i1 %92, i1 false
br i1 %93, label %25, label %94
94: ; preds = %81
br i1 %92, label %95, label %174
95: ; preds = %94
%96 = sub i64 %4, %82
%97 = xor i64 %82, -1
%98 = and i64 %96, 1
%99 = icmp eq i64 %98, 0
br i1 %99, label %119, label %100
100: ; preds = %95
%101 = load i32, i32* %88
%102 = icmp eq i32 %101, %84
br i1 %102, label %111, label %103
103: ; preds = %100
store i32 %101, i32* %86
%104 = sitofp i32 %85 to float
%105 = fmul float %104, %5
%106 = fcmp ogt float %105, %6
%107 = select i1 %106, float %105, float %6
store float %107, float* %89
%108 = getelementptr inbounds i32, i32* %86, i64 1
%109 = getelementptr inbounds float, float* %89, i64 1
%110 = add nsw i64 %83, 1
br label %111
111: ; preds = %103, %100
%112 = phi i64 [ %110, %103 ], [ %83, %100 ]
%113 = phi i32 [ %101, %103 ], [ %84, %100 ]
%114 = phi i32* [ %108, %103 ], [ %86, %100 ]
%115 = phi float* [ %109, %103 ], [ %89, %100 ]
%116 = add nsw i32 %85, -1
%117 = getelementptr inbounds i32, i32* %88, i64 1
%118 = add nsw i64 %82, 1
br label %119
119: ; preds = %111, %95
%120 = phi i64 [ undef, %95 ], [ %112, %111 ]
%121 = phi float* [ %89, %95 ], [ %115, %111 ]
%122 = phi i32* [ %88, %95 ], [ %117, %111 ]
%123 = phi i32* [ %86, %95 ], [ %114, %111 ]
%124 = phi i32 [ %85, %95 ], [ %116, %111 ]
%125 = phi i32 [ %84, %95 ], [ %113, %111 ]
%126 = phi i64 [ %83, %95 ], [ %112, %111 ]
%127 = phi i64 [ %82, %95 ], [ %118, %111 ]
%128 = sub i64 0, %4
%129 = icmp eq i64 %97, %128
br i1 %129, label %174, label %130
130: ; preds = %119, %165
%131 = phi float* [ %169, %165 ], [ %121, %119 ]
%132 = phi i32* [ %171, %165 ], [ %122, %119 ]
%133 = phi i32* [ %168, %165 ], [ %123, %119 ]
%134 = phi i32 [ %170, %165 ], [ %124, %119 ]
%135 = phi i32 [ %167, %165 ], [ %125, %119 ]
%136 = phi i64 [ %166, %165 ], [ %126, %119 ]
%137 = phi i64 [ %172, %165 ], [ %127, %119 ]
%138 = load i32, i32* %132
%139 = icmp eq i32 %138, %135
br i1 %139, label %148, label %140
140: ; preds = %130
store i32 %138, i32* %133
%141 = sitofp i32 %134 to float
%142 = fmul float %141, %5
%143 = fcmp ogt float %142, %6
%144 = select i1 %143, float %142, float %6
store float %144, float* %131
%145 = getelementptr inbounds i32, i32* %133, i64 1
%146 = getelementptr inbounds float, float* %131, i64 1
%147 = add nsw i64 %136, 1
br label %148
148: ; preds = %140, %130
%149 = phi i64 [ %147, %140 ], [ %136, %130 ]
%150 = phi i32 [ %138, %140 ], [ %135, %130 ]
%151 = phi i32* [ %145, %140 ], [ %133, %130 ]
%152 = phi float* [ %146, %140 ], [ %131, %130 ]
%153 = getelementptr inbounds i32, i32* %132, i64 1
%154 = load i32, i32* %153
%155 = icmp eq i32 %154, %150
br i1 %155, label %165, label %156
156: ; preds = %148
%157 = add nsw i32 %134, -1
store i32 %154, i32* %151
%158 = sitofp i32 %157 to float
%159 = fmul float %158, %5
%160 = fcmp ogt float %159, %6
%161 = select i1 %160, float %159, float %6
store float %161, float* %152
%162 = getelementptr inbounds i32, i32* %151, i64 1
%163 = getelementptr inbounds float, float* %152, i64 1
%164 = add nsw i64 %149, 1
br label %165
165: ; preds = %156, %148
%166 = phi i64 [ %164, %156 ], [ %149, %148 ]
%167 = phi i32 [ %154, %156 ], [ %150, %148 ]
%168 = phi i32* [ %162, %156 ], [ %151, %148 ]
%169 = phi float* [ %163, %156 ], [ %152, %148 ]
%170 = add nsw i32 %134, -2
%171 = getelementptr inbounds i32, i32* %132, i64 2
%172 = add nsw i64 %137, 2
%173 = icmp eq i64 %172, %4
br i1 %173, label %174, label %130
174: ; preds = %119, %165, %20, %94
%175 = phi i64 [ %83, %94 ], [ %21, %20 ], [ %120, %119 ], [ %166, %165 ]
ret i64 %175
}