void cluster_melt(double *h, int m, int n, double *Bsched, int t, int k, int l,
                  int *c) {
  double lambda, sum, beta, logsumexp, maxlp;
  int i, j, a, b, b0, b1, limit, B, it, maxiter, maxiter0, maxiter1;
  double **cl;
  int **nc;
  double **lp;
  int *oldc;
  lambda = 0.02;
  ;
  if (l > 0)
    limit = l;
  else
    limit = 20;
  ;
  B = 2 * limit + 1;
  maxiter0 = 20;
  maxiter1 = 5;
  cl = (double **)malloc(k * sizeof(double *));
  for (i = 0; i < k; i++)
    cl[i] = (double *)malloc(m * sizeof(double));
  nc = (int **)malloc(n * sizeof(int *));
  for (i = 0; i < n; i++)
    nc[i] = (int *)malloc(k * sizeof(int));
  lp = (double **)malloc(n * sizeof(double *));
  for (i = 0; i < n; i++)
    lp[i] = (double *)malloc(k * sizeof(double));
  oldc = (int *)malloc(n * sizeof(int));
  for (i = 0; i < k; i++) {
    sum = 0;
    for (j = 0; j < m; j++) {
      cl[i][j] = rand();
      sum += cl[i][j] * cl[i][j];
    }
    sum = sqrt(sum);
    for (j = 0; j < m; j++) {
      cl[i][j] /= sum;
    }
  }
  for (i = 0; i < n; i++)
    c[i] = 1;
  for (a = 0; a < t; a++) {
    beta = Bsched[a];
    if (a == 0)
      maxiter = maxiter0;
    else
      maxiter = maxiter1;
    for (it = 0; it < maxiter; it++) {
      for (i = 0; i < n; i++) {
        oldc[i] = c[i];
        sum = 0;
        for (j = 0; j < k; j++) {
          lp[i][j] = -beta * kldist(cl[j], &h[i * m], m);
          b0 = i - limit;
          if (b0 < 0)
            b0 = 0;
          b1 = i + limit;
          if (b1 >= n)
            b1 = n - 1;
          nc[i][j] = b1 - b0 + 1;
          for (b = b0; b <= b1; b++)
            if (c[b] == j + 1)
              nc[i][j]--;
          sum += exp(lp[i][j]);
        }
        logsumexp = log(sum);
        for (j = 0; j < k; j++)
          lp[i][j] -= logsumexp + lambda * nc[i][j];
      }
      for (i = 0; i < n; i++) {
        maxlp = lp[i][0];
        c[i] = 1;
        for (j = 1; j < k; j++)
          if (lp[i][j] > maxlp) {
            maxlp = lp[i][j];
            c[i] = j + 1;
          }
      }
      i = 0;
      while (i < n && oldc[i] == c[i])
        i++;
      if (i == n)
        break;
      for (j = 0; j < k; j++) {
        for (b = 0; b < m; b++) {
          cl[j][b] = 0;
          for (i = 0; i < n; i++) {
            cl[j][b] += exp(lp[i][j]) * h[i * m + b];
          }
        }
        sum = 0;
        for (i = 0; i < n; i++)
          sum += exp(lp[i][j]);
        for (b = 0; b < m; b++)
          cl[j][b] /= sum;
      }
    }
  }
  for (i = 0; i < k; i++)
    free(cl[i]);
  free(cl);
  for (i = 0; i < n; i++)
    free(nc[i]);
  free(nc);
  for (i = 0; i < n; i++)
    free(lp[i]);
  free(lp);
  free(oldc);
}


x86 assembly (clang, -O0):
<cluster_melt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movsd  0xe60(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
cmpl   $0x0,0x10(%rbp)
jle    11ba <cluster_melt+0x4a>
mov    0x10(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    11c1 <cluster_melt+0x51>
movl   $0x14,-0x64(%rbp)
mov    -0x64(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movl   $0x14,-0x74(%rbp)
movl   $0x5,-0x78(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1229 <cluster_melt+0xb9>
movslq -0xc(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11f3 <cluster_melt+0x83>
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    127d <cluster_melt+0x10d>
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1244 <cluster_melt+0xd4>
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12d1 <cluster_melt+0x161>
movslq -0x20(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1298 <cluster_melt+0x128>
movslq -0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13e3 <cluster_melt+0x273>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    137d <cluster_melt+0x20d>
mov    $0x0,%al
call   1090 <rand@plt>
cvtsi2sd %eax,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1307 <cluster_melt+0x197>
movsd  -0x30(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13d0 <cluster_melt+0x260>
movsd  -0x30(%rbp),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1393 <cluster_melt+0x223>
jmp    13d5 <cluster_melt+0x265>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12ec <cluster_melt+0x17c>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1413 <cluster_melt+0x2a3>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13ea <cluster_melt+0x27a>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    195e <cluster_melt+0x7ee>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
cmpl   $0x0,-0x54(%rbp)
jne    144d <cluster_melt+0x2dd>
mov    -0x74(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    1453 <cluster_melt+0x2e3>
mov    -0x78(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    194b <cluster_melt+0x7db>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1697 <cluster_melt+0x527>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1609 <cluster_melt+0x499>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x4c(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0xc(%rbp),%edx
mov    $0x0,%al
call   1040 <kldist@plt>
movsd  -0xa0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jge    153d <cluster_melt+0x3cd>
movl   $0x0,-0x5c(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     155b <cluster_melt+0x3eb>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%edx
sub    -0x5c(%rbp),%edx
add    $0x1,%edx
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     15d4 <cluster_melt+0x464>
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    15c1 <cluster_melt+0x451>
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    15c6 <cluster_melt+0x456>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1580 <cluster_melt+0x410>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <exp@plt>
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    14a1 <cluster_melt+0x331>
movsd  -0x30(%rbp),%xmm0
call   1070 <log@plt>
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1684 <cluster_melt+0x514>
movsd  -0x40(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    161f <cluster_melt+0x4af>
jmp    1689 <cluster_melt+0x519>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    146d <cluster_melt+0x2fd>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    175b <cluster_melt+0x5eb>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1748 <cluster_melt+0x5d8>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    1735 <cluster_melt+0x5c5>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x50(%rbp),%edx
add    $0x1,%edx
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    173a <cluster_melt+0x5ca>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    16d8 <cluster_melt+0x568>
jmp    174d <cluster_melt+0x5dd>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    169e <cluster_melt+0x52e>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0xa1(%rbp)
jge    1798 <cluster_melt+0x628>
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
sete   %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    17ab <cluster_melt+0x63b>
jmp    17b9 <cluster_melt+0x649>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1762 <cluster_melt+0x5f2>
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    17ca <cluster_melt+0x65a>
jmp    194b <cluster_melt+0x7db>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1938 <cluster_melt+0x7c8>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1891 <cluster_melt+0x721>
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    187e <cluster_melt+0x70e>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <exp@plt>
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    180f <cluster_melt+0x69f>
jmp    1883 <cluster_melt+0x713>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    17e4 <cluster_melt+0x674>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    18e1 <cluster_melt+0x771>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <exp@plt>
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    18a0 <cluster_melt+0x730>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1925 <cluster_melt+0x7b5>
movsd  -0x30(%rbp),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    18e8 <cluster_melt+0x778>
jmp    192a <cluster_melt+0x7ba>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    17d1 <cluster_melt+0x661>
jmp    193d <cluster_melt+0x7cd>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    145a <cluster_melt+0x2ea>
jmp    1950 <cluster_melt+0x7e0>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    141a <cluster_melt+0x2aa>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1990 <cluster_melt+0x820>
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1965 <cluster_melt+0x7f5>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19ce <cluster_melt+0x85e>
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    19a0 <cluster_melt+0x830>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a0f <cluster_melt+0x89f>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    19e1 <cluster_melt+0x871>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cluster_melt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9d,%ebx
mov    %r8d,0xc0(%rsp)
mov    %rcx,0xe0(%rsp)
mov    %rdx,0x8(%rsp)
mov    %esi,%ebp
mov    %rdi,0xb8(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    0x170(%rsp),%eax
test   %eax,%eax
mov    $0x14,%ecx
cmovg  %eax,%ecx
mov    %ecx,0x3c(%rsp)
movslq %r9d,%r15
lea    0x0(,%r15,8),%r13
mov    %r13,%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebp,0x4(%rsp)
movslq %ebp,%rax
mov    %rax,0x80(%rsp)
mov    %ebx,0x14(%rsp)
mov    %ebx,%ebp
test   %r15d,%r15d
jle    1225 <cluster_melt+0xb5>
mov    0x80(%rsp),%rax
lea    0x0(,%rax,8),%r12
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdi
call   1050 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1210 <cluster_melt+0xa0>
mov    %rbp,0x30(%rsp)
mov    %r14,0x20(%rsp)
mov    0x8(%rsp),%r14
movslq %r14d,%rbx
lea    0x0(,%rbx,8),%r12
mov    %r12,%rdi
call   1050 <malloc@plt>
mov    %r14d,%r14d
mov    %rbx,0xa8(%rsp)
test   %ebx,%ebx
mov    %rax,0x60(%rsp)
jle    12cc <cluster_melt+0x15c>
mov    %rax,%rbp
shl    $0x2,%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1270 <cluster_melt+0x100>
mov    %r12,%rdi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
cmpl   $0x0,0x8(%rsp)
mov    0x14(%rsp),%r15d
jle    12e5 <cluster_melt+0x175>
xor    %ebx,%ebx
mov    0x20(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
mov    %r13,%rdi
call   1050 <malloc@plt>
mov    0x18(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    12b0 <cluster_melt+0x140>
jmp    12ea <cluster_melt+0x17a>
mov    %r12,%rdi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    0x20(%rsp),%r12
mov    0x14(%rsp),%r15d
jmp    12ea <cluster_melt+0x17a>
mov    0x20(%rsp),%r12
mov    0xa8(%rsp),%rax
lea    0x0(,%rax,4),%rdi
call   1050 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    0x4(%rsp),%ebp
test   %r15d,%r15d
mov    0x28(%rsp),%r8
mov    %rbp,0x50(%rsp)
jle    14a7 <cluster_melt+0x337>
mov    %ebp,%r13d
and    $0xfffffffe,%r13d
lea    -0x2(%r13),%rax
mov    %rax,0x70(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x68(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x90(%rsp)
xor    %r15d,%r15d
jmp    136f <cluster_melt+0x1ff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x30(%rsp),%r15
je     14a7 <cluster_melt+0x337>
cmpl   $0x0,0x4(%rsp)
jle    1360 <cluster_melt+0x1f0>
xorps  %xmm0,%xmm0
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x40(%rsp)
xor    %eax,%eax
call   1090 <rand@plt>
mov    0x50(%rsp),%rbp
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    (%r12,%r15,8),%rax
movsd  %xmm0,(%rax,%rbx,8)
mulsd  %xmm0,%xmm0
movsd  0x40(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
movsd  0x40(%rsp),%xmm0
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1380 <cluster_melt+0x210>
ucomisd 0xc6b(%rip),%xmm0
jb     13e0 <cluster_melt+0x270>
sqrtsd %xmm0,%xmm0
jmp    13ea <cluster_melt+0x27a>
cs nopw 0x0(%rax,%rax,1)
nop
call   1080 <sqrt@plt>
mov    0x50(%rsp),%rbp
mov    0x28(%rsp),%r8
cmpl   $0x0,0x4(%rsp)
jle    1360 <cluster_melt+0x1f0>
mov    (%r12,%r15,8),%rax
cmpl   $0x1,0x4(%rsp)
jne    1409 <cluster_melt+0x299>
xor    %ecx,%ecx
jmp    1480 <cluster_melt+0x310>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x70(%rsp)
je     149c <cluster_melt+0x32c>
mov    0x90(%rsp),%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1430 <cluster_melt+0x2c0>
testb  $0x1,0x68(%rsp)
je     146d <cluster_melt+0x2fd>
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
mov    %r13,%rcx
cmp    %rbp,%r13
je     1360 <cluster_melt+0x1f0>
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1480 <cluster_melt+0x310>
jmp    1360 <cluster_melt+0x1f0>
xor    %ecx,%ecx
testb  $0x1,0x68(%rsp)
jne    145f <cluster_melt+0x2ef>
jmp    146d <cluster_melt+0x2fd>
cmpl   $0x0,0x8(%rsp)
mov    0x30(%rsp),%r15
mov    0x18(%rsp),%rdi
jle    15e1 <cluster_melt+0x471>
cmpl   $0x8,0x8(%rsp)
jae    14ca <cluster_melt+0x35a>
xor    %eax,%eax
jmp    15d0 <cluster_melt+0x460>
mov    %r14d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x38,%rsi
jae    14f1 <cluster_melt+0x381>
xor    %esi,%esi
jmp    1595 <cluster_melt+0x425>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movapd 0xb01(%rip),%xmm0
nop
movupd %xmm0,(%r8,%rsi,4)
movupd %xmm0,0x10(%r8,%rsi,4)
movupd %xmm0,0x20(%r8,%rsi,4)
movupd %xmm0,0x30(%r8,%rsi,4)
movupd %xmm0,0x40(%r8,%rsi,4)
movupd %xmm0,0x50(%r8,%rsi,4)
movupd %xmm0,0x60(%r8,%rsi,4)
movupd %xmm0,0x70(%r8,%rsi,4)
movupd %xmm0,0x80(%r8,%rsi,4)
movupd %xmm0,0x90(%r8,%rsi,4)
movupd %xmm0,0xa0(%r8,%rsi,4)
movupd %xmm0,0xb0(%r8,%rsi,4)
movupd %xmm0,0xc0(%r8,%rsi,4)
movupd %xmm0,0xd0(%r8,%rsi,4)
movupd %xmm0,0xe0(%r8,%rsi,4)
movupd %xmm0,0xf0(%r8,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1500 <cluster_melt+0x390>
test   %rcx,%rcx
je     15c4 <cluster_melt+0x454>
lea    (%r8,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movapd 0xa50(%rip),%xmm0
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    15b0 <cluster_melt+0x440>
cmp    %r14,%rax
je     15e1 <cluster_melt+0x471>
nopl   0x0(%rax)
movl   $0x1,(%r8,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    15d0 <cluster_melt+0x460>
mov    0xc0(%rsp),%eax
test   %eax,%eax
mov    0x14(%rsp),%r9d
jle    1d1a <cluster_melt+0xbaa>
mov    %eax,%edx
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0xa0(%rsp)
mov    0x3c(%rsp),%eax
movslq %eax,%rcx
mov    %rcx,0x128(%rsp)
neg    %eax
mov    %eax,0x3c(%rsp)
mov    %edx,%eax
mov    %rax,0xd8(%rsp)
lea    -0x1(%r15),%rcx
and    $0xfffffffe,%ebp
mov    %rbp,0x110(%rsp)
lea    -0x2(%rbp),%rax
mov    %rax,0x108(%rsp)
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xf8(%rsp)
mov    %rdx,%rax
mov    %rdx,0x100(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xf0(%rsp)
lea    0x0(,%r15,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,0x120(%rsp)
mov    %rcx,%rax
mov    %rcx,0x118(%rsp)
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    %rcx,0xb0(%rsp)
mov    0x80(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %r14,0x58(%rsp)
jmp    16da <cluster_melt+0x56a>
nopl   0x0(%rax,%rax,1)
mov    0xe8(%rsp),%rax
add    $0x1,%rax
cmp    0xd8(%rsp),%rax
je     1d1a <cluster_melt+0xbaa>
test   %rax,%rax
mov    $0x5,%edx
mov    %rax,%rcx
mov    $0x14,%eax
cmove  %eax,%edx
mov    %edx,0x9c(%rsp)
mov    0xe0(%rsp),%rax
mov    %rcx,0xe8(%rsp)
movsd  (%rax,%rcx,8),%xmm0
xorpd  0x8ff(%rip),%xmm0
movapd %xmm0,0xc0(%rsp)
movl   $0x0,0x4c(%rsp)
jmp    174d <cluster_melt+0x5dd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x4c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x4c(%rsp)
cmp    0x9c(%rsp),%eax
mov    0x14(%rsp),%r9d
je     16c0 <cluster_melt+0x550>
xor    %ecx,%ecx
cmpl   $0x0,0x8(%rsp)
jle    1b02 <cluster_melt+0x992>
xor    %ebp,%ebp
mov    0x3c(%rsp),%ebx
jmp    17ab <cluster_melt+0x63b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mov    %r9d,%r15d
call   1070 <log@plt>
mov    %r15d,%r9d
mov    0x30(%rsp),%r15
mov    0xb0(%rsp),%r10
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%r8
mov    0x20(%rsp),%r12
add    $0x1,%rbp
add    $0x1,%ebx
cmp    %r14,%rbp
je     1a20 <cluster_melt+0x8b0>
test   %ebx,%ebx
mov    $0x0,%edx
cmovg  %ebx,%edx
mov    (%r8,%rbp,4),%eax
mov    0x88(%rsp),%rcx
mov    %eax,(%rcx,%rbp,4)
test   %r9d,%r9d
jle    1770 <cluster_melt+0x600>
mov    %ebx,0xa4(%rsp)
add    $0xffffffffffffffff,%rdx
mov    %rdx,0x130(%rsp)
mov    %rbp,%rax
imul   0x80(%rsp),%rax
mov    0xb8(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    %rbp,%rdx
mov    0x128(%rsp),%rax
sub    %rax,%rdx
test   %rdx,%rdx
mov    $0x0,%ecx
cmovle %ecx,%edx
mov    %rbp,0x68(%rsp)
add    %rbp,%rax
cmp    0xa8(%rsp),%rax
cmovge 0xa0(%rsp),%eax
mov    %eax,%r12d
mov    %rdx,%r13
sub    %edx,%r12d
add    $0x1,%r12d
mov    %rax,%r14
movslq %eax,%rbp
xorpd  %xmm0,%xmm0
xor    %r15d,%r15d
jmp    1871 <cluster_melt+0x701>
nopl   0x0(%rax)
call   1060 <exp@plt>
movsd  0x70(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    %rbx,%r15
cmp    0x30(%rsp),%rbx
je     1910 <cluster_melt+0x7a0>
movsd  %xmm0,0x70(%rsp)
mov    0x20(%rsp),%rax
mov    (%rax,%r15,8),%rdi
mov    0x90(%rsp),%rsi
mov    0x4(%rsp),%edx
xor    %eax,%eax
call   1040 <kldist@plt>
lea    0x1(%r15),%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xc0(%rsp),%xmm0
mov    0x18(%rsp),%rax
mov    0x68(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    0x60(%rsp),%rax
mov    (%rax,%rcx,8),%rax
mov    %r12d,(%rax,%r15,4)
cmp    %r13d,%r14d
mov    0x28(%rsp),%rdi
jl     1850 <cluster_melt+0x6e0>
mov    0x130(%rsp),%rcx
mov    %r12d,%edx
jmp    18fd <cluster_melt+0x78d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
cmp    %rbp,%rcx
jge    1850 <cluster_melt+0x6e0>
mov    0x4(%rdi,%rcx,4),%esi
cmp    %rsi,%rbx
jne    18f0 <cluster_melt+0x780>
add    $0xffffffff,%edx
mov    %edx,(%rax,%r15,4)
jmp    18f0 <cluster_melt+0x780>
nop
call   1070 <log@plt>
mov    0x14(%rsp),%r9d
test   %r9d,%r9d
mov    0x30(%rsp),%r15
mov    0x28(%rsp),%r8
mov    0x18(%rsp),%rdi
mov    0x120(%rsp),%rsi
mov    0xb0(%rsp),%r10
movsd  0x6ec(%rip),%xmm5
movapd 0x6d4(%rip),%xmm6
mov    0x68(%rsp),%rbp
mov    0x58(%rsp),%r14
mov    0xa4(%rsp),%ebx
mov    0x20(%rsp),%r12
jle    179b <cluster_melt+0x62b>
mov    0x60(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rdi,%rbp,8),%rcx
cmp    $0x4,%r9d
jae    197f <cluster_melt+0x80f>
xor    %edx,%edx
jmp    19f0 <cluster_melt+0x880>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %edx,%edx
nopl   0x0(%rax)
cvtdq2pd (%rax,%rdx,1),%xmm2
cvtdq2pd 0x8(%rax,%rdx,1),%xmm3
mulpd  %xmm6,%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
movupd (%rcx,%rdx,2),%xmm4
subpd  %xmm2,%xmm4
movupd 0x10(%rcx,%rdx,2),%xmm2
subpd  %xmm3,%xmm2
movupd %xmm4,(%rcx,%rdx,2)
movupd %xmm2,0x10(%rcx,%rdx,2)
add    $0x10,%rdx
cmp    %rdx,%rsi
jne    1990 <cluster_melt+0x820>
mov    0xf8(%rsp),%rsi
mov    %rsi,%rdx
cmp    %r15,%rsi
je     179b <cluster_melt+0x62b>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rdx,4),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rcx,%rdx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    19f0 <cluster_melt+0x880>
jmp    179b <cluster_melt+0x62b>
nopl   0x0(%rax)
cmpl   $0x0,0x8(%rsp)
jle    1b00 <cluster_melt+0x990>
xor    %eax,%eax
jmp    1a3d <cluster_melt+0x8cd>
nop
add    $0x1,%rax
cmp    %r14,%rax
je     1ad0 <cluster_melt+0x960>
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx),%xmm0
movl   $0x1,(%r8,%rax,4)
cmp    $0x2,%r9d
jl     1a30 <cluster_melt+0x8c0>
mov    $0x1,%edx
jne    1a80 <cluster_melt+0x910>
testb  $0x1,0x118(%rsp)
01
je     1a30 <cluster_melt+0x8c0>
movsd  (%rcx,%rdx,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1a30 <cluster_melt+0x8c0>
add    $0x1,%edx
mov    %edx,(%r8,%rax,4)
jmp    1a30 <cluster_melt+0x8c0>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%esi
jmp    1a9d <cluster_melt+0x92d>
nopw   0x0(%rax,%rax,1)
lea    (%r10,%rdx,1),%rbp
mov    %rdx,%rsi
cmp    $0x1,%rbp
je     1a5a <cluster_melt+0x8ea>
movsd  (%rcx,%rsi,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1ab3 <cluster_melt+0x943>
lea    0x1(%rsi),%edx
mov    %edx,(%r8,%rax,4)
movapd %xmm1,%xmm0
movsd  0x8(%rcx,%rsi,8),%xmm1
lea    0x2(%rsi),%rdx
ucomisd %xmm0,%xmm1
jbe    1a90 <cluster_melt+0x920>
add    $0x2,%esi
mov    %esi,(%r8,%rax,4)
movapd %xmm1,%xmm0
jmp    1a90 <cluster_melt+0x920>
cmpl   $0x0,0x8(%rsp)
mov    $0x0,%ecx
jle    1b02 <cluster_melt+0x992>
xor    %ecx,%ecx
xchg   %ax,%ax
mov    0x88(%rsp),%rax
mov    (%rax,%rcx,4),%eax
cmp    (%r8,%rcx,4),%eax
jne    1b02 <cluster_melt+0x992>
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1ae0 <cluster_melt+0x970>
jmp    16c0 <cluster_melt+0x550>
nop
xor    %ecx,%ecx
cmp    0x8(%rsp),%ecx
je     16c0 <cluster_melt+0x550>
test   %r9d,%r9d
jle    1730 <cluster_melt+0x5c0>
xor    %ebp,%ebp
jmp    1b2d <cluster_melt+0x9bd>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    %r15,%rbp
je     1730 <cluster_melt+0x5c0>
cmpl   $0x0,0x4(%rsp)
jle    1bd0 <cluster_melt+0xa60>
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rbx
mov    0xb8(%rsp),%rax
mov    %rax,0x70(%rsp)
xor    %r14d,%r14d
jmp    1b71 <cluster_melt+0xa01>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
addq   $0x8,0x70(%rsp)
cmp    0x50(%rsp),%r14
je     1bd0 <cluster_melt+0xa60>
movq   $0x0,(%rbx,%r14,8)
cmpl   $0x0,0x8(%rsp)
mov    0x58(%rsp),%r12
jle    1b60 <cluster_melt+0x9f0>
mov    0x70(%rsp),%r15
xor    %r13d,%r13d
nopl   (%rax)
mov    (%rdi,%r13,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1060 <exp@plt>
mov    0x18(%rsp),%rdi
mulsd  (%r15),%xmm0
addsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,(%rbx,%r14,8)
add    $0x1,%r13
add    0x40(%rsp),%r15
cmp    %r13,%r12
jne    1b90 <cluster_melt+0xa20>
jmp    1b60 <cluster_melt+0x9f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,0x8(%rsp)
jle    1c20 <cluster_melt+0xab0>
xorpd  %xmm3,%xmm3
xor    %ebx,%ebx
mov    0x58(%rsp),%r14
mov    0x20(%rsp),%r12
mov    0x30(%rsp),%r15
nopl   0x0(%rax)
movapd %xmm3,0x70(%rsp)
mov    (%rdi,%rbx,8),%rax
movsd  (%rax,%rbp,8),%xmm0
call   1060 <exp@plt>
movapd 0x70(%rsp),%xmm3
mov    0x18(%rsp),%rdi
addsd  %xmm0,%xmm3
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1bf0 <cluster_melt+0xa80>
jmp    1c33 <cluster_melt+0xac3>
xchg   %ax,%ax
xorpd  %xmm3,%xmm3
mov    0x58(%rsp),%r14
mov    0x20(%rsp),%r12
mov    0x30(%rsp),%r15
cmpl   $0x0,0x4(%rsp)
mov    0x28(%rsp),%r8
mov    0x50(%rsp),%rsi
jle    1b20 <cluster_melt+0x9b0>
mov    (%r12,%rbp,8),%rax
cmpl   $0x1,0x4(%rsp)
jne    1c60 <cluster_melt+0xaf0>
xor    %ecx,%ecx
jmp    1cf0 <cluster_melt+0xb80>
nopw   0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x0,0x108(%rsp)
je     1d0c <cluster_melt+0xb9c>
mov    0xf0(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rax,%rcx,8),%xmm1
movupd 0x10(%rax,%rcx,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rcx,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1c90 <cluster_melt+0xb20>
testb  $0x1,0x100(%rsp)
01
je     1cd0 <cluster_melt+0xb60>
movupd (%rax,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rcx,8)
mov    0x110(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rsi,%rdx
je     1b20 <cluster_melt+0x9b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1cf0 <cluster_melt+0xb80>
jmp    1b20 <cluster_melt+0x9b0>
xor    %ecx,%ecx
testb  $0x1,0x100(%rsp)
01
jne    1cc2 <cluster_melt+0xb52>
jmp    1cd0 <cluster_melt+0xb60>
test   %r9d,%r9d
jle    1d42 <cluster_melt+0xbd2>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1d30 <cluster_melt+0xbc0>
mov    %r12,%rdi
call   1030 <free@plt>
cmpl   $0x0,0x8(%rsp)
jle    1da5 <cluster_melt+0xc35>
xor    %ebx,%ebx
mov    0x60(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1d60 <cluster_melt+0xbf0>
mov    %rbp,%rdi
call   1030 <free@plt>
cmpl   $0x0,0x8(%rsp)
mov    0x18(%rsp),%rbp
jle    1db4 <cluster_melt+0xc44>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1d90 <cluster_melt+0xc20>
jmp    1db4 <cluster_melt+0xc44>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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