void get_max_dist_for_each_cluster(const double *Z, double *max_dists, int n) {
  int *curNode;
  int ndid, lid, rid, k;
  unsigned char *lvisited, *rvisited;
  const double *Zrow;
  double max_dist;
  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)));
  k = 0;
  curNode = (int *)malloc(n * sizeof(int));
  lvisited = (unsigned char *)malloc(bff);
  rvisited = (unsigned char *)malloc(bff);
  curNode[k] = (n * 2) - 2;
  bzero(lvisited, bff);
  bzero(rvisited, bff);
  while (k >= 0) {
    ndid = curNode[k];
    Zrow = Z + ((ndid - n) * 4);
    lid = (int)Zrow[0];
    rid = (int)Zrow[1];
    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;
    }
    max_dist = Zrow[2];
    if (lid >= n) {
      max_dist =
          ((max_dist > max_dists[lid - n]) ? (max_dist) : (max_dists[lid - n]));
    }
    if (rid >= n) {
      max_dist =
          ((max_dist > max_dists[rid - n]) ? (max_dist) : (max_dists[rid - n]));
    }
    max_dists[ndid - n] = max_dist;
    ;
    k--;
  }
  free(curNode);
  free(lvisited);
  free(rvisited);
}


x86 assembly (clang, -O0):
<get_max_dist_for_each_cluster>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movslq -0x14(%rbp),%rax
mov    %eax,%ecx
cvtsi2sd %ecx,%xmm0
movsd  0xeab(%rip),%xmm1
divsd  %xmm1,%xmm0
shr    $0x3,%rax
cvtsi2sd %rax,%xmm1
ucomisd %xmm1,%xmm0
jne    1183 <get_max_dist_for_each_cluster+0x53>
jp     1183 <get_max_dist_for_each_cluster+0x53>
movslq -0x14(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x60(%rbp)
jmp    1193 <get_max_dist_for_each_cluster+0x63>
movslq -0x14(%rbp),%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x30(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x54(%rbp),%rdi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x54(%rbp),%rdi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
sub    $0x2,%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rdi
movslq -0x54(%rbp),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x40(%rbp),%rdi
movslq -0x54(%rbp),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
cmpl   $0x0,-0x30(%rbp)
jl     1467 <get_max_dist_for_each_cluster+0x337>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cvttsd2si (%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
cvttsd2si 0x8(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     12e5 <get_max_dist_for_each_cluster+0x1b5>
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rdx
and    $0x7,%rdx
mov    $0x7,%ecx
sub    %rdx,%rcx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    12e5 <get_max_dist_for_each_cluster+0x1b5>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
movslq %eax,%rcx
and    $0x7,%rcx
mov    $0x7,%eax
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fe <get_max_dist_for_each_cluster+0xce>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1382 <get_max_dist_for_each_cluster+0x252>
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rdx
and    $0x7,%rdx
mov    $0x7,%ecx
sub    %rdx,%rcx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1382 <get_max_dist_for_each_cluster+0x252>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
movslq %eax,%rcx
and    $0x7,%rcx
mov    $0x7,%eax
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fe <get_max_dist_for_each_cluster+0xce>
mov    -0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     13e9 <get_max_dist_for_each_cluster+0x2b9>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    13c8 <get_max_dist_for_each_cluster+0x298>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    13df <get_max_dist_for_each_cluster+0x2af>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1442 <get_max_dist_for_each_cluster+0x312>
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1421 <get_max_dist_for_each_cluster+0x2f1>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1438 <get_max_dist_for_each_cluster+0x308>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    11fe <get_max_dist_for_each_cluster+0xce>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_max_dist_for_each_cluster>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r13d
mov    %rsi,%r14
mov    %rdi,%r15
cvtsi2sd %edx,%xmm0
mulsd  0xeb0(%rip),%xmm0
movslq %edx,%rbx
mov    %rbx,%rbp
shr    $0x3,%rbp
cvtsi2sd %rbp,%xmm1
cmpneqsd %xmm0,%xmm1
movq   %xmm1,%rax
sub    %eax,%ebp
lea    0x0(,%rbx,4),%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
movslq %ebp,%rbp
mov    $0x1,%edi
mov    %rbp,%rsi
call   1040 <calloc@plt>
mov    %rax,(%rsp)
mov    $0x1,%edi
mov    %rbp,%rsi
call   1040 <calloc@plt>
mov    (%rsp),%r10
lea    (%rbx,%rbx,1),%edx
add    $0xfffffffe,%edx
mov    %edx,(%r12)
xor    %r8d,%r8d
jmp    11cb <get_max_dist_for_each_cluster+0x9b>
add    %r10,%rdi
or     %r11b,%sil
mov    %sil,(%rdi)
mov    %r8d,%ecx
add    $0x1,%r8d
mov    %ebp,0x4(%r12,%rcx,4)
mov    %r8d,%ecx
mov    (%r12,%rcx,4),%edx
sub    %r13d,%edx
lea    0x0(,%rdx,4),%ecx
movslq %ecx,%rbx
cvttsd2si (%r15,%rbx,8),%ebp
movslq %edx,%r9
cmp    %r13d,%ebp
jl     120a <get_max_dist_for_each_cluster+0xda>
mov    %r9,%rdi
mov    %r9d,%ecx
not    %cl
and    $0x7,%cl
mov    $0x1,%esi
shl    %cl,%esi
shr    $0x3,%rdi
movzbl (%r10,%rdi,1),%r11d
movzbl %cl,%ecx
bt     %ecx,%r11d
jae    11af <get_max_dist_for_each_cluster+0x7f>
cvttsd2si 0x8(%r15,%rbx,8),%edx
cmp    %r13d,%edx
jl     123a <get_max_dist_for_each_cluster+0x10a>
mov    %r9,%rdi
mov    %r9d,%ecx
not    %cl
and    $0x7,%cl
mov    $0x1,%esi
shl    %cl,%esi
shr    $0x3,%rdi
movzbl (%rax,%rdi,1),%r11d
movzbl %cl,%ecx
bt     %ecx,%r11d
jae    1271 <get_max_dist_for_each_cluster+0x141>
movsd  0x10(%r15,%rbx,8),%xmm0
sub    %r13d,%ebp
jl     124f <get_max_dist_for_each_cluster+0x11f>
movslq %ebp,%rcx
maxsd  (%r14,%rcx,8),%xmm0
sub    %r13d,%edx
jl     125d <get_max_dist_for_each_cluster+0x12d>
movslq %edx,%rcx
maxsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%r9,8)
test   %r8d,%r8d
jle    127b <get_max_dist_for_each_cluster+0x14b>
add    $0xffffffff,%r8d
jmp    11c4 <get_max_dist_for_each_cluster+0x94>
add    %rax,%rdi
mov    %edx,%ebp
jmp    11b2 <get_max_dist_for_each_cluster+0x82>
mov    %r12,%rdi
mov    %r10,%rbx
mov    %rax,%rbp
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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