float **kmeans_clustering(float **feature, int nfeatures, int npoints,
                          int nclusters, float threshold, int *membership) {
  int i, j, n = 0, index, loop = 0;
  int *new_centers_len;
  float delta;
  float **clusters;
  float **new_centers;
  clusters = (float **)malloc(nclusters * sizeof(float *));
  clusters[0] = (float *)malloc(nclusters * nfeatures * sizeof(float));
  for (i = 1; i < nclusters; i++)
    clusters[i] = clusters[i - 1] + nfeatures;
  for (i = 0; i < nclusters; i++) {
    for (j = 0; j < nfeatures; j++)
      clusters[i][j] = feature[n][j];
    n++;
  }
  for (i = 0; i < npoints; i++)
    membership[i] = -1;
  new_centers_len = (int *)calloc(nclusters, sizeof(int));
  new_centers = (float **)malloc(nclusters * sizeof(float *));
  new_centers[0] = (float *)calloc(nclusters * nfeatures, sizeof(float));
  for (i = 1; i < nclusters; i++)
    new_centers[i] = new_centers[i - 1] + nfeatures;
  do {
    delta = 0.0;
    for (i = 0; i < npoints; i++) {
      index = find_nearest_point(feature[i], nfeatures, clusters, nclusters);
      if (membership[i] != index)
        delta += 1.0;
      membership[i] = index;
      new_centers_len[index]++;
      for (j = 0; j < nfeatures; j++)
        new_centers[index][j] += feature[i][j];
    }
    for (i = 0; i < nclusters; i++) {
      for (j = 0; j < nfeatures; j++) {
        if (new_centers_len[i] > 0)
          clusters[i][j] = new_centers[i][j] / new_centers_len[i];
        new_centers[i][j] = 0.0;
      }
      new_centers_len[i] = 0;
    }
  } while (delta > threshold);
  free(new_centers[0]);
  free(new_centers);
  free(new_centers_len);
  return clusters;
}


x86 assembly (clang, -O0):
<kmeans_clustering>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,%rcx
mov    -0x50(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11e3 <kmeans_clustering+0xa3>
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a1 <kmeans_clustering+0x61>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1258 <kmeans_clustering+0x118>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1241 <kmeans_clustering+0x101>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11fd <kmeans_clustering+0xbd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ea <kmeans_clustering+0xaa>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1288 <kmeans_clustering+0x148>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    125f <kmeans_clustering+0x11f>
movslq -0x14(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x14(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rcx
mov    -0x58(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1312 <kmeans_clustering+0x1d2>
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12d0 <kmeans_clustering+0x190>
jmp    1317 <kmeans_clustering+0x1d7>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1406 <kmeans_clustering+0x2c6>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0xc(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    $0x0,%al
call   1040 <find_nearest_point@plt>
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     1384 <kmeans_clustering+0x244>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc89(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13f3 <kmeans_clustering+0x2b3>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13aa <kmeans_clustering+0x26a>
jmp    13f8 <kmeans_clustering+0x2b8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1326 <kmeans_clustering+0x1e6>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14bc <kmeans_clustering+0x37c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    149f <kmeans_clustering+0x35f>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1479 <kmeans_clustering+0x339>
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1420 <kmeans_clustering+0x2e0>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    140d <kmeans_clustering+0x2cd>
jmp    14c1 <kmeans_clustering+0x381>
movss  -0x44(%rbp),%xmm0
ucomiss -0x18(%rbp),%xmm0
ja     1317 <kmeans_clustering+0x1d7>
mov    -0x58(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kmeans_clustering>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,0x50(%rsp)
movss  %xmm0,0x4c(%rsp)
mov    %ecx,%r14d
mov    %edx,0xc(%rsp)
mov    %esi,%r15d
mov    %rdi,0x40(%rsp)
movslq %ecx,%rbp
lea    0x0(,%rbp,8),%rdi
mov    %rdi,0x38(%rsp)
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %r14d,%eax
imul   %r15d,%eax
cltq
mov    %rax,0x30(%rsp)
lea    0x0(,%rax,4),%rdi
call   1070 <malloc@plt>
mov    %rax,(%rbx)
mov    %r15d,0x4(%rsp)
movslq %r15d,%r11
mov    %r14d,0x8(%rsp)
mov    %r14d,%r10d
mov    %rbp,0x28(%rsp)
cmp    $0x2,%ebp
jl     1290 <kmeans_clustering+0x140>
lea    -0x1(%r10),%rsi
lea    -0x2(%r10),%rcx
mov    %esi,%r9d
and    $0x7,%r9d
cmp    $0x7,%rcx
jae    11f4 <kmeans_clustering+0xa4>
mov    $0x1,%edx
test   %r9,%r9
jne    126b <kmeans_clustering+0x11b>
jmp    1290 <kmeans_clustering+0x140>
and    $0xfffffffffffffff8,%rsi
mov    %r11,%r8
shl    $0x5,%r8
lea    0x0(,%r11,4),%rdi
xor    %edx,%edx
nopl   0x0(%rax)
mov    %rax,%rcx
add    %rdi,%rax
mov    %rax,0x8(%rbx,%rdx,8)
add    %rdi,%rax
mov    %rax,0x10(%rbx,%rdx,8)
add    %rdi,%rax
mov    %rax,0x18(%rbx,%rdx,8)
add    %rdi,%rax
mov    %rax,0x20(%rbx,%rdx,8)
add    %rdi,%rax
mov    %rax,0x28(%rbx,%rdx,8)
add    %rdi,%rax
mov    %rax,0x30(%rbx,%rdx,8)
add    %rdi,%rax
mov    %rax,0x38(%rbx,%rdx,8)
add    %rdi,%rax
mov    %rax,0x40(%rbx,%rdx,8)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1210 <kmeans_clustering+0xc0>
add    %r8,%rcx
add    $0x1,%rdx
mov    %rcx,%rax
test   %r9,%r9
je     1290 <kmeans_clustering+0x140>
lea    (%rax,%r11,4),%rax
lea    0x0(,%r11,4),%rcx
lea    (%rbx,%rdx,8),%rdx
xor    %esi,%esi
nopl   (%rax)
mov    %rax,(%rdx,%rsi,8)
add    $0x1,%rsi
add    %rcx,%rax
cmp    %rsi,%r9
jne    1280 <kmeans_clustering+0x130>
mov    %r11,0x10(%rsp)
mov    %r10,0x20(%rsp)
mov    0x4(%rsp),%ebp
mov    %ebp,%r12d
cmpl   $0x0,0x8(%rsp)
jle    1450 <kmeans_clustering+0x300>
mov    %r12d,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r8
mov    %r8,0x18(%rsp)
shr    $0x3,%r8
add    $0x1,%r8
mov    %r8d,%r15d
and    $0x3,%r15d
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%r8
mov    %r12d,%r13d
and    $0x3,%r13d
mov    %r15,%r9
shl    $0x5,%r9
xor    %r14d,%r14d
jmp    12ff <kmeans_clustering+0x1af>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    0x20(%rsp),%r14
je     1450 <kmeans_clustering+0x300>
test   %ebp,%ebp
jle    12f0 <kmeans_clustering+0x1a0>
mov    0x40(%rsp),%rax
mov    (%rax,%r14,8),%rdx
mov    (%rbx,%r14,8),%rax
cmp    $0x8,%ebp
jb     1327 <kmeans_clustering+0x1d7>
lea    (%rdx,%r12,4),%rcx
cmp    %rcx,%rax
jae    139c <kmeans_clustering+0x24c>
lea    (%rax,%r12,4),%rcx
cmp    %rcx,%rdx
jae    139c <kmeans_clustering+0x24c>
xor    %edi,%edi
mov    %rdi,%rsi
not    %rsi
add    %r12,%rsi
test   %r13,%r13
je     1354 <kmeans_clustering+0x204>
mov    %r13,%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rcx
jne    1340 <kmeans_clustering+0x1f0>
cmp    $0x3,%rsi
jb     12f0 <kmeans_clustering+0x1a0>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
movss  0x4(%rdx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rax,%rdi,4)
movss  0x8(%rdx,%rdi,4),%xmm0
movss  %xmm0,0x8(%rax,%rdi,4)
movss  0xc(%rdx,%rdi,4),%xmm0
movss  %xmm0,0xc(%rax,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%r12
jne    1360 <kmeans_clustering+0x210>
jmp    12f0 <kmeans_clustering+0x1a0>
cmpq   $0x18,0x18(%rsp)
jae    13a8 <kmeans_clustering+0x258>
xor    %edi,%edi
jmp    1408 <kmeans_clustering+0x2b8>
mov    %r8,%r10
xor    %edi,%edi
nopl   (%rax)
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
movups 0x20(%rdx,%rdi,4),%xmm0
movups 0x30(%rdx,%rdi,4),%xmm1
movups %xmm0,0x20(%rax,%rdi,4)
movups %xmm1,0x30(%rax,%rdi,4)
movups 0x40(%rdx,%rdi,4),%xmm0
movups 0x50(%rdx,%rdi,4),%xmm1
movups %xmm0,0x40(%rax,%rdi,4)
movups %xmm1,0x50(%rax,%rdi,4)
movups 0x60(%rdx,%rdi,4),%xmm0
movups 0x70(%rdx,%rdi,4),%xmm1
movups %xmm0,0x60(%rax,%rdi,4)
movups %xmm1,0x70(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%r10
jne    13b0 <kmeans_clustering+0x260>
test   %r15,%r15
je     143b <kmeans_clustering+0x2eb>
lea    (%rax,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rdx,%rdi,4),%rcx
add    $0x10,%rcx
xor    %edi,%edi
nop
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1420 <kmeans_clustering+0x2d0>
mov    %r11,%rdi
cmp    %r12,%r11
mov    0x4(%rsp),%ebp
je     12f0 <kmeans_clustering+0x1a0>
jmp    1329 <kmeans_clustering+0x1d9>
mov    0xc(%rsp),%eax
mov    %eax,%ebp
test   %eax,%eax
jle    1471 <kmeans_clustering+0x321>
lea    0x0(,%rbp,4),%rdx
mov    0x50(%rsp),%rdi
mov    $0xff,%esi
call   1050 <memset@plt>
mov    %rbp,0x70(%rsp)
mov    $0x4,%esi
mov    0x28(%rsp),%rdi
call   1060 <calloc@plt>
mov    %rax,%r15
mov    0x38(%rsp),%rdi
call   1070 <malloc@plt>
mov    %rax,%rbp
mov    $0x4,%esi
mov    0x30(%rsp),%rdi
call   1060 <calloc@plt>
mov    %rax,0x0(%rbp)
cmpl   $0x2,0x8(%rsp)
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%r10
jl     1580 <kmeans_clustering+0x430>
lea    -0x1(%rcx),%r11
add    $0xfffffffffffffffe,%rcx
mov    %r11d,%r9d
and    $0x7,%r9d
cmp    $0x7,%rcx
jae    14e4 <kmeans_clustering+0x394>
mov    $0x1,%ecx
mov    %rax,%rdx
test   %r9,%r9
jne    1558 <kmeans_clustering+0x408>
jmp    1580 <kmeans_clustering+0x430>
and    $0xfffffffffffffff8,%r11
mov    %r10,%r8
shl    $0x5,%r8
lea    0x0(,%r10,4),%rdi
xor    %ecx,%ecx
mov    %rax,%rsi
nopl   0x0(%rax)
mov    %rsi,%rdx
add    %rdi,%rsi
mov    %rsi,0x8(%rbp,%rcx,8)
add    %rdi,%rsi
mov    %rsi,0x10(%rbp,%rcx,8)
add    %rdi,%rsi
mov    %rsi,0x18(%rbp,%rcx,8)
add    %rdi,%rsi
mov    %rsi,0x20(%rbp,%rcx,8)
add    %rdi,%rsi
mov    %rsi,0x28(%rbp,%rcx,8)
add    %rdi,%rsi
mov    %rsi,0x30(%rbp,%rcx,8)
add    %rdi,%rsi
mov    %rsi,0x38(%rbp,%rcx,8)
add    %rdi,%rsi
mov    %rsi,0x40(%rbp,%rcx,8)
add    $0x8,%rcx
cmp    %rcx,%r11
jne    1500 <kmeans_clustering+0x3b0>
add    %r8,%rdx
add    $0x1,%rcx
test   %r9,%r9
je     1580 <kmeans_clustering+0x430>
lea    (%rdx,%r10,4),%rsi
shl    $0x2,%r10
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %edx,%edx
nopl   (%rax)
mov    %rsi,(%rcx,%rdx,8)
add    $0x1,%rdx
add    %r10,%rsi
cmp    %rdx,%r9
jne    1570 <kmeans_clustering+0x420>
mov    %rax,0x58(%rsp)
mov    %r12d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x30(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
lea    -0x1(%r12),%rax
mov    %rax,0x18(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
add    $0x2,%rax
mov    %rcx,%rdx
mov    %rcx,0x68(%rsp)
and    %rcx,%rax
mov    %rax,0x60(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %rax,0x38(%rsp)
mov    %r12d,%r13d
and    $0xfffffffe,%r13d
mov    0x4(%rsp),%esi
mov    %rbp,0x10(%rsp)
jmp    1601 <kmeans_clustering+0x4b1>
nopl   0x0(%rax)
movss  0x4(%rsp),%xmm0
ucomiss 0x4c(%rsp),%xmm0
jbe    18eb <kmeans_clustering+0x79b>
cmpl   $0x0,0xc(%rsp)
jle    1800 <kmeans_clustering+0x6b0>
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
xor    %r14d,%r14d
jmp    162f <kmeans_clustering+0x4df>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    0x70(%rsp),%r14
je     1809 <kmeans_clustering+0x6b9>
mov    0x40(%rsp),%rax
mov    (%rax,%r14,8),%rdi
mov    %rbx,%rdx
mov    0x8(%rsp),%ecx
xor    %eax,%eax
mov    %esi,%ebp
call   1040 <find_nearest_point@plt>
movss  0x4(%rsp),%xmm0
addss  0x9aa(%rip),%xmm0
mov    0x50(%rsp),%rcx
cmp    %eax,(%rcx,%r14,4)
je     1667 <kmeans_clustering+0x517>
movss  %xmm0,0x4(%rsp)
mov    %eax,(%rcx,%r14,4)
movslq %eax,%rcx
addl   $0x1,(%r15,%rcx,4)
test   %ebp,%ebp
mov    %ebp,%esi
jle    1620 <kmeans_clustering+0x4d0>
mov    0x40(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    0x10(%rsp),%rdx
mov    (%rdx,%rcx,8),%rcx
cmp    $0x8,%esi
jb     16aa <kmeans_clustering+0x55a>
lea    (%rax,%r12,4),%rdx
cmp    %rdx,%rcx
jae    1743 <kmeans_clustering+0x5f3>
lea    (%rcx,%r12,4),%rdx
cmp    %rdx,%rax
jae    1743 <kmeans_clustering+0x5f3>
xor    %edx,%edx
mov    0x18(%rsp),%rbp
sub    %rdx,%rbp
mov    0x38(%rsp),%rdi
test   %rdi,%rdi
je     16d9 <kmeans_clustering+0x589>
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    16c0 <kmeans_clustering+0x570>
cmp    $0x3,%rbp
jb     1620 <kmeans_clustering+0x4d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
addss  0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rcx,%rdx,4)
movss  0x8(%rax,%rdx,4),%xmm0
addss  0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rcx,%rdx,4)
movss  0xc(%rax,%rdx,4),%xmm0
addss  0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rcx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r12
jne    16f0 <kmeans_clustering+0x5a0>
jmp    1620 <kmeans_clustering+0x4d0>
cmpq   $0x0,0x28(%rsp)
je     17ed <kmeans_clustering+0x69d>
mov    0x60(%rsp),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rcx,%rdx,4),%xmm1
movups 0x30(%rcx,%rdx,4),%xmm3
movups %xmm2,(%rcx,%rdx,4)
movups %xmm0,0x10(%rcx,%rdx,4)
movups 0x20(%rax,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x30(%rax,%rdx,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rcx,%rdx,4)
movups %xmm1,0x30(%rcx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1760 <kmeans_clustering+0x610>
testb  $0x1,0x68(%rsp)
je     17d7 <kmeans_clustering+0x687>
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rcx,%rdx,4)
movups %xmm0,0x10(%rcx,%rdx,4)
mov    0x30(%rsp),%rdi
mov    %rdi,%rdx
cmp    %r12,%rdi
je     1620 <kmeans_clustering+0x4d0>
jmp    16ac <kmeans_clustering+0x55c>
xor    %edx,%edx
testb  $0x1,0x68(%rsp)
jne    17b6 <kmeans_clustering+0x666>
jmp    17d7 <kmeans_clustering+0x687>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
cmpl   $0x0,0x8(%rsp)
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%r14
jle    15f0 <kmeans_clustering+0x4a0>
xor    %eax,%eax
jmp    184c <kmeans_clustering+0x6fc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rcx,%rdx,4)
movl   $0x0,(%r15,%rax,4)
add    $0x1,%rax
cmp    %r8,%rax
je     15f0 <kmeans_clustering+0x4a0>
test   %esi,%esi
jle    1837 <kmeans_clustering+0x6e7>
mov    (%r15,%rax,4),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mov    (%r14,%rax,8),%rcx
cmpq   $0x0,0x18(%rsp)
je     18c0 <kmeans_clustering+0x770>
xor    %edx,%edx
jmp    1881 <kmeans_clustering+0x731>
nopl   0x0(%rax,%rax,1)
movl   $0x0,0x4(%rcx,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r13
je     18c2 <kmeans_clustering+0x772>
test   %ebp,%ebp
jle    1897 <kmeans_clustering+0x747>
movss  (%rcx,%rdx,4),%xmm1
divss  %xmm0,%xmm1
mov    (%rbx,%rax,8),%rdi
movss  %xmm1,(%rdi,%rdx,4)
movl   $0x0,(%rcx,%rdx,4)
test   %ebp,%ebp
jle    1870 <kmeans_clustering+0x720>
movss  0x4(%rcx,%rdx,4),%xmm1
divss  %xmm0,%xmm1
mov    (%rbx,%rax,8),%rdi
movss  %xmm1,0x4(%rdi,%rdx,4)
jmp    1870 <kmeans_clustering+0x720>
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
test   $0x1,%r12b
je     1837 <kmeans_clustering+0x6e7>
test   %ebp,%ebp
jle    1830 <kmeans_clustering+0x6e0>
movss  (%rcx,%rdx,4),%xmm1
divss  %xmm0,%xmm1
mov    (%rbx,%rax,8),%rdi
movss  %xmm1,(%rdi,%rdx,4)
jmp    1830 <kmeans_clustering+0x6e0>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define float** @kmeans_clustering(float** nocapture %0, i32 %1, i32 %2, i32 %3, float %4, i32* nocapture %5) {
%7 = bitcast i32* %5 to i8*
%8 = sext i32 %3 to i64
%9 = shl nsw i64 %8, 3
%10 = tail call i8* @malloc(i64 %9)
%11 = bitcast i8* %10 to float**
%12 = mul nsw i32 %3, %1
%13 = sext i32 %12 to i64
%14 = shl nsw i64 %13, 2
%15 = tail call i8* @malloc(i64 %14)
%16 = bitcast i8* %10 to i8**
store i8* %15, i8** %16
%17 = icmp sgt i32 %3, 1
br i1 %17, label %18, label %41
18: ; preds = %6
%19 = bitcast i8* %15 to float*
%20 = sext i32 %1 to i64
%21 = zext i32 %3 to i64
%22 = add nsw i64 %21, -1
%23 = add nsw i64 %21, -2
%24 = and i64 %22, 7
%25 = icmp ult i64 %23, 7
br i1 %25, label %28, label %26
26: ; preds = %18
%27 = and i64 %22, -8
br label %60
28: ; preds = %60, %18
%29 = phi float* [ %19, %18 ], [ %85, %60 ]
%30 = phi i64 [ 1, %18 ], [ %87, %60 ]
%31 = icmp eq i64 %24, 0
br i1 %31, label %41, label %32
32: ; preds = %28, %32
%33 = phi float* [ %36, %32 ], [ %29, %28 ]
%34 = phi i64 [ %38, %32 ], [ %30, %28 ]
%35 = phi i64 [ %39, %32 ], [ 0, %28 ]
%36 = getelementptr inbounds float, float* %33, i64 %20
%37 = getelementptr inbounds float*, float** %11, i64 %34
store float* %36, float** %37
%38 = add nuw nsw i64 %34, 1
%39 = add i64 %35, 1
%40 = icmp eq i64 %39, %24
br i1 %40, label %41, label %32
41: ; preds = %28, %32, %6
%42 = icmp sgt i32 %3, 0
br i1 %42, label %43, label %188
43: ; preds = %41
%44 = icmp sgt i32 %1, 0
%45 = zext i32 %3 to i64
%46 = zext i32 %1 to i64
%47 = and i64 %46, 4294967288
%48 = add nsw i64 %47, -8
%49 = lshr exact i64 %48, 3
%50 = add nuw nsw i64 %49, 1
%51 = icmp ult i32 %1, 8
%52 = and i64 %46, 4294967288
%53 = and i64 %50, 3
%54 = icmp ult i64 %48, 24
%55 = and i64 %50, 4611686018427387900
%56 = icmp eq i64 %53, 0
%57 = icmp eq i64 %52, %46
%58 = and i64 %46, 3
%59 = icmp eq i64 %58, 0
br label %90
60: ; preds = %60, %26
%61 = phi float* [ %19, %26 ], [ %85, %60 ]
%62 = phi i64 [ 1, %26 ], [ %87, %60 ]
%63 = phi i64 [ 0, %26 ], [ %88, %60 ]
%64 = getelementptr inbounds float, float* %61, i64 %20
%65 = getelementptr inbounds float*, float** %11, i64 %62
store float* %64, float** %65
%66 = add nuw nsw i64 %62, 1
%67 = getelementptr inbounds float, float* %64, i64 %20
%68 = getelementptr inbounds float*, float** %11, i64 %66
store float* %67, float** %68
%69 = add nuw nsw i64 %62, 2
%70 = getelementptr inbounds float, float* %67, i64 %20
%71 = getelementptr inbounds float*, float** %11, i64 %69
store float* %70, float** %71
%72 = add nuw nsw i64 %62, 3
%73 = getelementptr inbounds float, float* %70, i64 %20
%74 = getelementptr inbounds float*, float** %11, i64 %72
store float* %73, float** %74
%75 = add nuw nsw i64 %62, 4
%76 = getelementptr inbounds float, float* %73, i64 %20
%77 = getelementptr inbounds float*, float** %11, i64 %75
store float* %76, float** %77
%78 = add nuw nsw i64 %62, 5
%79 = getelementptr inbounds float, float* %76, i64 %20
%80 = getelementptr inbounds float*, float** %11, i64 %78
store float* %79, float** %80
%81 = add nuw nsw i64 %62, 6
%82 = getelementptr inbounds float, float* %79, i64 %20
%83 = getelementptr inbounds float*, float** %11, i64 %81
store float* %82, float** %83
%84 = add nuw nsw i64 %62, 7
%85 = getelementptr inbounds float, float* %82, i64 %20
%86 = getelementptr inbounds float*, float** %11, i64 %84
store float* %85, float** %86
%87 = add nuw nsw i64 %62, 8
%88 = add i64 %63, 8
%89 = icmp eq i64 %88, %27
br i1 %89, label %28, label %60
90: ; preds = %43, %212
%91 = phi i64 [ 0, %43 ], [ %213, %212 ]
br i1 %44, label %92, label %212
92: ; preds = %90
%93 = getelementptr inbounds float*, float** %0, i64 %91
%94 = load float*, float** %93
%95 = getelementptr inbounds float*, float** %11, i64 %91
%96 = load float*, float** %95
br i1 %51, label %172, label %97
97: ; preds = %92
%98 = getelementptr float, float* %96, i64 %46
%99 = getelementptr float, float* %94, i64 %46
%100 = icmp ult float* %96, %99
%101 = icmp ult float* %94, %98
%102 = and i1 %100, %101
br i1 %102, label %172, label %103
103: ; preds = %97
br i1 %54, label %153, label %104
104: ; preds = %103, %104
%105 = phi i64 [ %150, %104 ], [ 0, %103 ]
%106 = phi i64 [ %151, %104 ], [ 0, %103 ]
%107 = getelementptr inbounds float, float* %94, i64 %105
%108 = bitcast float* %107 to <4 x float>*
%109 = load <4 x float>, <4 x float>* %108
%110 = getelementptr inbounds float, float* %107, i64 4
%111 = bitcast float* %110 to <4 x float>*
%112 = load <4 x float>, <4 x float>* %111
%113 = getelementptr inbounds float, float* %96, i64 %105
%114 = bitcast float* %113 to <4 x float>*
store <4 x float> %109, <4 x float>* %114
%115 = getelementptr inbounds float, float* %113, i64 4
%116 = bitcast float* %115 to <4 x float>*
store <4 x float> %112, <4 x float>* %116
%117 = or i64 %105, 8
%118 = getelementptr inbounds float, float* %94, i64 %117
%119 = bitcast float* %118 to <4 x float>*
%120 = load <4 x float>, <4 x float>* %119
%121 = getelementptr inbounds float, float* %118, i64 4
%122 = bitcast float* %121 to <4 x float>*
%123 = load <4 x float>, <4 x float>* %122
%124 = getelementptr inbounds float, float* %96, i64 %117
%125 = bitcast float* %124 to <4 x float>*
store <4 x float> %120, <4 x float>* %125
%126 = getelementptr inbounds float, float* %124, i64 4
%127 = bitcast float* %126 to <4 x float>*
store <4 x float> %123, <4 x float>* %127
%128 = or i64 %105, 16
%129 = getelementptr inbounds float, float* %94, i64 %128
%130 = bitcast float* %129 to <4 x float>*
%131 = load <4 x float>, <4 x float>* %130
%132 = getelementptr inbounds float, float* %129, i64 4
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = getelementptr inbounds float, float* %96, i64 %128
%136 = bitcast float* %135 to <4 x float>*
store <4 x float> %131, <4 x float>* %136
%137 = getelementptr inbounds float, float* %135, i64 4
%138 = bitcast float* %137 to <4 x float>*
store <4 x float> %134, <4 x float>* %138
%139 = or i64 %105, 24
%140 = getelementptr inbounds float, float* %94, i64 %139
%141 = bitcast float* %140 to <4 x float>*
%142 = load <4 x float>, <4 x float>* %141
%143 = getelementptr inbounds float, float* %140, i64 4
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = getelementptr inbounds float, float* %96, i64 %139
%147 = bitcast float* %146 to <4 x float>*
store <4 x float> %142, <4 x float>* %147
%148 = getelementptr inbounds float, float* %146, i64 4
%149 = bitcast float* %148 to <4 x float>*
store <4 x float> %145, <4 x float>* %149
%150 = add nuw i64 %105, 32
%151 = add i64 %106, 4
%152 = icmp eq i64 %151, %55
br i1 %152, label %153, label %104
153: ; preds = %104, %103
%154 = phi i64 [ 0, %103 ], [ %150, %104 ]
br i1 %56, label %171, label %155
155: ; preds = %153, %155
%156 = phi i64 [ %168, %155 ], [ %154, %153 ]
%157 = phi i64 [ %169, %155 ], [ 0, %153 ]
%158 = getelementptr inbounds float, float* %94, i64 %156
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %158, i64 4
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = getelementptr inbounds float, float* %96, i64 %156
%165 = bitcast float* %164 to <4 x float>*
store <4 x float> %160, <4 x float>* %165
%166 = getelementptr inbounds float, float* %164, i64 4
%167 = bitcast float* %166 to <4 x float>*
store <4 x float> %163, <4 x float>* %167
%168 = add nuw i64 %156, 8
%169 = add i64 %157, 1
%170 = icmp eq i64 %169, %53
br i1 %170, label %171, label %155
171: ; preds = %155, %153
br i1 %57, label %212, label %172
172: ; preds = %97, %92, %171
%173 = phi i64 [ 0, %97 ], [ 0, %92 ], [ %52, %171 ]
%174 = xor i64 %173, -1
%175 = add nsw i64 %174, %46
br i1 %59, label %185, label %176
176: ; preds = %172, %176
%177 = phi i64 [ %182, %176 ], [ %173, %172 ]
%178 = phi i64 [ %183, %176 ], [ 0, %172 ]
%179 = getelementptr inbounds float, float* %94, i64 %177
%180 = load float, float* %179
%181 = getelementptr inbounds float, float* %96, i64 %177
store float %180, float* %181
%182 = add nuw nsw i64 %177, 1
%183 = add i64 %178, 1
%184 = icmp eq i64 %183, %58
br i1 %184, label %185, label %176
185: ; preds = %176, %172
%186 = phi i64 [ %173, %172 ], [ %182, %176 ]
%187 = icmp ult i64 %175, 3
br i1 %187, label %212, label %193
188: ; preds = %212, %41
%189 = icmp sgt i32 %2, 0
br i1 %189, label %190, label %215
190: ; preds = %188
%191 = zext i32 %2 to i64
%192 = shl nuw nsw i64 %191, 2
br label %215
193: ; preds = %185, %193
%194 = phi i64 [ %210, %193 ], [ %186, %185 ]
%195 = getelementptr inbounds float, float* %94, i64 %194
%196 = load float, float* %195
%197 = getelementptr inbounds float, float* %96, i64 %194
store float %196, float* %197
%198 = add nuw nsw i64 %194, 1
%199 = getelementptr inbounds float, float* %94, i64 %198
%200 = load float, float* %199
%201 = getelementptr inbounds float, float* %96, i64 %198
store float %200, float* %201
%202 = add nuw nsw i64 %194, 2
%203 = getelementptr inbounds float, float* %94, i64 %202
%204 = load float, float* %203
%205 = getelementptr inbounds float, float* %96, i64 %202
store float %204, float* %205
%206 = add nuw nsw i64 %194, 3
%207 = getelementptr inbounds float, float* %94, i64 %206
%208 = load float, float* %207
%209 = getelementptr inbounds float, float* %96, i64 %206
store float %208, float* %209
%210 = add nuw nsw i64 %194, 4
%211 = icmp eq i64 %210, %46
br i1 %211, label %212, label %193
212: ; preds = %185, %193, %171, %90
%213 = add nuw nsw i64 %91, 1
%214 = icmp eq i64 %213, %45
br i1 %214, label %188, label %90
215: ; preds = %190, %188
%216 = tail call i8* @calloc(i64 %8, i64 4)
%217 = bitcast i8* %216 to i32*
%218 = tail call i8* @malloc(i64 %9)
%219 = bitcast i8* %218 to float**
%220 = tail call i8* @calloc(i64 %13, i64 4)
%221 = bitcast i8* %218 to i8**
store i8* %220, i8** %221
br i1 %17, label %222, label %245
222: ; preds = %215
%223 = bitcast i8* %220 to float*
%224 = sext i32 %1 to i64
%225 = zext i32 %3 to i64
%226 = add nsw i64 %225, -1
%227 = add nsw i64 %225, -2
%228 = and i64 %226, 7
%229 = icmp ult i64 %227, 7
br i1 %229, label %232, label %230
230: ; preds = %222
%231 = and i64 %226, -8
br label %268
232: ; preds = %268, %222
%233 = phi float* [ %223, %222 ], [ %293, %268 ]
%234 = phi i64 [ 1, %222 ], [ %295, %268 ]
%235 = icmp eq i64 %228, 0
br i1 %235, label %245, label %236
236: ; preds = %232, %236
%237 = phi float* [ %240, %236 ], [ %233, %232 ]
%238 = phi i64 [ %242, %236 ], [ %234, %232 ]
%239 = phi i64 [ %243, %236 ], [ 0, %232 ]
%240 = getelementptr inbounds float, float* %237, i64 %224
%241 = getelementptr inbounds float*, float** %219, i64 %238
store float* %240, float** %241
%242 = add nuw nsw i64 %238, 1
%243 = add i64 %239, 1
%244 = icmp eq i64 %243, %228
br i1 %244, label %245, label %236
245: ; preds = %232, %236, %215
%246 = icmp sgt i32 %1, 0
%247 = zext i32 %2 to i64
%248 = zext i32 %1 to i64
%249 = zext i32 %3 to i64
%250 = and i64 %248, 4294967288
%251 = add nsw i64 %250, -8
%252 = lshr exact i64 %251, 3
%253 = add nuw nsw i64 %252, 1
%254 = add nsw i64 %248, -1
%255 = icmp ult i32 %1, 8
%256 = and i64 %248, 4294967288
%257 = and i64 %253, 1
%258 = icmp eq i64 %251, 0
%259 = and i64 %253, 4611686018427387902
%260 = icmp eq i64 %257, 0
%261 = icmp eq i64 %256, %248
%262 = and i64 %248, 3
%263 = icmp eq i64 %262, 0
%264 = and i64 %248, 1
%265 = icmp eq i64 %254, 0
%266 = and i64 %248, 4294967294
%267 = icmp eq i64 %264, 0
br label %298
268: ; preds = %268, %230
%269 = phi float* [ %223, %230 ], [ %293, %268 ]
%270 = phi i64 [ 1, %230 ], [ %295, %268 ]
%271 = phi i64 [ 0, %230 ], [ %296, %268 ]
%272 = getelementptr inbounds float, float* %269, i64 %224
%273 = getelementptr inbounds float*, float** %219, i64 %270
store float* %272, float** %273
%274 = add nuw nsw i64 %270, 1
%275 = getelementptr inbounds float, float* %272, i64 %224
%276 = getelementptr inbounds float*, float** %219, i64 %274
store float* %275, float** %276
%277 = add nuw nsw i64 %270, 2
%278 = getelementptr inbounds float, float* %275, i64 %224
%279 = getelementptr inbounds float*, float** %219, i64 %277
store float* %278, float** %279
%280 = add nuw nsw i64 %270, 3
%281 = getelementptr inbounds float, float* %278, i64 %224
%282 = getelementptr inbounds float*, float** %219, i64 %280
store float* %281, float** %282
%283 = add nuw nsw i64 %270, 4
%284 = getelementptr inbounds float, float* %281, i64 %224
%285 = getelementptr inbounds float*, float** %219, i64 %283
store float* %284, float** %285
%286 = add nuw nsw i64 %270, 5
%287 = getelementptr inbounds float, float* %284, i64 %224
%288 = getelementptr inbounds float*, float** %219, i64 %286
store float* %287, float** %288
%289 = add nuw nsw i64 %270, 6
%290 = getelementptr inbounds float, float* %287, i64 %224
%291 = getelementptr inbounds float*, float** %219, i64 %289
store float* %290, float** %291
%292 = add nuw nsw i64 %270, 7
%293 = getelementptr inbounds float, float* %290, i64 %224
%294 = getelementptr inbounds float*, float** %219, i64 %292
store float* %293, float** %294
%295 = add nuw nsw i64 %270, 8
%296 = add i64 %271, 8
%297 = icmp eq i64 %296, %231
br i1 %297, label %232, label %268
298: ; preds = %245, %481
br i1 %189, label %301, label %299
299: ; preds = %430, %298
%300 = phi float [ 0.000000e+00, %298 ], [ %311, %430 ]
br i1 %42, label %433, label %481
301: ; preds = %298, %430
%302 = phi i64 [ %431, %430 ], [ 0, %298 ]
%303 = phi float [ %311, %430 ], [ 0.000000e+00, %298 ]
%304 = getelementptr inbounds float*, float** %0, i64 %302
%305 = load float*, float** %304
%306 = tail call i32 (float*, i32, float**, i32, ...) bitcast (i32 (...)* @find_nearest_point to i32 (float*, i32, float**, i32, ...)*)(float* %305, i32 %1, float** %11, i32 %3)
%307 = getelementptr inbounds i32, i32* %5, i64 %302
%308 = load i32, i32* %307
%309 = icmp eq i32 %308, %306
%310 = fadd float %303, 1.000000e+00
%311 = select i1 %309, float %303, float %310
store i32 %306, i32* %307
%312 = sext i32 %306 to i64
%313 = getelementptr inbounds i32, i32* %217, i64 %312
%314 = load i32, i32* %313
%315 = add nsw i32 %314, 1
store i32 %315, i32* %313
br i1 %246, label %316, label %430
316: ; preds = %301
%317 = load float*, float** %304
%318 = getelementptr inbounds float*, float** %219, i64 %312
%319 = load float*, float** %318
br i1 %255, label %386, label %320
320: ; preds = %316
%321 = getelementptr float, float* %319, i64 %248
%322 = getelementptr float, float* %317, i64 %248
%323 = icmp ult float* %319, %322
%324 = icmp ult float* %317, %321
%325 = and i1 %323, %324
br i1 %325, label %386, label %326
326: ; preds = %320
br i1 %258, label %366, label %327
327: ; preds = %326, %327
%328 = phi i64 [ %363, %327 ], [ 0, %326 ]
%329 = phi i64 [ %364, %327 ], [ 0, %326 ]
%330 = getelementptr inbounds float, float* %317, i64 %328
%331 = bitcast float* %330 to <4 x float>*
%332 = load <4 x float>, <4 x float>* %331
%333 = getelementptr inbounds float, float* %330, i64 4
%334 = bitcast float* %333 to <4 x float>*
%335 = load <4 x float>, <4 x float>* %334
%336 = getelementptr inbounds float, float* %319, i64 %328
%337 = bitcast float* %336 to <4 x float>*
%338 = load <4 x float>, <4 x float>* %337
%339 = getelementptr inbounds float, float* %336, i64 4
%340 = bitcast float* %339 to <4 x float>*
%341 = load <4 x float>, <4 x float>* %340
%342 = fadd <4 x float> %332, %338
%343 = fadd <4 x float> %335, %341
%344 = bitcast float* %336 to <4 x float>*
store <4 x float> %342, <4 x float>* %344
%345 = bitcast float* %339 to <4 x float>*
store <4 x float> %343, <4 x float>* %345
%346 = or i64 %328, 8
%347 = getelementptr inbounds float, float* %317, i64 %346
%348 = bitcast float* %347 to <4 x float>*
%349 = load <4 x float>, <4 x float>* %348
%350 = getelementptr inbounds float, float* %347, i64 4
%351 = bitcast float* %350 to <4 x float>*
%352 = load <4 x float>, <4 x float>* %351
%353 = getelementptr inbounds float, float* %319, i64 %346
%354 = bitcast float* %353 to <4 x float>*
%355 = load <4 x float>, <4 x float>* %354
%356 = getelementptr inbounds float, float* %353, i64 4
%357 = bitcast float* %356 to <4 x float>*
%358 = load <4 x float>, <4 x float>* %357
%359 = fadd <4 x float> %349, %355
%360 = fadd <4 x float> %352, %358
%361 = bitcast float* %353 to <4 x float>*
store <4 x float> %359, <4 x float>* %361
%362 = bitcast float* %356 to <4 x float>*
store <4 x float> %360, <4 x float>* %362
%363 = add nuw i64 %328, 16
%364 = add i64 %329, 2
%365 = icmp eq i64 %364, %259
br i1 %365, label %366, label %327
366: ; preds = %327, %326
%367 = phi i64 [ 0, %326 ], [ %363, %327 ]
br i1 %260, label %385, label %368
368: ; preds = %366
%369 = getelementptr inbounds float, float* %317, i64 %367
%370 = bitcast float* %369 to <4 x float>*
%371 = load <4 x float>, <4 x float>* %370
%372 = getelementptr inbounds float, float* %369, i64 4
%373 = bitcast float* %372 to <4 x float>*
%374 = load <4 x float>, <4 x float>* %373
%375 = getelementptr inbounds float, float* %319, i64 %367
%376 = bitcast float* %375 to <4 x float>*
%377 = load <4 x float>, <4 x float>* %376
%378 = getelementptr inbounds float, float* %375, i64 4
%379 = bitcast float* %378 to <4 x float>*
%380 = load <4 x float>, <4 x float>* %379
%381 = fadd <4 x float> %371, %377
%382 = fadd <4 x float> %374, %380
%383 = bitcast float* %375 to <4 x float>*
store <4 x float> %381, <4 x float>* %383
%384 = bitcast float* %378 to <4 x float>*
store <4 x float> %382, <4 x float>* %384
br label %385
385: ; preds = %366, %368
br i1 %261, label %430, label %386
386: ; preds = %320, %316, %385
%387 = phi i64 [ 0, %320 ], [ 0, %316 ], [ %256, %385 ]
%388 = sub nsw i64 %254, %387
br i1 %263, label %400, label %389
389: ; preds = %386, %389
%390 = phi i64 [ %397, %389 ], [ %387, %386 ]
%391 = phi i64 [ %398, %389 ], [ 0, %386 ]
%392 = getelementptr inbounds float, float* %317, i64 %390
%393 = load float, float* %392
%394 = getelementptr inbounds float, float* %319, i64 %390
%395 = load float, float* %394
%396 = fadd float %393, %395
store float %396, float* %394
%397 = add nuw nsw i64 %390, 1
%398 = add i64 %391, 1
%399 = icmp eq i64 %398, %262
br i1 %399, label %400, label %389
400: ; preds = %389, %386
%401 = phi i64 [ %387, %386 ], [ %397, %389 ]
%402 = icmp ult i64 %388, 3
br i1 %402, label %430, label %403
403: ; preds = %400, %403
%404 = phi i64 [ %428, %403 ], [ %401, %400 ]
%405 = getelementptr inbounds float, float* %317, i64 %404
%406 = load float, float* %405
%407 = getelementptr inbounds float, float* %319, i64 %404
%408 = load float, float* %407
%409 = fadd float %406, %408
store float %409, float* %407
%410 = add nuw nsw i64 %404, 1
%411 = getelementptr inbounds float, float* %317, i64 %410
%412 = load float, float* %411
%413 = getelementptr inbounds float, float* %319, i64 %410
%414 = load float, float* %413
%415 = fadd float %412, %414
store float %415, float* %413
%416 = add nuw nsw i64 %404, 2
%417 = getelementptr inbounds float, float* %317, i64 %416
%418 = load float, float* %417
%419 = getelementptr inbounds float, float* %319, i64 %416
%420 = load float, float* %419
%421 = fadd float %418, %420
store float %421, float* %419
%422 = add nuw nsw i64 %404, 3
%423 = getelementptr inbounds float, float* %317, i64 %422
%424 = load float, float* %423
%425 = getelementptr inbounds float, float* %319, i64 %422
%426 = load float, float* %425
%427 = fadd float %424, %426
store float %427, float* %425
%428 = add nuw nsw i64 %404, 4
%429 = icmp eq i64 %428, %248
br i1 %429, label %430, label %403
430: ; preds = %400, %403, %385, %301
%431 = add nuw nsw i64 %302, 1
%432 = icmp eq i64 %431, %247
br i1 %432, label %299, label %301
433: ; preds = %299, %477
%434 = phi i64 [ %479, %477 ], [ 0, %299 ]
br i1 %246, label %435, label %477
435: ; preds = %433
%436 = getelementptr inbounds i32, i32* %217, i64 %434
%437 = load i32, i32* %436
%438 = icmp sgt i32 %437, 0
%439 = getelementptr inbounds float*, float** %219, i64 %434
%440 = sitofp i32 %437 to float
%441 = getelementptr inbounds float*, float** %11, i64 %434
%442 = load float*, float** %439
br i1 %265, label %466, label %443
443: ; preds = %435, %461
%444 = phi i64 [ %463, %461 ], [ 0, %435 ]
%445 = phi i64 [ %464, %461 ], [ 0, %435 ]
br i1 %438, label %446, label %452
446: ; preds = %443
%447 = getelementptr inbounds float, float* %442, i64 %444
%448 = load float, float* %447
%449 = fdiv float %448, %440
%450 = load float*, float** %441
%451 = getelementptr inbounds float, float* %450, i64 %444
store float %449, float* %451
br label %452
452: ; preds = %446, %443
%453 = getelementptr inbounds float, float* %442, i64 %444
store float 0.000000e+00, float* %453
%454 = or i64 %444, 1
br i1 %438, label %455, label %461
455: ; preds = %452
%456 = getelementptr inbounds float, float* %442, i64 %454
%457 = load float, float* %456
%458 = fdiv float %457, %440
%459 = load float*, float** %441
%460 = getelementptr inbounds float, float* %459, i64 %454
store float %458, float* %460
br label %461
461: ; preds = %455, %452
%462 = getelementptr inbounds float, float* %442, i64 %454
store float 0.000000e+00, float* %462
%463 = add nuw nsw i64 %444, 2
%464 = add i64 %445, 2
%465 = icmp eq i64 %464, %266
br i1 %465, label %466, label %443
466: ; preds = %461, %435
%467 = phi i64 [ 0, %435 ], [ %463, %461 ]
br i1 %267, label %477, label %468
468: ; preds = %466
br i1 %438, label %469, label %475
469: ; preds = %468
%470 = getelementptr inbounds float, float* %442, i64 %467
%471 = load float, float* %470
%472 = fdiv float %471, %440
%473 = load float*, float** %441
%474 = getelementptr inbounds float, float* %473, i64 %467
store float %472, float* %474
br label %475
475: ; preds = %469, %468
%476 = getelementptr inbounds float, float* %442, i64 %467
store float 0.000000e+00, float* %476
br label %477
477: ; preds = %475, %466, %433
%478 = getelementptr inbounds i32, i32* %217, i64 %434
store i32 0, i32* %478
%479 = add nuw nsw i64 %434, 1
%480 = icmp eq i64 %479, %249
br i1 %480, label %481, label %433
481: ; preds = %477, %299
%482 = fcmp ogt float %300, %4
br i1 %482, label %298, label %483
483: ; preds = %481
tail call void @free(i8* %220)
tail call void @free(i8* %218)
tail call void @free(i8* %216)
ret float** %11
}