void scaleDistances(float **aafDist, int nN) {
  int i = 0, j = 0;
  float fMin = aafDist[1][0], fMax = aafDist[1][0];
  for (i = 2; i < nN; i++) {
    for (j = 0; j < i; j++) {
      if (aafDist[i][j] < fMin) {
        fMin = aafDist[i][j];
      }
      if (aafDist[i][j] > fMax) {
        fMax = aafDist[i][j];
      }
    }
  }
  for (i = 1; i < nN; i++) {
    for (j = 0; j < i; j++) {
      aafDist[i][j] = (aafDist[i][j] - fMin) / (fMax - fMin);
    }
  }
}


x86 assembly (clang, -O0):
<scaleDistances>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x2,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11fd <scaleDistances+0xfd>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11ea <scaleDistances+0xea>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x18(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    119e <scaleDistances+0x9e>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jbe    11d7 <scaleDistances+0xd7>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    11dc <scaleDistances+0xdc>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1155 <scaleDistances+0x55>
jmp    11ef <scaleDistances+0xef>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1142 <scaleDistances+0x42>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1281 <scaleDistances+0x181>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    126e <scaleDistances+0x16e>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x18(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
subss  -0x18(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1217 <scaleDistances+0x117>
jmp    1273 <scaleDistances+0x173>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1204 <scaleDistances+0x104>
pop    %rbp
ret

x86 assembly (clang, -O2):
<scaleDistances>:
push   %rbx
mov    0x8(%rdi),%rbx
movss  (%rbx),%xmm2
mov    %esi,%r8d
cmp    $0x3,%esi
jl     1204 <scaleDistances+0x104>
mov    $0x2,%r10d
xor    %r9d,%r9d
movaps %xmm2,%xmm3
jmp    1143 <scaleDistances+0x43>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
movaps %xmm1,%xmm2
movaps %xmm0,%xmm3
cmp    %r8,%r10
je     120a <scaleDistances+0x10a>
add    $0x1,%r9
mov    (%rdi,%r10,8),%rax
cmp    $0x3,%r9
jae    1160 <scaleDistances+0x60>
xor    %edx,%edx
jmp    11bc <scaleDistances+0xbc>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
xor    %edx,%edx
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm0
movss  0x4(%rax,%rdx,4),%xmm1
movaps %xmm0,%xmm4
minss  %xmm3,%xmm4
maxss  %xmm2,%xmm0
movaps %xmm1,%xmm2
minss  %xmm4,%xmm2
maxss  %xmm0,%xmm1
movss  0x8(%rax,%rdx,4),%xmm0
movaps %xmm0,%xmm4
minss  %xmm2,%xmm4
maxss  %xmm1,%xmm0
movss  0xc(%rax,%rdx,4),%xmm2
movaps %xmm2,%xmm3
minss  %xmm4,%xmm3
maxss  %xmm0,%xmm2
add    $0x4,%rdx
cmp    %rdx,%r11
jne    1170 <scaleDistances+0x70>
movaps %xmm3,%xmm0
movaps %xmm2,%xmm1
test   $0x3,%r10b
je     1130 <scaleDistances+0x30>
mov    %r10d,%ecx
and    $0x3,%ecx
lea    (%rax,%rdx,4),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm1
movaps %xmm1,%xmm0
minss  %xmm3,%xmm0
maxss  %xmm2,%xmm1
add    $0x1,%rdx
movaps %xmm1,%xmm2
movaps %xmm0,%xmm3
cmp    %rdx,%rcx
jne    11e0 <scaleDistances+0xe0>
jmp    1130 <scaleDistances+0x30>
movaps %xmm2,%xmm0
movaps %xmm2,%xmm1
cmp    $0x2,%esi
jl     1324 <scaleDistances+0x224>
subss  %xmm0,%xmm1
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
mov    $0x1,%eax
mov    $0xfffffffffffffffd,%r9
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rcx),%r10
cmp    $0x4,%r10
jae    1260 <scaleDistances+0x160>
xor    %edx,%edx
jmp    12f0 <scaleDistances+0x1f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffffffffffffd,%rcx
mov    %rcx,%r11
shr    $0x2,%r11
add    $0x1,%r11
cmp    $0x4,%rcx
jae    1280 <scaleDistances+0x180>
xor    %esi,%esi
jmp    12c8 <scaleDistances+0x1c8>
nopl   0x0(%rax)
mov    %r9,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rsi,4),%xmm4
movups 0x10(%rbx,%rsi,4),%xmm5
subps  %xmm2,%xmm4
divps  %xmm3,%xmm4
movups %xmm4,(%rbx,%rsi,4)
subps  %xmm2,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,0x10(%rbx,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdx
jne    12a0 <scaleDistances+0x1a0>
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
test   $0x1,%r11b
je     12e3 <scaleDistances+0x1e3>
movups (%rbx,%rsi,4),%xmm4
subps  %xmm2,%xmm4
divps  %xmm3,%xmm4
movups %xmm4,(%rbx,%rsi,4)
cmp    %rdx,%r10
je     130b <scaleDistances+0x20b>
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rdx,4),%xmm4
subss  %xmm0,%xmm4
divss  %xmm1,%xmm4
movss  %xmm4,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12f0 <scaleDistances+0x1f0>
add    $0x1,%rax
cmp    %r8,%rax
je     1324 <scaleDistances+0x224>
mov    (%rdi,%rax,8),%rbx
add    $0x1,%r9
mov    %r10,%rcx
jmp    1240 <scaleDistances+0x140>
pop    %rbx
ret

LLVM IR (-O0):
define void @scaleDistances(float** %0, i32 %1) {
%3 = alloca float**
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca float
%8 = alloca float
store float** %0, float*** %3
store i32 %1, i32* %4
store i32 0, i32* %5
store i32 0, i32* %6
%9 = load float**, float*** %3
%10 = getelementptr inbounds float*, float** %9, i64 1
%11 = load float*, float** %10
%12 = getelementptr inbounds float, float* %11, i64 0
%13 = load float, float* %12
store float %13, float* %7
%14 = load float**, float*** %3
%15 = getelementptr inbounds float*, float** %14, i64 1
%16 = load float*, float** %15
%17 = getelementptr inbounds float, float* %16, i64 0
%18 = load float, float* %17
store float %18, float* %8
store i32 2, i32* %5
br label %19
19: ; preds = %77, %2
%20 = load i32, i32* %5
%21 = load i32, i32* %4
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %80
23: ; preds = %19
store i32 0, i32* %6
br label %24
24: ; preds = %73, %23
%25 = load i32, i32* %6
%26 = load i32, i32* %5
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %76
28: ; preds = %24
%29 = load float**, float*** %3
%30 = load i32, i32* %5
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds float*, float** %29, i64 %31
%33 = load float*, float** %32
%34 = load i32, i32* %6
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %33, i64 %35
%37 = load float, float* %36
%38 = load float, float* %7
%39 = fcmp olt float %37, %38
br i1 %39, label %40, label %50
40: ; preds = %28
%41 = load float**, float*** %3
%42 = load i32, i32* %5
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float*, float** %41, i64 %43
%45 = load float*, float** %44
%46 = load i32, i32* %6
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
%49 = load float, float* %48
store float %49, float* %7
br label %50
50: ; preds = %40, %28
%51 = load float**, float*** %3
%52 = load i32, i32* %5
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float*, float** %51, i64 %53
%55 = load float*, float** %54
%56 = load i32, i32* %6
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %55, i64 %57
%59 = load float, float* %58
%60 = load float, float* %8
%61 = fcmp ogt float %59, %60
br i1 %61, label %62, label %72
62: ; preds = %50
%63 = load float**, float*** %3
%64 = load i32, i32* %5
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float*, float** %63, i64 %65
%67 = load float*, float** %66
%68 = load i32, i32* %6
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %67, i64 %69
%71 = load float, float* %70
store float %71, float* %8
br label %72
72: ; preds = %62, %50
br label %73
73: ; preds = %72
%74 = load i32, i32* %6
%75 = add nsw i32 %74, 1
store i32 %75, i32* %6
br label %24
76: ; preds = %24
br label %77
77: ; preds = %76
%78 = load i32, i32* %5
%79 = add nsw i32 %78, 1
store i32 %79, i32* %5
br label %19
80: ; preds = %19
store i32 1, i32* %5
br label %81
81: ; preds = %118, %80
%82 = load i32, i32* %5
%83 = load i32, i32* %4
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %121
85: ; preds = %81
store i32 0, i32* %6
br label %86
86: ; preds = %114, %85
%87 = load i32, i32* %6
%88 = load i32, i32* %5
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %117
90: ; preds = %86
%91 = load float**, float*** %3
%92 = load i32, i32* %5
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float*, float** %91, i64 %93
%95 = load float*, float** %94
%96 = load i32, i32* %6
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %95, i64 %97
%99 = load float, float* %98
%100 = load float, float* %7
%101 = fsub float %99, %100
%102 = load float, float* %8
%103 = load float, float* %7
%104 = fsub float %102, %103
%105 = fdiv float %101, %104
%106 = load float**, float*** %3
%107 = load i32, i32* %5
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds float*, float** %106, i64 %108
%110 = load float*, float** %109
%111 = load i32, i32* %6
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float, float* %110, i64 %112
store float %105, float* %113
br label %114
114: ; preds = %90
%115 = load i32, i32* %6
%116 = add nsw i32 %115, 1
store i32 %116, i32* %6
br label %86
117: ; preds = %86
br label %118
118: ; preds = %117
%119 = load i32, i32* %5
%120 = add nsw i32 %119, 1
store i32 %120, i32* %5
br label %81
121: ; preds = %81
ret void
}

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