#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
float distance2(float *, float *, int);
int /*<<< orphan*/ free(float *);
float gettotalJC(float *, unsigned char *, int, float **, int, int, float);
int /*<<< orphan*/ printf(char *, int, float, float, ...);
int mergecb1(float **dist, float *B, float **cb, unsigned char *P, int npt,
             int newN, float *thresh, int dim, int *count, int status) {
  int i, j, l, mini, minj, total, k, ei, endloop;
  float mindist, avgJC, oldJC, newthresh, maxJ, olddist, thresh2, *cent, ST, *A;
  int debug = 0;
  ei = newN - 1;
  mindist = 100000;
  for (i = 0; i < ei; i++) {
    for (j = i + 1; j < newN; j++) {
      if (dist[i][j] < mindist) {
        mindist = dist[i][j];
        mini = i;
        minj = j;
      }
    }
  }
  if (status == 1) {
    cent = (float *)calloc(dim, sizeof(float));
    i = 0;
    for (l = 0; l < npt; l++)
      for (j = 0; j < dim; j++)
        cent[j] += B[i++];
    for (j = 0; j < dim; j++)
      cent[j] /= npt;
    ST = 0;
    A = B;
    for (l = 0; l < npt; l++) {
      ST += distance2(A, cent, dim);
      A += dim;
    }
    free(cent);
    avgJC = gettotalJC(B, P, newN, cb, dim, npt, ST);
    if (debug)
      printf("N=%d avgJC=%f dist=%f\n", newN - 1, avgJC, mindist);
    oldJC = avgJC;
    maxJ = 0;
    olddist = 0;
    if (dim == 3)
      thresh2 = 260;
    else
      thresh2 = 500;
  }
  endloop = 0;
  while (endloop == 0 && newN > 1) {
    if (mindist >= *thresh) {
      if (status == 1)
        endloop = 1;
      else
        break;
    }
    total = count[mini] + count[minj];
    for (k = 0; k < dim; k++)
      cb[mini][k] =
          (count[mini] * cb[mini][k] + count[minj] * cb[minj][k]) / total;
    count[mini] = total;
    ei = newN - 1;
    for (i = minj; i < ei; i++) {
      count[i] = count[i + 1];
      for (k = 0; k < dim; k++)
        cb[i][k] = cb[i + 1][k];
    }
    for (i = minj; i < ei; i++) {
      for (j = 0; j < minj; j++)
        dist[i][j] = dist[i + 1][j];
    }
    for (j = minj; j < ei; j++) {
      for (i = 0; i < minj; i++)
        dist[i][j] = dist[i][j + 1];
    }
    for (i = minj; i < ei; i++) {
      for (j = minj; j < ei; j++)
        dist[i][j] = dist[i + 1][j + 1];
    }
    newN--;
    if (status == 1) {
      avgJC = gettotalJC(B, P, newN, cb, dim, npt, ST);
      if (oldJC - avgJC > maxJ && mindist > thresh2) {
        maxJ = oldJC - avgJC;
        if (olddist < mindist)
          thresh2 = (olddist + mindist) / 2;
        else
          thresh2 = olddist - 0.01;
      }
      if (debug)
        printf("N=%d avgJC=%f dif=%f dist=%f thresh=%f maxJ=%f \n", newN, avgJC,
               oldJC - avgJC, mindist, thresh2, maxJ);
      oldJC = avgJC;
      olddist = mindist;
    }
    for (j = 0; j < newN; j++) {
      dist[mini][j] = distance2(cb[mini], cb[j], dim);
      dist[j][mini] = dist[mini][j];
    }
    mindist = 100000;
    ei = newN - 1;
    for (i = 0; i < ei; i++) {
      for (j = i + 1; j < newN; j++) {
        if (dist[i][j] < mindist) {
          mindist = dist[i][j];
          mini = i;
          minj = j;
        }
      }
    }
  }
  if (status == 1)
    *thresh = thresh2;
  return newN;
}


x86 assembly (clang, -O0):
<mergecb1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
movss  0xe64(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1238 <mergecb1+0xe8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1225 <mergecb1+0xd5>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1212 <mergecb1+0xc2>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1217 <mergecb1+0xc7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11bd <mergecb1+0x6d>
jmp    122a <mergecb1+0xda>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a8 <mergecb1+0x58>
cmpl   $0x1,0x28(%rbp)
jne    1408 <mergecb1+0x2b8>
mov    0x18(%rbp),%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12ca <mergecb1+0x17a>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    12b7 <mergecb1+0x167>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1274 <mergecb1+0x124>
jmp    12bc <mergecb1+0x16c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1261 <mergecb1+0x111>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1306 <mergecb1+0x1b6>
cvtsi2ssl -0x24(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12d1 <mergecb1+0x181>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1366 <mergecb1+0x216>
mov    -0x80(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    0x18(%rbp),%edx
call   1040 <distance2@plt>
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    0x18(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    131d <mergecb1+0x1cd>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    0x18(%rbp),%r8d
mov    -0x24(%rbp),%r9d
movss  -0x74(%rbp),%xmm0
call   1070 <gettotalJC@plt>
movss  %xmm0,-0x54(%rbp)
cmpl   $0x0,-0x84(%rbp)
je     13c0 <mergecb1+0x270>
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
movss  -0x54(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
lea    0xc5f(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
cmpl   $0x3,0x18(%rbp)
jne    13f6 <mergecb1+0x2a6>
movss  0xc1c(%rip),%xmm0
movss  %xmm0,-0x68(%rbp)
jmp    1403 <mergecb1+0x2b3>
movss  0xc06(%rip),%xmm0
movss  %xmm0,-0x68(%rbp)
jmp    1408 <mergecb1+0x2b8>
movl   $0x0,-0x4c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x4c(%rbp)
mov    %al,-0x85(%rbp)
jne    142e <mergecb1+0x2de>
cmpl   $0x1,-0x28(%rbp)
setg   %al
mov    %al,-0x85(%rbp)
mov    -0x85(%rbp),%al
test   $0x1,%al
jne    1441 <mergecb1+0x2f1>
jmp    1970 <mergecb1+0x820>
movss  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomiss (%rax),%xmm0
jb     1473 <mergecb1+0x323>
cmpl   $0x1,0x28(%rbp)
jne    1469 <mergecb1+0x319>
movl   $0x1,-0x4c(%rbp)
jmp    146e <mergecb1+0x31e>
jmp    1970 <mergecb1+0x820>
jmp    1473 <mergecb1+0x323>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1517 <mergecb1+0x3c7>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtsi2ssl -0x40(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1493 <mergecb1+0x343>
mov    -0x40(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15be <mergecb1+0x46e>
mov    0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    15ab <mergecb1+0x45b>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1562 <mergecb1+0x412>
jmp    15b0 <mergecb1+0x460>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1534 <mergecb1+0x3e4>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1633 <mergecb1+0x4e3>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1620 <mergecb1+0x4d0>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15d7 <mergecb1+0x487>
jmp    1625 <mergecb1+0x4d5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15c4 <mergecb1+0x474>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    16a8 <mergecb1+0x558>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1695 <mergecb1+0x545>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    164c <mergecb1+0x4fc>
jmp    169a <mergecb1+0x54a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1639 <mergecb1+0x4e9>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1721 <mergecb1+0x5d1>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    170e <mergecb1+0x5be>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16c0 <mergecb1+0x570>
jmp    1713 <mergecb1+0x5c3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16ae <mergecb1+0x55e>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x1,0x28(%rbp)
jne    183e <mergecb1+0x6ee>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    0x18(%rbp),%r8d
mov    -0x24(%rbp),%r9d
movss  -0x74(%rbp),%xmm0
call   1070 <gettotalJC@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jbe    17e2 <mergecb1+0x692>
movss  -0x50(%rbp),%xmm0
ucomiss -0x68(%rbp),%xmm0
jbe    17e2 <mergecb1+0x692>
movss  -0x58(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    17bf <mergecb1+0x66f>
movss  -0x64(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  0x85b(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
jmp    17dd <mergecb1+0x68d>
movss  -0x64(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x840(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
jmp    17e2 <mergecb1+0x692>
cmpl   $0x0,-0x84(%rbp)
je     182a <mergecb1+0x6da>
mov    -0x28(%rbp),%esi
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
subss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x68(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x60(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
lea    0x80c(%rip),%rdi
mov    $0x5,%al
call   1050 <printf@plt>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    18be <mergecb1+0x76e>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x18(%rbp),%edx
call   1040 <distance2@plt>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1845 <mergecb1+0x6f5>
movss  0x73a(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    196b <mergecb1+0x81b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1958 <mergecb1+0x808>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1945 <mergecb1+0x7f5>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    194a <mergecb1+0x7fa>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18f0 <mergecb1+0x7a0>
jmp    195d <mergecb1+0x80d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18db <mergecb1+0x78b>
jmp    140f <mergecb1+0x2bf>
cmpl   $0x1,0x28(%rbp)
jne    1987 <mergecb1+0x837>
movss  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mergecb1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9d,%r14d
mov    %rcx,0x98(%rsp)
mov    %rdx,%r10
mov    %rsi,0x30(%rsp)
mov    %rdi,%r15
lea    -0x1(%r14),%eax
mov    %r9d,%ebp
mov    %eax,%r11d
cmp    $0x2,%r9d
jl     11e1 <mergecb1+0xa1>
movss  0x1e81(%rip),%xmm0
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    119f <mergecb1+0x5f>
nopl   0x0(%rax,%rax,1)
movaps %xmm0,%xmm5
add    $0x1,%rax
movaps %xmm5,%xmm0
cmp    %r11,%rcx
je     11e9 <mergecb1+0xa9>
mov    %rcx,%rdx
add    $0x1,%rcx
cmp    %rbp,%rcx
jae    1190 <mergecb1+0x50>
mov    (%r15,%rdx,8),%rsi
mov    %rax,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rdi,4),%xmm5
ucomiss %xmm5,%xmm0
cmova  %edx,%r13d
cmova  %edi,%ebx
minss  %xmm0,%xmm5
add    $0x1,%rdi
movaps %xmm5,%xmm0
cmp    %rdi,%rbp
jne    11c0 <mergecb1+0x80>
jmp    1193 <mergecb1+0x53>
movss  0x1e17(%rip),%xmm5
mov    %r8d,0x1c(%rsp)
cmpl   $0x1,0x158(%rsp)
01
mov    %r10,0x28(%rsp)
mov    %rbp,0x90(%rsp)
jne    15ea <mergecb1+0x4aa>
movss  %xmm5,0x8(%rsp)
mov    %r11,0x88(%rsp)
mov    0x148(%rsp),%ebp
mov    %ebp,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %ebp,%r11d
mov    0x1c(%rsp),%r10d
test   %r10d,%r10d
jle    146e <mergecb1+0x32e>
mov    %r11d,%r12d
lea    (%rax,%r12,4),%rcx
mov    %rcx,0x40(%rsp)
mov    0x30(%rsp),%rdx
lea    (%rdx,%r12,4),%rcx
mov    %rcx,0x48(%rsp)
mov    %r12d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x80(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x78(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
mov    %rcx,%rsi
mov    %rcx,0x70(%rsp)
and    %rcx,%rdi
mov    %rdi,0x38(%rsp)
mov    %r12,%rcx
neg    %rcx
lea    0x30(%rdx),%rsi
mov    %rsi,0x68(%rsp)
lea    0x4(%rax),%rsi
mov    %rsi,0x10(%rsp)
add    $0x4,%rdx
mov    %rdx,0x20(%rsp)
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    12cd <mergecb1+0x18d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9d
cmp    %r10d,%r9d
je     146e <mergecb1+0x32e>
test   %r11d,%r11d
jle    12c0 <mergecb1+0x180>
movslq %r8d,%r8
cmp    $0x8,%r11d
jb     1301 <mergecb1+0x1c1>
mov    0x48(%rsp),%rdx
lea    (%rdx,%r8,4),%rdx
cmp    %rdx,%rax
jae    1394 <mergecb1+0x254>
mov    0x30(%rsp),%rdx
lea    (%rdx,%r8,4),%rdx
cmp    0x40(%rsp),%rdx
jae    1394 <mergecb1+0x254>
xor    %esi,%esi
test   $0x1,%r12b
jne    1310 <mergecb1+0x1d0>
mov    %rsi,%rbp
jmp    1330 <mergecb1+0x1f0>
xchg   %ax,%ax
mov    0x30(%rsp),%rdx
movss  (%rdx,%r8,4),%xmm0
add    $0x1,%r8
addss  (%rax,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rsi,4)
mov    %rsi,%rbp
or     $0x1,%rbp
not    %rsi
cmp    %rcx,%rsi
je     12c0 <mergecb1+0x180>
mov    %r12,%rsi
sub    %rbp,%rsi
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbp,4),%rbp
mov    0x20(%rsp),%rdx
lea    (%rdx,%r8,4),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rdi,%rdx,4),%xmm0
addss  -0x4(%rbp,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rdx,4)
movss  (%rdi,%rdx,4),%xmm0
addss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1360 <mergecb1+0x220>
add    %rdx,%r8
jmp    12c0 <mergecb1+0x180>
cmpq   $0x0,0x78(%rsp)
je     140d <mergecb1+0x2cd>
mov    0x68(%rsp),%rdx
lea    (%rdx,%r8,4),%rsi
mov    0x38(%rsp),%r11
xor    %r10d,%r10d
nopl   (%rax)
movups -0x30(%rsi,%r10,4),%xmm0
movups -0x20(%rsi,%r10,4),%xmm1
movups (%rax,%r10,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rax,%r10,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rax,%r10,4),%xmm1
movups 0x30(%rax,%r10,4),%xmm3
movups %xmm2,(%rax,%r10,4)
movups %xmm0,0x10(%rax,%r10,4)
movups -0x10(%rsi,%r10,4),%xmm0
addps  %xmm1,%xmm0
movups (%rsi,%r10,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rax,%r10,4)
movups %xmm1,0x30(%rax,%r10,4)
add    $0x10,%r10
add    $0xfffffffffffffffe,%r11
jne    13b0 <mergecb1+0x270>
jmp    1410 <mergecb1+0x2d0>
xor    %r10d,%r10d
testb  $0x1,0x70(%rsp)
mov    0x148(%rsp),%r11d
je     144d <mergecb1+0x30d>
lea    (%r10,%r8,1),%rdx
mov    0x30(%rsp),%rsi
movups (%rsi,%rdx,4),%xmm0
movups 0x10(%rsi,%rdx,4),%xmm1
movups (%rax,%r10,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rax,%r10,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rax,%r10,4)
movups %xmm0,0x10(%rax,%r10,4)
mov    0x80(%rsp),%rdx
add    %rdx,%r8
mov    %rdx,%rsi
cmp    %r12,%rdx
mov    0x1c(%rsp),%r10d
je     12c0 <mergecb1+0x180>
jmp    1303 <mergecb1+0x1c3>
test   %r11d,%r11d
jle    1517 <mergecb1+0x3d7>
xorps  %xmm0,%xmm0
cvtsi2ss %r10d,%xmm0
mov    %r11d,%ebp
cmp    $0x4,%r11d
jae    148c <mergecb1+0x34c>
xor    %ecx,%ecx
jmp    1500 <mergecb1+0x3c0>
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     2177 <mergecb1+0x1037>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rax,%rsi,4),%xmm2
movups 0x10(%rax,%rsi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%rax,%rsi,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%rax,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    14c0 <mergecb1+0x380>
test   $0x1,%dl
je     14f2 <mergecb1+0x3b2>
movups (%rax,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rax,%rsi,4)
cmp    %rbp,%rcx
je     1517 <mergecb1+0x3d7>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1500 <mergecb1+0x3c0>
test   %r10d,%r10d
mov    %rax,0x58(%rsp)
jle    1570 <mergecb1+0x430>
movslq %r11d,%rcx
shl    $0x2,%rcx
mov    %rcx,0x48(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x40(%rsp)
mov    %r10d,%ebp
mov    0x30(%rsp),%r12
xchg   %ax,%ax
mov    %r12,%rdi
mov    0x58(%rsp),%rsi
mov    0x148(%rsp),%edx
call   1040 <distance2@plt>
movss  0x40(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x40(%rsp)
add    0x48(%rsp),%r12
add    $0xffffffff,%ebp
jne    1540 <mergecb1+0x400>
jmp    1579 <mergecb1+0x439>
xorps  %xmm0,%xmm0
movss  %xmm0,0x40(%rsp)
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
mov    0x98(%rsp),%rsi
mov    %r14d,%edx
mov    0x28(%rsp),%rbp
mov    %rbp,%rcx
mov    0x148(%rsp),%r12d
mov    %r12d,%r8d
mov    0x1c(%rsp),%r9d
movss  0x40(%rsp),%xmm0
call   1060 <gettotalJC@plt>
mov    %rbp,%r10
movss  %xmm0,0x4(%rsp)
xor    %eax,%eax
cmp    $0x3,%r12d
sete   %al
lea    0x1a39(%rip),%rcx
movss  (%rcx,%rax,4),%xmm1
mov    0x90(%rsp),%rbp
mov    0x88(%rsp),%r11
movss  0x8(%rsp),%xmm5
cmp    $0x2,%r14d
jl     2145 <mergecb1+0x1005>
movss  %xmm1,0x18(%rsp)
add    $0xfffffffe,%r14d
mov    0x148(%rsp),%eax
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xd0(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xc8(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0xd8(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x80(%rsp)
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rdx,%rcx
mov    %rdx,0xc0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xb8(%rsp)
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0xe0(%rsp)
mov    %esi,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0xf8(%rsp)
and    $0x3,%eax
mov    %rax,0x48(%rsp)
mov    %rcx,0x78(%rsp)
shl    $0x5,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rsp)
mov    %r14,0x58(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x54(%rsp)
lea    -0x9(%rbp),%rax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0xb0(%rsp)
mov    %rbp,0x20(%rsp)
mov    %r15,0xf0(%rsp)
mov    %rcx,0x70(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x140(%rsp),%rax
movss  (%rax),%xmm10
cmpl   $0x1,0x158(%rsp)
01
je     1701 <mergecb1+0x5c1>
ucomiss %xmm10,%xmm5
jae    215d <mergecb1+0x101d>
movslq %r13d,%r9
mov    0x150(%rsp),%rdx
mov    (%rdx,%r9,4),%eax
movslq %ebx,%rcx
mov    (%rdx,%rcx,4),%esi
lea    (%rsi,%rax,1),%r8d
cmpl   $0x0,0x148(%rsp)
mov    0x148(%rsp),%ebp
jle    18d0 <mergecb1+0x790>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%r10,%r9,8),%rdx
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
mov    (%r10,%rcx,8),%rsi
xorps  %xmm2,%xmm2
cvtsi2ss %r8d,%xmm2
cmpl   $0x4,0x148(%rsp)
04
jb     1771 <mergecb1+0x631>
lea    (%rsi,%rbp,4),%rax
cmp    %rax,%rdx
jae    180f <mergecb1+0x6cf>
lea    (%rdx,%rbp,4),%rax
cmp    %rax,%rsi
jae    180f <mergecb1+0x6cf>
xor    %edi,%edi
mov    %rdi,%rax
test   $0x1,%bpl
je     17a2 <mergecb1+0x662>
movss  (%rsi,%rdi,4),%xmm3
mulss  %xmm1,%xmm3
movss  (%rdx,%rdi,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,(%rdx,%rdi,4)
mov    %rdi,%rax
or     $0x1,%rax
not    %rdi
cmp    0xe0(%rsp),%rdi
je     18d0 <mergecb1+0x790>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rsi,%rax,4),%xmm3
mulss  %xmm1,%xmm3
movss  (%rdx,%rax,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,(%rdx,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm3
mulss  %xmm1,%xmm3
movss  0x4(%rdx,%rax,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,0x4(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    17c0 <mergecb1+0x680>
jmp    18d0 <mergecb1+0x790>
movaps %xmm1,%xmm9
shufps $0x0,%xmm1,%xmm9
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
movaps %xmm2,%xmm8
shufps $0x0,%xmm2,%xmm8
cmpq   $0x0,0xc8(%rsp)
je     212a <mergecb1+0xfea>
mov    0xb8(%rsp),%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm6
mulps  %xmm9,%xmm6
movups (%rdx,%rax,4),%xmm7
movups 0x10(%rdx,%rax,4),%xmm4
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
divps  %xmm8,%xmm7
movups %xmm7,(%rdx,%rax,4)
movups 0x10(%rsi,%rax,4),%xmm6
mulps  %xmm9,%xmm6
mulps  %xmm3,%xmm4
addps  %xmm6,%xmm4
divps  %xmm8,%xmm4
movups %xmm4,0x10(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    1850 <mergecb1+0x710>
testb  $0x1,0xc0(%rsp)
01
je     18b5 <mergecb1+0x775>
movups (%rdx,%rax,4),%xmm4
movups (%rsi,%rax,4),%xmm6
mulps  %xmm9,%xmm6
mulps  %xmm4,%xmm3
addps  %xmm6,%xmm3
divps  %xmm8,%xmm3
movups %xmm3,(%rdx,%rax,4)
mov    0xd0(%rsp),%rax
mov    %rax,%rdi
cmp    %rbp,%rax
jne    1773 <mergecb1+0x633>
nopl   0x0(%rax)
mov    %r11,0x88(%rsp)
mov    %r9,0x38(%rsp)
mov    0x150(%rsp),%r11
mov    %r8d,(%r11,%r9,4)
mov    0x20(%rsp),%rax
lea    -0x1(%rax),%r14
cmp    %rcx,%r14
movss  0x40(%rsp),%xmm2
mov    0x48(%rsp),%rbp
jle    1f20 <mergecb1+0xde0>
mov    0xb0(%rsp),%rax
not    %rax
add    0x90(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
mov    %rcx,%r9
mov    0x148(%rsp),%r8d
mov    0x148(%rsp),%ecx
mov    0xd8(%rsp),%r12
jmp    1959 <mergecb1+0x819>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r14,%r9
jge    1ae0 <mergecb1+0x9a0>
mov    %r9,%rdx
add    $0x1,%r9
mov    0x4(%r11,%rdx,4),%eax
mov    %eax,(%r11,%rdx,4)
test   %r8d,%r8d
jle    1950 <mergecb1+0x810>
mov    (%r10,%r9,8),%rax
mov    (%r10,%rdx,8),%rdx
cmp    $0x8,%r8d
jb     198e <mergecb1+0x84e>
lea    (%rax,%rcx,4),%rsi
cmp    %rsi,%rdx
jae    19fc <mergecb1+0x8bc>
lea    (%rdx,%rcx,4),%rsi
cmp    %rsi,%rax
jae    19fc <mergecb1+0x8bc>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %rcx,%rdi
test   %rbp,%rbp
je     19b4 <mergecb1+0x874>
xchg   %ax,%ax
movss  (%rax,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    19a0 <mergecb1+0x860>
cmp    $0x3,%rdi
mov    0x48(%rsp),%rbp
jb     1950 <mergecb1+0x810>
nop
movss  (%rax,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm0
movss  %xmm0,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    19c0 <mergecb1+0x880>
jmp    1950 <mergecb1+0x810>
cmpq   $0x18,0x80(%rsp)
jae    1a0b <mergecb1+0x8cb>
xor    %esi,%esi
jmp    1a78 <mergecb1+0x938>
mov    0xf8(%rsp),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movups %xmm0,(%rdx,%rsi,4)
movups %xmm1,0x10(%rdx,%rsi,4)
movups 0x20(%rax,%rsi,4),%xmm0
movups 0x30(%rax,%rsi,4),%xmm1
movups %xmm0,0x20(%rdx,%rsi,4)
movups %xmm1,0x30(%rdx,%rsi,4)
movups 0x40(%rax,%rsi,4),%xmm0
movups 0x50(%rax,%rsi,4),%xmm1
movups %xmm0,0x40(%rdx,%rsi,4)
movups %xmm1,0x50(%rdx,%rsi,4)
movups 0x60(%rax,%rsi,4),%xmm0
movups 0x70(%rax,%rsi,4),%xmm1
movups %xmm0,0x60(%rdx,%rsi,4)
movups %xmm1,0x70(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1a20 <mergecb1+0x8e0>
cmpq   $0x0,0x78(%rsp)
mov    0x70(%rsp),%r11
je     1abb <mergecb1+0x97b>
lea    (%rdx,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    1aa0 <mergecb1+0x960>
mov    %r12,%rdi
mov    %r12,%rsi
cmp    %rcx,%r12
mov    0x48(%rsp),%rbp
mov    0x150(%rsp),%r11
je     1950 <mergecb1+0x810>
jmp    1990 <mergecb1+0x850>
nopl   0x0(%rax)
mov    0x10(%rsp),%rsi
cmp    %rsi,%r14
jle    1f20 <mergecb1+0xde0>
mov    %ebx,%r9d
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
lea    -0x1(%r9),%rax
mov    %rax,0x8(%rsp)
mov    %edx,%edi
and    $0x3,%edi
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rdx
mov    %rdx,0xe8(%rsp)
mov    %r9d,%r11d
and    $0x3,%r11d
mov    %rdi,0x100(%rsp)
mov    %rdi,%rdx
shl    $0x5,%rdx
mov    %rsi,%rax
jmp    1b59 <mergecb1+0xa19>
nopl   0x0(%rax)
cmp    %r14,%rax
jge    1ce0 <mergecb1+0xba0>
mov    %rax,%rsi
add    $0x1,%rax
test   %ebx,%ebx
jle    1b50 <mergecb1+0xa10>
mov    (%r15,%rax,8),%r8
mov    (%r15,%rsi,8),%r10
cmp    $0x8,%ebx
jb     1b8b <mergecb1+0xa4b>
lea    (%r8,%r9,4),%rsi
cmp    %rsi,%r10
jae    1c04 <mergecb1+0xac4>
lea    (%r10,%r9,4),%rsi
cmp    %rsi,%r8
jae    1c04 <mergecb1+0xac4>
xor    %esi,%esi
mov    0x8(%rsp),%rbp
sub    %rsi,%rbp
test   %r11,%r11
je     1bb6 <mergecb1+0xa76>
mov    %r11,%rdi
nopl   (%rax)
movss  (%r8,%rsi,4),%xmm0
movss  %xmm0,(%r10,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1ba0 <mergecb1+0xa60>
cmp    $0x3,%rbp
jb     1b50 <mergecb1+0xa10>
nopl   0x0(%rax)
movss  (%r8,%rsi,4),%xmm0
movss  %xmm0,(%r10,%rsi,4)
movss  0x4(%r8,%rsi,4),%xmm0
movss  %xmm0,0x4(%r10,%rsi,4)
movss  0x8(%r8,%rsi,4),%xmm0
movss  %xmm0,0x8(%r10,%rsi,4)
movss  0xc(%r8,%rsi,4),%xmm0
movss  %xmm0,0xc(%r10,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1bc0 <mergecb1+0xa80>
jmp    1b50 <mergecb1+0xa10>
cmpq   $0x18,0x60(%rsp)
jae    1c10 <mergecb1+0xad0>
xor    %esi,%esi
jmp    1c88 <mergecb1+0xb48>
mov    0xe8(%rsp),%rbp
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r8,%rsi,4),%xmm0
movups 0x10(%r8,%rsi,4),%xmm1
movups %xmm0,(%r10,%rsi,4)
movups %xmm1,0x10(%r10,%rsi,4)
movups 0x20(%r8,%rsi,4),%xmm0
movups 0x30(%r8,%rsi,4),%xmm1
movups %xmm0,0x20(%r10,%rsi,4)
movups %xmm1,0x30(%r10,%rsi,4)
movups 0x40(%r8,%rsi,4),%xmm0
movups 0x50(%r8,%rsi,4),%xmm1
movups %xmm0,0x40(%r10,%rsi,4)
movups %xmm1,0x50(%r10,%rsi,4)
movups 0x60(%r8,%rsi,4),%xmm0
movups 0x70(%r8,%rsi,4),%xmm1
movups %xmm0,0x60(%r10,%rsi,4)
movups %xmm1,0x70(%r10,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rbp
jne    1c20 <mergecb1+0xae0>
cmpq   $0x0,0x100(%rsp)
je     1ccc <mergecb1+0xb8c>
lea    (%r10,%rsi,4),%rbp
add    $0x10,%rbp
lea    (%r8,%rsi,4),%rsi
add    $0x10,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,1)
movups %xmm1,0x0(%rbp,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1cb0 <mergecb1+0xb70>
mov    %rcx,%rsi
cmp    %r9,%rcx
je     1b50 <mergecb1+0xa10>
jmp    1b8d <mergecb1+0xa4d>
nopl   (%rax)
mov    0x10(%rsp),%r8
cmp    %r8,%r14
mov    0x28(%rsp),%r10
jle    1f20 <mergecb1+0xde0>
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %r8,%rsi
jmp    1d09 <mergecb1+0xbc9>
xchg   %ax,%ax
cmp    %r14,%rsi
jge    1d9c <mergecb1+0xc5c>
mov    %rsi,%rcx
add    $0x1,%rsi
test   %ebx,%ebx
jle    1d00 <mergecb1+0xbc0>
cmpq   $0x3,0x8(%rsp)
jae    1d20 <mergecb1+0xbe0>
xor    %ebp,%ebp
jmp    1d74 <mergecb1+0xc34>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbp,8),%rdi
movss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
mov    0x8(%r15,%rbp,8),%rdi
movss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
mov    0x10(%r15,%rbp,8),%rdi
movss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
mov    0x18(%r15,%rbp,8),%rdi
movss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    $0x4,%rbp
cmp    %rbp,%rax
jne    1d30 <mergecb1+0xbf0>
test   $0x3,%r9b
je     1d00 <mergecb1+0xbc0>
lea    (%r15,%rbp,8),%rdi
xor    %ebp,%ebp
mov    (%rdi,%rbp,8),%rdx
movss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1d80 <mergecb1+0xc40>
jmp    1d00 <mergecb1+0xbc0>
cmp    %r8,%r14
jle    1f20 <mergecb1+0xde0>
mov    %r8,%rdx
mov    0xa8(%rsp),%rax
sub    %r8,%rax
lea    -0x8(%rax),%r12
mov    %r12,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0x8(%rsp)
add    %r8,%rcx
mov    %rcx,0x60(%rsp)
mov    0xa0(%rsp),%r11
sub    %r8,%r11
shr    $0x3,%r11
add    $0x1,%r11
and    $0xfffffffffffffffe,%r11
mov    %r8,%rcx
jmp    1e0e <mergecb1+0xcce>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r14,%rcx
mov    0x10(%rsp),%rdx
jge    1f20 <mergecb1+0xde0>
mov    (%r15,%rcx,8),%rsi
mov    0x8(%r15,%rcx,8),%r8
add    $0x1,%rcx
cmp    $0x8,%rax
jb     1f00 <mergecb1+0xdc0>
mov    0x10(%rsp),%rdx
lea    (%rsi,%rdx,4),%rdx
mov    0x20(%rsp),%rdi
lea    (%r8,%rdi,4),%rdi
cmp    %rdi,%rdx
jae    1e5e <mergecb1+0xd1e>
mov    0xa8(%rsp),%rdx
lea    (%rsi,%rdx,4),%rdi
mov    0x10(%rsp),%rdx
lea    (%r8,%rdx,4),%rbp
add    $0x4,%rbp
cmp    %rdi,%rbp
jb     1f00 <mergecb1+0xdc0>
cmp    $0x8,%r12
jae    1e68 <mergecb1+0xd28>
xor    %ebp,%ebp
jmp    1ec4 <mergecb1+0xd84>
mov    0x10(%rsp),%rdi
lea    (%rsi,%rdi,4),%rdx
add    $0x30,%rdx
lea    (%r8,%rdi,4),%r10
add    $0x34,%r10
mov    %r11,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%r10,%rbp,4),%xmm0
movups -0x20(%r10,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,4)
movups %xmm1,-0x20(%rdx,%rbp,4)
movups -0x10(%r10,%rbp,4),%xmm0
movups (%r10,%rbp,4),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,4)
movups %xmm1,(%rdx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1e90 <mergecb1+0xd50>
test   $0x1,%r9b
mov    0x28(%rsp),%r10
je     1ee9 <mergecb1+0xda9>
add    0x10(%rsp),%rbp
movups 0x4(%r8,%rbp,4),%xmm0
movups 0x14(%r8,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rbp,4)
movups %xmm1,0x10(%rsi,%rbp,4)
mov    0x60(%rsp),%rdx
cmp    0x8(%rsp),%rax
je     1e00 <mergecb1+0xcc0>
nopl   0x0(%rax)
movss  0x4(%r8,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
lea    0x1(%rdx),%rdi
mov    %rdi,%rdx
cmp    %r14,%rdi
jl     1f00 <mergecb1+0xdc0>
jmp    1e00 <mergecb1+0xcc0>
nopl   (%rax)
cmpl   $0x1,0x158(%rsp)
01
movss  %xmm5,0x8(%rsp)
movss  %xmm10,0x68(%rsp)
jne    1fa0 <mergecb1+0xe60>
mov    0x30(%rsp),%rdi
mov    0x98(%rsp),%rsi
mov    %r14d,%edx
mov    %r10,%rcx
mov    0x148(%rsp),%r8d
mov    0x1c(%rsp),%r9d
movaps %xmm2,%xmm0
call   1060 <gettotalJC@plt>
movss  0x4(%rsp),%xmm1
subss  %xmm0,%xmm1
ucomiss 0x54(%rsp),%xmm1
jbe    1fa7 <mergecb1+0xe67>
movss  0x8(%rsp),%xmm3
ucomiss 0x18(%rsp),%xmm3
jbe    1fbf <mergecb1+0xe7f>
movss  (%rsp),%xmm2
ucomiss %xmm2,%xmm3
jbe    1fcc <mergecb1+0xe8c>
mov    0x38(%rsp),%r12
addss  %xmm3,%xmm2
mulss  0x106c(%rip),%xmm2
jmp    1fe1 <mergecb1+0xea1>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%r12
jmp    1ffd <mergecb1+0xebd>
mov    0x38(%rsp),%r12
movss  %xmm0,0x4(%rsp)
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%rsp)
jmp    1ff8 <mergecb1+0xeb8>
mov    0x38(%rsp),%r12
movss  %xmm0,0x4(%rsp)
jmp    1ff3 <mergecb1+0xeb3>
mov    0x38(%rsp),%r12
cvtss2sd %xmm2,%xmm2
addsd  0x1033(%rip),%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x18(%rsp)
movss  %xmm0,0x4(%rsp)
movss  %xmm1,0x54(%rsp)
movss  %xmm3,(%rsp)
mov    0x28(%rsp),%r10
xor    %ebp,%ebp
mov    0xf0(%rsp),%r15
nopw   0x0(%rax,%rax,1)
mov    (%r10,%r12,8),%rdi
mov    (%r10,%rbp,8),%rsi
mov    0x148(%rsp),%edx
call   1040 <distance2@plt>
mov    0x88(%rsp),%r11
mov    0x28(%rsp),%r10
mov    (%r15,%r12,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    (%r15,%rbp,8),%rax
movss  %xmm0,(%rax,%r12,4)
add    $0x1,%rbp
cmp    %rbp,%r11
jne    2010 <mergecb1+0xed0>
cmpq   $0x3,0x20(%rsp)
movss  0x8(%rsp),%xmm2
movabs $0x100000000,%r12
jl     213f <mergecb1+0xfff>
mov    $0x1,%r9d
movabs $0x200000000,%rbp
xor    %r8d,%r8d
movss  0xf7c(%rip),%xmm0
movss  0x68(%rsp),%xmm3
jmp    209e <mergecb1+0xf5e>
nopl   0x0(%rax)
add    $0x1,%r9
add    %r12,%rbp
cmp    0x58(%rsp),%r8
je     20f0 <mergecb1+0xfb0>
mov    %r8,%rsi
add    $0x1,%r8
cmp    %r14,%r8
jge    2090 <mergecb1+0xf50>
mov    (%r15,%rsi,8),%rdi
mov    %rbp,%rcx
mov    %r9,%rax
movaps %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rax,4),%xmm0
ucomiss %xmm0,%xmm1
cmova  %esi,%r13d
cmova  %eax,%ebx
minss  %xmm1,%xmm0
add    $0x1,%rax
mov    %rcx,%rdx
sar    $0x20,%rdx
add    %r12,%rcx
movaps %xmm0,%xmm1
cmp    %r14,%rdx
jl     20c0 <mergecb1+0xf80>
jmp    2090 <mergecb1+0xf50>
nopl   0x0(%rax,%rax,1)
ucomiss %xmm3,%xmm2
jae    213f <mergecb1+0xfff>
add    $0xffffffffffffffff,%r11
addq   $0xffffffffffffffff,0x58(%rsp)
addq   $0x1,0xb0(%rsp)
addq   $0xffffffffffffffff,0xa0(%rsp)
movaps %xmm0,%xmm5
cmpq   $0x3,0x20(%rsp)
mov    %r14,%rax
mov    %r14,0x20(%rsp)
jge    16e0 <mergecb1+0x5a0>
jmp    213f <mergecb1+0xfff>
xor    %eax,%eax
testb  $0x1,0xc0(%rsp)
01
jne    189b <mergecb1+0x75b>
jmp    18b5 <mergecb1+0x775>
movss  0x18(%rsp),%xmm1
cmpl   $0x1,0x158(%rsp)
01
jne    2162 <mergecb1+0x1022>
mov    0x140(%rsp),%rax
movss  %xmm1,(%rax)
jmp    2162 <mergecb1+0x1022>
mov    0x20(%rsp),%r14
mov    %r14d,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    14e7 <mergecb1+0x3a7>
jmp    14f2 <mergecb1+0x3b2>

LLVM IR (-O0):
@.str = [23 x i8] c"N=%d avgJC=%f dist=%f\0A\00"
@.str.1 = [49 x i8] c"N=%d avgJC=%f dif=%f dist=%f thresh=%f maxJ=%f \0A\00"
define i32 @mergecb1(float** %0, float* %1, float** %2, i8* %3, i32 %4, i32 %5, float* %6, i32 %7, i32* %8, i32 %9) {
%11 = alloca float**
%12 = alloca float*
%13 = alloca float**
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca float*
%18 = alloca i32
%19 = alloca i32*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float*
%38 = alloca float
%39 = alloca float*
%40 = alloca i32
store float** %0, float*** %11
store float* %1, float** %12
store float** %2, float*** %13
store i8* %3, i8** %14
store i32 %4, i32* %15
store i32 %5, i32* %16
store float* %6, float** %17
store i32 %7, i32* %18
store i32* %8, i32** %19
store i32 %9, i32* %20
store i32 0, i32* %40
%41 = load i32, i32* %16
%42 = sub nsw i32 %41, 1
store i32 %42, i32* %28
store float 1.000000e+05, float* %30
store i32 0, i32* %21
br label %43
43: ; preds = %83, %10
%44 = load i32, i32* %21
%45 = load i32, i32* %28
%46 = icmp slt i32 %44, %45
br i1 %46, label %47, label %86
47: ; preds = %43
%48 = load i32, i32* %21
%49 = add nsw i32 %48, 1
store i32 %49, i32* %22
br label %50
50: ; preds = %79, %47
%51 = load i32, i32* %22
%52 = load i32, i32* %16
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %82
54: ; preds = %50
%55 = load float**, float*** %11
%56 = load i32, i32* %21
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float*, float** %55, i64 %57
%59 = load float*, float** %58
%60 = load i32, i32* %22
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = load float, float* %30
%65 = fcmp olt float %63, %64
br i1 %65, label %66, label %78
66: ; preds = %54
%67 = load float**, float*** %11
%68 = load i32, i32* %21
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float*, float** %67, i64 %69
%71 = load float*, float** %70
%72 = load i32, i32* %22
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
store float %75, float* %30
%76 = load i32, i32* %21
store i32 %76, i32* %24
%77 = load i32, i32* %22
store i32 %77, i32* %25
br label %78
78: ; preds = %66, %54
br label %79
79: ; preds = %78
%80 = load i32, i32* %22
%81 = add nsw i32 %80, 1
store i32 %81, i32* %22
br label %50
82: ; preds = %50
br label %83
83: ; preds = %82
%84 = load i32, i32* %21
%85 = add nsw i32 %84, 1
store i32 %85, i32* %21
br label %43
86: ; preds = %43
%87 = load i32, i32* %20
%88 = icmp eq i32 %87, 1
br i1 %88, label %89, label %185
89: ; preds = %86
%90 = load i32, i32* %18
%91 = call i64 @calloc(i32 %90, i32 4)
%92 = inttoptr i64 %91 to float*
store float* %92, float** %37
store i32 0, i32* %21
store i32 0, i32* %23
br label %93
93: ; preds = %119, %89
%94 = load i32, i32* %23
%95 = load i32, i32* %15
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %122
97: ; preds = %93
store i32 0, i32* %22
br label %98
98: ; preds = %115, %97
%99 = load i32, i32* %22
%100 = load i32, i32* %18
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %118
102: ; preds = %98
%103 = load float*, float** %12
%104 = load i32, i32* %21
%105 = add nsw i32 %104, 1
store i32 %105, i32* %21
%106 = sext i32 %104 to i64
%107 = getelementptr inbounds float, float* %103, i64 %106
%108 = load float, float* %107
%109 = load float*, float** %37
%110 = load i32, i32* %22
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = load float, float* %112
%114 = fadd float %113, %108
store float %114, float* %112
br label %115
115: ; preds = %102
%116 = load i32, i32* %22
%117 = add nsw i32 %116, 1
store i32 %117, i32* %22
br label %98
118: ; preds = %98
br label %119
119: ; preds = %118
%120 = load i32, i32* %23
%121 = add nsw i32 %120, 1
store i32 %121, i32* %23
br label %93
122: ; preds = %93
store i32 0, i32* %22
br label %123
123: ; preds = %136, %122
%124 = load i32, i32* %22
%125 = load i32, i32* %18
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %139
127: ; preds = %123
%128 = load i32, i32* %15
%129 = sitofp i32 %128 to float
%130 = load float*, float** %37
%131 = load i32, i32* %22
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %130, i64 %132
%134 = load float, float* %133
%135 = fdiv float %134, %129
store float %135, float* %133
br label %136
136: ; preds = %127
%137 = load i32, i32* %22
%138 = add nsw i32 %137, 1
store i32 %138, i32* %22
br label %123
139: ; preds = %123
store float 0.000000e+00, float* %38
%140 = load float*, float** %12
store float* %140, float** %39
store i32 0, i32* %23
br label %141
141: ; preds = %156, %139
%142 = load i32, i32* %23
%143 = load i32, i32* %15
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %159
145: ; preds = %141
%146 = load float*, float** %39
%147 = load float*, float** %37
%148 = load i32, i32* %18
%149 = call float @distance2(float* %146, float* %147, i32 %148)
%150 = load float, float* %38
%151 = fadd float %150, %149
store float %151, float* %38
%152 = load i32, i32* %18
%153 = load float*, float** %39
%154 = sext i32 %152 to i64
%155 = getelementptr inbounds float, float* %153, i64 %154
store float* %155, float** %39
br label %156
156: ; preds = %145
%157 = load i32, i32* %23
%158 = add nsw i32 %157, 1
store i32 %158, i32* %23
br label %141
159: ; preds = %141
%160 = load float*, float** %37
%161 = call i32 @free(float* %160)
%162 = load float*, float** %12
%163 = load i8*, i8** %14
%164 = load i32, i32* %16
%165 = load float**, float*** %13
%166 = load i32, i32* %18
%167 = load i32, i32* %15
%168 = load float, float* %38
%169 = call float @gettotalJC(float* %162, i8* %163, i32 %164, float** %165, i32 %166, i32 %167, float %168)
store float %169, float* %31
%170 = load i32, i32* %40
%171 = icmp ne i32 %170, 0
br i1 %171, label %172, label %178
172: ; preds = %159
%173 = load i32, i32* %16
%174 = sub nsw i32 %173, 1
%175 = load float, float* %31
%176 = load float, float* %30
%177 = call i32 (i8*, i32, float, float, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 %174, float %175, float %176)
br label %178
178: ; preds = %172, %159
%179 = load float, float* %31
store float %179, float* %32
store float 0.000000e+00, float* %34
store float 0.000000e+00, float* %35
%180 = load i32, i32* %18
%181 = icmp eq i32 %180, 3
br i1 %181, label %182, label %183
182: ; preds = %178
store float 2.600000e+02, float* %36
br label %184
183: ; preds = %178
store float 5.000000e+02, float* %36
br label %184
184: ; preds = %183, %182
br label %185
185: ; preds = %184, %86
store i32 0, i32* %29
br label %186
186: ; preds = %587, %185
%187 = load i32, i32* %29
%188 = icmp eq i32 %187, 0
br i1 %188, label %189, label %192
189: ; preds = %186
%190 = load i32, i32* %16
%191 = icmp sgt i32 %190, 1
br label %192
192: ; preds = %189, %186
%193 = phi i1 [ false, %186 ], [ %191, %189 ]
br i1 %193, label %194, label %588
194: ; preds = %192
%195 = load float, float* %30
%196 = load float*, float** %17
%197 = load float, float* %196
%198 = fcmp oge float %195, %197
br i1 %198, label %199, label %205
199: ; preds = %194
%200 = load i32, i32* %20
%201 = icmp eq i32 %200, 1
br i1 %201, label %202, label %203
202: ; preds = %199
store i32 1, i32* %29
br label %204
203: ; preds = %199
br label %588
204: ; preds = %202
br label %205
205: ; preds = %204, %194
%206 = load i32*, i32** %19
%207 = load i32, i32* %24
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32, i32* %206, i64 %208
%210 = load i32, i32* %209
%211 = load i32*, i32** %19
%212 = load i32, i32* %25
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds i32, i32* %211, i64 %213
%215 = load i32, i32* %214
%216 = add nsw i32 %210, %215
store i32 %216, i32* %26
store i32 0, i32* %27
br label %217
217: ; preds = %265, %205
%218 = load i32, i32* %27
%219 = load i32, i32* %18
%220 = icmp slt i32 %218, %219
br i1 %220, label %221, label %268
221: ; preds = %217
%222 = load i32*, i32** %19
%223 = load i32, i32* %24
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i32, i32* %222, i64 %224
%226 = load i32, i32* %225
%227 = sitofp i32 %226 to float
%228 = load float**, float*** %13
%229 = load i32, i32* %24
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float*, float** %228, i64 %230
%232 = load float*, float** %231
%233 = load i32, i32* %27
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds float, float* %232, i64 %234
%236 = load float, float* %235
%237 = load i32*, i32** %19
%238 = load i32, i32* %25
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i32, i32* %237, i64 %239
%241 = load i32, i32* %240
%242 = sitofp i32 %241 to float
%243 = load float**, float*** %13
%244 = load i32, i32* %25
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float*, float** %243, i64 %245
%247 = load float*, float** %246
%248 = load i32, i32* %27
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %247, i64 %249
%251 = load float, float* %250
%252 = fmul float %242, %251
%253 = call float @llvm.fmuladd.f32(float %227, float %236, float %252)
%254 = load i32, i32* %26
%255 = sitofp i32 %254 to float
%256 = fdiv float %253, %255
%257 = load float**, float*** %13
%258 = load i32, i32* %24
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds float*, float** %257, i64 %259
%261 = load float*, float** %260
%262 = load i32, i32* %27
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %261, i64 %263
store float %256, float* %264
br label %265
265: ; preds = %221
%266 = load i32, i32* %27
%267 = add nsw i32 %266, 1
store i32 %267, i32* %27
br label %217
268: ; preds = %217
%269 = load i32, i32* %26
%270 = load i32*, i32** %19
%271 = load i32, i32* %24
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i32, i32* %270, i64 %272
store i32 %269, i32* %273
%274 = load i32, i32* %16
%275 = sub nsw i32 %274, 1
store i32 %275, i32* %28
%276 = load i32, i32* %25
store i32 %276, i32* %21
br label %277
277: ; preds = %319, %268
%278 = load i32, i32* %21
%279 = load i32, i32* %28
%280 = icmp slt i32 %278, %279
br i1 %280, label %281, label %322
281: ; preds = %277
%282 = load i32*, i32** %19
%283 = load i32, i32* %21
%284 = add nsw i32 %283, 1
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %282, i64 %285
%287 = load i32, i32* %286
%288 = load i32*, i32** %19
%289 = load i32, i32* %21
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i32, i32* %288, i64 %290
store i32 %287, i32* %291
store i32 0, i32* %27
br label %292
292: ; preds = %315, %281
%293 = load i32, i32* %27
%294 = load i32, i32* %18
%295 = icmp slt i32 %293, %294
br i1 %295, label %296, label %318
296: ; preds = %292
%297 = load float**, float*** %13
%298 = load i32, i32* %21
%299 = add nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float*, float** %297, i64 %300
%302 = load float*, float** %301
%303 = load i32, i32* %27
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds float, float* %302, i64 %304
%306 = load float, float* %305
%307 = load float**, float*** %13
%308 = load i32, i32* %21
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float*, float** %307, i64 %309
%311 = load float*, float** %310
%312 = load i32, i32* %27
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %311, i64 %313
store float %306, float* %314
br label %315
315: ; preds = %296
%316 = load i32, i32* %27
%317 = add nsw i32 %316, 1
store i32 %317, i32* %27
br label %292
318: ; preds = %292
br label %319
319: ; preds = %318
%320 = load i32, i32* %21
%321 = add nsw i32 %320, 1
store i32 %321, i32* %21
br label %277
322: ; preds = %277
%323 = load i32, i32* %25
store i32 %323, i32* %21
br label %324
324: ; preds = %356, %322
%325 = load i32, i32* %21
%326 = load i32, i32* %28
%327 = icmp slt i32 %325, %326
br i1 %327, label %328, label %359
328: ; preds = %324
store i32 0, i32* %22
br label %329
329: ; preds = %352, %328
%330 = load i32, i32* %22
%331 = load i32, i32* %25
%332 = icmp slt i32 %330, %331
br i1 %332, label %333, label %355
333: ; preds = %329
%334 = load float**, float*** %11
%335 = load i32, i32* %21
%336 = add nsw i32 %335, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float*, float** %334, i64 %337
%339 = load float*, float** %338
%340 = load i32, i32* %22
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float, float* %339, i64 %341
%343 = load float, float* %342
%344 = load float**, float*** %11
%345 = load i32, i32* %21
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float*, float** %344, i64 %346
%348 = load float*, float** %347
%349 = load i32, i32* %22
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float, float* %348, i64 %350
store float %343, float* %351
br label %352
352: ; preds = %333
%353 = load i32, i32* %22
%354 = add nsw i32 %353, 1
store i32 %354, i32* %22
br label %329
355: ; preds = %329
br label %356
356: ; preds = %355
%357 = load i32, i32* %21
%358 = add nsw i32 %357, 1
store i32 %358, i32* %21
br label %324
359: ; preds = %324
%360 = load i32, i32* %25
store i32 %360, i32* %22
br label %361
361: ; preds = %393, %359
%362 = load i32, i32* %22
%363 = load i32, i32* %28
%364 = icmp slt i32 %362, %363
br i1 %364, label %365, label %396
365: ; preds = %361
store i32 0, i32* %21
br label %366
366: ; preds = %389, %365
%367 = load i32, i32* %21
%368 = load i32, i32* %25
%369 = icmp slt i32 %367, %368
br i1 %369, label %370, label %392
370: ; preds = %366
%371 = load float**, float*** %11
%372 = load i32, i32* %21
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds float*, float** %371, i64 %373
%375 = load float*, float** %374
%376 = load i32, i32* %22
%377 = add nsw i32 %376, 1
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds float, float* %375, i64 %378
%380 = load float, float* %379
%381 = load float**, float*** %11
%382 = load i32, i32* %21
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds float*, float** %381, i64 %383
%385 = load float*, float** %384
%386 = load i32, i32* %22
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds float, float* %385, i64 %387
store float %380, float* %388
br label %389
389: ; preds = %370
%390 = load i32, i32* %21
%391 = add nsw i32 %390, 1
store i32 %391, i32* %21
br label %366
392: ; preds = %366
br label %393
393: ; preds = %392
%394 = load i32, i32* %22
%395 = add nsw i32 %394, 1
store i32 %395, i32* %22
br label %361
396: ; preds = %361
%397 = load i32, i32* %25
store i32 %397, i32* %21
br label %398
398: ; preds = %432, %396
%399 = load i32, i32* %21
%400 = load i32, i32* %28
%401 = icmp slt i32 %399, %400
br i1 %401, label %402, label %435
402: ; preds = %398
%403 = load i32, i32* %25
store i32 %403, i32* %22
br label %404
404: ; preds = %428, %402
%405 = load i32, i32* %22
%406 = load i32, i32* %28
%407 = icmp slt i32 %405, %406
br i1 %407, label %408, label %431
408: ; preds = %404
%409 = load float**, float*** %11
%410 = load i32, i32* %21
%411 = add nsw i32 %410, 1
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds float*, float** %409, i64 %412
%414 = load float*, float** %413
%415 = load i32, i32* %22
%416 = add nsw i32 %415, 1
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds float, float* %414, i64 %417
%419 = load float, float* %418
%420 = load float**, float*** %11
%421 = load i32, i32* %21
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float*, float** %420, i64 %422
%424 = load float*, float** %423
%425 = load i32, i32* %22
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %424, i64 %426
store float %419, float* %427
br label %428
428: ; preds = %408
%429 = load i32, i32* %22
%430 = add nsw i32 %429, 1
store i32 %430, i32* %22
br label %404
431: ; preds = %404
br label %432
432: ; preds = %431
%433 = load i32, i32* %21
%434 = add nsw i32 %433, 1
store i32 %434, i32* %21
br label %398
435: ; preds = %398
%436 = load i32, i32* %16
%437 = add nsw i32 %436, -1
store i32 %437, i32* %16
%438 = load i32, i32* %20
%439 = icmp eq i32 %438, 1
br i1 %439, label %440, label %495
440: ; preds = %435
%441 = load float*, float** %12
%442 = load i8*, i8** %14
%443 = load i32, i32* %16
%444 = load float**, float*** %13
%445 = load i32, i32* %18
%446 = load i32, i32* %15
%447 = load float, float* %38
%448 = call float @gettotalJC(float* %441, i8* %442, i32 %443, float** %444, i32 %445, i32 %446, float %447)
store float %448, float* %31
%449 = load float, float* %32
%450 = load float, float* %31
%451 = fsub float %449, %450
%452 = load float, float* %34
%453 = fcmp ogt float %451, %452
br i1 %453, label %454, label %476
454: ; preds = %440
%455 = load float, float* %30
%456 = load float, float* %36
%457 = fcmp ogt float %455, %456
br i1 %457, label %458, label %476
458: ; preds = %454
%459 = load float, float* %32
%460 = load float, float* %31
%461 = fsub float %459, %460
store float %461, float* %34
%462 = load float, float* %35
%463 = load float, float* %30
%464 = fcmp olt float %462, %463
br i1 %464, label %465, label %470
465: ; preds = %458
%466 = load float, float* %35
%467 = load float, float* %30
%468 = fadd float %466, %467
%469 = fdiv float %468, 2.000000e+00
store float %469, float* %36
br label %475
470: ; preds = %458
%471 = load float, float* %35
%472 = fpext float %471 to double
%473 = fsub double %472, 1.000000e-02
%474 = fptrunc double %473 to float
store float %474, float* %36
br label %475
475: ; preds = %470, %465
br label %476
476: ; preds = %475, %454, %440
%477 = load i32, i32* %40
%478 = icmp ne i32 %477, 0
br i1 %478, label %479, label %492
479: ; preds = %476
%480 = load i32, i32* %16
%481 = load float, float* %31
%482 = load float, float* %32
%483 = load float, float* %31
%484 = fsub float %482, %483
%485 = load float, float* %30
%486 = fpext float %485 to double
%487 = load float, float* %36
%488 = fpext float %487 to double
%489 = load float, float* %34
%490 = fpext float %489 to double
%491 = call i32 (i8*, i32, float, float, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.1, i64 0, i64 0), i32 %480, float %481, float %484, double %486, double %488, double %490)
br label %492
492: ; preds = %479, %476
%493 = load float, float* %31
store float %493, float* %32
%494 = load float, float* %30
store float %494, float* %35
br label %495
495: ; preds = %492, %435
store i32 0, i32* %22
br label %496
496: ; preds = %538, %495
%497 = load i32, i32* %22
%498 = load i32, i32* %16
%499 = icmp slt i32 %497, %498
br i1 %499, label %500, label %541
500: ; preds = %496
%501 = load float**, float*** %13
%502 = load i32, i32* %24
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds float*, float** %501, i64 %503
%505 = load float*, float** %504
%506 = load float**, float*** %13
%507 = load i32, i32* %22
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float*, float** %506, i64 %508
%510 = load float*, float** %509
%511 = load i32, i32* %18
%512 = call float @distance2(float* %505, float* %510, i32 %511)
%513 = load float**, float*** %11
%514 = load i32, i32* %24
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds float*, float** %513, i64 %515
%517 = load float*, float** %516
%518 = load i32, i32* %22
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds float, float* %517, i64 %519
store float %512, float* %520
%521 = load float**, float*** %11
%522 = load i32, i32* %24
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds float*, float** %521, i64 %523
%525 = load float*, float** %524
%526 = load i32, i32* %22
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds float, float* %525, i64 %527
%529 = load float, float* %528
%530 = load float**, float*** %11
%531 = load i32, i32* %22
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds float*, float** %530, i64 %532
%534 = load float*, float** %533
%535 = load i32, i32* %24
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds float, float* %534, i64 %536
store float %529, float* %537
br label %538
538: ; preds = %500
%539 = load i32, i32* %22
%540 = add nsw i32 %539, 1
store i32 %540, i32* %22
br label %496
541: ; preds = %496
store float 1.000000e+05, float* %30
%542 = load i32, i32* %16
%543 = sub nsw i32 %542, 1
store i32 %543, i32* %28
store i32 0, i32* %21
br label %544
544: ; preds = %584, %541
%545 = load i32, i32* %21
%546 = load i32, i32* %28
%547 = icmp slt i32 %545, %546
br i1 %547, label %548, label %587
548: ; preds = %544
%549 = load i32, i32* %21
%550 = add nsw i32 %549, 1
store i32 %550, i32* %22
br label %551
551: ; preds = %580, %548
%552 = load i32, i32* %22
%553 = load i32, i32* %16
%554 = icmp slt i32 %552, %553
br i1 %554, label %555, label %583
555: ; preds = %551
%556 = load float**, float*** %11
%557 = load i32, i32* %21
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds float*, float** %556, i64 %558
%560 = load float*, float** %559
%561 = load i32, i32* %22
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds float, float* %560, i64 %562
%564 = load float, float* %563
%565 = load float, float* %30
%566 = fcmp olt float %564, %565
br i1 %566, label %567, label %579
567: ; preds = %555
%568 = load float**, float*** %11
%569 = load i32, i32* %21
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds float*, float** %568, i64 %570
%572 = load float*, float** %571
%573 = load i32, i32* %22
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds float, float* %572, i64 %574
%576 = load float, float* %575
store float %576, float* %30
%577 = load i32, i32* %21
store i32 %577, i32* %24
%578 = load i32, i32* %22
store i32 %578, i32* %25
br label %579
579: ; preds = %567, %555
br label %580
580: ; preds = %579
%581 = load i32, i32* %22
%582 = add nsw i32 %581, 1
store i32 %582, i32* %22
br label %551
583: ; preds = %551
br label %584
584: ; preds = %583
%585 = load i32, i32* %21
%586 = add nsw i32 %585, 1
store i32 %586, i32* %21
br label %544
587: ; preds = %544
br label %186
588: ; preds = %203, %192
%589 = load i32, i32* %20
%590 = icmp eq i32 %589, 1
br i1 %590, label %591, label %594
591: ; preds = %588
%592 = load float, float* %36
%593 = load float*, float** %17
store float %592, float* %593
br label %594
594: ; preds = %591, %588
%595 = load i32, i32* %16
ret i32 %595
}

LLVM IR (-O2):
define i32 @mergecb1(float** nocapture %0, float* %1, float** %2, i8* %3, i32 %4, i32 %5, float* nocapture %6, i32 %7, i32* nocapture %8, i32 %9) {
%11 = add i32 %5, -1
%12 = icmp sgt i32 %5, 1
br i1 %12, label %13, label %49
13: ; preds = %10
%14 = zext i32 %5 to i64
%15 = zext i32 %11 to i64
%16 = zext i32 %5 to i64
br label %23
17: ; preds = %35, %23
%18 = phi i32 [ %28, %23 ], [ %43, %35 ]
%19 = phi i32 [ %27, %23 ], [ %45, %35 ]
%20 = phi float [ %26, %23 ], [ %46, %35 ]
%21 = add nuw nsw i64 %25, 1
%22 = icmp eq i64 %29, %15
br i1 %22, label %49, label %23
23: ; preds = %13, %17
%24 = phi i64 [ 0, %13 ], [ %29, %17 ]
%25 = phi i64 [ 1, %13 ], [ %21, %17 ]
%26 = phi float [ 1.000000e+05, %13 ], [ %20, %17 ]
%27 = phi i32 [ undef, %13 ], [ %19, %17 ]
%28 = phi i32 [ undef, %13 ], [ %18, %17 ]
%29 = add nuw nsw i64 %24, 1
%30 = icmp ult i64 %29, %14
br i1 %30, label %31, label %17
31: ; preds = %23
%32 = getelementptr inbounds float*, float** %0, i64 %24
%33 = load float*, float** %32
%34 = trunc i64 %24 to i32
br label %35
35: ; preds = %31, %35
%36 = phi i64 [ %25, %31 ], [ %47, %35 ]
%37 = phi float [ %26, %31 ], [ %46, %35 ]
%38 = phi i32 [ %27, %31 ], [ %45, %35 ]
%39 = phi i32 [ %28, %31 ], [ %43, %35 ]
%40 = getelementptr inbounds float, float* %33, i64 %36
%41 = load float, float* %40
%42 = fcmp olt float %41, %37
%43 = select i1 %42, i32 %34, i32 %39
%44 = trunc i64 %36 to i32
%45 = select i1 %42, i32 %44, i32 %38
%46 = select i1 %42, float %41, float %37
%47 = add nuw nsw i64 %36, 1
%48 = icmp eq i64 %47, %16
br i1 %48, label %17, label %35
49: ; preds = %17, %10
%50 = phi i32 [ undef, %10 ], [ %18, %17 ]
%51 = phi i32 [ undef, %10 ], [ %19, %17 ]
%52 = phi float [ 1.000000e+05, %10 ], [ %20, %17 ]
%53 = icmp eq i32 %9, 1
br i1 %53, label %54, label %268
54: ; preds = %49
%55 = tail call i64 @calloc(i32 %7, i32 4)
%56 = inttoptr i64 %55 to float*
%57 = inttoptr i64 %55 to i8*
%58 = icmp sgt i32 %4, 0
br i1 %58, label %59, label %171
59: ; preds = %54
%60 = icmp sgt i32 %7, 0
%61 = zext i32 %7 to i64
%62 = getelementptr float, float* %56, i64 %61
%63 = getelementptr float, float* %1, i64 %61
%64 = and i64 %61, 4294967288
%65 = add nsw i64 %64, -8
%66 = lshr exact i64 %65, 3
%67 = add nuw nsw i64 %66, 1
%68 = icmp ult i32 %7, 8
%69 = and i64 %61, 4294967288
%70 = and i64 %67, 1
%71 = icmp eq i64 %65, 0
%72 = and i64 %67, 4611686018427387902
%73 = icmp eq i64 %70, 0
%74 = icmp eq i64 %69, %61
%75 = and i64 %61, 1
%76 = icmp eq i64 %75, 0
%77 = sub nsw i64 0, %61
br label %78
78: ; preds = %59, %239
%79 = phi i32 [ 0, %59 ], [ %240, %239 ]
%80 = phi i32 [ 0, %59 ], [ %241, %239 ]
br i1 %60, label %81, label %239
81: ; preds = %78
%82 = sext i32 %79 to i64
br i1 %68, label %154, label %83
83: ; preds = %81
%84 = getelementptr float, float* %1, i64 %82
%85 = getelementptr float, float* %63, i64 %82
%86 = bitcast float* %85 to i8*
%87 = icmp ult i8* %57, %86
%88 = icmp ult float* %84, %62
%89 = and i1 %87, %88
br i1 %89, label %154, label %90
90: ; preds = %83
%91 = add nsw i64 %69, %82
br i1 %71, label %133, label %92
92: ; preds = %90, %92
%93 = phi i64 [ %130, %92 ], [ 0, %90 ]
%94 = phi i64 [ %131, %92 ], [ 0, %90 ]
%95 = add i64 %93, %82
%96 = getelementptr inbounds float, float* %1, i64 %95
%97 = bitcast float* %96 to <4 x float>*
%98 = load <4 x float>, <4 x float>* %97
%99 = getelementptr inbounds float, float* %96, i64 4
%100 = bitcast float* %99 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = getelementptr inbounds float, float* %56, i64 %93
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = getelementptr inbounds float, float* %102, i64 4
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = fadd <4 x float> %98, %104
%109 = fadd <4 x float> %101, %107
%110 = bitcast float* %102 to <4 x float>*
store <4 x float> %108, <4 x float>* %110
%111 = bitcast float* %105 to <4 x float>*
store <4 x float> %109, <4 x float>* %111
%112 = or i64 %93, 8
%113 = add i64 %112, %82
%114 = getelementptr inbounds float, float* %1, i64 %113
%115 = bitcast float* %114 to <4 x float>*
%116 = load <4 x float>, <4 x float>* %115
%117 = getelementptr inbounds float, float* %114, i64 4
%118 = bitcast float* %117 to <4 x float>*
%119 = load <4 x float>, <4 x float>* %118
%120 = getelementptr inbounds float, float* %56, i64 %112
%121 = bitcast float* %120 to <4 x float>*
%122 = load <4 x float>, <4 x float>* %121
%123 = getelementptr inbounds float, float* %120, i64 4
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = fadd <4 x float> %116, %122
%127 = fadd <4 x float> %119, %125
%128 = bitcast float* %120 to <4 x float>*
store <4 x float> %126, <4 x float>* %128
%129 = bitcast float* %123 to <4 x float>*
store <4 x float> %127, <4 x float>* %129
%130 = add nuw i64 %93, 16
%131 = add i64 %94, 2
%132 = icmp eq i64 %131, %72
br i1 %132, label %133, label %92
133: ; preds = %92, %90
%134 = phi i64 [ 0, %90 ], [ %130, %92 ]
br i1 %73, label %153, label %135
135: ; preds = %133
%136 = add i64 %134, %82
%137 = getelementptr inbounds float, float* %1, i64 %136
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = getelementptr inbounds float, float* %137, i64 4
%141 = bitcast float* %140 to <4 x float>*
%142 = load <4 x float>, <4 x float>* %141
%143 = getelementptr inbounds float, float* %56, i64 %134
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = getelementptr inbounds float, float* %143, i64 4
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = fadd <4 x float> %139, %145
%150 = fadd <4 x float> %142, %148
%151 = bitcast float* %143 to <4 x float>*
store <4 x float> %149, <4 x float>* %151
%152 = bitcast float* %146 to <4 x float>*
store <4 x float> %150, <4 x float>* %152
br label %153
153: ; preds = %133, %135
br i1 %74, label %236, label %154
154: ; preds = %83, %81, %153
%155 = phi i64 [ 0, %83 ], [ 0, %81 ], [ %69, %153 ]
%156 = phi i64 [ %82, %83 ], [ %82, %81 ], [ %91, %153 ]
%157 = xor i64 %155, -1
br i1 %76, label %166, label %158
158: ; preds = %154
%159 = add nsw i64 %156, 1
%160 = getelementptr inbounds float, float* %1, i64 %156
%161 = load float, float* %160
%162 = getelementptr inbounds float, float* %56, i64 %155
%163 = load float, float* %162
%164 = fadd float %161, %163
store float %164, float* %162
%165 = or i64 %155, 1
br label %166
166: ; preds = %158, %154
%167 = phi i64 [ undef, %154 ], [ %159, %158 ]
%168 = phi i64 [ %155, %154 ], [ %165, %158 ]
%169 = phi i64 [ %156, %154 ], [ %159, %158 ]
%170 = icmp eq i64 %157, %77
br i1 %170, label %236, label %218
171: ; preds = %239, %54
%172 = icmp sgt i32 %7, 0
br i1 %172, label %173, label %243
173: ; preds = %171
%174 = sitofp i32 %4 to float
%175 = zext i32 %7 to i64
%176 = icmp ult i32 %7, 4
br i1 %176, label %216, label %177
177: ; preds = %173
%178 = and i64 %175, 4294967292
%179 = insertelement <4 x float> poison, float %174, i64 0
%180 = shufflevector <4 x float> %179, <4 x float> poison, <4 x i32> zeroinitializer
%181 = add nsw i64 %178, -4
%182 = lshr exact i64 %181, 2
%183 = add nuw nsw i64 %182, 1
%184 = and i64 %183, 1
%185 = icmp eq i64 %181, 0
br i1 %185, label %205, label %186
186: ; preds = %177
%187 = and i64 %183, 9223372036854775806
br label %188
188: ; preds = %188, %186
%189 = phi i64 [ 0, %186 ], [ %202, %188 ]
%190 = phi i64 [ 0, %186 ], [ %203, %188 ]
%191 = getelementptr inbounds float, float* %56, i64 %189
%192 = bitcast float* %191 to <4 x float>*
%193 = load <4 x float>, <4 x float>* %192
%194 = fdiv <4 x float> %193, %180
%195 = bitcast float* %191 to <4 x float>*
store <4 x float> %194, <4 x float>* %195
%196 = or i64 %189, 4
%197 = getelementptr inbounds float, float* %56, i64 %196
%198 = bitcast float* %197 to <4 x float>*
%199 = load <4 x float>, <4 x float>* %198
%200 = fdiv <4 x float> %199, %180
%201 = bitcast float* %197 to <4 x float>*
store <4 x float> %200, <4 x float>* %201
%202 = add nuw i64 %189, 8
%203 = add i64 %190, 2
%204 = icmp eq i64 %203, %187
br i1 %204, label %205, label %188
205: ; preds = %188, %177
%206 = phi i64 [ 0, %177 ], [ %202, %188 ]
%207 = icmp eq i64 %184, 0
br i1 %207, label %214, label %208
208: ; preds = %205
%209 = getelementptr inbounds float, float* %56, i64 %206
%210 = bitcast float* %209 to <4 x float>*
%211 = load <4 x float>, <4 x float>* %210
%212 = fdiv <4 x float> %211, %180
%213 = bitcast float* %209 to <4 x float>*
store <4 x float> %212, <4 x float>* %213
br label %214
214: ; preds = %205, %208
%215 = icmp eq i64 %178, %175
br i1 %215, label %243, label %216
216: ; preds = %173, %214
%217 = phi i64 [ 0, %173 ], [ %178, %214 ]
br label %246
218: ; preds = %166, %218
%219 = phi i64 [ %234, %218 ], [ %168, %166 ]
%220 = phi i64 [ %228, %218 ], [ %169, %166 ]
%221 = add nsw i64 %220, 1
%222 = getelementptr inbounds float, float* %1, i64 %220
%223 = load float, float* %222
%224 = getelementptr inbounds float, float* %56, i64 %219
%225 = load float, float* %224
%226 = fadd float %223, %225
store float %226, float* %224
%227 = add nuw nsw i64 %219, 1
%228 = add nsw i64 %220, 2
%229 = getelementptr inbounds float, float* %1, i64 %221
%230 = load float, float* %229
%231 = getelementptr inbounds float, float* %56, i64 %227
%232 = load float, float* %231
%233 = fadd float %230, %232
store float %233, float* %231
%234 = add nuw nsw i64 %219, 2
%235 = icmp eq i64 %234, %61
br i1 %235, label %236, label %218
236: ; preds = %166, %218, %153
%237 = phi i64 [ %91, %153 ], [ %167, %166 ], [ %228, %218 ]
%238 = trunc i64 %237 to i32
br label %239
239: ; preds = %236, %78
%240 = phi i32 [ %79, %78 ], [ %238, %236 ]
%241 = add nuw nsw i32 %80, 1
%242 = icmp eq i32 %241, %4
br i1 %242, label %171, label %78
243: ; preds = %246, %214, %171
br i1 %58, label %244, label %262
244: ; preds = %243
%245 = sext i32 %7 to i64
br label %253
246: ; preds = %216, %246
%247 = phi i64 [ %251, %246 ], [ %217, %216 ]
%248 = getelementptr inbounds float, float* %56, i64 %247
%249 = load float, float* %248
%250 = fdiv float %249, %174
store float %250, float* %248
%251 = add nuw nsw i64 %247, 1
%252 = icmp eq i64 %251, %175
br i1 %252, label %243, label %246
253: ; preds = %244, %253
%254 = phi float* [ %1, %244 ], [ %259, %253 ]
%255 = phi float [ 0.000000e+00, %244 ], [ %258, %253 ]
%256 = phi i32 [ 0, %244 ], [ %260, %253 ]
%257 = tail call float @distance2(float* %254, float* %56, i32 %7)
%258 = fadd float %255, %257
%259 = getelementptr inbounds float, float* %254, i64 %245
%260 = add nuw nsw i32 %256, 1
%261 = icmp eq i32 %260, %4
br i1 %261, label %262, label %253
262: ; preds = %253, %243
%263 = phi float [ 0.000000e+00, %243 ], [ %258, %253 ]
%264 = tail call i32 @free(float* %56)
%265 = tail call float @gettotalJC(float* %1, i8* %3, i32 %5, float** %2, i32 %7, i32 %4, float %263)
%266 = icmp eq i32 %7, 3
%267 = select i1 %266, float 2.600000e+02, float 5.000000e+02
br label %268
268: ; preds = %262, %49
%269 = phi float [ undef, %49 ], [ %265, %262 ]
%270 = phi float [ undef, %49 ], [ %267, %262 ]
%271 = phi float [ undef, %49 ], [ %263, %262 ]
br i1 %12, label %272, label %917
272: ; preds = %268
%273 = icmp sgt i32 %7, 0
%274 = add nsw i32 %5, -2
%275 = zext i32 %274 to i64
%276 = zext i32 %11 to i64
%277 = zext i32 %5 to i64
%278 = zext i32 %7 to i64
%279 = zext i32 %7 to i64
%280 = and i64 %278, 4294967292
%281 = add nsw i64 %280, -4
%282 = lshr exact i64 %281, 2
%283 = add nuw nsw i64 %282, 1
%284 = and i64 %278, 4294967288
%285 = add nsw i64 %284, -8
%286 = lshr exact i64 %285, 3
%287 = add nuw nsw i64 %286, 1
%288 = icmp ult i32 %7, 4
%289 = and i64 %278, 4294967292
%290 = and i64 %283, 1
%291 = icmp eq i64 %281, 0
%292 = and i64 %283, 9223372036854775806
%293 = icmp eq i64 %290, 0
%294 = icmp eq i64 %289, %278
%295 = and i64 %278, 1
%296 = icmp eq i64 %295, 0
%297 = sub nsw i64 0, %278
%298 = icmp ult i32 %7, 8
%299 = and i64 %278, 4294967288
%300 = and i64 %287, 3
%301 = icmp ult i64 %285, 24
%302 = and i64 %287, 4611686018427387900
%303 = icmp eq i64 %300, 0
%304 = icmp eq i64 %299, %278
%305 = and i64 %278, 3
%306 = icmp eq i64 %305, 0
br label %312
307: ; preds = %881
%308 = select i1 %329, i1 %880, i1 false
%309 = add nsw i64 %315, -1
%310 = add nsw i64 %316, -1
%311 = add i64 %313, 1
br i1 %308, label %312, label %915
312: ; preds = %272, %307
%313 = phi i64 [ 0, %272 ], [ %311, %307 ]
%314 = phi i64 [ %277, %272 ], [ %436, %307 ]
%315 = phi i64 [ %276, %272 ], [ %309, %307 ]
%316 = phi i64 [ %275, %272 ], [ %310, %307 ]
%317 = phi float [ %270, %272 ], [ %863, %307 ]
%318 = phi float [ 0.000000e+00, %272 ], [ %862, %307 ]
%319 = phi float [ 0.000000e+00, %272 ], [ %861, %307 ]
%320 = phi float [ %269, %272 ], [ %860, %307 ]
%321 = phi float [ %52, %272 ], [ %884, %307 ]
%322 = phi i32 [ %51, %272 ], [ %883, %307 ]
%323 = phi i32 [ %50, %272 ], [ %882, %307 ]
%324 = xor i64 %313, -1
%325 = add i64 %324, %277
%326 = xor i64 %313, -1
%327 = add i64 %326, %277
%328 = load float, float* %6
%329 = fcmp ult float %321, %328
%330 = or i1 %53, %329
br i1 %330, label %331, label %921
331: ; preds = %312
%332 = sext i32 %323 to i64
%333 = getelementptr inbounds i32, i32* %8, i64 %332
%334 = load i32, i32* %333
%335 = sext i32 %322 to i64
%336 = getelementptr inbounds i32, i32* %8, i64 %335
%337 = load i32, i32* %336
%338 = add nsw i32 %337, %334
br i1 %273, label %339, label %435
339: ; preds = %331
%340 = sitofp i32 %334 to float
%341 = getelementptr inbounds float*, float** %2, i64 %332
%342 = load float*, float** %341
%343 = sitofp i32 %337 to float
%344 = getelementptr inbounds float*, float** %2, i64 %335
%345 = load float*, float** %344
%346 = sitofp i32 %338 to float
br i1 %288, label %401, label %347
347: ; preds = %339
%348 = getelementptr float, float* %342, i64 %278
%349 = getelementptr float, float* %345, i64 %278
%350 = icmp ult float* %342, %349
%351 = icmp ult float* %345, %348
%352 = and i1 %350, %351
br i1 %352, label %401, label %353
353: ; preds = %347
%354 = insertelement <4 x float> poison, float %343, i64 0
%355 = shufflevector <4 x float> %354, <4 x float> poison, <4 x i32> zeroinitializer
%356 = insertelement <4 x float> poison, float %340, i64 0
%357 = shufflevector <4 x float> %356, <4 x float> poison, <4 x i32> zeroinitializer
%358 = insertelement <4 x float> poison, float %346, i64 0
%359 = shufflevector <4 x float> %358, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %291, label %387, label %360
360: ; preds = %353, %360
%361 = phi i64 [ %384, %360 ], [ 0, %353 ]
%362 = phi i64 [ %385, %360 ], [ 0, %353 ]
%363 = getelementptr inbounds float, float* %342, i64 %361
%364 = bitcast float* %363 to <4 x float>*
%365 = load <4 x float>, <4 x float>* %364
%366 = getelementptr inbounds float, float* %345, i64 %361
%367 = bitcast float* %366 to <4 x float>*
%368 = load <4 x float>, <4 x float>* %367
%369 = fmul <4 x float> %368, %355
%370 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %357, <4 x float> %365, <4 x float> %369)
%371 = fdiv <4 x float> %370, %359
%372 = bitcast float* %363 to <4 x float>*
store <4 x float> %371, <4 x float>* %372
%373 = or i64 %361, 4
%374 = getelementptr inbounds float, float* %342, i64 %373
%375 = bitcast float* %374 to <4 x float>*
%376 = load <4 x float>, <4 x float>* %375
%377 = getelementptr inbounds float, float* %345, i64 %373
%378 = bitcast float* %377 to <4 x float>*
%379 = load <4 x float>, <4 x float>* %378
%380 = fmul <4 x float> %379, %355
%381 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %357, <4 x float> %376, <4 x float> %380)
%382 = fdiv <4 x float> %381, %359
%383 = bitcast float* %374 to <4 x float>*
store <4 x float> %382, <4 x float>* %383
%384 = add nuw i64 %361, 8
%385 = add i64 %362, 2
%386 = icmp eq i64 %385, %292
br i1 %386, label %387, label %360
387: ; preds = %360, %353
%388 = phi i64 [ 0, %353 ], [ %384, %360 ]
br i1 %293, label %400, label %389
389: ; preds = %387
%390 = getelementptr inbounds float, float* %342, i64 %388
%391 = bitcast float* %390 to <4 x float>*
%392 = load <4 x float>, <4 x float>* %391
%393 = getelementptr inbounds float, float* %345, i64 %388
%394 = bitcast float* %393 to <4 x float>*
%395 = load <4 x float>, <4 x float>* %394
%396 = fmul <4 x float> %395, %355
%397 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %357, <4 x float> %392, <4 x float> %396)
%398 = fdiv <4 x float> %397, %359
%399 = bitcast float* %390 to <4 x float>*
store <4 x float> %398, <4 x float>* %399
br label %400
400: ; preds = %387, %389
br i1 %294, label %435, label %401
401: ; preds = %347, %339, %400
%402 = phi i64 [ 0, %347 ], [ 0, %339 ], [ %289, %400 ]
%403 = xor i64 %402, -1
br i1 %296, label %413, label %404
404: ; preds = %401
%405 = getelementptr inbounds float, float* %342, i64 %402
%406 = load float, float* %405
%407 = getelementptr inbounds float, float* %345, i64 %402
%408 = load float, float* %407
%409 = fmul float %408, %343
%410 = tail call float @llvm.fmuladd.f32(float %340, float %406, float %409)
%411 = fdiv float %410, %346
store float %411, float* %405
%412 = or i64 %402, 1
br label %413
413: ; preds = %404, %401
%414 = phi i64 [ %402, %401 ], [ %412, %404 ]
%415 = icmp eq i64 %403, %297
br i1 %415, label %435, label %416
416: ; preds = %413, %416
%417 = phi i64 [ %433, %416 ], [ %414, %413 ]
%418 = getelementptr inbounds float, float* %342, i64 %417
%419 = load float, float* %418
%420 = getelementptr inbounds float, float* %345, i64 %417
%421 = load float, float* %420
%422 = fmul float %421, %343
%423 = tail call float @llvm.fmuladd.f32(float %340, float %419, float %422)
%424 = fdiv float %423, %346
store float %424, float* %418
%425 = add nuw nsw i64 %417, 1
%426 = getelementptr inbounds float, float* %342, i64 %425
%427 = load float, float* %426
%428 = getelementptr inbounds float, float* %345, i64 %425
%429 = load float, float* %428
%430 = fmul float %429, %343
%431 = tail call float @llvm.fmuladd.f32(float %340, float %427, float %430)
%432 = fdiv float %431, %346
store float %432, float* %426
%433 = add nuw nsw i64 %417, 2
%434 = icmp eq i64 %433, %278
br i1 %434, label %435, label %416
435: ; preds = %413, %416, %400, %331
store i32 %338, i32* %333
%436 = add nsw i64 %314, -1
%437 = icmp sgt i64 %436, %335
br i1 %437, label %458, label %842
438: ; preds = %557, %560, %543, %458
%439 = icmp slt i64 %460, %436
br i1 %439, label %458, label %440
440: ; preds = %438
br i1 %437, label %441, label %842
441: ; preds = %440
%442 = icmp sgt i32 %322, 0
%443 = zext i32 %322 to i64
%444 = and i64 %443, 4294967288
%445 = add nsw i64 %444, -8
%446 = lshr exact i64 %445, 3
%447 = add nuw nsw i64 %446, 1
%448 = add nsw i64 %443, -1
%449 = icmp ult i32 %322, 8
%450 = and i64 %443, 4294967288
%451 = and i64 %447, 3
%452 = icmp ult i64 %445, 24
%453 = and i64 %447, 4611686018427387900
%454 = icmp eq i64 %451, 0
%455 = icmp eq i64 %450, %443
%456 = and i64 %443, 3
%457 = icmp eq i64 %456, 0
br label %586
458: ; preds = %435, %438
%459 = phi i64 [ %460, %438 ], [ %335, %435 ]
%460 = add nsw i64 %459, 1
%461 = getelementptr inbounds i32, i32* %8, i64 %460
%462 = load i32, i32* %461
%463 = getelementptr inbounds i32, i32* %8, i64 %459
store i32 %462, i32* %463
br i1 %273, label %464, label %438
464: ; preds = %458
%465 = getelementptr inbounds float*, float** %2, i64 %460
%466 = load float*, float** %465
%467 = getelementptr inbounds float*, float** %2, i64 %459
%468 = load float*, float** %467
br i1 %298, label %544, label %469
469: ; preds = %464
%470 = getelementptr float, float* %468, i64 %278
%471 = getelementptr float, float* %466, i64 %278
%472 = icmp ult float* %468, %471
%473 = icmp ult float* %466, %470
%474 = and i1 %472, %473
br i1 %474, label %544, label %475
475: ; preds = %469
br i1 %301, label %525, label %476
476: ; preds = %475, %476
%477 = phi i64 [ %522, %476 ], [ 0, %475 ]
%478 = phi i64 [ %523, %476 ], [ 0, %475 ]
%479 = getelementptr inbounds float, float* %466, i64 %477
%480 = bitcast float* %479 to <4 x float>*
%481 = load <4 x float>, <4 x float>* %480
%482 = getelementptr inbounds float, float* %479, i64 4
%483 = bitcast float* %482 to <4 x float>*
%484 = load <4 x float>, <4 x float>* %483
%485 = getelementptr inbounds float, float* %468, i64 %477
%486 = bitcast float* %485 to <4 x float>*
store <4 x float> %481, <4 x float>* %486
%487 = getelementptr inbounds float, float* %485, i64 4
%488 = bitcast float* %487 to <4 x float>*
store <4 x float> %484, <4 x float>* %488
%489 = or i64 %477, 8
%490 = getelementptr inbounds float, float* %466, i64 %489
%491 = bitcast float* %490 to <4 x float>*
%492 = load <4 x float>, <4 x float>* %491
%493 = getelementptr inbounds float, float* %490, i64 4
%494 = bitcast float* %493 to <4 x float>*
%495 = load <4 x float>, <4 x float>* %494
%496 = getelementptr inbounds float, float* %468, i64 %489
%497 = bitcast float* %496 to <4 x float>*
store <4 x float> %492, <4 x float>* %497
%498 = getelementptr inbounds float, float* %496, i64 4
%499 = bitcast float* %498 to <4 x float>*
store <4 x float> %495, <4 x float>* %499
%500 = or i64 %477, 16
%501 = getelementptr inbounds float, float* %466, i64 %500
%502 = bitcast float* %501 to <4 x float>*
%503 = load <4 x float>, <4 x float>* %502
%504 = getelementptr inbounds float, float* %501, i64 4
%505 = bitcast float* %504 to <4 x float>*
%506 = load <4 x float>, <4 x float>* %505
%507 = getelementptr inbounds float, float* %468, i64 %500
%508 = bitcast float* %507 to <4 x float>*
store <4 x float> %503, <4 x float>* %508
%509 = getelementptr inbounds float, float* %507, i64 4
%510 = bitcast float* %509 to <4 x float>*
store <4 x float> %506, <4 x float>* %510
%511 = or i64 %477, 24
%512 = getelementptr inbounds float, float* %466, i64 %511
%513 = bitcast float* %512 to <4 x float>*
%514 = load <4 x float>, <4 x float>* %513
%515 = getelementptr inbounds float, float* %512, i64 4
%516 = bitcast float* %515 to <4 x float>*
%517 = load <4 x float>, <4 x float>* %516
%518 = getelementptr inbounds float, float* %468, i64 %511
%519 = bitcast float* %518 to <4 x float>*
store <4 x float> %514, <4 x float>* %519
%520 = getelementptr inbounds float, float* %518, i64 4
%521 = bitcast float* %520 to <4 x float>*
store <4 x float> %517, <4 x float>* %521
%522 = add nuw i64 %477, 32
%523 = add i64 %478, 4
%524 = icmp eq i64 %523, %302
br i1 %524, label %525, label %476
525: ; preds = %476, %475
%526 = phi i64 [ 0, %475 ], [ %522, %476 ]
br i1 %303, label %543, label %527
527: ; preds = %525, %527
%528 = phi i64 [ %540, %527 ], [ %526, %525 ]
%529 = phi i64 [ %541, %527 ], [ 0, %525 ]
%530 = getelementptr inbounds float, float* %466, i64 %528
%531 = bitcast float* %530 to <4 x float>*
%532 = load <4 x float>, <4 x float>* %531
%533 = getelementptr inbounds float, float* %530, i64 4
%534 = bitcast float* %533 to <4 x float>*
%535 = load <4 x float>, <4 x float>* %534
%536 = getelementptr inbounds float, float* %468, i64 %528
%537 = bitcast float* %536 to <4 x float>*
store <4 x float> %532, <4 x float>* %537
%538 = getelementptr inbounds float, float* %536, i64 4
%539 = bitcast float* %538 to <4 x float>*
store <4 x float> %535, <4 x float>* %539
%540 = add nuw i64 %528, 8
%541 = add i64 %529, 1
%542 = icmp eq i64 %541, %300
br i1 %542, label %543, label %527
543: ; preds = %527, %525
br i1 %304, label %438, label %544
544: ; preds = %469, %464, %543
%545 = phi i64 [ 0, %469 ], [ 0, %464 ], [ %299, %543 ]
%546 = xor i64 %545, -1
%547 = add nsw i64 %546, %278
br i1 %306, label %557, label %548
548: ; preds = %544, %548
%549 = phi i64 [ %554, %548 ], [ %545, %544 ]
%550 = phi i64 [ %555, %548 ], [ 0, %544 ]
%551 = getelementptr inbounds float, float* %466, i64 %549
%552 = load float, float* %551
%553 = getelementptr inbounds float, float* %468, i64 %549
store float %552, float* %553
%554 = add nuw nsw i64 %549, 1
%555 = add i64 %550, 1
%556 = icmp eq i64 %555, %305
br i1 %556, label %557, label %548
557: ; preds = %548, %544
%558 = phi i64 [ %545, %544 ], [ %554, %548 ]
%559 = icmp ult i64 %547, 3
br i1 %559, label %438, label %560
560: ; preds = %557, %560
%561 = phi i64 [ %577, %560 ], [ %558, %557 ]
%562 = getelementptr inbounds float, float* %466, i64 %561
%563 = load float, float* %562
%564 = getelementptr inbounds float, float* %468, i64 %561
store float %563, float* %564
%565 = add nuw nsw i64 %561, 1
%566 = getelementptr inbounds float, float* %466, i64 %565
%567 = load float, float* %566
%568 = getelementptr inbounds float, float* %468, i64 %565
store float %567, float* %568
%569 = add nuw nsw i64 %561, 2
%570 = getelementptr inbounds float, float* %466, i64 %569
%571 = load float, float* %570
%572 = getelementptr inbounds float, float* %468, i64 %569
store float %571, float* %572
%573 = add nuw nsw i64 %561, 3
%574 = getelementptr inbounds float, float* %466, i64 %573
%575 = load float, float* %574
%576 = getelementptr inbounds float, float* %468, i64 %573
store float %575, float* %576
%577 = add nuw nsw i64 %561, 4
%578 = icmp eq i64 %577, %279
br i1 %578, label %438, label %560
579: ; preds = %703
br i1 %437, label %580, label %842
580: ; preds = %579
%581 = icmp sgt i32 %322, 0
%582 = and i64 %443, 3
%583 = icmp ult i64 %448, 3
%584 = and i64 %443, 4294967292
%585 = icmp eq i64 %582, 0
br label %719
586: ; preds = %441, %703
%587 = phi i64 [ %335, %441 ], [ %588, %703 ]
%588 = add nsw i64 %587, 1
br i1 %442, label %589, label %703
589: ; preds = %586
%590 = getelementptr inbounds float*, float** %0, i64 %588
%591 = load float*, float** %590
%592 = getelementptr inbounds float*, float** %0, i64 %587
%593 = load float*, float** %592
br i1 %449, label %669, label %594
594: ; preds = %589
%595 = getelementptr float, float* %593, i64 %443
%596 = getelementptr float, float* %591, i64 %443
%597 = icmp ult float* %593, %596
%598 = icmp ult float* %591, %595
%599 = and i1 %597, %598
br i1 %599, label %669, label %600
600: ; preds = %594
br i1 %452, label %650, label %601
601: ; preds = %600, %601
%602 = phi i64 [ %647, %601 ], [ 0, %600 ]
%603 = phi i64 [ %648, %601 ], [ 0, %600 ]
%604 = getelementptr inbounds float, float* %591, i64 %602
%605 = bitcast float* %604 to <4 x float>*
%606 = load <4 x float>, <4 x float>* %605
%607 = getelementptr inbounds float, float* %604, i64 4
%608 = bitcast float* %607 to <4 x float>*
%609 = load <4 x float>, <4 x float>* %608
%610 = getelementptr inbounds float, float* %593, i64 %602
%611 = bitcast float* %610 to <4 x float>*
store <4 x float> %606, <4 x float>* %611
%612 = getelementptr inbounds float, float* %610, i64 4
%613 = bitcast float* %612 to <4 x float>*
store <4 x float> %609, <4 x float>* %613
%614 = or i64 %602, 8
%615 = getelementptr inbounds float, float* %591, i64 %614
%616 = bitcast float* %615 to <4 x float>*
%617 = load <4 x float>, <4 x float>* %616
%618 = getelementptr inbounds float, float* %615, i64 4
%619 = bitcast float* %618 to <4 x float>*
%620 = load <4 x float>, <4 x float>* %619
%621 = getelementptr inbounds float, float* %593, i64 %614
%622 = bitcast float* %621 to <4 x float>*
store <4 x float> %617, <4 x float>* %622
%623 = getelementptr inbounds float, float* %621, i64 4
%624 = bitcast float* %623 to <4 x float>*
store <4 x float> %620, <4 x float>* %624
%625 = or i64 %602, 16
%626 = getelementptr inbounds float, float* %591, i64 %625
%627 = bitcast float* %626 to <4 x float>*
%628 = load <4 x float>, <4 x float>* %627
%629 = getelementptr inbounds float, float* %626, i64 4
%630 = bitcast float* %629 to <4 x float>*
%631 = load <4 x float>, <4 x float>* %630
%632 = getelementptr inbounds float, float* %593, i64 %625
%633 = bitcast float* %632 to <4 x float>*
store <4 x float> %628, <4 x float>* %633
%634 = getelementptr inbounds float, float* %632, i64 4
%635 = bitcast float* %634 to <4 x float>*
store <4 x float> %631, <4 x float>* %635
%636 = or i64 %602, 24
%637 = getelementptr inbounds float, float* %591, i64 %636
%638 = bitcast float* %637 to <4 x float>*
%639 = load <4 x float>, <4 x float>* %638
%640 = getelementptr inbounds float, float* %637, i64 4
%641 = bitcast float* %640 to <4 x float>*
%642 = load <4 x float>, <4 x float>* %641
%643 = getelementptr inbounds float, float* %593, i64 %636
%644 = bitcast float* %643 to <4 x float>*
store <4 x float> %639, <4 x float>* %644
%645 = getelementptr inbounds float, float* %643, i64 4
%646 = bitcast float* %645 to <4 x float>*
store <4 x float> %642, <4 x float>* %646
%647 = add nuw i64 %602, 32
%648 = add i64 %603, 4
%649 = icmp eq i64 %648, %453
br i1 %649, label %650, label %601
650: ; preds = %601, %600
%651 = phi i64 [ 0, %600 ], [ %647, %601 ]
br i1 %454, label %668, label %652
652: ; preds = %650, %652
%653 = phi i64 [ %665, %652 ], [ %651, %650 ]
%654 = phi i64 [ %666, %652 ], [ 0, %650 ]
%655 = getelementptr inbounds float, float* %591, i64 %653
%656 = bitcast float* %655 to <4 x float>*
%657 = load <4 x float>, <4 x float>* %656
%658 = getelementptr inbounds float, float* %655, i64 4
%659 = bitcast float* %658 to <4 x float>*
%660 = load <4 x float>, <4 x float>* %659
%661 = getelementptr inbounds float, float* %593, i64 %653
%662 = bitcast float* %661 to <4 x float>*
store <4 x float> %657, <4 x float>* %662
%663 = getelementptr inbounds float, float* %661, i64 4
%664 = bitcast float* %663 to <4 x float>*
store <4 x float> %660, <4 x float>* %664
%665 = add nuw i64 %653, 8
%666 = add i64 %654, 1
%667 = icmp eq i64 %666, %451
br i1 %667, label %668, label %652
668: ; preds = %652, %650
br i1 %455, label %703, label %669
669: ; preds = %594, %589, %668
%670 = phi i64 [ 0, %594 ], [ 0, %589 ], [ %450, %668 ]
%671 = sub nsw i64 %448, %670
br i1 %457, label %681, label %672
672: ; preds = %669, %672
%673 = phi i64 [ %678, %672 ], [ %670, %669 ]
%674 = phi i64 [ %679, %672 ], [ 0, %669 ]
%675 = getelementptr inbounds float, float* %591, i64 %673
%676 = load float, float* %675
%677 = getelementptr inbounds float, float* %593, i64 %673
store float %676, float* %677
%678 = add nuw nsw i64 %673, 1
%679 = add i64 %674, 1
%680 = icmp eq i64 %679, %456
br i1 %680, label %681, label %672
681: ; preds = %672, %669
%682 = phi i64 [ %670, %669 ], [ %678, %672 ]
%683 = icmp ult i64 %671, 3
br i1 %683, label %703, label %684
684: ; preds = %681, %684
%685 = phi i64 [ %701, %684 ], [ %682, %681 ]
%686 = getelementptr inbounds float, float* %591, i64 %685
%687 = load float, float* %686
%688 = getelementptr inbounds float, float* %593, i64 %685
store float %687, float* %688
%689 = add nuw nsw i64 %685, 1
%690 = getelementptr inbounds float, float* %591, i64 %689
%691 = load float, float* %690
%692 = getelementptr inbounds float, float* %593, i64 %689
store float %691, float* %692
%693 = add nuw nsw i64 %685, 2
%694 = getelementptr inbounds float, float* %591, i64 %693
%695 = load float, float* %694
%696 = getelementptr inbounds float, float* %593, i64 %693
store float %695, float* %696
%697 = add nuw nsw i64 %685, 3
%698 = getelementptr inbounds float, float* %591, i64 %697
%699 = load float, float* %698
%700 = getelementptr inbounds float, float* %593, i64 %697
store float %699, float* %700
%701 = add nuw nsw i64 %685, 4
%702 = icmp eq i64 %701, %443
br i1 %702, label %703, label %684
703: ; preds = %681, %684, %668, %586
%704 = icmp slt i64 %588, %436
br i1 %704, label %586, label %579
705: ; preds = %765
br i1 %437, label %706, label %842
706: ; preds = %705
%707 = sub i64 %325, %335
%708 = add i64 %707, -8
%709 = lshr i64 %708, 3
%710 = add nuw nsw i64 %709, 1
%711 = icmp ult i64 %707, 8
%712 = and i64 %707, -8
%713 = add i64 %712, %335
%714 = and i64 %710, 1
%715 = icmp ult i64 %708, 8
%716 = and i64 %710, 4611686018427387902
%717 = icmp eq i64 %714, 0
%718 = icmp eq i64 %707, %712
br label %767
719: ; preds = %580, %765
%720 = phi i64 [ %335, %580 ], [ %721, %765 ]
%721 = add nsw i64 %720, 1
br i1 %581, label %722, label %765
722: ; preds = %719
br i1 %583, label %752, label %723
723: ; preds = %722, %723
%724 = phi i64 [ %749, %723 ], [ 0, %722 ]
%725 = phi i64 [ %750, %723 ], [ 0, %722 ]
%726 = getelementptr inbounds float*, float** %0, i64 %724
%727 = load float*, float** %726
%728 = getelementptr inbounds float, float* %727, i64 %721
%729 = load float, float* %728
%730 = getelementptr inbounds float, float* %727, i64 %720
store float %729, float* %730
%731 = or i64 %724, 1
%732 = getelementptr inbounds float*, float** %0, i64 %731
%733 = load float*, float** %732
%734 = getelementptr inbounds float, float* %733, i64 %721
%735 = load float, float* %734
%736 = getelementptr inbounds float, float* %733, i64 %720
store float %735, float* %736
%737 = or i64 %724, 2
%738 = getelementptr inbounds float*, float** %0, i64 %737
%739 = load float*, float** %738
%740 = getelementptr inbounds float, float* %739, i64 %721
%741 = load float, float* %740
%742 = getelementptr inbounds float, float* %739, i64 %720
store float %741, float* %742
%743 = or i64 %724, 3
%744 = getelementptr inbounds float*, float** %0, i64 %743
%745 = load float*, float** %744
%746 = getelementptr inbounds float, float* %745, i64 %721
%747 = load float, float* %746
%748 = getelementptr inbounds float, float* %745, i64 %720
store float %747, float* %748
%749 = add nuw nsw i64 %724, 4
%750 = add i64 %725, 4
%751 = icmp eq i64 %750, %584
br i1 %751, label %752, label %723
752: ; preds = %723, %722
%753 = phi i64 [ 0, %722 ], [ %749, %723 ]
br i1 %585, label %765, label %754
754: ; preds = %752, %754
%755 = phi i64 [ %762, %754 ], [ %753, %752 ]
%756 = phi i64 [ %763, %754 ], [ 0, %752 ]
%757 = getelementptr inbounds float*, float** %0, i64 %755
%758 = load float*, float** %757
%759 = getelementptr inbounds float, float* %758, i64 %721
%760 = load float, float* %759
%761 = getelementptr inbounds float, float* %758, i64 %720
store float %760, float* %761
%762 = add nuw nsw i64 %755, 1
%763 = add i64 %756, 1
%764 = icmp eq i64 %763, %582
br i1 %764, label %765, label %754
765: ; preds = %752, %754, %719
%766 = icmp slt i64 %721, %436
br i1 %766, label %719, label %705
767: ; preds = %706, %840
%768 = phi i64 [ %769, %840 ], [ %335, %706 ]
%769 = add nsw i64 %768, 1
%770 = getelementptr inbounds float*, float** %0, i64 %769
%771 = load float*, float** %770
%772 = getelementptr inbounds float*, float** %0, i64 %768
%773 = load float*, float** %772
br i1 %711, label %831, label %774
774: ; preds = %767
%775 = getelementptr float, float* %773, i64 %335
%776 = getelementptr float, float* %773, i64 %327
%777 = getelementptr float, float* %771, i64 1
%778 = getelementptr float, float* %777, i64 %335
%779 = getelementptr float, float* %771, i64 %314
%780 = icmp ult float* %775, %779
%781 = icmp ult float* %778, %776
%782 = and i1 %780, %781
br i1 %782, label %831, label %783
783: ; preds = %774
br i1 %715, label %815, label %784
784: ; preds = %783, %784
%785 = phi i64 [ %812, %784 ], [ 0, %783 ]
%786 = phi i64 [ %813, %784 ], [ 0, %783 ]
%787 = add i64 %785, %335
%788 = add nsw i64 %787, 1
%789 = getelementptr inbounds float, float* %771, i64 %788
%790 = bitcast float* %789 to <4 x float>*
%791 = load <4 x float>, <4 x float>* %790
%792 = getelementptr inbounds float, float* %789, i64 4
%793 = bitcast float* %792 to <4 x float>*
%794 = load <4 x float>, <4 x float>* %793
%795 = getelementptr inbounds float, float* %773, i64 %787
%796 = bitcast float* %795 to <4 x float>*
store <4 x float> %791, <4 x float>* %796
%797 = getelementptr inbounds float, float* %795, i64 4
%798 = bitcast float* %797 to <4 x float>*
store <4 x float> %794, <4 x float>* %798
%799 = or i64 %785, 8
%800 = add i64 %799, %335
%801 = add nsw i64 %800, 1
%802 = getelementptr inbounds float, float* %771, i64 %801
%803 = bitcast float* %802 to <4 x float>*
%804 = load <4 x float>, <4 x float>* %803
%805 = getelementptr inbounds float, float* %802, i64 4
%806 = bitcast float* %805 to <4 x float>*
%807 = load <4 x float>, <4 x float>* %806
%808 = getelementptr inbounds float, float* %773, i64 %800
%809 = bitcast float* %808 to <4 x float>*
store <4 x float> %804, <4 x float>* %809
%810 = getelementptr inbounds float, float* %808, i64 4
%811 = bitcast float* %810 to <4 x float>*
store <4 x float> %807, <4 x float>* %811
%812 = add nuw i64 %785, 16
%813 = add i64 %786, 2
%814 = icmp eq i64 %813, %716
br i1 %814, label %815, label %784
815: ; preds = %784, %783
%816 = phi i64 [ 0, %783 ], [ %812, %784 ]
br i1 %717, label %830, label %817
817: ; preds = %815
%818 = add i64 %816, %335
%819 = add nsw i64 %818, 1
%820 = getelementptr inbounds float, float* %771, i64 %819
%821 = bitcast float* %820 to <4 x float>*
%822 = load <4 x float>, <4 x float>* %821
%823 = getelementptr inbounds float, float* %820, i64 4
%824 = bitcast float* %823 to <4 x float>*
%825 = load <4 x float>, <4 x float>* %824
%826 = getelementptr inbounds float, float* %773, i64 %818
%827 = bitcast float* %826 to <4 x float>*
store <4 x float> %822, <4 x float>* %827
%828 = getelementptr inbounds float, float* %826, i64 4
%829 = bitcast float* %828 to <4 x float>*
store <4 x float> %825, <4 x float>* %829
br label %830
830: ; preds = %815, %817
br i1 %718, label %840, label %831
831: ; preds = %774, %767, %830
%832 = phi i64 [ %335, %774 ], [ %335, %767 ], [ %713, %830 ]
br label %833
833: ; preds = %831, %833
%834 = phi i64 [ %835, %833 ], [ %832, %831 ]
%835 = add nsw i64 %834, 1
%836 = getelementptr inbounds float, float* %771, i64 %835
%837 = load float, float* %836
%838 = getelementptr inbounds float, float* %773, i64 %834
store float %837, float* %838
%839 = icmp slt i64 %835, %436
br i1 %839, label %833, label %840
840: ; preds = %833, %830
%841 = icmp slt i64 %769, %436
br i1 %841, label %767, label %842
842: ; preds = %840, %435, %440, %579, %705
br i1 %53, label %843, label %859
843: ; preds = %842
%844 = trunc i64 %436 to i32
%845 = tail call float @gettotalJC(float* %1, i8* %3, i32 %844, float** %2, i32 %7, i32 %4, float %271)
%846 = fsub float %320, %845
%847 = fcmp ogt float %846, %319
%848 = fcmp ogt float %321, %317
%849 = select i1 %847, i1 %848, i1 false
br i1 %849, label %850, label %859
850: ; preds = %843
%851 = fcmp olt float %318, %321
br i1 %851, label %852, label %855
852: ; preds = %850
%853 = fadd float %321, %318
%854 = fmul float %853, 5.000000e-01
br label %859
855: ; preds = %850
%856 = fpext float %318 to double
%857 = fadd double %856, -1.000000e-02
%858 = fptrunc double %857 to float
br label %859
859: ; preds = %842, %843, %855, %852
%860 = phi float [ %320, %842 ], [ %845, %843 ], [ %845, %855 ], [ %845, %852 ]
%861 = phi float [ %319, %842 ], [ %319, %843 ], [ %846, %855 ], [ %846, %852 ]
%862 = phi float [ %318, %842 ], [ %321, %843 ], [ %321, %855 ], [ %321, %852 ]
%863 = phi float [ %317, %842 ], [ %317, %843 ], [ %858, %855 ], [ %854, %852 ]
%864 = getelementptr inbounds float*, float** %2, i64 %332
%865 = getelementptr inbounds float*, float** %0, i64 %332
br label %866
866: ; preds = %859, %866
%867 = phi i64 [ 0, %859 ], [ %877, %866 ]
%868 = load float*, float** %864
%869 = getelementptr inbounds float*, float** %2, i64 %867
%870 = load float*, float** %869
%871 = tail call float @distance2(float* %868, float* %870, i32 %7)
%872 = load float*, float** %865
%873 = getelementptr inbounds float, float* %872, i64 %867
store float %871, float* %873
%874 = getelementptr inbounds float*, float** %0, i64 %867
%875 = load float*, float** %874
%876 = getelementptr inbounds float, float* %875, i64 %332
store float %871, float* %876
%877 = add nuw nsw i64 %867, 1
%878 = icmp eq i64 %877, %315
br i1 %878, label %879, label %866
879: ; preds = %866
%880 = icmp sgt i64 %314, 2
br i1 %880, label %887, label %915
881: ; preds = %899, %887
%882 = phi i32 [ %892, %887 ], [ %907, %899 ]
%883 = phi i32 [ %891, %887 ], [ %909, %899 ]
%884 = phi float [ %890, %887 ], [ %910, %899 ]
%885 = add nuw nsw i64 %889, 1
%886 = icmp eq i64 %893, %316
br i1 %886, label %307, label %887
887: ; preds = %879, %881
%888 = phi i64 [ %893, %881 ], [ 0, %879 ]
%889 = phi i64 [ %885, %881 ], [ 1, %879 ]
%890 = phi float [ %884, %881 ], [ 1.000000e+05, %879 ]
%891 = phi i32 [ %883, %881 ], [ %322, %879 ]
%892 = phi i32 [ %882, %881 ], [ %323, %879 ]
%893 = add nuw nsw i64 %888, 1
%894 = icmp slt i64 %893, %436
br i1 %894, label %895, label %881
895: ; preds = %887
%896 = getelementptr inbounds float*, float** %0, i64 %888
%897 = load float*, float** %896
%898 = trunc i64 %888 to i32
br label %899
899: ; preds = %895, %899
%900 = phi i64 [ %889, %895 ], [ %911, %899 ]
%901 = phi float [ %890, %895 ], [ %910, %899 ]
%902 = phi i32 [ %891, %895 ], [ %909, %899 ]
%903 = phi i32 [ %892, %895 ], [ %907, %899 ]
%904 = getelementptr inbounds float, float* %897, i64 %900
%905 = load float, float* %904
%906 = fcmp olt float %905, %901
%907 = select i1 %906, i32 %898, i32 %903
%908 = trunc i64 %900 to i32
%909 = select i1 %906, i32 %908, i32 %902
%910 = select i1 %906, float %905, float %901
%911 = add nuw nsw i64 %900, 1
%912 = shl i64 %911, 32
%913 = ashr exact i64 %912, 32
%914 = icmp slt i64 %913, %436
br i1 %914, label %899, label %881
915: ; preds = %879, %307
%916 = trunc i64 %436 to i32
br label %917
917: ; preds = %915, %268
%918 = phi float [ %270, %268 ], [ %863, %915 ]
%919 = phi i32 [ %5, %268 ], [ %916, %915 ]
br i1 %53, label %920, label %923
920: ; preds = %917
store float %918, float* %6
br label %923
921: ; preds = %312
%922 = trunc i64 %314 to i32
br label %923
923: ; preds = %921, %920, %917
%924 = phi i32 [ %919, %920 ], [ %919, %917 ], [ %922, %921 ]
ret i32 %924
}