int merge(unsigned char *rmap, unsigned char *cmap, int N, int nt, int ny,
          int nx, int TR, float threshcolor, int threshtr) {
  int it, iy, ix, ir, *npt, npttotal, jr, i, mini, minj, newtr;
  float **P, mindist, **distnpt, **distcolor, nptT = 0.2;
  int loc, loc1, l, datasize, imgsize, *convert;
  ;
  imgsize = ny * nx;
  datasize = nt * imgsize;
  distnpt = (float **)fmatrix(TR + 1, TR + 1);
  distcolor = (float **)fmatrix(TR + 1, TR + 1);
  loc = 0;
  for (it = 0; it < nt; it++) {
    for (iy = 0; iy < ny; iy++) {
      loc++;
      for (ix = 1; ix < nx; ix++) {
        loc1 = loc - 1;
        if (rmap[loc1] != rmap[loc]) {
          ir = rmap[loc1];
          jr = rmap[loc];
          distnpt[ir][jr] += 1;
          distnpt[jr][ir] = distnpt[ir][jr];
        }
        loc++;
      }
    }
  }
  loc = 0;
  for (it = 0; it < nt; it++) {
    loc += nx;
    for (iy = 1; iy < ny; iy++) {
      for (ix = 0; ix < nx; ix++) {
        loc1 = loc - nx;
        if (rmap[loc1] != rmap[loc]) {
          ir = rmap[loc1];
          jr = rmap[loc];
          distnpt[ir][jr] += 1;
          distnpt[jr][ir] = distnpt[ir][jr];
        }
        loc++;
      }
    }
  }
  P = (float **)fmatrix(TR + 1, N);
  npt = (int *)calloc(TR + 1, sizeof(int));
  for (l = 0; l < datasize; l++) {
    ir = rmap[l];
    P[ir][cmap[l]] += 1;
    npt[ir]++;
  }
  for (ir = 1; ir <= TR; ir++)
    for (i = 0; i < N; i++)
      P[ir][i] /= npt[ir];
  mindist = 10000;
  for (ir = 1; ir < TR; ir++) {
    for (jr = ir + 1; jr <= TR; jr++) {
      if (distnpt[ir][jr] != 0.0) {
        distcolor[jr][ir] = distcolor[ir][jr] = distance(P[ir], P[jr], N);
        if (distcolor[ir][jr] < mindist) {
          mindist = distcolor[ir][jr];
          mini = ir;
          minj = jr;
        }
      }
    }
  }
  convert = (int *)calloc(TR + 1, sizeof(int));
  for (i = 1; i <= TR; i++)
    convert[i] = i;
  newtr = TR;
  while (mindist < threshcolor && newtr > threshtr) {
    for (i = 1; i <= TR; i++) {
      if (convert[i] == minj)
        convert[i] = mini;
      else if (convert[i] > minj)
        convert[i]--;
    }
    npttotal = npt[mini] + npt[minj];
    for (i = 0; i < N; i++) {
      P[mini][i] = (P[mini][i] * npt[mini] + P[minj][i] * npt[minj]) / npttotal;
    }
    npt[mini] = npttotal;
    for (ir = 1; ir <= newtr; ir++) {
      if (ir != mini && ir != minj) {
        if (distnpt[mini][ir] != 0.0 || distnpt[minj][ir] != 0.0) {
          distcolor[mini][ir] = distance(P[mini], P[ir], N);
          distcolor[ir][mini] = distcolor[mini][ir];
          distnpt[mini][ir] = distnpt[mini][ir] + distnpt[minj][ir];
          distnpt[ir][mini] = distnpt[mini][ir];
        }
      }
    }
    for (ir = 1; ir <= newtr; ir++) {
      for (jr = minj + 1; jr <= newtr; jr++) {
        distnpt[ir][jr - 1] = distnpt[ir][jr];
        distcolor[ir][jr - 1] = distcolor[ir][jr];
      }
    }
    for (ir = minj + 1; ir <= newtr; ir++) {
      for (jr = 1; jr <= newtr - 1; jr++) {
        distnpt[ir - 1][jr] = distnpt[ir][jr];
        distcolor[ir - 1][jr] = distcolor[ir][jr];
      }
      npt[ir - 1] = npt[ir];
      for (i = 0; i < N; i++)
        P[ir - 1][i] = P[ir][i];
    }
    newtr--;
    mindist = 10000;
    for (ir = 1; ir < newtr; ir++) {
      for (jr = ir + 1; jr <= newtr; jr++) {
        if (distnpt[ir][jr] != 0) {
          if (distcolor[ir][jr] < mindist) {
            mindist = distcolor[ir][jr];
            mini = ir;
            minj = jr;
          }
        }
      }
    }
  }
  for (l = 0; l < datasize; l++)
    rmap[l] = convert[rmap[l]];
  free(convert);
  free(npt);
  free_fmatrix(P, TR + 1);
  free_fmatrix(distnpt, TR + 1);
  free_fmatrix(distcolor, TR + 1);
  return newtr;
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  0xe7c(%rip),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    0x10(%rbp),%edi
add    $0x1,%edi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1060 <fmatrix@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    0x10(%rbp),%edi
add    $0x1,%edi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1060 <fmatrix@plt>
cltq
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x80(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12fa <merge+0x1aa>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12e7 <merge+0x197>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12d4 <merge+0x184>
mov    -0x80(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x80(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     12bd <merge+0x16d>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x80(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x48(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  0xd7f(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1215 <merge+0xc5>
jmp    12d9 <merge+0x189>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f9 <merge+0xa9>
jmp    12ec <merge+0x19c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e6 <merge+0x96>
movl   $0x0,-0x80(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    141c <merge+0x2cc>
mov    -0x20(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x80(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1409 <merge+0x2b9>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13f6 <merge+0x2a6>
mov    -0x80(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x80(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     13df <merge+0x28f>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x80(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x48(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  0xc5d(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1337 <merge+0x1e7>
jmp    13fb <merge+0x2ab>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1324 <merge+0x1d4>
jmp    140e <merge+0x2be>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1308 <merge+0x1b8>
mov    0x10(%rbp),%edi
add    $0x1,%edi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1060 <fmatrix@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    14c9 <merge+0x379>
mov    -0x8(%rbp),%rax
movslq -0x88(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movslq -0x88(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  0xb6e(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1453 <merge+0x303>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     153b <merge+0x3eb>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1528 <merge+0x3d8>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14e3 <merge+0x393>
jmp    152d <merge+0x3dd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14d0 <merge+0x380>
movss  0xac1(%rip),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1665 <merge+0x515>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1652 <merge+0x502>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15a1 <merge+0x451>
jp     15a1 <merge+0x451>
jmp    163f <merge+0x4ef>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
mov    $0x0,%al
call   1070 <distance@plt>
cvtsi2ss %eax,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    163a <merge+0x4ea>
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    163f <merge+0x4ef>
jmp    1644 <merge+0x4f4>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1564 <merge+0x414>
jmp    1657 <merge+0x507>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    154f <merge+0x3ff>
mov    0x10(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x98(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     16b1 <merge+0x561>
mov    -0x4c(%rbp),%edx
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1686 <merge+0x536>
mov    0x10(%rbp),%eax
mov    %eax,-0x58(%rbp)
movss  -0x64(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
xor    %eax,%eax
ucomiss %xmm1,%xmm0
mov    %al,-0x99(%rbp)
jbe    16e1 <merge+0x591>
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
setg   %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    16f4 <merge+0x5a4>
jmp    1c3c <merge+0xaec>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1777 <merge+0x627>
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
jne    1734 <merge+0x5e4>
mov    -0x50(%rbp),%edx
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1764 <merge+0x614>
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
jle    175f <merge+0x60f>
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1764 <merge+0x614>
jmp    1769 <merge+0x619>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16fb <merge+0x5ab>
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x54(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    181f <merge+0x6cf>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtsi2ssl -0x44(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1797 <merge+0x647>
mov    -0x44(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     199b <merge+0x84b>
mov    -0x34(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     1988 <merge+0x838>
mov    -0x34(%rbp),%eax
cmp    -0x54(%rbp),%eax
je     1988 <merge+0x838>
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18b5 <merge+0x765>
jp     18b5 <merge+0x765>
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18b5 <merge+0x765>
jp     18b5 <merge+0x765>
jmp    1983 <merge+0x833>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x14(%rbp),%edx
mov    $0x0,%al
call   1070 <distance@plt>
cvtsi2ss %eax,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1988 <merge+0x838>
jmp    198d <merge+0x83d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1834 <merge+0x6e4>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1a42 <merge+0x8f2>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1a2f <merge+0x8df>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    19b7 <merge+0x867>
jmp    1a34 <merge+0x8e4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19a2 <merge+0x852>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1b59 <merge+0xa09>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1adb <merge+0x98b>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1a5e <merge+0x90e>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b46 <merge+0x9f6>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1afd <merge+0x9ad>
jmp    1b4b <merge+0x9fb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a4b <merge+0x8fb>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
movss  0x49a(%rip),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1c37 <merge+0xae7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1c24 <merge+0xad4>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1bc3 <merge+0xa73>
jp     1bc3 <merge+0xa73>
jmp    1c11 <merge+0xac1>
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1c0c <merge+0xabc>
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1c11 <merge+0xac1>
jmp    1c16 <merge+0xac6>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1b8b <merge+0xa3b>
jmp    1c29 <merge+0xad9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b76 <merge+0xa26>
jmp    16b7 <merge+0x567>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    1c95 <merge+0xb45>
mov    -0x98(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x88(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1c46 <merge+0xaf6>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1040 <free_fmatrix@plt>
mov    -0x70(%rbp),%rdi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1040 <free_fmatrix@plt>
mov    -0x78(%rbp),%rdi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1040 <free_fmatrix@plt>
mov    -0x58(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
movss  %xmm0,0x74(%rsp)
mov    %r9d,%r14d
mov    %r8d,%r13d
mov    %ecx,%ebp
mov    %edx,0xc(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rdi,0x30(%rsp)
mov    0x180(%rsp),%eax
mov    %r8d,%ecx
imul   %ebp,%ecx
imul   %r9d,%ecx
mov    %ecx,0x50(%rsp)
lea    0x1(%rax),%ebx
xor    %r12d,%r12d
mov    %ebx,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <fmatrix@plt>
movslq %eax,%r15
mov    %ebx,%edi
mov    %ebx,0x28(%rsp)
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <fmatrix@plt>
mov    %eax,0x2c(%rsp)
test   %ebp,%ebp
jle    1313 <merge+0x1c3>
mov    %ebp,%r11d
lea    -0x1(%r14),%r9d
movss  0x1e30(%rip),%xmm0
xor    %ecx,%ecx
mov    0x30(%rsp),%rax
jmp    11ed <merge+0x9d>
nopl   0x0(%rax)
mov    %ecx,%esi
add    $0x1,%r12d
mov    %esi,%ecx
cmp    %r11d,%r12d
je     1269 <merge+0x119>
test   %r13d,%r13d
jle    11e0 <merge+0x90>
xor    %r8d,%r8d
jmp    1210 <merge+0xc0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
mov    %ecx,%esi
add    $0x1,%r8d
mov    %esi,%ecx
cmp    %r13d,%r8d
je     11e2 <merge+0x92>
lea    0x1(%rcx),%esi
cmp    $0x2,%r14d
jl     1205 <merge+0xb5>
movslq %esi,%rsi
add    %rax,%rsi
xor    %edi,%edi
jmp    123c <merge+0xec>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ecx
add    $0x1,%rdi
cmp    %edi,%r9d
je     1200 <merge+0xb0>
movslq %ecx,%rbp
movzbl (%rax,%rbp,1),%ebp
movzbl (%rsi,%rdi,1),%ebx
cmp    %bl,%bpl
je     1230 <merge+0xe0>
mov    (%r15,%rbp,8),%rdx
movss  (%rdx,%rbx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rbx,4)
mov    (%r15,%rbx,8),%rdx
movss  %xmm1,(%rdx,%rbp,4)
jmp    1230 <merge+0xe0>
test   %r11d,%r11d
jle    1313 <merge+0x1c3>
movslq %r14d,%rax
mov    0x30(%rsp),%r9
sub    %rax,%r9
mov    %r14d,%ecx
xor    %r8d,%r8d
xor    %r10d,%r10d
mov    %r11d,%r12d
jmp    129c <merge+0x14c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8d
mov    %r12d,%eax
cmp    %r12d,%r8d
je     1313 <merge+0x1c3>
add    %r14d,%r10d
cmp    $0x2,%r13d
jl     1290 <merge+0x140>
mov    $0x1,%r11d
jmp    12bc <merge+0x16c>
nopl   (%rax)
add    %edx,%r10d
add    $0x1,%r11d
cmp    %r13d,%r11d
je     1290 <merge+0x140>
test   %r14d,%r14d
jle    12b3 <merge+0x163>
movslq %r10d,%rbp
lea    (%r9,%rbp,1),%rbx
add    0x30(%rsp),%rbp
xor    %edx,%edx
jmp    12e8 <merge+0x198>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %edx,%ecx
je     12b0 <merge+0x160>
movzbl (%rbx,%rdx,1),%eax
movzbl 0x0(%rbp,%rdx,1),%esi
cmp    %sil,%al
je     12e0 <merge+0x190>
mov    (%r15,%rax,8),%rdi
movss  (%rdi,%rsi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rsi,4)
mov    (%r15,%rsi,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
jmp    12e0 <merge+0x190>
mov    0x28(%rsp),%ebx
mov    %ebx,%edi
mov    0xc(%rsp),%esi
mov    %esi,%r12d
xor    %eax,%eax
call   1060 <fmatrix@plt>
cltq
mov    %rax,0x10(%rsp)
movslq %ebx,%rdi
mov    $0x4,%esi
mov    %rdi,0x80(%rsp)
call   1050 <calloc@plt>
mov    %rax,%r13
mov    0x50(%rsp),%eax
mov    %eax,%r8d
test   %eax,%eax
mov    0x180(%rsp),%r14d
mov    0x30(%rsp),%rbp
mov    0x40(%rsp),%rcx
jle    140c <merge+0x2bc>
cmpl   $0x1,0x50(%rsp)
jne    1372 <merge+0x222>
xor    %eax,%eax
jmp    13dc <merge+0x28c>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %eax,%eax
movss  0x1c7d(%rip),%xmm0
mov    0x10(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rax,1),%edx
mov    (%rbx,%rdx,8),%rsi
movzbl (%rcx,%rax,1),%edi
movss  (%rsi,%rdi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
addl   $0x1,0x0(%r13,%rdx,4)
movzbl 0x1(%rbp,%rax,1),%edx
mov    (%rbx,%rdx,8),%rsi
movzbl 0x1(%rcx,%rax,1),%edi
movss  (%rsi,%rdi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
addl   $0x1,0x0(%r13,%rdx,4)
add    $0x2,%rax
cmp    %rax,%r9
jne    1390 <merge+0x240>
test   $0x1,%r8b
je     140c <merge+0x2bc>
movzbl 0x0(%rbp,%rax,1),%esi
mov    0x10(%rsp),%rdx
mov    (%rdx,%rsi,8),%rdx
movzbl (%rcx,%rax,1),%eax
movss  (%rdx,%rax,4),%xmm0
addss  0x1bff(%rip),%xmm0
movss  %xmm0,(%rdx,%rax,4)
addl   $0x1,0x0(%r13,%rsi,4)
mov    %r8,0x78(%rsp)
movslq 0x2c(%rsp),%rax
mov    %rax,0x40(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    0x28(%rsp),%ebp
mov    %r12d,%ecx
test   %r14d,%r14d
mov    %r13,0x68(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rcx,0x88(%rsp)
mov    %rax,0x90(%rsp)
jle    1625 <merge+0x4d5>
mov    %ecx,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%r9
mov    %r9,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10,%r8
and    %rax,%r8
mov    $0x1,%edi
mov    0x10(%rsp),%rbx
jmp    148d <merge+0x33d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %rbp,%rdi
je     1546 <merge+0x3f6>
test   %r12d,%r12d
jle    1480 <merge+0x330>
xorps  %xmm0,%xmm0
cvtsi2ssl 0x0(%r13,%rdi,4),%xmm0
mov    (%rbx,%rdi,8),%rsi
cmp    $0x4,%r12d
jae    14b0 <merge+0x360>
xor    %eax,%eax
jmp    1520 <merge+0x3d0>
nopw   0x0(%rax,%rax,1)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
test   %r9,%r9
je     153c <merge+0x3ec>
mov    %r8,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rbp,4),%xmm2
movups 0x10(%rsi,%rbp,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rbp,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%rsi,%rbp,4)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    14d0 <merge+0x380>
test   $0x1,%r10b
je     1503 <merge+0x3b3>
movups (%rsi,%rbp,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rbp,4)
mov    %rdx,%rax
cmp    %rcx,%rdx
mov    0x10(%rsp),%rbx
mov    0x58(%rsp),%rbp
je     1480 <merge+0x330>
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1520 <merge+0x3d0>
jmp    1480 <merge+0x330>
xor    %ebp,%ebp
test   $0x1,%r10b
jne    14f8 <merge+0x3a8>
jmp    1503 <merge+0x3b3>
cmp    $0x2,%r14d
jl     1652 <merge+0x502>
mov    %r14d,%eax
mov    %rax,0x48(%rsp)
lea    -0x2(%rbp),%r12
movss  0x1aa0(%rip),%xmm1
mov    $0x1,%r13d
xor    %r14d,%r14d
jmp    1587 <merge+0x437>
nop
mov    %rbp,%r14
add    $0x1,%r14
mov    0x38(%rsp),%r13
cmp    0x48(%rsp),%r13
je     165a <merge+0x50a>
lea    0x1(%r13),%rax
mov    %rax,0x38(%rsp)
mov    %r14,%rbp
jmp    15a9 <merge+0x459>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14
cmp    %r14,%r12
je     1570 <merge+0x420>
mov    (%r15,%r13,8),%rax
movss  0x8(%rax,%r14,4),%xmm0
ucomiss 0x1a4d(%rip),%xmm0
jne    15bf <merge+0x46f>
jnp    15a0 <merge+0x450>
mov    (%rbx,%r13,8),%rdi
mov    0x10(%rbx,%r14,8),%rsi
mov    0xc(%rsp),%edx
xor    %eax,%eax
movss  %xmm1,0x20(%rsp)
call   1070 <distance@plt>
movss  0x20(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x40(%rsp),%rcx
mov    (%rcx,%r13,8),%rax
movss  %xmm0,0x8(%rax,%r14,4)
mov    0x10(%rcx,%r14,8),%rcx
movss  %xmm0,(%rcx,%r13,4)
movss  0x8(%rax,%r14,4),%xmm0
ucomiss %xmm0,%xmm1
jbe    15a0 <merge+0x450>
lea    0x2(%r14),%eax
mov    %eax,0x2c(%rsp)
mov    %r13d,%eax
mov    %r13d,0x54(%rsp)
movaps %xmm0,%xmm1
jmp    15a0 <merge+0x450>
mov    $0x4,%esi
mov    0x80(%rsp),%rdi
call   1050 <calloc@plt>
mov    0x30(%rsp),%rbp
mov    %rax,%r10
movss  0x19bc(%rip),%xmm11
mov    0x78(%rsp),%r9
jmp    185d <merge+0x70d>
movss  0x19aa(%rip),%xmm1
movss  %xmm1,0x20(%rsp)
mov    $0x4,%esi
mov    0x80(%rsp),%rdi
call   1050 <calloc@plt>
mov    %rax,%r10
mov    0x180(%rsp),%r14d
test   %r14d,%r14d
jle    16e8 <merge+0x598>
mov    0x58(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
mov    0x30(%rsp),%rbp
mov    0xc(%rsp),%r12d
mov    0x68(%rsp),%r13
mov    0x78(%rsp),%r9
movss  0x20(%rsp),%xmm11
jb     1840 <merge+0x6f0>
mov    %r12d,%r8d
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    1708 <merge+0x5b8>
movdqa 0x192f(%rip),%xmm0
xor    %esi,%esi
jmp    17e5 <merge+0x695>
mov    0x30(%rsp),%rbp
mov    0xc(%rsp),%r12d
mov    0x68(%rsp),%r13
mov    0x78(%rsp),%r9
movss  0x20(%rsp),%xmm11
jmp    185d <merge+0x70d>
and    $0xfffffffffffffffc,%rdi
movdqa 0x18fc(%rip),%xmm0
xor    %esi,%esi
movdqa 0x1901(%rip),%xmm8
movdqa 0x1908(%rip),%xmm9
movdqa 0x190f(%rip),%xmm10
movdqa 0x1917(%rip),%xmm4
movdqa 0x191f(%rip),%xmm5
movdqa 0x1927(%rip),%xmm6
movdqa 0x192f(%rip),%xmm7
movdqa 0x1937(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x4(%r10,%rsi,4)
movdqu %xmm2,0x14(%r10,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x24(%r10,%rsi,4)
movdqu %xmm3,0x34(%r10,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x44(%r10,%rsi,4)
movdqu %xmm3,0x54(%r10,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x64(%r10,%rsi,4)
movdqu %xmm3,0x74(%r10,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1760 <merge+0x610>
test   %rdx,%rdx
je     182f <merge+0x6df>
movdqa 0x182e(%rip),%xmm1
movdqa 0x1836(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rsi,4),%rdi
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
or     $0x4,%rdi
movdqu %xmm0,(%r10,%rdi,1)
movdqu %xmm3,0x10(%r10,%rdi,1)
add    $0x8,%rsi
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rdx
jne    1800 <merge+0x6b0>
cmp    %rax,%rcx
jne    1839 <merge+0x6e9>
mov    %r8d,%r12d
jmp    185d <merge+0x70d>
or     $0x1,%rax
mov    %r8d,%r12d
mov    0x58(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,(%r10,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1850 <merge+0x700>
movss  0x74(%rsp),%xmm0
ucomiss %xmm11,%xmm0
jbe    24c4 <merge+0x1374>
mov    0x188(%rsp),%eax
cmp    %eax,%r14d
jle    24c4 <merge+0x1374>
movslq %r14d,%r14
cltq
mov    %rax,0xd0(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0xc8(%rsp)
mov    0x58(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0x88(%rsp),%r9
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xb8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xb0(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r9d,%edx
and    $0xfffffff8,%edx
mov    %rdx,0x130(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x128(%rsp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rcx,%rdx
mov    %rcx,0xa8(%rsp)
and    %rcx,0x90(%rsp)
mov    %r9,%rcx
neg    %rcx
mov    %rcx,0xc0(%rsp)
mov    %esi,%edx
and    $0x3,%edx
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0xe8(%rsp)
mov    %r9d,%r11d
and    $0x3,%r11d
mov    %rax,%rcx
mov    %rax,0x58(%rsp)
mov    %rax,%rbx
and    $0xfffffffffffffffe,%rbx
neg    %rbx
mov    %rdx,0x120(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x118(%rsp)
pxor   %xmm5,%xmm5
lea    -0x8(%r14),%rax
mov    %rax,0x98(%rsp)
xor    %eax,%eax
mov    %rax,0xa0(%rsp)
mov    0x28(%rsp),%eax
mov    %rax,0x38(%rsp)
mov    %r10,0xe0(%rsp)
mov    %r11,0x80(%rsp)
mov    %rbx,0xd8(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r12d,%r8d
mov    0x180(%rsp),%eax
test   %eax,%eax
mov    0x2c(%rsp),%esi
mov    0x54(%rsp),%edi
jle    19d2 <merge+0x882>
mov    $0x1,%eax
cmpl   $0x2,0x28(%rsp)
jne    1ad0 <merge+0x980>
testb  $0x1,0x58(%rsp)
je     19d2 <merge+0x882>
mov    (%r10,%rax,4),%ecx
mov    %edi,%edx
cmp    %esi,%ecx
je     19ce <merge+0x87e>
jle    19d2 <merge+0x882>
add    $0xffffffff,%ecx
mov    %ecx,%edx
mov    %edx,(%r10,%rax,4)
movslq %edi,%rbp
mov    0x0(%r13,%rbp,4),%edx
movslq %esi,%r12
mov    0x0(%r13,%r12,4),%esi
lea    (%rsi,%rdx,1),%eax
test   %r8d,%r8d
jle    1be0 <merge+0xa90>
mov    0x10(%rsp),%rdi
mov    (%rdi,%rbp,8),%rcx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mov    (%rdi,%r12,8),%rdx
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
cmpl   $0x4,0xc(%rsp)
jb     1a31 <merge+0x8e1>
lea    (%rdx,%r9,4),%rsi
cmp    %rsi,%rcx
jae    1b24 <merge+0x9d4>
lea    (%rcx,%r9,4),%rsi
cmp    %rsi,%rdx
jae    1b24 <merge+0x9d4>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%r9b
je     1a62 <merge+0x912>
movss  (%rdx,%rdi,4),%xmm3
mulss  %xmm1,%xmm3
movss  (%rcx,%rdi,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,(%rcx,%rdi,4)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0xc0(%rsp),%rdi
je     1be0 <merge+0xa90>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rsi,4),%xmm3
mulss  %xmm1,%xmm3
movss  (%rcx,%rsi,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,(%rcx,%rsi,4)
movss  0x4(%rdx,%rsi,4),%xmm3
mulss  %xmm1,%xmm3
movss  0x4(%rcx,%rsi,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r9
jne    1a80 <merge+0x930>
jmp    1be0 <merge+0xa90>
nop
mov    $0x1,%eax
jmp    1afb <merge+0x9ab>
nopw   0x0(%rax,%rax,1)
mov    %edx,0x4(%r10,%rax,4)
lea    (%rbx,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
je     19b6 <merge+0x866>
mov    (%r10,%rax,4),%ecx
mov    %edi,%edx
cmp    %esi,%ecx
je     1b0c <merge+0x9bc>
jle    1b10 <merge+0x9c0>
add    $0xffffffff,%ecx
mov    %ecx,%edx
mov    %edx,(%r10,%rax,4)
mov    0x4(%r10,%rax,4),%ecx
mov    %edi,%edx
cmp    %esi,%ecx
je     1ae0 <merge+0x990>
jle    1ae5 <merge+0x995>
add    $0xffffffff,%ecx
mov    %ecx,%edx
jmp    1ae0 <merge+0x990>
movaps %xmm1,%xmm4
shufps $0x0,%xmm1,%xmm4
movaps %xmm0,%xmm9
shufps $0x0,%xmm0,%xmm9
movaps %xmm2,%xmm8
shufps $0x0,%xmm2,%xmm8
cmpq   $0x0,0xb0(%rsp)
je     24a7 <merge+0x1357>
mov    0x90(%rsp),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups (%rdx,%rsi,4),%xmm6
mulps  %xmm4,%xmm6
movups (%rcx,%rsi,4),%xmm7
movups 0x10(%rcx,%rsi,4),%xmm3
mulps  %xmm9,%xmm7
addps  %xmm6,%xmm7
divps  %xmm8,%xmm7
movups %xmm7,(%rcx,%rsi,4)
movups 0x10(%rdx,%rsi,4),%xmm6
mulps  %xmm4,%xmm6
mulps  %xmm9,%xmm3
addps  %xmm6,%xmm3
divps  %xmm8,%xmm3
movups %xmm3,0x10(%rcx,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1b60 <merge+0xa10>
testb  $0x1,0xa8(%rsp)
01
je     1bc5 <merge+0xa75>
movups (%rcx,%rsi,4),%xmm3
movups (%rdx,%rsi,4),%xmm6
mulps  %xmm4,%xmm6
mulps  %xmm9,%xmm3
addps  %xmm6,%xmm3
divps  %xmm8,%xmm3
movups %xmm3,(%rcx,%rsi,4)
mov    0xb8(%rsp),%rsi
mov    %rsi,%rdi
cmp    %r9,%rsi
jne    1a33 <merge+0x8e3>
nopl   0x0(%rax)
mov    0x38(%rsp),%rcx
mov    %ecx,%ecx
mov    %rcx,0x38(%rsp)
mov    %eax,0x0(%r13,%rbp,4)
test   %r14,%r14
jle    1e80 <merge+0xd30>
mov    0xc8(%rsp),%rax
sub    0xa0(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x2c(%rsp),%eax
mov    %rax,0x20(%rsp)
mov    0x54(%rsp),%r13d
mov    $0x1,%ebx
mov    %r12,%rdx
jmp    1c97 <merge+0xb47>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
mov    (%rax,%rbx,8),%rsi
mov    0xc(%rsp),%edx
xor    %eax,%eax
call   1070 <distance@plt>
mov    %r12,%rdx
xorps  %xmm5,%xmm5
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x40(%rsp),%rcx
mov    (%rcx,%rbp,8),%rax
movss  %xmm0,(%rax,%rbx,4)
mov    (%rcx,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    (%r15,%rbp,8),%rax
movss  (%rax,%rbx,4),%xmm0
mov    (%r15,%r12,8),%rcx
addss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
mov    (%r15,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbx
cmp    %rbx,0x38(%rsp)
je     1ce0 <merge+0xb90>
cmp    %rbx,%r13
je     1c8c <merge+0xb3c>
cmp    %rbx,0x20(%rsp)
je     1c8c <merge+0xb3c>
mov    (%r15,%rbp,8),%rax
movss  (%rax,%rbx,4),%xmm0
ucomiss %xmm5,%xmm0
jne    1c30 <merge+0xae0>
jp     1c30 <merge+0xae0>
mov    (%r15,%rdx,8),%rax
movss  (%rax,%rbx,4),%xmm0
ucomiss %xmm5,%xmm0
jne    1c30 <merge+0xae0>
jp     1c30 <merge+0xae0>
jmp    1c8c <merge+0xb3c>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r14,%r14
jle    1e80 <merge+0xd30>
mov    %r14,%rax
mov    %r12,%rcx
sub    %r12,%rax
lea    -0x8(%rax),%r9
mov    %r9,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
lea    (%r10,%r12,1),%rdx
mov    %rdx,0x20(%rsp)
mov    0x98(%rsp),%r8
sub    %r12,%r8
shr    $0x3,%r8
add    $0x1,%r8
and    $0xfffffffffffffffe,%r8
mov    $0x1,%ecx
jmp    1d3f <merge+0xbef>
nop
add    $0x1,%rcx
cmp    0x38(%rsp),%rcx
je     1e80 <merge+0xd30>
cmp    %r12,%r14
jle    1d30 <merge+0xbe0>
mov    (%r15,%rcx,8),%rsi
mov    0x40(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
mov    %r12,%rdi
cmp    $0x8,%rax
jb     1e50 <merge+0xd00>
lea    (%rsi,%r12,4),%rdi
mov    0x48(%rsp),%rbx
lea    (%rdx,%rbx,4),%rbx
cmp    %rbx,%rdi
jae    1d89 <merge+0xc39>
mov    0x48(%rsp),%rdi
lea    (%rsi,%rdi,4),%rbx
mov    %r12,%rdi
lea    (%rdx,%r12,4),%rbp
cmp    %rbx,%rbp
jb     1e50 <merge+0xd00>
cmp    $0x8,%r9
jae    1d93 <merge+0xc43>
xor    %ebx,%ebx
jmp    1e09 <merge+0xcb9>
mov    %r12,%rdi
lea    (%rdx,%r12,4),%rbp
add    $0x34,%rbp
lea    (%rsi,%r12,4),%rdi
add    $0x34,%rdi
mov    %r8,%r13
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdi,%rbx,4),%xmm0
movups -0x20(%rdi,%rbx,4),%xmm1
movups %xmm0,-0x34(%rdi,%rbx,4)
movups %xmm1,-0x24(%rdi,%rbx,4)
movups -0x30(%rbp,%rbx,4),%xmm0
movups -0x20(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x34(%rbp,%rbx,4)
movups %xmm1,-0x24(%rbp,%rbx,4)
movups -0x10(%rdi,%rbx,4),%xmm0
movups (%rdi,%rbx,4),%xmm1
movups %xmm0,-0x14(%rdi,%rbx,4)
movups %xmm1,-0x4(%rdi,%rbx,4)
movups -0x10(%rbp,%rbx,4),%xmm0
movups 0x0(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x14(%rbp,%rbx,4)
movups %xmm1,-0x4(%rbp,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%r13
jne    1db0 <merge+0xc60>
test   $0x1,%r11b
je     1e38 <merge+0xce8>
add    %r12,%rbx
movups 0x4(%rsi,%rbx,4),%xmm0
movups 0x14(%rsi,%rbx,4),%xmm1
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
movups 0x4(%rdx,%rbx,4),%xmm0
movups 0x14(%rdx,%rbx,4),%xmm1
movups %xmm0,(%rdx,%rbx,4)
movups %xmm1,0x10(%rdx,%rbx,4)
mov    0x20(%rsp),%rdi
cmp    %r10,%rax
je     1d30 <merge+0xbe0>
cs nopw 0x0(%rax,%rax,1)
movss  0x4(%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
movss  0x4(%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
lea    0x1(%rdi),%rbx
mov    %rbx,%rdi
cmp    %r14,%rbx
jl     1e50 <merge+0xd00>
jmp    1d30 <merge+0xbe0>
nopw   0x0(%rax,%rax,1)
cmp    %r12,%r14
mov    0xc(%rsp),%r13d
mov    0x10(%rsp),%rbp
jle    2380 <merge+0x1230>
mov    %r12,%r9
mov    %r14d,%r12d
lea    -0x9(%r12),%rax
mov    %rax,0x110(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x108(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xf0(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0x48(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,0x100(%rsp)
add    $0x1,%rax
mov    %rax,0xf8(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x138(%rsp)
jmp    1f09 <merge+0xdb9>
nopw   0x0(%rax,%rax,1)
cmp    %r14,%r9
jge    2380 <merge+0x1230>
mov    %r9,%rsi
lea    0x1(%r9),%rax
mov    %rax,0x20(%rsp)
cmp    $0x2,%r14
jl     2190 <merge+0x1040>
mov    0x20(%rsp),%rax
mov    (%r15,%rax,8),%rdx
mov    (%r15,%rsi,8),%r8
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%r9
mov    (%rcx,%rsi,8),%r10
mov    $0x1,%r11d
cmpq   $0x8,0x48(%rsp)
jae    1fd0 <merge+0xe80>
mov    %r11,%rbx
test   $0x1,%r12b
jne    1f70 <merge+0xe20>
movss  (%rdx,%r11,4),%xmm0
movss  %xmm0,(%r8,%r11,4)
movss  (%r9,%r11,4),%xmm0
movss  %xmm0,(%r10,%r11,4)
lea    0x1(%r11),%rbx
not    %r11
cmp    0x138(%rsp),%r11
je     2190 <merge+0x1040>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rbx,4),%xmm0
movss  %xmm0,(%r8,%rbx,4)
movss  (%r9,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rbx,4)
movss  0x4(%rdx,%rbx,4),%xmm0
movss  %xmm0,0x4(%r8,%rbx,4)
movss  0x4(%r9,%rbx,4),%xmm0
movss  %xmm0,0x4(%r10,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r12
jne    1f90 <merge+0xe40>
jmp    2190 <merge+0x1040>
mov    %rsi,0x60(%rsp)
lea    0x4(%r8),%rcx
lea    (%r8,%r12,4),%rbp
lea    0x4(%r10),%rbx
lea    (%r10,%r12,4),%rdi
lea    0x4(%rdx),%rax
lea    (%rdx,%r12,4),%r13
lea    0x4(%r9),%rsi
mov    %rsi,0x140(%rsp)
lea    (%r9,%r12,4),%rsi
cmp    %rdi,%rcx
setb   0x1f(%rsp)
cmp    %rbp,%rbx
setb   0x1e(%rsp)
cmp    %r13,%rcx
setb   0x1d(%rsp)
cmp    %rbp,%rax
setb   0x1c(%rsp)
cmp    %rsi,%rcx
setb   0x1b(%rsp)
mov    0x140(%rsp),%rcx
cmp    %rbp,%rcx
setb   0x1a(%rsp)
cmp    %r13,%rbx
setb   %r13b
cmp    %rdi,%rax
setb   0x19(%rsp)
cmp    %rsi,%rbx
setb   %sil
cmp    %rdi,%rcx
setb   %bl
mov    0x1e(%rsp),%al
test   %al,0x1f(%rsp)
jne    235e <merge+0x120e>
mov    0x1c(%rsp),%al
and    %al,0x1d(%rsp)
mov    0xc(%rsp),%eax
jne    234c <merge+0x11fc>
mov    0x1a(%rsp),%cl
and    %cl,0x1b(%rsp)
jne    234c <merge+0x11fc>
and    0x19(%rsp),%r13b
jne    234c <merge+0x11fc>
and    %bl,%sil
mov    0x10(%rsp),%rbp
mov    %eax,%r13d
mov    0x60(%rsp),%rsi
jne    1f4b <merge+0xdfb>
cmpq   $0x8,0x110(%rsp)
jae    20af <merge+0xf5f>
xor    %ebp,%ebp
jmp    2126 <merge+0xfd6>
mov    0xf0(%rsp),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups 0x4(%rdx,%rbp,4),%xmm0
movups 0x14(%rdx,%rbp,4),%xmm1
movups %xmm0,0x4(%r8,%rbp,4)
movups %xmm1,0x14(%r8,%rbp,4)
movups 0x4(%r9,%rbp,4),%xmm0
movups 0x14(%r9,%rbp,4),%xmm1
movups %xmm0,0x4(%r10,%rbp,4)
movups %xmm1,0x14(%r10,%rbp,4)
movups 0x24(%rdx,%rbp,4),%xmm0
movups 0x34(%rdx,%rbp,4),%xmm1
movups %xmm0,0x24(%r8,%rbp,4)
movups %xmm1,0x34(%r8,%rbp,4)
movups 0x24(%r9,%rbp,4),%xmm0
movups 0x34(%r9,%rbp,4),%xmm1
movups %xmm0,0x24(%r10,%rbp,4)
movups %xmm1,0x34(%r10,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rbx
jne    20c0 <merge+0xf70>
testb  $0x1,0x108(%rsp)
01
je     2162 <merge+0x1012>
shl    $0x2,%rbp
or     $0x4,%rbp
movups (%rdx,%rbp,1),%xmm0
movups 0x10(%rdx,%rbp,1),%xmm1
movups %xmm0,(%r8,%rbp,1)
movups %xmm1,0x10(%r8,%rbp,1)
movups (%r9,%rbp,1),%xmm0
movups 0x10(%r9,%rbp,1),%xmm1
movups %xmm0,(%r10,%rbp,1)
movups %xmm1,0x10(%r10,%rbp,1)
mov    0xf8(%rsp),%r11
mov    0x100(%rsp),%rax
cmp    %rax,0x48(%rsp)
mov    0x10(%rsp),%rbp
jne    1f4b <merge+0xdfb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%r9
mov    0x68(%rsp),%rax
mov    (%rax,%r9,4),%ecx
mov    %ecx,(%rax,%rsi,4)
test   %r13d,%r13d
mov    0x88(%rsp),%rax
jle    1f00 <merge+0xdb0>
mov    0x0(%rbp,%r9,8),%rdx
mov    0x0(%rbp,%rsi,8),%rsi
cmp    $0x8,%r13d
jb     21dc <merge+0x108c>
lea    (%rdx,%rax,4),%rcx
cmp    %rcx,%rsi
jae    226c <merge+0x111c>
lea    (%rsi,%rax,4),%rcx
cmp    %rcx,%rdx
jae    226c <merge+0x111c>
xor    %ebx,%ebx
mov    %rbx,%rbp
not    %rbp
add    %rax,%rbp
mov    0x80(%rsp),%rcx
test   %rcx,%rcx
je     2214 <merge+0x10c4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdx,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rcx
jne    2200 <merge+0x10b0>
cmp    $0x3,%rbp
mov    0x10(%rsp),%rbp
jb     1f00 <merge+0xdb0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
movss  0x4(%rdx,%rbx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rbx,4)
movss  0x8(%rdx,%rbx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rbx,4)
movss  0xc(%rdx,%rbx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    2230 <merge+0x10e0>
jmp    1f00 <merge+0xdb0>
cmpq   $0x18,0x128(%rsp)
jae    227e <merge+0x112e>
mov    %r13d,%r8d
xor    %ebp,%ebp
jmp    22e8 <merge+0x1198>
mov    %r13d,%r8d
mov    0xe8(%rsp),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rbp,4),%xmm0
movups 0x10(%rdx,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rbp,4)
movups %xmm1,0x10(%rsi,%rbp,4)
movups 0x20(%rdx,%rbp,4),%xmm0
movups 0x30(%rdx,%rbp,4),%xmm1
movups %xmm0,0x20(%rsi,%rbp,4)
movups %xmm1,0x30(%rsi,%rbp,4)
movups 0x40(%rdx,%rbp,4),%xmm0
movups 0x50(%rdx,%rbp,4),%xmm1
movups %xmm0,0x40(%rsi,%rbp,4)
movups %xmm1,0x50(%rsi,%rbp,4)
movups 0x60(%rdx,%rbp,4),%xmm0
movups 0x70(%rdx,%rbp,4),%xmm1
movups %xmm0,0x60(%rsi,%rbp,4)
movups %xmm1,0x70(%rsi,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rbx
jne    2290 <merge+0x1140>
cmpq   $0x0,0x120(%rsp)
mov    0x118(%rsp),%rbx
je     232b <merge+0x11db>
lea    (%rsi,%rbp,4),%rcx
add    $0x10,%rcx
lea    (%rdx,%rbp,4),%rdi
add    $0x10,%rdi
xor    %ebp,%ebp
nopl   (%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    2310 <merge+0x11c0>
mov    0x130(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rax,%rcx
mov    0x10(%rsp),%rbp
mov    %r8d,%r13d
je     1f00 <merge+0xdb0>
jmp    21de <merge+0x108e>
mov    0x10(%rsp),%rbp
mov    %eax,%r13d
mov    0x60(%rsp),%rsi
jmp    1f4b <merge+0xdfb>
mov    0xc(%rsp),%r13d
mov    0x10(%rsp),%rbp
mov    0x60(%rsp),%rsi
jmp    1f4b <merge+0xdfb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13d,%r12d
lea    -0x1(%r14),%r8
cmp    $0x3,%r14
jl     2440 <merge+0x12f0>
mov    %r8d,%r9d
mov    $0x2,%r11d
mov    $0x1,%r10d
movabs $0x300000000,%rbp
movss  0xc52(%rip),%xmm0
mov    0x68(%rsp),%r13
jmp    23d6 <merge+0x1286>
nopl   0x0(%rax)
add    $0x1,%r11
movabs $0x100000000,%rax
add    %rax,%rbp
cmp    %r9,%r10
je     244d <merge+0x12fd>
mov    %r10,%rdi
add    $0x1,%r10
mov    (%r15,%rdi,8),%rax
mov    %rbp,%rcx
mov    %r11,%rdx
jmp    240d <merge+0x12bd>
nopl   0x0(%rax)
add    $0x1,%rdx
mov    %rcx,%rsi
sar    $0x20,%rsi
movabs $0x100000000,%rbx
add    %rbx,%rcx
cmp    %r14,%rsi
jge    23c0 <merge+0x1270>
movss  (%rax,%rdx,4),%xmm1
ucomiss %xmm5,%xmm1
jne    2419 <merge+0x12c9>
jnp    23f0 <merge+0x12a0>
mov    0x40(%rsp),%rsi
mov    (%rsi,%rdi,8),%rbx
movss  (%rbx,%rdx,4),%xmm1
ucomiss %xmm1,%xmm0
jbe    23f0 <merge+0x12a0>
mov    %edx,%esi
mov    %edx,0x2c(%rsp)
mov    %edi,%esi
mov    %edi,0x54(%rsp)
movaps %xmm1,%xmm0
jmp    23f0 <merge+0x12a0>
nopl   (%rax)
movss  0xbbc(%rip),%xmm0
mov    0x68(%rsp),%r13
movss  0x74(%rsp),%xmm1
ucomiss %xmm0,%xmm1
mov    0x30(%rsp),%rbp
mov    0x88(%rsp),%r9
mov    0xe0(%rsp),%r10
mov    0xd8(%rsp),%rbx
jbe    24bc <merge+0x136c>
mov    0x38(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x38(%rsp)
addq   $0x1,0xa0(%rsp)
addq   $0xffffffffffffffff,0x98(%rsp)
mov    %r8,%r14
cmp    0xd0(%rsp),%r8
jg     1990 <merge+0x840>
jmp    24bc <merge+0x136c>
xor    %esi,%esi
testb  $0x1,0xa8(%rsp)
01
jne    1bab <merge+0xa5b>
jmp    1bc5 <merge+0xa75>
mov    %r8d,%r14d
mov    0x78(%rsp),%r9
cmpl   $0x0,0x50(%rsp)
jle    2557 <merge+0x1407>
lea    -0x1(%r9),%rcx
mov    %r9d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    24e3 <merge+0x1393>
xor    %ecx,%ecx
jmp    2531 <merge+0x13e1>
and    $0xfffffffc,%r9d
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rcx,1),%edx
movzbl (%r10,%rdx,4),%edx
mov    %dl,0x0(%rbp,%rcx,1)
movzbl 0x1(%rbp,%rcx,1),%edx
movzbl (%r10,%rdx,4),%edx
mov    %dl,0x1(%rbp,%rcx,1)
movzbl 0x2(%rbp,%rcx,1),%edx
movzbl (%r10,%rdx,4),%edx
mov    %dl,0x2(%rbp,%rcx,1)
movzbl 0x3(%rbp,%rcx,1),%edx
movzbl (%r10,%rdx,4),%edx
mov    %dl,0x3(%rbp,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    24f0 <merge+0x13a0>
test   %rax,%rax
je     2557 <merge+0x1407>
add    %rcx,%rbp
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rcx,1),%edx
movzbl (%r10,%rdx,4),%edx
mov    %dl,0x0(%rbp,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2540 <merge+0x13f0>
mov    %r10,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
mov    0x28(%rsp),%ebx
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <free_fmatrix@plt>
mov    %r15,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <free_fmatrix@plt>
mov    0x40(%rsp),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <free_fmatrix@plt>
mov    %r14d,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @merge(i8* nocapture %0, i8* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, float %7, i32 %8) {
%10 = mul i32 %4, %3
%11 = mul i32 %10, %5
%12 = add i32 %6, 1
%13 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %12, i32 %12)
%14 = sext i32 %13 to i64
%15 = inttoptr i64 %14 to float**
%16 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %12, i32 %12)
%17 = sext i32 %16 to i64
%18 = inttoptr i64 %17 to float**
%19 = icmp sgt i32 %3, 0
br i1 %19, label %20, label %116
20: ; preds = %9
%21 = icmp sgt i32 %4, 0
%22 = icmp sgt i32 %5, 1
br label %23
23: ; preds = %20, %69
%24 = phi i32 [ 0, %20 ], [ %71, %69 ]
%25 = phi i32 [ 0, %20 ], [ %70, %69 ]
br i1 %21, label %31, label %69
26: ; preds = %69
br i1 %19, label %27, label %116
27: ; preds = %26
%28 = icmp sgt i32 %4, 1
%29 = icmp sgt i32 %5, 0
%30 = sext i32 %5 to i64
br label %73
31: ; preds = %23, %65
%32 = phi i32 [ %67, %65 ], [ 0, %23 ]
%33 = phi i32 [ %66, %65 ], [ %25, %23 ]
%34 = add i32 %33, 1
br i1 %22, label %35, label %65
35: ; preds = %31
%36 = sext i32 %34 to i64
br label %37
37: ; preds = %35, %58
%38 = phi i64 [ %36, %35 ], [ %60, %58 ]
%39 = phi i32 [ 1, %35 ], [ %59, %58 ]
%40 = phi i32 [ %33, %35 ], [ %61, %58 ]
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %0, i64 %41
%43 = load i8, i8* %42
%44 = getelementptr inbounds i8, i8* %0, i64 %38
%45 = load i8, i8* %44
%46 = icmp eq i8 %43, %45
br i1 %46, label %58, label %47
47: ; preds = %37
%48 = zext i8 %43 to i64
%49 = getelementptr inbounds float*, float** %15, i64 %48
%50 = load float*, float** %49
%51 = zext i8 %45 to i64
%52 = getelementptr inbounds float, float* %50, i64 %51
%53 = load float, float* %52
%54 = fadd float %53, 1.000000e+00
store float %54, float* %52
%55 = getelementptr inbounds float*, float** %15, i64 %51
%56 = load float*, float** %55
%57 = getelementptr inbounds float, float* %56, i64 %48
store float %54, float* %57
br label %58
58: ; preds = %47, %37
%59 = add nuw nsw i32 %39, 1
%60 = add nsw i64 %38, 1
%61 = trunc i64 %38 to i32
%62 = icmp eq i32 %59, %5
br i1 %62, label %63, label %37
63: ; preds = %58
%64 = trunc i64 %60 to i32
br label %65
65: ; preds = %63, %31
%66 = phi i32 [ %34, %31 ], [ %64, %63 ]
%67 = add nuw nsw i32 %32, 1
%68 = icmp eq i32 %67, %4
br i1 %68, label %69, label %31
69: ; preds = %65, %23
%70 = phi i32 [ %25, %23 ], [ %66, %65 ]
%71 = add nuw nsw i32 %24, 1
%72 = icmp eq i32 %71, %3
br i1 %72, label %26, label %23
73: ; preds = %27, %112
%74 = phi i32 [ 0, %27 ], [ %114, %112 ]
%75 = phi i32 [ 0, %27 ], [ %113, %112 ]
%76 = add nsw i32 %75, %5
br i1 %28, label %77, label %112
77: ; preds = %73, %108
%78 = phi i32 [ %110, %108 ], [ 1, %73 ]
%79 = phi i32 [ %109, %108 ], [ %76, %73 ]
br i1 %29, label %80, label %108
80: ; preds = %77
%81 = sext i32 %79 to i64
br label %82
82: ; preds = %80, %102
%83 = phi i64 [ %81, %80 ], [ %103, %102 ]
%84 = phi i32 [ 0, %80 ], [ %104, %102 ]
%85 = sub nsw i64 %83, %30
%86 = getelementptr inbounds i8, i8* %0, i64 %85
%87 = load i8, i8* %86
%88 = getelementptr inbounds i8, i8* %0, i64 %83
%89 = load i8, i8* %88
%90 = icmp eq i8 %87, %89
br i1 %90, label %102, label %91
91: ; preds = %82
%92 = zext i8 %87 to i64
%93 = getelementptr inbounds float*, float** %15, i64 %92
%94 = load float*, float** %93
%95 = zext i8 %89 to i64
%96 = getelementptr inbounds float, float* %94, i64 %95
%97 = load float, float* %96
%98 = fadd float %97, 1.000000e+00
store float %98, float* %96
%99 = getelementptr inbounds float*, float** %15, i64 %95
%100 = load float*, float** %99
%101 = getelementptr inbounds float, float* %100, i64 %92
store float %98, float* %101
br label %102
102: ; preds = %91, %82
%103 = add nsw i64 %83, 1
%104 = add nuw nsw i32 %84, 1
%105 = icmp eq i32 %104, %5
br i1 %105, label %106, label %82
106: ; preds = %102
%107 = trunc i64 %103 to i32
br label %108
108: ; preds = %106, %77
%109 = phi i32 [ %79, %77 ], [ %107, %106 ]
%110 = add nuw nsw i32 %78, 1
%111 = icmp eq i32 %110, %4
br i1 %111, label %112, label %77
112: ; preds = %108, %73
%113 = phi i32 [ %76, %73 ], [ %109, %108 ]
%114 = add nuw nsw i32 %74, 1
%115 = icmp eq i32 %114, %3
br i1 %115, label %116, label %73
116: ; preds = %112, %9, %26
%117 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %12, i32 %2)
%118 = sext i32 %117 to i64
%119 = inttoptr i64 %118 to float**
%120 = sext i32 %12 to i64
%121 = tail call i8* @calloc(i64 %120, i64 4)
%122 = bitcast i8* %121 to i32*
%123 = icmp sgt i32 %11, 0
br i1 %123, label %124, label %148
124: ; preds = %116
%125 = zext i32 %11 to i64
%126 = and i64 %125, 1
%127 = icmp eq i32 %11, 1
br i1 %127, label %130, label %128
128: ; preds = %124
%129 = and i64 %125, 4294967294
br label %168
130: ; preds = %168, %124
%131 = phi i64 [ 0, %124 ], [ %200, %168 ]
%132 = icmp eq i64 %126, 0
br i1 %132, label %148, label %133
133: ; preds = %130
%134 = getelementptr inbounds i8, i8* %0, i64 %131
%135 = load i8, i8* %134
%136 = zext i8 %135 to i64
%137 = getelementptr inbounds float*, float** %119, i64 %136
%138 = load float*, float** %137
%139 = getelementptr inbounds i8, i8* %1, i64 %131
%140 = load i8, i8* %139
%141 = zext i8 %140 to i64
%142 = getelementptr inbounds float, float* %138, i64 %141
%143 = load float, float* %142
%144 = fadd float %143, 1.000000e+00
store float %144, float* %142
%145 = getelementptr inbounds i32, i32* %122, i64 %136
%146 = load i32, i32* %145
%147 = add nsw i32 %146, 1
store i32 %147, i32* %145
br label %148
148: ; preds = %133, %130, %116
%149 = icmp slt i32 %6, 1
br i1 %149, label %150, label %153
150: ; preds = %148
%151 = tail call i8* @calloc(i64 %120, i64 4)
%152 = bitcast i8* %151 to i32*
br label %378
153: ; preds = %148
%154 = icmp sgt i32 %2, 0
%155 = zext i32 %12 to i64
%156 = zext i32 %2 to i64
%157 = and i64 %156, 4294967292
%158 = add nsw i64 %157, -4
%159 = lshr exact i64 %158, 2
%160 = add nuw nsw i64 %159, 1
%161 = icmp ult i32 %2, 4
%162 = and i64 %156, 4294967292
%163 = and i64 %160, 1
%164 = icmp eq i64 %158, 0
%165 = and i64 %160, 9223372036854775806
%166 = icmp eq i64 %163, 0
%167 = icmp eq i64 %162, %156
br label %203
168: ; preds = %168, %128
%169 = phi i64 [ 0, %128 ], [ %200, %168 ]
%170 = phi i64 [ 0, %128 ], [ %201, %168 ]
%171 = getelementptr inbounds i8, i8* %0, i64 %169
%172 = load i8, i8* %171
%173 = zext i8 %172 to i64
%174 = getelementptr inbounds float*, float** %119, i64 %173
%175 = load float*, float** %174
%176 = getelementptr inbounds i8, i8* %1, i64 %169
%177 = load i8, i8* %176
%178 = zext i8 %177 to i64
%179 = getelementptr inbounds float, float* %175, i64 %178
%180 = load float, float* %179
%181 = fadd float %180, 1.000000e+00
store float %181, float* %179
%182 = getelementptr inbounds i32, i32* %122, i64 %173
%183 = load i32, i32* %182
%184 = add nsw i32 %183, 1
store i32 %184, i32* %182
%185 = or i64 %169, 1
%186 = getelementptr inbounds i8, i8* %0, i64 %185
%187 = load i8, i8* %186
%188 = zext i8 %187 to i64
%189 = getelementptr inbounds float*, float** %119, i64 %188
%190 = load float*, float** %189
%191 = getelementptr inbounds i8, i8* %1, i64 %185
%192 = load i8, i8* %191
%193 = zext i8 %192 to i64
%194 = getelementptr inbounds float, float* %190, i64 %193
%195 = load float, float* %194
%196 = fadd float %195, 1.000000e+00
store float %196, float* %194
%197 = getelementptr inbounds i32, i32* %122, i64 %188
%198 = load i32, i32* %197
%199 = add nsw i32 %198, 1
store i32 %199, i32* %197
%200 = add nuw nsw i64 %169, 2
%201 = add i64 %170, 2
%202 = icmp eq i64 %201, %129
br i1 %202, label %130, label %168
203: ; preds = %153, %254
%204 = phi i64 [ 1, %153 ], [ %255, %254 ]
br i1 %154, label %205, label %254
205: ; preds = %203
%206 = getelementptr inbounds i32, i32* %122, i64 %204
%207 = load i32, i32* %206
%208 = sitofp i32 %207 to float
%209 = getelementptr inbounds float*, float** %119, i64 %204
%210 = load float*, float** %209
br i1 %161, label %240, label %211
211: ; preds = %205
%212 = insertelement <4 x float> poison, float %208, i64 0
%213 = shufflevector <4 x float> %212, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %164, label %231, label %214
214: ; preds = %211, %214
%215 = phi i64 [ %228, %214 ], [ 0, %211 ]
%216 = phi i64 [ %229, %214 ], [ 0, %211 ]
%217 = getelementptr inbounds float, float* %210, i64 %215
%218 = bitcast float* %217 to <4 x float>*
%219 = load <4 x float>, <4 x float>* %218
%220 = fdiv <4 x float> %219, %213
%221 = bitcast float* %217 to <4 x float>*
store <4 x float> %220, <4 x float>* %221
%222 = or i64 %215, 4
%223 = getelementptr inbounds float, float* %210, i64 %222
%224 = bitcast float* %223 to <4 x float>*
%225 = load <4 x float>, <4 x float>* %224
%226 = fdiv <4 x float> %225, %213
%227 = bitcast float* %223 to <4 x float>*
store <4 x float> %226, <4 x float>* %227
%228 = add nuw i64 %215, 8
%229 = add i64 %216, 2
%230 = icmp eq i64 %229, %165
br i1 %230, label %231, label %214
231: ; preds = %214, %211
%232 = phi i64 [ 0, %211 ], [ %228, %214 ]
br i1 %166, label %239, label %233
233: ; preds = %231
%234 = getelementptr inbounds float, float* %210, i64 %232
%235 = bitcast float* %234 to <4 x float>*
%236 = load <4 x float>, <4 x float>* %235
%237 = fdiv <4 x float> %236, %213
%238 = bitcast float* %234 to <4 x float>*
store <4 x float> %237, <4 x float>* %238
br label %239
239: ; preds = %231, %233
br i1 %167, label %254, label %240
240: ; preds = %205, %239
%241 = phi i64 [ 0, %205 ], [ %162, %239 ]
br label %247
242: ; preds = %254
%243 = icmp sgt i32 %6, 1
br i1 %243, label %244, label %301
244: ; preds = %242
%245 = zext i32 %6 to i64
%246 = zext i32 %12 to i64
br label %260
247: ; preds = %240, %247
%248 = phi i64 [ %252, %247 ], [ %241, %240 ]
%249 = getelementptr inbounds float, float* %210, i64 %248
%250 = load float, float* %249
%251 = fdiv float %250, %208
store float %251, float* %249
%252 = add nuw nsw i64 %248, 1
%253 = icmp eq i64 %252, %156
br i1 %253, label %254, label %247
254: ; preds = %247, %239, %203
%255 = add nuw nsw i64 %204, 1
%256 = icmp eq i64 %255, %155
br i1 %256, label %242, label %203
257: ; preds = %295
%258 = add nuw nsw i64 %262, 1
%259 = icmp eq i64 %266, %245
br i1 %259, label %301, label %260
260: ; preds = %257, %244
%261 = phi i64 [ 1, %244 ], [ %266, %257 ]
%262 = phi i64 [ 2, %244 ], [ %258, %257 ]
%263 = phi float [ 1.000000e+04, %244 ], [ %298, %257 ]
%264 = phi i32 [ undef, %244 ], [ %297, %257 ]
%265 = phi i32 [ undef, %244 ], [ %296, %257 ]
%266 = add nuw nsw i64 %261, 1
%267 = getelementptr inbounds float*, float** %15, i64 %261
%268 = getelementptr inbounds float*, float** %119, i64 %261
%269 = getelementptr inbounds float*, float** %18, i64 %261
%270 = trunc i64 %261 to i32
br label %271
271: ; preds = %260, %295
%272 = phi i64 [ %262, %260 ], [ %299, %295 ]
%273 = phi float [ %263, %260 ], [ %298, %295 ]
%274 = phi i32 [ %264, %260 ], [ %297, %295 ]
%275 = phi i32 [ %265, %260 ], [ %296, %295 ]
%276 = load float*, float** %267
%277 = getelementptr inbounds float, float* %276, i64 %272
%278 = load float, float* %277
%279 = fcmp une float %278, 0.000000e+00
br i1 %279, label %280, label %295
280: ; preds = %271
%281 = load float*, float** %268
%282 = getelementptr inbounds float*, float** %119, i64 %272
%283 = load float*, float** %282
%284 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @distance to i32 (float*, float*, i32, ...)*)(float* %281, float* %283, i32 %2)
%285 = sitofp i32 %284 to float
%286 = load float*, float** %269
%287 = getelementptr inbounds float, float* %286, i64 %272
store float %285, float* %287
%288 = getelementptr inbounds float*, float** %18, i64 %272
%289 = load float*, float** %288
%290 = getelementptr inbounds float, float* %289, i64 %261
store float %285, float* %290
%291 = load float, float* %287
%292 = fcmp olt float %291, %273
br i1 %292, label %293, label %295
293: ; preds = %280
%294 = trunc i64 %272 to i32
br label %295
295: ; preds = %271, %293, %280
%296 = phi i32 [ %294, %293 ], [ %275, %280 ], [ %275, %271 ]
%297 = phi i32 [ %270, %293 ], [ %274, %280 ], [ %274, %271 ]
%298 = phi float [ %291, %293 ], [ %273, %280 ], [ %273, %271 ]
%299 = add nuw nsw i64 %272, 1
%300 = icmp eq i64 %299, %246
br i1 %300, label %257, label %271
301: ; preds = %257, %242
%302 = phi i32 [ undef, %242 ], [ %296, %257 ]
%303 = phi i32 [ undef, %242 ], [ %297, %257 ]
%304 = phi float [ 1.000000e+04, %242 ], [ %298, %257 ]
%305 = tail call i8* @calloc(i64 %120, i64 4)
%306 = bitcast i8* %305 to i32*
br i1 %149, label %378, label %307
307: ; preds = %301
%308 = zext i32 %12 to i64
%309 = add nsw i64 %155, -1
%310 = icmp ult i64 %309, 8
br i1 %310, label %376, label %311
311: ; preds = %307
%312 = and i64 %309, -8
%313 = or i64 %312, 1
%314 = add nsw i64 %312, -8
%315 = lshr exact i64 %314, 3
%316 = add nuw nsw i64 %315, 1
%317 = and i64 %316, 3
%318 = icmp ult i64 %314, 24
br i1 %318, label %356, label %319
319: ; preds = %311
%320 = and i64 %316, 4611686018427387900
br label %321
321: ; preds = %321, %319
%322 = phi i64 [ 0, %319 ], [ %352, %321 ]
%323 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %319 ], [ %353, %321 ]
%324 = phi i64 [ 0, %319 ], [ %354, %321 ]
%325 = or i64 %322, 1
%326 = add <4 x i32> %323, <i32 4, i32 4, i32 4, i32 4>
%327 = getelementptr inbounds i32, i32* %306, i64 %325
%328 = bitcast i32* %327 to <4 x i32>*
store <4 x i32> %323, <4 x i32>* %328
%329 = getelementptr inbounds i32, i32* %327, i64 4
%330 = bitcast i32* %329 to <4 x i32>*
store <4 x i32> %326, <4 x i32>* %330
%331 = add <4 x i32> %323, <i32 8, i32 8, i32 8, i32 8>
%332 = or i64 %322, 9
%333 = add <4 x i32> %323, <i32 12, i32 12, i32 12, i32 12>
%334 = getelementptr inbounds i32, i32* %306, i64 %332
%335 = bitcast i32* %334 to <4 x i32>*
store <4 x i32> %331, <4 x i32>* %335
%336 = getelementptr inbounds i32, i32* %334, i64 4
%337 = bitcast i32* %336 to <4 x i32>*
store <4 x i32> %333, <4 x i32>* %337
%338 = add <4 x i32> %323, <i32 16, i32 16, i32 16, i32 16>
%339 = or i64 %322, 17
%340 = add <4 x i32> %323, <i32 20, i32 20, i32 20, i32 20>
%341 = getelementptr inbounds i32, i32* %306, i64 %339
%342 = bitcast i32* %341 to <4 x i32>*
store <4 x i32> %338, <4 x i32>* %342
%343 = getelementptr inbounds i32, i32* %341, i64 4
%344 = bitcast i32* %343 to <4 x i32>*
store <4 x i32> %340, <4 x i32>* %344
%345 = add <4 x i32> %323, <i32 24, i32 24, i32 24, i32 24>
%346 = or i64 %322, 25
%347 = add <4 x i32> %323, <i32 28, i32 28, i32 28, i32 28>
%348 = getelementptr inbounds i32, i32* %306, i64 %346
%349 = bitcast i32* %348 to <4 x i32>*
store <4 x i32> %345, <4 x i32>* %349
%350 = getelementptr inbounds i32, i32* %348, i64 4
%351 = bitcast i32* %350 to <4 x i32>*
store <4 x i32> %347, <4 x i32>* %351
%352 = add nuw i64 %322, 32
%353 = add <4 x i32> %323, <i32 32, i32 32, i32 32, i32 32>
%354 = add i64 %324, 4
%355 = icmp eq i64 %354, %320
br i1 %355, label %356, label %321
356: ; preds = %321, %311
%357 = phi i64 [ 0, %311 ], [ %352, %321 ]
%358 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %311 ], [ %353, %321 ]
%359 = icmp eq i64 %317, 0
br i1 %359, label %374, label %360
360: ; preds = %356, %360
%361 = phi i64 [ %370, %360 ], [ %357, %356 ]
%362 = phi <4 x i32> [ %371, %360 ], [ %358, %356 ]
%363 = phi i64 [ %372, %360 ], [ 0, %356 ]
%364 = or i64 %361, 1
%365 = add <4 x i32> %362, <i32 4, i32 4, i32 4, i32 4>
%366 = getelementptr inbounds i32, i32* %306, i64 %364
%367 = bitcast i32* %366 to <4 x i32>*
store <4 x i32> %362, <4 x i32>* %367
%368 = getelementptr inbounds i32, i32* %366, i64 4
%369 = bitcast i32* %368 to <4 x i32>*
store <4 x i32> %365, <4 x i32>* %369
%370 = add nuw i64 %361, 8
%371 = add <4 x i32> %362, <i32 8, i32 8, i32 8, i32 8>
%372 = add i64 %363, 1
%373 = icmp eq i64 %372, %317
br i1 %373, label %374, label %360
374: ; preds = %360, %356
%375 = icmp eq i64 %309, %312
br i1 %375, label %378, label %376
376: ; preds = %307, %374
%377 = phi i64 [ 1, %307 ], [ %313, %374 ]
br label %427
378: ; preds = %427, %374, %150, %301
%379 = phi i32* [ %152, %150 ], [ %306, %301 ], [ %306, %374 ], [ %306, %427 ]
%380 = phi i8* [ %151, %150 ], [ %305, %301 ], [ %305, %374 ], [ %305, %427 ]
%381 = phi float [ 1.000000e+04, %150 ], [ %304, %301 ], [ %304, %374 ], [ %304, %427 ]
%382 = phi i32 [ undef, %150 ], [ %303, %301 ], [ %303, %374 ], [ %303, %427 ]
%383 = phi i32 [ undef, %150 ], [ %302, %301 ], [ %302, %374 ], [ %302, %427 ]
%384 = fcmp olt float %381, %7
%385 = icmp sgt i32 %6, %8
%386 = and i1 %384, %385
br i1 %386, label %387, label %462
387: ; preds = %378
%388 = icmp sgt i32 %2, 0
%389 = sext i32 %6 to i64
%390 = sext i32 %8 to i64
%391 = zext i32 %12 to i64
%392 = zext i32 %2 to i64
%393 = zext i32 %2 to i64
%394 = add nsw i64 %389, 1
%395 = add nsw i64 %391, -1
%396 = and i64 %392, 4294967292
%397 = add nsw i64 %396, -4
%398 = lshr exact i64 %397, 2
%399 = add nuw nsw i64 %398, 1
%400 = and i64 %392, 4294967288
%401 = add nsw i64 %400, -8
%402 = lshr exact i64 %401, 3
%403 = add nuw nsw i64 %402, 1
%404 = and i64 %395, 1
%405 = icmp eq i32 %12, 2
%406 = and i64 %395, -2
%407 = icmp eq i64 %404, 0
%408 = icmp ult i32 %2, 4
%409 = and i64 %392, 4294967292
%410 = and i64 %399, 1
%411 = icmp eq i64 %397, 0
%412 = and i64 %399, 9223372036854775806
%413 = icmp eq i64 %410, 0
%414 = icmp eq i64 %409, %392
%415 = and i64 %392, 1
%416 = icmp eq i64 %415, 0
%417 = sub nsw i64 0, %392
%418 = icmp ult i32 %2, 8
%419 = and i64 %392, 4294967288
%420 = and i64 %403, 3
%421 = icmp ult i64 %401, 24
%422 = and i64 %403, 4611686018427387900
%423 = icmp eq i64 %420, 0
%424 = icmp eq i64 %419, %392
%425 = and i64 %392, 3
%426 = icmp eq i64 %425, 0
br label %442
427: ; preds = %376, %427
%428 = phi i64 [ %431, %427 ], [ %377, %376 ]
%429 = getelementptr inbounds i32, i32* %306, i64 %428
%430 = trunc i64 %428 to i32
store i32 %430, i32* %429
%431 = add nuw nsw i64 %428, 1
%432 = icmp eq i64 %431, %308
br i1 %432, label %378, label %427
433: ; preds = %1074, %1069
%434 = phi i32 [ %448, %1069 ], [ %1104, %1074 ]
%435 = phi i32 [ %447, %1069 ], [ %1105, %1074 ]
%436 = phi float [ 1.000000e+04, %1069 ], [ %1106, %1074 ]
%437 = fcmp olt float %436, %7
%438 = icmp sgt i64 %1070, %390
%439 = select i1 %437, i1 %438, i1 false
%440 = add i32 %446, -1
%441 = add i64 %443, 1
br i1 %439, label %442, label %460
442: ; preds = %387, %433
%443 = phi i64 [ 0, %387 ], [ %441, %433 ]
%444 = phi i64 [ %389, %387 ], [ %1070, %433 ]
%445 = phi i32 [ %6, %387 ], [ %458, %433 ]
%446 = phi i32 [ %12, %387 ], [ %440, %433 ]
%447 = phi i32 [ %382, %387 ], [ %435, %433 ]
%448 = phi i32 [ %383, %387 ], [ %434, %433 ]
%449 = zext i32 %445 to i64
%450 = zext i32 %445 to i64
%451 = add nsw i64 %450, -9
%452 = lshr i64 %451, 3
%453 = add nuw nsw i64 %452, 1
%454 = sub i64 %394, %443
%455 = zext i32 %445 to i64
%456 = add nsw i64 %455, -1
%457 = zext i32 %445 to i64
%458 = add i32 %445, -1
br i1 %149, label %510, label %459
459: ; preds = %442
br i1 %405, label %498, label %471
460: ; preds = %433
%461 = trunc i64 %1070 to i32
br label %462
462: ; preds = %460, %378
%463 = phi i32 [ %6, %378 ], [ %461, %460 ]
br i1 %123, label %464, label %1159
464: ; preds = %462
%465 = zext i32 %11 to i64
%466 = add nsw i64 %465, -1
%467 = and i64 %465, 3
%468 = icmp ult i64 %466, 3
br i1 %468, label %1144, label %469
469: ; preds = %464
%470 = and i64 %465, 4294967292
br label %1111
471: ; preds = %459, %494
%472 = phi i64 [ %495, %494 ], [ 1, %459 ]
%473 = phi i64 [ %496, %494 ], [ 0, %459 ]
%474 = getelementptr inbounds i32, i32* %379, i64 %472
%475 = load i32, i32* %474
%476 = icmp eq i32 %475, %448
br i1 %476, label %481, label %477
477: ; preds = %471
%478 = icmp sgt i32 %475, %448
br i1 %478, label %479, label %483
479: ; preds = %477
%480 = add nsw i32 %475, -1
br label %481
481: ; preds = %471, %479
%482 = phi i32 [ %480, %479 ], [ %447, %471 ]
store i32 %482, i32* %474
br label %483
483: ; preds = %481, %477
%484 = add nuw nsw i64 %472, 1
%485 = getelementptr inbounds i32, i32* %379, i64 %484
%486 = load i32, i32* %485
%487 = icmp eq i32 %486, %448
br i1 %487, label %492, label %488
488: ; preds = %483
%489 = icmp sgt i32 %486, %448
br i1 %489, label %490, label %494
490: ; preds = %488
%491 = add nsw i32 %486, -1
br label %492
492: ; preds = %490, %483
%493 = phi i32 [ %491, %490 ], [ %447, %483 ]
store i32 %493, i32* %485
br label %494
494: ; preds = %492, %488
%495 = add nuw nsw i64 %472, 2
%496 = add i64 %473, 2
%497 = icmp eq i64 %496, %406
br i1 %497, label %498, label %471
498: ; preds = %494, %459
%499 = phi i64 [ 1, %459 ], [ %495, %494 ]
br i1 %407, label %510, label %500
500: ; preds = %498
%501 = getelementptr inbounds i32, i32* %379, i64 %499
%502 = load i32, i32* %501
%503 = icmp eq i32 %502, %448
br i1 %503, label %508, label %504
504: ; preds = %500
%505 = icmp sgt i32 %502, %448
br i1 %505, label %506, label %510
506: ; preds = %504
%507 = add nsw i32 %502, -1
br label %508
508: ; preds = %506, %500
%509 = phi i32 [ %507, %506 ], [ %447, %500 ]
store i32 %509, i32* %501
br label %510
510: ; preds = %498, %508, %504, %442
%511 = sext i32 %447 to i64
%512 = getelementptr inbounds i32, i32* %122, i64 %511
%513 = load i32, i32* %512
%514 = sext i32 %448 to i64
%515 = getelementptr inbounds i32, i32* %122, i64 %514
%516 = load i32, i32* %515
%517 = add nsw i32 %516, %513
br i1 %388, label %518, label %614
518: ; preds = %510
%519 = getelementptr inbounds float*, float** %119, i64 %511
%520 = load float*, float** %519
%521 = sitofp i32 %513 to float
%522 = getelementptr inbounds float*, float** %119, i64 %514
%523 = load float*, float** %522
%524 = sitofp i32 %516 to float
%525 = sitofp i32 %517 to float
br i1 %408, label %580, label %526
526: ; preds = %518
%527 = getelementptr float, float* %520, i64 %392
%528 = getelementptr float, float* %523, i64 %392
%529 = icmp ult float* %520, %528
%530 = icmp ult float* %523, %527
%531 = and i1 %529, %530
br i1 %531, label %580, label %532
532: ; preds = %526
%533 = insertelement <4 x float> poison, float %524, i64 0
%534 = shufflevector <4 x float> %533, <4 x float> poison, <4 x i32> zeroinitializer
%535 = insertelement <4 x float> poison, float %521, i64 0
%536 = shufflevector <4 x float> %535, <4 x float> poison, <4 x i32> zeroinitializer
%537 = insertelement <4 x float> poison, float %525, i64 0
%538 = shufflevector <4 x float> %537, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %411, label %566, label %539
539: ; preds = %532, %539
%540 = phi i64 [ %563, %539 ], [ 0, %532 ]
%541 = phi i64 [ %564, %539 ], [ 0, %532 ]
%542 = getelementptr inbounds float, float* %520, i64 %540
%543 = bitcast float* %542 to <4 x float>*
%544 = load <4 x float>, <4 x float>* %543
%545 = getelementptr inbounds float, float* %523, i64 %540
%546 = bitcast float* %545 to <4 x float>*
%547 = load <4 x float>, <4 x float>* %546
%548 = fmul <4 x float> %547, %534
%549 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %544, <4 x float> %536, <4 x float> %548)
%550 = fdiv <4 x float> %549, %538
%551 = bitcast float* %542 to <4 x float>*
store <4 x float> %550, <4 x float>* %551
%552 = or i64 %540, 4
%553 = getelementptr inbounds float, float* %520, i64 %552
%554 = bitcast float* %553 to <4 x float>*
%555 = load <4 x float>, <4 x float>* %554
%556 = getelementptr inbounds float, float* %523, i64 %552
%557 = bitcast float* %556 to <4 x float>*
%558 = load <4 x float>, <4 x float>* %557
%559 = fmul <4 x float> %558, %534
%560 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %555, <4 x float> %536, <4 x float> %559)
%561 = fdiv <4 x float> %560, %538
%562 = bitcast float* %553 to <4 x float>*
store <4 x float> %561, <4 x float>* %562
%563 = add nuw i64 %540, 8
%564 = add i64 %541, 2
%565 = icmp eq i64 %564, %412
br i1 %565, label %566, label %539
566: ; preds = %539, %532
%567 = phi i64 [ 0, %532 ], [ %563, %539 ]
br i1 %413, label %579, label %568
568: ; preds = %566
%569 = getelementptr inbounds float, float* %520, i64 %567
%570 = bitcast float* %569 to <4 x float>*
%571 = load <4 x float>, <4 x float>* %570
%572 = getelementptr inbounds float, float* %523, i64 %567
%573 = bitcast float* %572 to <4 x float>*
%574 = load <4 x float>, <4 x float>* %573
%575 = fmul <4 x float> %574, %534
%576 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %571, <4 x float> %536, <4 x float> %575)
%577 = fdiv <4 x float> %576, %538
%578 = bitcast float* %569 to <4 x float>*
store <4 x float> %577, <4 x float>* %578
br label %579
579: ; preds = %566, %568
br i1 %414, label %614, label %580
580: ; preds = %526, %518, %579
%581 = phi i64 [ 0, %526 ], [ 0, %518 ], [ %409, %579 ]
%582 = xor i64 %581, -1
br i1 %416, label %592, label %583
583: ; preds = %580
%584 = getelementptr inbounds float, float* %520, i64 %581
%585 = load float, float* %584
%586 = getelementptr inbounds float, float* %523, i64 %581
%587 = load float, float* %586
%588 = fmul float %587, %524
%589 = tail call float @llvm.fmuladd.f32(float %585, float %521, float %588)
%590 = fdiv float %589, %525
store float %590, float* %584
%591 = or i64 %581, 1
br label %592
592: ; preds = %583, %580
%593 = phi i64 [ %581, %580 ], [ %591, %583 ]
%594 = icmp eq i64 %582, %417
br i1 %594, label %614, label %595
595: ; preds = %592, %595
%596 = phi i64 [ %612, %595 ], [ %593, %592 ]
%597 = getelementptr inbounds float, float* %520, i64 %596
%598 = load float, float* %597
%599 = getelementptr inbounds float, float* %523, i64 %596
%600 = load float, float* %599
%601 = fmul float %600, %524
%602 = tail call float @llvm.fmuladd.f32(float %598, float %521, float %601)
%603 = fdiv float %602, %525
store float %603, float* %597
%604 = add nuw nsw i64 %596, 1
%605 = getelementptr inbounds float, float* %520, i64 %604
%606 = load float, float* %605
%607 = getelementptr inbounds float, float* %523, i64 %604
%608 = load float, float* %607
%609 = fmul float %608, %524
%610 = tail call float @llvm.fmuladd.f32(float %606, float %521, float %609)
%611 = fdiv float %610, %525
store float %611, float* %605
%612 = add nuw nsw i64 %596, 2
%613 = icmp eq i64 %612, %392
br i1 %613, label %614, label %595
614: ; preds = %592, %595, %579, %510
store i32 %517, i32* %512
%615 = icmp slt i64 %444, 1
br i1 %615, label %679, label %616
616: ; preds = %614
%617 = getelementptr inbounds float*, float** %15, i64 %511
%618 = getelementptr inbounds float*, float** %15, i64 %514
%619 = getelementptr inbounds float*, float** %119, i64 %511
%620 = getelementptr inbounds float*, float** %18, i64 %511
%621 = zext i32 %448 to i64
%622 = zext i32 %447 to i64
%623 = zext i32 %446 to i64
br label %640
624: ; preds = %676
br i1 %615, label %679, label %625
625: ; preds = %624
%626 = icmp sgt i64 %444, %514
%627 = zext i32 %446 to i64
%628 = sub i64 %444, %514
%629 = add i64 %628, -8
%630 = lshr i64 %629, 3
%631 = add nuw nsw i64 %630, 1
%632 = icmp ult i64 %628, 8
%633 = and i64 %628, -8
%634 = add i64 %633, %514
%635 = and i64 %631, 1
%636 = icmp ult i64 %629, 8
%637 = and i64 %631, 4611686018427387902
%638 = icmp eq i64 %635, 0
%639 = icmp eq i64 %628, %633
br label %695
640: ; preds = %616, %676
%641 = phi i64 [ 1, %616 ], [ %677, %676 ]
%642 = icmp eq i64 %641, %622
%643 = icmp eq i64 %641, %621
%644 = select i1 %642, i1 true, i1 %643
br i1 %644, label %676, label %645
645: ; preds = %640
%646 = load float*, float** %617
%647 = getelementptr inbounds float, float* %646, i64 %641
%648 = load float, float* %647
%649 = fcmp une float %648, 0.000000e+00
br i1 %649, label %655, label %650
650: ; preds = %645
%651 = load float*, float** %618
%652 = getelementptr inbounds float, float* %651, i64 %641
%653 = load float, float* %652
%654 = fcmp une float %653, 0.000000e+00
br i1 %654, label %655, label %676
655: ; preds = %650, %645
%656 = load float*, float** %619
%657 = getelementptr inbounds float*, float** %119, i64 %641
%658 = load float*, float** %657
%659 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @distance to i32 (float*, float*, i32, ...)*)(float* %656, float* %658, i32 %2)
%660 = sitofp i32 %659 to float
%661 = load float*, float** %620
%662 = getelementptr inbounds float, float* %661, i64 %641
store float %660, float* %662
%663 = getelementptr inbounds float*, float** %18, i64 %641
%664 = load float*, float** %663
%665 = getelementptr inbounds float, float* %664, i64 %511
store float %660, float* %665
%666 = load float*, float** %617
%667 = getelementptr inbounds float, float* %666, i64 %641
%668 = load float, float* %667
%669 = load float*, float** %618
%670 = getelementptr inbounds float, float* %669, i64 %641
%671 = load float, float* %670
%672 = fadd float %668, %671
store float %672, float* %667
%673 = getelementptr inbounds float*, float** %15, i64 %641
%674 = load float*, float** %673
%675 = getelementptr inbounds float, float* %674, i64 %511
store float %672, float* %675
br label %676
676: ; preds = %640, %655, %650
%677 = add nuw nsw i64 %641, 1
%678 = icmp eq i64 %677, %623
br i1 %678, label %624, label %640
679: ; preds = %800, %614, %624
%680 = icmp sgt i64 %444, %514
br i1 %680, label %681, label %1069
681: ; preds = %679
%682 = icmp sgt i64 %444, 1
%683 = and i64 %444, 4294967295
%684 = icmp ult i64 %456, 8
%685 = and i64 %456, -8
%686 = or i64 %685, 1
%687 = and i64 %453, 1
%688 = icmp ult i64 %451, 8
%689 = and i64 %453, 4611686018427387902
%690 = icmp eq i64 %687, 0
%691 = icmp eq i64 %456, %685
%692 = and i64 %449, 1
%693 = icmp eq i64 %692, 0
%694 = sub nsw i64 0, %449
br label %805
695: ; preds = %625, %800
%696 = phi i64 [ 1, %625 ], [ %801, %800 ]
br i1 %626, label %697, label %800
697: ; preds = %695
%698 = getelementptr inbounds float*, float** %15, i64 %696
%699 = load float*, float** %698
%700 = getelementptr inbounds float*, float** %18, i64 %696
%701 = load float*, float** %700
br i1 %632, label %788, label %702
702: ; preds = %697
%703 = getelementptr float, float* %699, i64 %514
%704 = getelementptr float, float* %699, i64 %454
%705 = getelementptr float, float* %701, i64 %514
%706 = getelementptr float, float* %701, i64 %454
%707 = icmp ult float* %703, %706
%708 = icmp ult float* %705, %704
%709 = and i1 %707, %708
br i1 %709, label %788, label %710
710: ; preds = %702
br i1 %636, label %762, label %711
711: ; preds = %710, %711
%712 = phi i64 [ %759, %711 ], [ 0, %710 ]
%713 = phi i64 [ %760, %711 ], [ 0, %710 ]
%714 = add i64 %712, %514
%715 = add nsw i64 %714, 1
%716 = getelementptr inbounds float, float* %699, i64 %715
%717 = bitcast float* %716 to <4 x float>*
%718 = load <4 x float>, <4 x float>* %717
%719 = getelementptr inbounds float, float* %716, i64 4
%720 = bitcast float* %719 to <4 x float>*
%721 = load <4 x float>, <4 x float>* %720
%722 = getelementptr inbounds float, float* %699, i64 %714
%723 = bitcast float* %722 to <4 x float>*
store <4 x float> %718, <4 x float>* %723
%724 = getelementptr inbounds float, float* %722, i64 4
%725 = bitcast float* %724 to <4 x float>*
store <4 x float> %721, <4 x float>* %725
%726 = getelementptr inbounds float, float* %701, i64 %715
%727 = bitcast float* %726 to <4 x float>*
%728 = load <4 x float>, <4 x float>* %727
%729 = getelementptr inbounds float, float* %726, i64 4
%730 = bitcast float* %729 to <4 x float>*
%731 = load <4 x float>, <4 x float>* %730
%732 = getelementptr inbounds float, float* %701, i64 %714
%733 = bitcast float* %732 to <4 x float>*
store <4 x float> %728, <4 x float>* %733
%734 = getelementptr inbounds float, float* %732, i64 4
%735 = bitcast float* %734 to <4 x float>*
store <4 x float> %731, <4 x float>* %735
%736 = or i64 %712, 8
%737 = add i64 %736, %514
%738 = add nsw i64 %737, 1
%739 = getelementptr inbounds float, float* %699, i64 %738
%740 = bitcast float* %739 to <4 x float>*
%741 = load <4 x float>, <4 x float>* %740
%742 = getelementptr inbounds float, float* %739, i64 4
%743 = bitcast float* %742 to <4 x float>*
%744 = load <4 x float>, <4 x float>* %743
%745 = getelementptr inbounds float, float* %699, i64 %737
%746 = bitcast float* %745 to <4 x float>*
store <4 x float> %741, <4 x float>* %746
%747 = getelementptr inbounds float, float* %745, i64 4
%748 = bitcast float* %747 to <4 x float>*
store <4 x float> %744, <4 x float>* %748
%749 = getelementptr inbounds float, float* %701, i64 %738
%750 = bitcast float* %749 to <4 x float>*
%751 = load <4 x float>, <4 x float>* %750
%752 = getelementptr inbounds float, float* %749, i64 4
%753 = bitcast float* %752 to <4 x float>*
%754 = load <4 x float>, <4 x float>* %753
%755 = getelementptr inbounds float, float* %701, i64 %737
%756 = bitcast float* %755 to <4 x float>*
store <4 x float> %751, <4 x float>* %756
%757 = getelementptr inbounds float, float* %755, i64 4
%758 = bitcast float* %757 to <4 x float>*
store <4 x float> %754, <4 x float>* %758
%759 = add nuw i64 %712, 16
%760 = add i64 %713, 2
%761 = icmp eq i64 %760, %637
br i1 %761, label %762, label %711
762: ; preds = %711, %710
%763 = phi i64 [ 0, %710 ], [ %759, %711 ]
br i1 %638, label %787, label %764
764: ; preds = %762
%765 = add i64 %763, %514
%766 = add nsw i64 %765, 1
%767 = getelementptr inbounds float, float* %699, i64 %766
%768 = bitcast float* %767 to <4 x float>*
%769 = load <4 x float>, <4 x float>* %768
%770 = getelementptr inbounds float, float* %767, i64 4
%771 = bitcast float* %770 to <4 x float>*
%772 = load <4 x float>, <4 x float>* %771
%773 = getelementptr inbounds float, float* %699, i64 %765
%774 = bitcast float* %773 to <4 x float>*
store <4 x float> %769, <4 x float>* %774
%775 = getelementptr inbounds float, float* %773, i64 4
%776 = bitcast float* %775 to <4 x float>*
store <4 x float> %772, <4 x float>* %776
%777 = getelementptr inbounds float, float* %701, i64 %766
%778 = bitcast float* %777 to <4 x float>*
%779 = load <4 x float>, <4 x float>* %778
%780 = getelementptr inbounds float, float* %777, i64 4
%781 = bitcast float* %780 to <4 x float>*
%782 = load <4 x float>, <4 x float>* %781
%783 = getelementptr inbounds float, float* %701, i64 %765
%784 = bitcast float* %783 to <4 x float>*
store <4 x float> %779, <4 x float>* %784
%785 = getelementptr inbounds float, float* %783, i64 4
%786 = bitcast float* %785 to <4 x float>*
store <4 x float> %782, <4 x float>* %786
br label %787
787: ; preds = %762, %764
br i1 %639, label %800, label %788
788: ; preds = %702, %697, %787
%789 = phi i64 [ %514, %702 ], [ %514, %697 ], [ %634, %787 ]
br label %790
790: ; preds = %788, %790
%791 = phi i64 [ %792, %790 ], [ %789, %788 ]
%792 = add nsw i64 %791, 1
%793 = getelementptr inbounds float, float* %699, i64 %792
%794 = load float, float* %793
%795 = getelementptr inbounds float, float* %699, i64 %791
store float %794, float* %795
%796 = getelementptr inbounds float, float* %701, i64 %792
%797 = load float, float* %796
%798 = getelementptr inbounds float, float* %701, i64 %791
store float %797, float* %798
%799 = icmp slt i64 %792, %444
br i1 %799, label %790, label %800
800: ; preds = %790, %787, %695
%801 = add nuw nsw i64 %696, 1
%802 = icmp eq i64 %801, %627
br i1 %802, label %679, label %695
803: ; preds = %1047, %1050, %1033, %950
%804 = icmp slt i64 %807, %444
br i1 %804, label %805, label %1069
805: ; preds = %681, %803
%806 = phi i64 [ %514, %681 ], [ %807, %803 ]
%807 = add nsw i64 %806, 1
br i1 %682, label %808, label %950
808: ; preds = %805
%809 = getelementptr inbounds float*, float** %15, i64 %807
%810 = load float*, float** %809
%811 = getelementptr inbounds float*, float** %15, i64 %806
%812 = load float*, float** %811
%813 = getelementptr inbounds float*, float** %18, i64 %807
%814 = load float*, float** %813
%815 = getelementptr inbounds float*, float** %18, i64 %806
%816 = load float*, float** %815
br i1 %684, label %919, label %817
817: ; preds = %808
%818 = getelementptr float, float* %812, i64 1
%819 = getelementptr float, float* %812, i64 %457
%820 = getelementptr float, float* %816, i64 1
%821 = getelementptr float, float* %816, i64 %457
%822 = getelementptr float, float* %810, i64 1
%823 = getelementptr float, float* %810, i64 %457
%824 = getelementptr float, float* %814, i64 1
%825 = getelementptr float, float* %814, i64 %457
%826 = icmp ult float* %818, %821
%827 = icmp ult float* %820, %819
%828 = and i1 %826, %827
%829 = icmp ult float* %818, %823
%830 = icmp ult float* %822, %819
%831 = and i1 %829, %830
%832 = or i1 %828, %831
%833 = icmp ult float* %818, %825
%834 = icmp ult float* %824, %819
%835 = and i1 %833, %834
%836 = or i1 %832, %835
%837 = icmp ult float* %820, %823
%838 = icmp ult float* %822, %821
%839 = and i1 %837, %838
%840 = or i1 %836, %839
%841 = icmp ult float* %820, %825
%842 = icmp ult float* %824, %821
%843 = and i1 %841, %842
%844 = or i1 %840, %843
br i1 %844, label %919, label %845
845: ; preds = %817
br i1 %688, label %894, label %846
846: ; preds = %845, %846
%847 = phi i64 [ %891, %846 ], [ 0, %845 ]
%848 = phi i64 [ %892, %846 ], [ 0, %845 ]
%849 = or i64 %847, 1
%850 = getelementptr inbounds float, float* %810, i64 %849
%851 = bitcast float* %850 to <4 x float>*
%852 = load <4 x float>, <4 x float>* %851
%853 = getelementptr inbounds float, float* %850, i64 4
%854 = bitcast float* %853 to <4 x float>*
%855 = load <4 x float>, <4 x float>* %854
%856 = getelementptr inbounds float, float* %812, i64 %849
%857 = bitcast float* %856 to <4 x float>*
store <4 x float> %852, <4 x float>* %857
%858 = getelementptr inbounds float, float* %856, i64 4
%859 = bitcast float* %858 to <4 x float>*
store <4 x float> %855, <4 x float>* %859
%860 = getelementptr inbounds float, float* %814, i64 %849
%861 = bitcast float* %860 to <4 x float>*
%862 = load <4 x float>, <4 x float>* %861
%863 = getelementptr inbounds float, float* %860, i64 4
%864 = bitcast float* %863 to <4 x float>*
%865 = load <4 x float>, <4 x float>* %864
%866 = getelementptr inbounds float, float* %816, i64 %849
%867 = bitcast float* %866 to <4 x float>*
store <4 x float> %862, <4 x float>* %867
%868 = getelementptr inbounds float, float* %866, i64 4
%869 = bitcast float* %868 to <4 x float>*
store <4 x float> %865, <4 x float>* %869
%870 = or i64 %847, 9
%871 = getelementptr inbounds float, float* %810, i64 %870
%872 = bitcast float* %871 to <4 x float>*
%873 = load <4 x float>, <4 x float>* %872
%874 = getelementptr inbounds float, float* %871, i64 4
%875 = bitcast float* %874 to <4 x float>*
%876 = load <4 x float>, <4 x float>* %875
%877 = getelementptr inbounds float, float* %812, i64 %870
%878 = bitcast float* %877 to <4 x float>*
store <4 x float> %873, <4 x float>* %878
%879 = getelementptr inbounds float, float* %877, i64 4
%880 = bitcast float* %879 to <4 x float>*
store <4 x float> %876, <4 x float>* %880
%881 = getelementptr inbounds float, float* %814, i64 %870
%882 = bitcast float* %881 to <4 x float>*
%883 = load <4 x float>, <4 x float>* %882
%884 = getelementptr inbounds float, float* %881, i64 4
%885 = bitcast float* %884 to <4 x float>*
%886 = load <4 x float>, <4 x float>* %885
%887 = getelementptr inbounds float, float* %816, i64 %870
%888 = bitcast float* %887 to <4 x float>*
store <4 x float> %883, <4 x float>* %888
%889 = getelementptr inbounds float, float* %887, i64 4
%890 = bitcast float* %889 to <4 x float>*
store <4 x float> %886, <4 x float>* %890
%891 = add nuw i64 %847, 16
%892 = add i64 %848, 2
%893 = icmp eq i64 %892, %689
br i1 %893, label %894, label %846
894: ; preds = %846, %845
%895 = phi i64 [ 0, %845 ], [ %891, %846 ]
br i1 %690, label %918, label %896
896: ; preds = %894
%897 = or i64 %895, 1
%898 = getelementptr inbounds float, float* %810, i64 %897
%899 = bitcast float* %898 to <4 x float>*
%900 = load <4 x float>, <4 x float>* %899
%901 = getelementptr inbounds float, float* %898, i64 4
%902 = bitcast float* %901 to <4 x float>*
%903 = load <4 x float>, <4 x float>* %902
%904 = getelementptr inbounds float, float* %812, i64 %897
%905 = bitcast float* %904 to <4 x float>*
store <4 x float> %900, <4 x float>* %905
%906 = getelementptr inbounds float, float* %904, i64 4
%907 = bitcast float* %906 to <4 x float>*
store <4 x float> %903, <4 x float>* %907
%908 = getelementptr inbounds float, float* %814, i64 %897
%909 = bitcast float* %908 to <4 x float>*
%910 = load <4 x float>, <4 x float>* %909
%911 = getelementptr inbounds float, float* %908, i64 4
%912 = bitcast float* %911 to <4 x float>*
%913 = load <4 x float>, <4 x float>* %912
%914 = getelementptr inbounds float, float* %816, i64 %897
%915 = bitcast float* %914 to <4 x float>*
store <4 x float> %910, <4 x float>* %915
%916 = getelementptr inbounds float, float* %914, i64 4
%917 = bitcast float* %916 to <4 x float>*
store <4 x float> %913, <4 x float>* %917
br label %918
918: ; preds = %894, %896
br i1 %691, label %950, label %919
919: ; preds = %817, %808, %918
%920 = phi i64 [ 1, %817 ], [ 1, %808 ], [ %686, %918 ]
%921 = xor i64 %920, -1
br i1 %693, label %922, label %930
922: ; preds = %919
%923 = getelementptr inbounds float, float* %810, i64 %920
%924 = load float, float* %923
%925 = getelementptr inbounds float, float* %812, i64 %920
store float %924, float* %925
%926 = getelementptr inbounds float, float* %814, i64 %920
%927 = load float, float* %926
%928 = getelementptr inbounds float, float* %816, i64 %920
store float %927, float* %928
%929 = add nuw nsw i64 %920, 1
br label %930
930: ; preds = %922, %919
%931 = phi i64 [ %920, %919 ], [ %929, %922 ]
%932 = icmp eq i64 %921, %694
br i1 %932, label %950, label %933
933: ; preds = %930, %933
%934 = phi i64 [ %948, %933 ], [ %931, %930 ]
%935 = getelementptr inbounds float, float* %810, i64 %934
%936 = load float, float* %935
%937 = getelementptr inbounds float, float* %812, i64 %934
store float %936, float* %937
%938 = getelementptr inbounds float, float* %814, i64 %934
%939 = load float, float* %938
%940 = getelementptr inbounds float, float* %816, i64 %934
store float %939, float* %940
%941 = add nuw nsw i64 %934, 1
%942 = getelementptr inbounds float, float* %810, i64 %941
%943 = load float, float* %942
%944 = getelementptr inbounds float, float* %812, i64 %941
store float %943, float* %944
%945 = getelementptr inbounds float, float* %814, i64 %941
%946 = load float, float* %945
%947 = getelementptr inbounds float, float* %816, i64 %941
store float %946, float* %947
%948 = add nuw nsw i64 %934, 2
%949 = icmp eq i64 %948, %683
br i1 %949, label %950, label %933
950: ; preds = %930, %933, %918, %805
%951 = getelementptr inbounds i32, i32* %122, i64 %807
%952 = load i32, i32* %951
%953 = getelementptr inbounds i32, i32* %122, i64 %806
store i32 %952, i32* %953
br i1 %388, label %954, label %803
954: ; preds = %950
%955 = getelementptr inbounds float*, float** %119, i64 %807
%956 = load float*, float** %955
%957 = getelementptr inbounds float*, float** %119, i64 %806
%958 = load float*, float** %957
br i1 %418, label %1034, label %959
959: ; preds = %954
%960 = getelementptr float, float* %958, i64 %392
%961 = getelementptr float, float* %956, i64 %392
%962 = icmp ult float* %958, %961
%963 = icmp ult float* %956, %960
%964 = and i1 %962, %963
br i1 %964, label %1034, label %965
965: ; preds = %959
br i1 %421, label %1015, label %966
966: ; preds = %965, %966
%967 = phi i64 [ %1012, %966 ], [ 0, %965 ]
%968 = phi i64 [ %1013, %966 ], [ 0, %965 ]
%969 = getelementptr inbounds float, float* %956, i64 %967
%970 = bitcast float* %969 to <4 x float>*
%971 = load <4 x float>, <4 x float>* %970
%972 = getelementptr inbounds float, float* %969, i64 4
%973 = bitcast float* %972 to <4 x float>*
%974 = load <4 x float>, <4 x float>* %973
%975 = getelementptr inbounds float, float* %958, i64 %967
%976 = bitcast float* %975 to <4 x float>*
store <4 x float> %971, <4 x float>* %976
%977 = getelementptr inbounds float, float* %975, i64 4
%978 = bitcast float* %977 to <4 x float>*
store <4 x float> %974, <4 x float>* %978
%979 = or i64 %967, 8
%980 = getelementptr inbounds float, float* %956, i64 %979
%981 = bitcast float* %980 to <4 x float>*
%982 = load <4 x float>, <4 x float>* %981
%983 = getelementptr inbounds float, float* %980, i64 4
%984 = bitcast float* %983 to <4 x float>*
%985 = load <4 x float>, <4 x float>* %984
%986 = getelementptr inbounds float, float* %958, i64 %979
%987 = bitcast float* %986 to <4 x float>*
store <4 x float> %982, <4 x float>* %987
%988 = getelementptr inbounds float, float* %986, i64 4
%989 = bitcast float* %988 to <4 x float>*
store <4 x float> %985, <4 x float>* %989
%990 = or i64 %967, 16
%991 = getelementptr inbounds float, float* %956, i64 %990
%992 = bitcast float* %991 to <4 x float>*
%993 = load <4 x float>, <4 x float>* %992
%994 = getelementptr inbounds float, float* %991, i64 4
%995 = bitcast float* %994 to <4 x float>*
%996 = load <4 x float>, <4 x float>* %995
%997 = getelementptr inbounds float, float* %958, i64 %990
%998 = bitcast float* %997 to <4 x float>*
store <4 x float> %993, <4 x float>* %998
%999 = getelementptr inbounds float, float* %997, i64 4
%1000 = bitcast float* %999 to <4 x float>*
store <4 x float> %996, <4 x float>* %1000
%1001 = or i64 %967, 24
%1002 = getelementptr inbounds float, float* %956, i64 %1001
%1003 = bitcast float* %1002 to <4 x float>*
%1004 = load <4 x float>, <4 x float>* %1003
%1005 = getelementptr inbounds float, float* %1002, i64 4
%1006 = bitcast float* %1005 to <4 x float>*
%1007 = load <4 x float>, <4 x float>* %1006
%1008 = getelementptr inbounds float, float* %958, i64 %1001
%1009 = bitcast float* %1008 to <4 x float>*
store <4 x float> %1004, <4 x float>* %1009
%1010 = getelementptr inbounds float, float* %1008, i64 4
%1011 = bitcast float* %1010 to <4 x float>*
store <4 x float> %1007, <4 x float>* %1011
%1012 = add nuw i64 %967, 32
%1013 = add i64 %968, 4
%1014 = icmp eq i64 %1013, %422
br i1 %1014, label %1015, label %966
1015: ; preds = %966, %965
%1016 = phi i64 [ 0, %965 ], [ %1012, %966 ]
br i1 %423, label %1033, label %1017
1017: ; preds = %1015, %1017
%1018 = phi i64 [ %1030, %1017 ], [ %1016, %1015 ]
%1019 = phi i64 [ %1031, %1017 ], [ 0, %1015 ]
%1020 = getelementptr inbounds float, float* %956, i64 %1018
%1021 = bitcast float* %1020 to <4 x float>*
%1022 = load <4 x float>, <4 x float>* %1021
%1023 = getelementptr inbounds float, float* %1020, i64 4
%1024 = bitcast float* %1023 to <4 x float>*
%1025 = load <4 x float>, <4 x float>* %1024
%1026 = getelementptr inbounds float, float* %958, i64 %1018
%1027 = bitcast float* %1026 to <4 x float>*
store <4 x float> %1022, <4 x float>* %1027
%1028 = getelementptr inbounds float, float* %1026, i64 4
%1029 = bitcast float* %1028 to <4 x float>*
store <4 x float> %1025, <4 x float>* %1029
%1030 = add nuw i64 %1018, 8
%1031 = add i64 %1019, 1
%1032 = icmp eq i64 %1031, %420
br i1 %1032, label %1033, label %1017
1033: ; preds = %1017, %1015
br i1 %424, label %803, label %1034
1034: ; preds = %959, %954, %1033
%1035 = phi i64 [ 0, %959 ], [ 0, %954 ], [ %419, %1033 ]
%1036 = xor i64 %1035, -1
%1037 = add nsw i64 %1036, %392
br i1 %426, label %1047, label %1038
1038: ; preds = %1034, %1038
%1039 = phi i64 [ %1044, %1038 ], [ %1035, %1034 ]
%1040 = phi i64 [ %1045, %1038 ], [ 0, %1034 ]
%1041 = getelementptr inbounds float, float* %956, i64 %1039
%1042 = load float, float* %1041
%1043 = getelementptr inbounds float, float* %958, i64 %1039
store float %1042, float* %1043
%1044 = add nuw nsw i64 %1039, 1
%1045 = add i64 %1040, 1
%1046 = icmp eq i64 %1045, %425
br i1 %1046, label %1047, label %1038
1047: ; preds = %1038, %1034
%1048 = phi i64 [ %1035, %1034 ], [ %1044, %1038 ]
%1049 = icmp ult i64 %1037, 3
br i1 %1049, label %803, label %1050
1050: ; preds = %1047, %1050
%1051 = phi i64 [ %1067, %1050 ], [ %1048, %1047 ]
%1052 = getelementptr inbounds float, float* %956, i64 %1051
%1053 = load float, float* %1052
%1054 = getelementptr inbounds float, float* %958, i64 %1051
store float %1053, float* %1054
%1055 = add nuw nsw i64 %1051, 1
%1056 = getelementptr inbounds float, float* %956, i64 %1055
%1057 = load float, float* %1056
%1058 = getelementptr inbounds float, float* %958, i64 %1055
store float %1057, float* %1058
%1059 = add nuw nsw i64 %1051, 2
%1060 = getelementptr inbounds float, float* %956, i64 %1059
%1061 = load float, float* %1060
%1062 = getelementptr inbounds float, float* %958, i64 %1059
store float %1061, float* %1062
%1063 = add nuw nsw i64 %1051, 3
%1064 = getelementptr inbounds float, float* %956, i64 %1063
%1065 = load float, float* %1064
%1066 = getelementptr inbounds float, float* %958, i64 %1063
store float %1065, float* %1066
%1067 = add nuw nsw i64 %1051, 4
%1068 = icmp eq i64 %1067, %393
br i1 %1068, label %803, label %1050
1069: ; preds = %803, %679
%1070 = add nsw i64 %444, -1
%1071 = icmp sgt i64 %444, 2
br i1 %1071, label %1072, label %433
1072: ; preds = %1069
%1073 = zext i32 %458 to i64
br label %1077
1074: ; preds = %1103
%1075 = add nuw nsw i64 %1079, 1
%1076 = icmp eq i64 %1083, %1073
br i1 %1076, label %433, label %1077
1077: ; preds = %1074, %1072
%1078 = phi i64 [ 1, %1072 ], [ %1083, %1074 ]
%1079 = phi i64 [ 2, %1072 ], [ %1075, %1074 ]
%1080 = phi float [ 1.000000e+04, %1072 ], [ %1106, %1074 ]
%1081 = phi i32 [ %447, %1072 ], [ %1105, %1074 ]
%1082 = phi i32 [ %448, %1072 ], [ %1104, %1074 ]
%1083 = add nuw nsw i64 %1078, 1
%1084 = getelementptr inbounds float*, float** %15, i64 %1078
%1085 = load float*, float** %1084
%1086 = getelementptr inbounds float*, float** %18, i64 %1078
%1087 = trunc i64 %1078 to i32
br label %1088
1088: ; preds = %1077, %1103
%1089 = phi i64 [ %1079, %1077 ], [ %1107, %1103 ]
%1090 = phi float [ %1080, %1077 ], [ %1106, %1103 ]
%1091 = phi i32 [ %1081, %1077 ], [ %1105, %1103 ]
%1092 = phi i32 [ %1082, %1077 ], [ %1104, %1103 ]
%1093 = getelementptr inbounds float, float* %1085, i64 %1089
%1094 = load float, float* %1093
%1095 = fcmp une float %1094, 0.000000e+00
br i1 %1095, label %1096, label %1103
1096: ; preds = %1088
%1097 = load float*, float** %1086
%1098 = getelementptr inbounds float, float* %1097, i64 %1089
%1099 = load float, float* %1098
%1100 = fcmp olt float %1099, %1090
br i1 %1100, label %1101, label %1103
1101: ; preds = %1096
%1102 = trunc i64 %1089 to i32
br label %1103
1103: ; preds = %1088, %1101, %1096
%1104 = phi i32 [ %1102, %1101 ], [ %1092, %1096 ], [ %1092, %1088 ]
%1105 = phi i32 [ %1087, %1101 ], [ %1091, %1096 ], [ %1091, %1088 ]
%1106 = phi float [ %1099, %1101 ], [ %1090, %1096 ], [ %1090, %1088 ]
%1107 = add nuw nsw i64 %1089, 1
%1108 = shl i64 %1107, 32
%1109 = ashr exact i64 %1108, 32
%1110 = icmp slt i64 %1109, %444
br i1 %1110, label %1088, label %1074
1111: ; preds = %1111, %469
%1112 = phi i64 [ 0, %469 ], [ %1141, %1111 ]
%1113 = phi i64 [ 0, %469 ], [ %1142, %1111 ]
%1114 = getelementptr inbounds i8, i8* %0, i64 %1112
%1115 = load i8, i8* %1114
%1116 = zext i8 %1115 to i64
%1117 = getelementptr inbounds i32, i32* %379, i64 %1116
%1118 = load i32, i32* %1117
%1119 = trunc i32 %1118 to i8
store i8 %1119, i8* %1114
%1120 = or i64 %1112, 1
%1121 = getelementptr inbounds i8, i8* %0, i64 %1120
%1122 = load i8, i8* %1121
%1123 = zext i8 %1122 to i64
%1124 = getelementptr inbounds i32, i32* %379, i64 %1123
%1125 = load i32, i32* %1124
%1126 = trunc i32 %1125 to i8
store i8 %1126, i8* %1121
%1127 = or i64 %1112, 2
%1128 = getelementptr inbounds i8, i8* %0, i64 %1127
%1129 = load i8, i8* %1128
%1130 = zext i8 %1129 to i64
%1131 = getelementptr inbounds i32, i32* %379, i64 %1130
%1132 = load i32, i32* %1131
%1133 = trunc i32 %1132 to i8
store i8 %1133, i8* %1128
%1134 = or i64 %1112, 3
%1135 = getelementptr inbounds i8, i8* %0, i64 %1134
%1136 = load i8, i8* %1135
%1137 = zext i8 %1136 to i64
%1138 = getelementptr inbounds i32, i32* %379, i64 %1137
%1139 = load i32, i32* %1138
%1140 = trunc i32 %1139 to i8
store i8 %1140, i8* %1135
%1141 = add nuw nsw i64 %1112, 4
%1142 = add i64 %1113, 4
%1143 = icmp eq i64 %1142, %470
br i1 %1143, label %1144, label %1111
1144: ; preds = %1111, %464
%1145 = phi i64 [ 0, %464 ], [ %1141, %1111 ]
%1146 = icmp eq i64 %467, 0
br i1 %1146, label %1159, label %1147
1147: ; preds = %1144, %1147
%1148 = phi i64 [ %1156, %1147 ], [ %1145, %1144 ]
%1149 = phi i64 [ %1157, %1147 ], [ 0, %1144 ]
%1150 = getelementptr inbounds i8, i8* %0, i64 %1148
%1151 = load i8, i8* %1150
%1152 = zext i8 %1151 to i64
%1153 = getelementptr inbounds i32, i32* %379, i64 %1152
%1154 = load i32, i32* %1153
%1155 = trunc i32 %1154 to i8
store i8 %1155, i8* %1150
%1156 = add nuw nsw i64 %1148, 1
%1157 = add i64 %1149, 1
%1158 = icmp eq i64 %1157, %467
br i1 %1158, label %1159, label %1147
1159: ; preds = %1144, %1147, %462
tail call void @free(i8* %380)
tail call void @free(i8* %121)
%1160 = tail call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %119, i32 %12)
%1161 = tail call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %15, i32 %12)
%1162 = tail call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %18, i32 %12)
ret i32 %463
}