void form_flat_clusters_from_monotonic_criterion(const double *Z,
                                                 const double *mono_crit,
                                                 int *T, double cutoff, int n) {
  int *curNode;
  int ndid, lid, rid, k, ms, nc;
  unsigned char *lvisited, *rvisited;
  double max_crit;
  const double *Zrow;
  const int bff = (((((double)(n)) / (double)(sizeof(unsigned char) * 8)) ==
                            ((double)(((n)) / ((sizeof(unsigned char) * 8))))
                        ? (((n)) / ((sizeof(unsigned char) * 8)))
                        : (((n)) / ((sizeof(unsigned char) * 8)) + 1)));
  curNode = (int *)malloc(n * sizeof(int));
  lvisited = (unsigned char *)malloc(bff);
  rvisited = (unsigned char *)malloc(bff);
  nc = 0;
  ms = -1;
  k = 0;
  curNode[k] = (n * 2) - 2;
  bzero(lvisited, bff);
  bzero(rvisited, bff);
  ms = -1;
  while (k >= 0) {
    ndid = curNode[k];
    Zrow = Z + ((ndid - n) * 4);
    lid = (int)Zrow[0];
    rid = (int)Zrow[1];
    max_crit = mono_crit[ndid - n];
    ;
    if (ms == -1 && max_crit <= cutoff) {
      ;
      ms = k;
      nc++;
    }
    if (lid >= n && !(((lvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] >>
                       (((sizeof(unsigned char) * 8) - 1) -
                        ((ndid - n) % (sizeof(unsigned char) * 8)))) &
                      0x1)) {
      ((lvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] |=
       ((0x1) << (((sizeof(unsigned char) * 8) - 1) -
                  ((ndid - n) % (sizeof(unsigned char) * 8)))));
      curNode[k + 1] = lid;
      k++;
      continue;
    }
    if (rid >= n && !(((rvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] >>
                       (((sizeof(unsigned char) * 8) - 1) -
                        ((ndid - n) % (sizeof(unsigned char) * 8)))) &
                      0x1)) {
      ((rvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] |=
       ((0x1) << (((sizeof(unsigned char) * 8) - 1) -
                  ((ndid - n) % (sizeof(unsigned char) * 8)))));
      curNode[k + 1] = rid;
      k++;
      continue;
    }
    if (ndid >= n) {
      if (lid < n) {
        if (ms == -1) {
          nc++;
          T[lid] = nc;
        } else {
          T[lid] = nc;
        }
      }
      if (rid < n) {
        if (ms == -1) {
          nc++;
          T[rid] = nc;
        } else {
          T[rid] = nc;
        }
      }
      if (ms == k) {
        ms = -1;
      }
    }
    k--;
  }
  free(curNode);
  free(lvisited);
  free(rvisited);
}


x86 assembly (clang, -O0):
<form_flat_clusters_from_monotonic_criterion>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movslq -0x24(%rbp),%rax
mov    %eax,%ecx
cvtsi2sd %ecx,%xmm0
movsd  0xe9f(%rip),%xmm1
divsd  %xmm1,%xmm0
shr    $0x3,%rax
cvtsi2sd %rax,%xmm1
ucomisd %xmm1,%xmm0
jne    118f <form_flat_clusters_from_monotonic_criterion+0x5f>
jp     118f <form_flat_clusters_from_monotonic_criterion+0x5f>
movslq -0x24(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x78(%rbp)
jmp    119f <form_flat_clusters_from_monotonic_criterion+0x6f>
movslq -0x24(%rbp),%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    %eax,-0x6c(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x6c(%rbp),%rdi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x6c(%rbp),%rdi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0xffffffff,-0x44(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
sub    $0x2,%edx
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rdi
movslq -0x6c(%rbp),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x58(%rbp),%rdi
movslq -0x6c(%rbp),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0xffffffff,-0x44(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     14a3 <form_flat_clusters_from_monotonic_criterion+0x373>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cvttsd2si (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x68(%rbp),%rax
cvttsd2si 0x8(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0xffffffff,-0x44(%rbp)
jne    12ad <form_flat_clusters_from_monotonic_criterion+0x17d>
movsd  -0x60(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     12ad <form_flat_clusters_from_monotonic_criterion+0x17d>
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     134a <form_flat_clusters_from_monotonic_criterion+0x21a>
mov    -0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rdx
and    $0x7,%rdx
mov    $0x7,%ecx
sub    %rdx,%rcx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    134a <form_flat_clusters_from_monotonic_criterion+0x21a>
mov    -0x34(%rbp),%eax
sub    -0x24(%rbp),%eax
movslq %eax,%rcx
and    $0x7,%rcx
mov    $0x7,%eax
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    121f <form_flat_clusters_from_monotonic_criterion+0xef>
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     13e7 <form_flat_clusters_from_monotonic_criterion+0x2b7>
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rdx
and    $0x7,%rdx
mov    $0x7,%ecx
sub    %rdx,%rcx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    13e7 <form_flat_clusters_from_monotonic_criterion+0x2b7>
mov    -0x34(%rbp),%eax
sub    -0x24(%rbp),%eax
movslq %eax,%rcx
and    $0x7,%rcx
mov    $0x7,%eax
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    121f <form_flat_clusters_from_monotonic_criterion+0xef>
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     1495 <form_flat_clusters_from_monotonic_criterion+0x365>
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1438 <form_flat_clusters_from_monotonic_criterion+0x308>
cmpl   $0xffffffff,-0x44(%rbp)
jne    1425 <form_flat_clusters_from_monotonic_criterion+0x2f5>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1433 <form_flat_clusters_from_monotonic_criterion+0x303>
mov    -0x48(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1438 <form_flat_clusters_from_monotonic_criterion+0x308>
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    147d <form_flat_clusters_from_monotonic_criterion+0x34d>
cmpl   $0xffffffff,-0x44(%rbp)
jne    146a <form_flat_clusters_from_monotonic_criterion+0x33a>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1478 <form_flat_clusters_from_monotonic_criterion+0x348>
mov    -0x48(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    147d <form_flat_clusters_from_monotonic_criterion+0x34d>
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    1490 <form_flat_clusters_from_monotonic_criterion+0x360>
movl   $0xffffffff,-0x44(%rbp)
jmp    1495 <form_flat_clusters_from_monotonic_criterion+0x365>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    121f <form_flat_clusters_from_monotonic_criterion+0xef>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<form_flat_clusters_from_monotonic_criterion>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %ecx,%r14d
movsd  %xmm0,0x18(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rdi,%r12
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  0xe9d(%rip),%xmm0
movslq %ecx,%rbp
mov    %rbp,%rbx
shr    $0x3,%rbx
cvtsi2sd %rbx,%xmm1
cmpneqsd %xmm0,%xmm1
movq   %xmm1,%rax
sub    %eax,%ebx
lea    0x0(,%rbp,4),%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
movslq %ebx,%rbx
mov    $0x1,%edi
mov    %rbx,%rsi
call   1040 <calloc@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %rbx,%rsi
call   1040 <calloc@plt>
movsd  0x18(%rsp),%xmm0
mov    %rax,0x10(%rsp)
lea    -0x2(%rbp,%rbp,1),%edi
mov    %edi,0x0(%r13)
xor    %esi,%esi
mov    $0xffffffff,%r10d
xor    %r9d,%r9d
nopl   0x0(%rax)
mov    %edi,%ecx
sub    %r14d,%ecx
movslq %ecx,%rax
shl    $0x2,%ecx
cmp    $0xffffffff,%r10d
jne    1200 <form_flat_clusters_from_monotonic_criterion+0xd0>
mov    $0xffffffff,%r10d
mov    0x20(%rsp),%rdx
ucomisd (%rdx,%rax,8),%xmm0
jb     1200 <form_flat_clusters_from_monotonic_criterion+0xd0>
add    $0x1,%r9d
mov    %esi,%r10d
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rcx
cvttsd2si (%r12,%rcx,8),%edx
cvttsd2si 0x8(%r12,%rcx,8),%r11d
cmp    %r14d,%edx
jl     1238 <form_flat_clusters_from_monotonic_criterion+0x108>
mov    %rax,%rbx
mov    %eax,%ecx
not    %cl
and    $0x7,%cl
mov    $0x1,%ebp
shl    %cl,%ebp
shr    $0x3,%rbx
movzbl (%r15,%rbx,1),%r8d
movzbl %cl,%ecx
bt     %ecx,%r8d
jae    128f <form_flat_clusters_from_monotonic_criterion+0x15f>
cmp    %r14d,%r11d
jl     1262 <form_flat_clusters_from_monotonic_criterion+0x132>
mov    %rax,%rbx
not    %al
and    $0x7,%al
mov    $0x1,%ebp
mov    %eax,%ecx
shl    %cl,%ebp
shr    $0x3,%rbx
mov    0x10(%rsp),%rcx
movzbl (%rcx,%rbx,1),%ecx
movzbl %al,%eax
bt     %eax,%ecx
jae    12a2 <form_flat_clusters_from_monotonic_criterion+0x172>
cmp    %r14d,%edi
jl     12eb <form_flat_clusters_from_monotonic_criterion+0x1bb>
cmp    %r14d,%edx
jge    1282 <form_flat_clusters_from_monotonic_criterion+0x152>
cmp    $0xffffffff,%r10d
je     12ba <form_flat_clusters_from_monotonic_criterion+0x18a>
movslq %edx,%rax
mov    0x8(%rsp),%rcx
mov    %r9d,(%rcx,%rax,4)
cmp    %r14d,%r11d
jge    12df <form_flat_clusters_from_monotonic_criterion+0x1af>
cmp    $0xffffffff,%r10d
jne    12d3 <form_flat_clusters_from_monotonic_criterion+0x1a3>
jmp    12cf <form_flat_clusters_from_monotonic_criterion+0x19f>
or     %r8b,%bpl
mov    %bpl,(%r15,%rbx,1)
mov    %esi,%eax
add    $0x1,%esi
mov    %edx,0x4(%r13,%rax,4)
jmp    12ee <form_flat_clusters_from_monotonic_criterion+0x1be>
or     %cl,%bpl
mov    0x10(%rsp),%rax
mov    %bpl,(%rax,%rbx,1)
mov    %esi,%eax
add    $0x1,%esi
mov    %r11d,0x4(%r13,%rax,4)
jmp    12ee <form_flat_clusters_from_monotonic_criterion+0x1be>
add    $0x1,%r9d
movslq %edx,%rax
mov    0x8(%rsp),%rcx
mov    %r9d,(%rcx,%rax,4)
cmp    %r14d,%r11d
jge    12df <form_flat_clusters_from_monotonic_criterion+0x1af>
add    $0x1,%r9d
movslq %r11d,%rax
mov    0x8(%rsp),%rcx
mov    %r9d,(%rcx,%rax,4)
cmp    %esi,%r10d
mov    $0xffffffff,%eax
cmove  %eax,%r10d
add    $0xffffffff,%esi
test   %esi,%esi
js     12fe <form_flat_clusters_from_monotonic_criterion+0x1ce>
mov    %esi,%eax
mov    0x0(%r13,%rax,4),%edi
jmp    11d0 <form_flat_clusters_from_monotonic_criterion+0xa0>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @form_flat_clusters_from_monotonic_criterion(double* %0, double* %1, i32* %2, double %3, i32 %4) {
%6 = alloca double*
%7 = alloca double*
%8 = alloca i32*
%9 = alloca double
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca double
%21 = alloca double*
%22 = alloca i32
store double* %0, double** %6
store double* %1, double** %7
store i32* %2, i32** %8
store double %3, double* %9
store i32 %4, i32* %10
%23 = load i32, i32* %10
%24 = sitofp i32 %23 to double
%25 = fdiv double %24, 8.000000e+00
%26 = load i32, i32* %10
%27 = sext i32 %26 to i64
%28 = udiv i64 %27, 8
%29 = uitofp i64 %28 to double
%30 = fcmp oeq double %25, %29
br i1 %30, label %31, label %35
31: ; preds = %5
%32 = load i32, i32* %10
%33 = sext i32 %32 to i64
%34 = udiv i64 %33, 8
br label %40
35: ; preds = %5
%36 = load i32, i32* %10
%37 = sext i32 %36 to i64
%38 = udiv i64 %37, 8
%39 = add i64 %38, 1
br label %40
40: ; preds = %35, %31
%41 = phi i64 [ %34, %31 ], [ %39, %35 ]
%42 = trunc i64 %41 to i32
store i32 %42, i32* %22
%43 = load i32, i32* %10
%44 = sext i32 %43 to i64
%45 = mul i64 %44, 4
%46 = call i8* @malloc(i64 %45)
%47 = bitcast i8* %46 to i32*
store i32* %47, i32** %11
%48 = load i32, i32* %22
%49 = sext i32 %48 to i64
%50 = call i8* @malloc(i64 %49)
store i8* %50, i8** %18
%51 = load i32, i32* %22
%52 = sext i32 %51 to i64
%53 = call i8* @malloc(i64 %52)
store i8* %53, i8** %19
store i32 0, i32* %17
store i32 -1, i32* %16
store i32 0, i32* %15
%54 = load i32, i32* %10
%55 = mul nsw i32 %54, 2
%56 = sub nsw i32 %55, 2
%57 = load i32*, i32** %11
%58 = load i32, i32* %15
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %57, i64 %59
store i32 %56, i32* %60
%61 = load i8*, i8** %18
%62 = load i32, i32* %22
%63 = sext i32 %62 to i64
%64 = load i8*, i8** %19
%65 = load i32, i32* %22
%66 = sext i32 %65 to i64
store i32 -1, i32* %16
br label %67
67: ; preds = %266, %184, %132, %40
%68 = load i32, i32* %15
%69 = icmp sge i32 %68, 0
br i1 %69, label %70, label %269
70: ; preds = %67
%71 = load i32*, i32** %11
%72 = load i32, i32* %15
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = load i32, i32* %74
store i32 %75, i32* %12
%76 = load double*, double** %6
%77 = load i32, i32* %12
%78 = load i32, i32* %10
%79 = sub nsw i32 %77, %78
%80 = mul nsw i32 %79, 4
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %76, i64 %81
store double* %82, double** %21
%83 = load double*, double** %21
%84 = getelementptr inbounds double, double* %83, i64 0
%85 = load double, double* %84
%86 = fptosi double %85 to i32
store i32 %86, i32* %13
%87 = load double*, double** %21
%88 = getelementptr inbounds double, double* %87, i64 1
%89 = load double, double* %88
%90 = fptosi double %89 to i32
store i32 %90, i32* %14
%91 = load double*, double** %7
%92 = load i32, i32* %12
%93 = load i32, i32* %10
%94 = sub nsw i32 %92, %93
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %91, i64 %95
%97 = load double, double* %96
store double %97, double* %20
%98 = load i32, i32* %16
%99 = icmp eq i32 %98, -1
br i1 %99, label %100, label %108
100: ; preds = %70
%101 = load double, double* %20
%102 = load double, double* %9
%103 = fcmp ole double %101, %102
br i1 %103, label %104, label %108
104: ; preds = %100
%105 = load i32, i32* %15
store i32 %105, i32* %16
%106 = load i32, i32* %17
%107 = add nsw i32 %106, 1
store i32 %107, i32* %17
br label %108
108: ; preds = %104, %100, %70
%109 = load i32, i32* %13
%110 = load i32, i32* %10
%111 = icmp sge i32 %109, %110
br i1 %111, label %112, label %160
112: ; preds = %108
%113 = load i8*, i8** %18
%114 = load i32, i32* %12
%115 = load i32, i32* %10
%116 = sub nsw i32 %114, %115
%117 = sext i32 %116 to i64
%118 = udiv i64 %117, 8
%119 = getelementptr inbounds i8, i8* %113, i64 %118
%120 = load i8, i8* %119
%121 = zext i8 %120 to i32
%122 = load i32, i32* %12
%123 = load i32, i32* %10
%124 = sub nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = urem i64 %125, 8
%127 = sub i64 7, %126
%128 = trunc i64 %127 to i32
%129 = ashr i32 %121, %128
%130 = and i32 %129, 1
%131 = icmp ne i32 %130, 0
br i1 %131, label %160, label %132
132: ; preds = %112
%133 = load i32, i32* %12
%134 = load i32, i32* %10
%135 = sub nsw i32 %133, %134
%136 = sext i32 %135 to i64
%137 = urem i64 %136, 8
%138 = sub i64 7, %137
%139 = trunc i64 %138 to i32
%140 = shl i32 1, %139
%141 = load i8*, i8** %18
%142 = load i32, i32* %12
%143 = load i32, i32* %10
%144 = sub nsw i32 %142, %143
%145 = sext i32 %144 to i64
%146 = udiv i64 %145, 8
%147 = getelementptr inbounds i8, i8* %141, i64 %146
%148 = load i8, i8* %147
%149 = zext i8 %148 to i32
%150 = or i32 %149, %140
%151 = trunc i32 %150 to i8
store i8 %151, i8* %147
%152 = load i32, i32* %13
%153 = load i32*, i32** %11
%154 = load i32, i32* %15
%155 = add nsw i32 %154, 1
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i32, i32* %153, i64 %156
store i32 %152, i32* %157
%158 = load i32, i32* %15
%159 = add nsw i32 %158, 1
store i32 %159, i32* %15
br label %67
160: ; preds = %112, %108
%161 = load i32, i32* %14
%162 = load i32, i32* %10
%163 = icmp sge i32 %161, %162
br i1 %163, label %164, label %212
164: ; preds = %160
%165 = load i8*, i8** %19
%166 = load i32, i32* %12
%167 = load i32, i32* %10
%168 = sub nsw i32 %166, %167
%169 = sext i32 %168 to i64
%170 = udiv i64 %169, 8
%171 = getelementptr inbounds i8, i8* %165, i64 %170
%172 = load i8, i8* %171
%173 = zext i8 %172 to i32
%174 = load i32, i32* %12
%175 = load i32, i32* %10
%176 = sub nsw i32 %174, %175
%177 = sext i32 %176 to i64
%178 = urem i64 %177, 8
%179 = sub i64 7, %178
%180 = trunc i64 %179 to i32
%181 = ashr i32 %173, %180
%182 = and i32 %181, 1
%183 = icmp ne i32 %182, 0
br i1 %183, label %212, label %184
184: ; preds = %164
%185 = load i32, i32* %12
%186 = load i32, i32* %10
%187 = sub nsw i32 %185, %186
%188 = sext i32 %187 to i64
%189 = urem i64 %188, 8
%190 = sub i64 7, %189
%191 = trunc i64 %190 to i32
%192 = shl i32 1, %191
%193 = load i8*, i8** %19
%194 = load i32, i32* %12
%195 = load i32, i32* %10
%196 = sub nsw i32 %194, %195
%197 = sext i32 %196 to i64
%198 = udiv i64 %197, 8
%199 = getelementptr inbounds i8, i8* %193, i64 %198
%200 = load i8, i8* %199
%201 = zext i8 %200 to i32
%202 = or i32 %201, %192
%203 = trunc i32 %202 to i8
store i8 %203, i8* %199
%204 = load i32, i32* %14
%205 = load i32*, i32** %11
%206 = load i32, i32* %15
%207 = add nsw i32 %206, 1
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32, i32* %205, i64 %208
store i32 %204, i32* %209
%210 = load i32, i32* %15
%211 = add nsw i32 %210, 1
store i32 %211, i32* %15
br label %67
212: ; preds = %164, %160
%213 = load i32, i32* %12
%214 = load i32, i32* %10
%215 = icmp sge i32 %213, %214
br i1 %215, label %216, label %266
216: ; preds = %212
%217 = load i32, i32* %13
%218 = load i32, i32* %10
%219 = icmp slt i32 %217, %218
br i1 %219, label %220, label %238
220: ; preds = %216
%221 = load i32, i32* %16
%222 = icmp eq i32 %221, -1
br i1 %222, label %223, label %231
223: ; preds = %220
%224 = load i32, i32* %17
%225 = add nsw i32 %224, 1
store i32 %225, i32* %17
%226 = load i32, i32* %17
%227 = load i32*, i32** %8
%228 = load i32, i32* %13
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i32, i32* %227, i64 %229
store i32 %226, i32* %230
br label %237
231: ; preds = %220
%232 = load i32, i32* %17
%233 = load i32*, i32** %8
%234 = load i32, i32* %13
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %233, i64 %235
store i32 %232, i32* %236
br label %237
237: ; preds = %231, %223
br label %238
238: ; preds = %237, %216
%239 = load i32, i32* %14
%240 = load i32, i32* %10
%241 = icmp slt i32 %239, %240
br i1 %241, label %242, label %260
242: ; preds = %238
%243 = load i32, i32* %16
%244 = icmp eq i32 %243, -1
br i1 %244, label %245, label %253
245: ; preds = %242
%246 = load i32, i32* %17
%247 = add nsw i32 %246, 1
store i32 %247, i32* %17
%248 = load i32, i32* %17
%249 = load i32*, i32** %8
%250 = load i32, i32* %14
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %249, i64 %251
store i32 %248, i32* %252
br label %259
253: ; preds = %242
%254 = load i32, i32* %17
%255 = load i32*, i32** %8
%256 = load i32, i32* %14
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i32, i32* %255, i64 %257
store i32 %254, i32* %258
br label %259
259: ; preds = %253, %245
br label %260
260: ; preds = %259, %238
%261 = load i32, i32* %16
%262 = load i32, i32* %15
%263 = icmp eq i32 %261, %262
br i1 %263, label %264, label %265
264: ; preds = %260
store i32 -1, i32* %16
br label %265
265: ; preds = %264, %260
br label %266
266: ; preds = %265, %212
%267 = load i32, i32* %15
%268 = add nsw i32 %267, -1
store i32 %268, i32* %15
br label %67
269: ; preds = %67
%270 = load i32*, i32** %11
%271 = bitcast i32* %270 to i8*
%272 = load i8*, i8** %18
%273 = load i8*, i8** %19
ret void
}

LLVM IR (-O2):
define void @form_flat_clusters_from_monotonic_criterion(double* nocapture %0, double* nocapture %1, i32* nocapture writeonly %2, double %3, i32 %4) {
%6 = sitofp i32 %4 to double
%7 = fmul double %6, 1.250000e-01
%8 = sext i32 %4 to i64
%9 = lshr i64 %8, 3
%10 = uitofp i64 %9 to double
%11 = fcmp une double %7, %10
%12 = zext i1 %11 to i64
%13 = add nuw nsw i64 %9, %12
%14 = shl nsw i64 %8, 2
%15 = tail call i8* @malloc(i64 %14)
%16 = bitcast i8* %15 to i32*
%17 = shl i64 %13, 32
%18 = ashr exact i64 %17, 32
%19 = call i8* @calloc(i64 1, i64 %18)
%20 = call i8* @calloc(i64 1, i64 %18)
%21 = shl nsw i32 %4, 1
%22 = add nsw i32 %21, -2
store i32 %22, i32* %16
br label %23
23: ; preds = %70, %5
%24 = phi i32 [ %22, %5 ], [ %73, %70 ]
%25 = phi i32 [ 0, %5 ], [ %68, %70 ]
%26 = phi i32 [ -1, %5 ], [ %67, %70 ]
%27 = phi i32 [ 0, %5 ], [ %66, %70 ]
%28 = sub nsw i32 %24, %4
%29 = shl nsw i32 %28, 2
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double, double* %0, i64 %30
%32 = load double, double* %31
%33 = fptosi double %32 to i32
%34 = getelementptr inbounds double, double* %31, i64 1
%35 = load double, double* %34
%36 = fptosi double %35 to i32
%37 = sext i32 %28 to i64
%38 = icmp eq i32 %26, -1
br i1 %38, label %39, label %45
39: ; preds = %23
%40 = getelementptr inbounds double, double* %1, i64 %37
%41 = load double, double* %40
%42 = fcmp ugt double %41, %3
br i1 %42, label %45, label %43
43: ; preds = %39
%44 = add nsw i32 %27, 1
br label %45
45: ; preds = %43, %39, %23
%46 = phi i32 [ %44, %43 ], [ %27, %39 ], [ %27, %23 ]
%47 = phi i32 [ %25, %43 ], [ -1, %39 ], [ %26, %23 ]
%48 = icmp slt i32 %33, %4
br i1 %48, label %74, label %49
49: ; preds = %45
%50 = lshr i64 %37, 3
%51 = getelementptr inbounds i8, i8* %19, i64 %50
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
%54 = and i32 %28, 7
%55 = xor i32 %54, 7
%56 = shl nuw i32 1, %55
%57 = and i32 %56, %53
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %74
59: ; preds = %49
%60 = trunc i32 %56 to i8
%61 = or i8 %52, %60
store i8 %61, i8* %51
%62 = add nuw nsw i32 %25, 1
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %16, i64 %63
store i32 %33, i32* %64
br label %65
65: ; preds = %59, %86, %118
%66 = phi i32 [ %119, %118 ], [ %46, %86 ], [ %46, %59 ]
%67 = phi i32 [ %120, %118 ], [ %47, %86 ], [ %47, %59 ]
%68 = phi i32 [ %121, %118 ], [ %89, %86 ], [ %62, %59 ]
%69 = icmp sgt i32 %68, -1
br i1 %69, label %70, label %122
70: ; preds = %65
%71 = zext i32 %68 to i64
%72 = getelementptr inbounds i32, i32* %16, i64 %71
%73 = load i32, i32* %72
br label %23
74: ; preds = %49, %45
%75 = icmp slt i32 %36, %4
br i1 %75, label %92, label %76
76: ; preds = %74
%77 = lshr i64 %37, 3
%78 = getelementptr inbounds i8, i8* %20, i64 %77
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = and i32 %28, 7
%82 = xor i32 %81, 7
%83 = shl nuw i32 1, %82
%84 = and i32 %83, %80
%85 = icmp eq i32 %84, 0
br i1 %85, label %86, label %92
86: ; preds = %76
%87 = trunc i32 %83 to i8
%88 = or i8 %79, %87
store i8 %88, i8* %78
%89 = add nuw nsw i32 %25, 1
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds i32, i32* %16, i64 %90
store i32 %36, i32* %91
br label %65
92: ; preds = %76, %74
%93 = icmp slt i32 %24, %4
br i1 %93, label %118, label %94
94: ; preds = %92
br i1 %48, label %95, label %100
95: ; preds = %94
%96 = icmp eq i32 %47, -1
br i1 %96, label %101, label %97
97: ; preds = %95
%98 = sext i32 %33 to i64
%99 = getelementptr inbounds i32, i32* %2, i64 %98
store i32 %46, i32* %99
br label %100
100: ; preds = %97, %94
br i1 %75, label %105, label %114
101: ; preds = %95
%102 = add nsw i32 %46, 1
%103 = sext i32 %33 to i64
%104 = getelementptr inbounds i32, i32* %2, i64 %103
store i32 %102, i32* %104
br i1 %75, label %107, label %114
105: ; preds = %100
%106 = icmp eq i32 %47, -1
br i1 %106, label %107, label %110
107: ; preds = %101, %105
%108 = phi i32 [ %46, %105 ], [ %102, %101 ]
%109 = add nsw i32 %108, 1
br label %110
110: ; preds = %105, %107
%111 = phi i32 [ %109, %107 ], [ %46, %105 ]
%112 = sext i32 %36 to i64
%113 = getelementptr inbounds i32, i32* %2, i64 %112
store i32 %111, i32* %113
br label %114
114: ; preds = %110, %101, %100
%115 = phi i32 [ %46, %100 ], [ %102, %101 ], [ %111, %110 ]
%116 = icmp eq i32 %47, %25
%117 = select i1 %116, i32 -1, i32 %47
br label %118
118: ; preds = %114, %92
%119 = phi i32 [ %115, %114 ], [ %46, %92 ]
%120 = phi i32 [ %117, %114 ], [ %47, %92 ]
%121 = add nsw i32 %25, -1
br label %65
122: ; preds = %65
tail call void @free(i8* %15)
tail call void @free(i8* %19)
tail call void @free(i8* %20)
ret void
}