int merge1(unsigned char *rmap, unsigned char *cmap, int N, int nt, int ny,
           int nx, int TR, float threshcolor) {
  int it, iy, ix, ir, jr, i, mini, minj, newtr, *npt, npttotal;
  float *currentJ, *mergeJ, mindist, **distnpt, **distcolor, **distJ, **unused,
      **P;
  int loc, loc1, l, datasize, imgsize, *convert, threshtr;
  unsigned char *rmap1, *rmap2;
  float oldoverallJ, overallJ;
  int debug = 0;
  if (threshcolor >= 0) {
    TR = merge(rmap, cmap, N, nt, ny, nx, TR, threshcolor, 0);
    return TR;
  }
  threshcolor = 0.5;
  threshtr = TR;
  imgsize = ny * nx;
  datasize = nt * imgsize;
  distnpt = (float **)fmatrix(TR + 1, TR + 1);
  distJ = (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++;
      }
    }
  }
  rmap1 = (unsigned char *)calloc(datasize, sizeof(unsigned char));
  currentJ = (float *)calloc(TR + 1, sizeof(float));
  mergeJ = (float *)calloc(2, sizeof(float));
  overallJ = gettotalJS(cmap, N, ny, nx, rmap, TR, currentJ, unused, 0);
  oldoverallJ = overallJ;
  if (debug)
    printf("%d %f\n", TR, overallJ);
  P = (float **)fmatrix(TR + 1, N);
  npt = (int *)calloc(TR + 1, sizeof(int));
  for (l = 0; l < datasize; l++) {
    P[rmap[l]][cmap[l]] += 1;
    npt[rmap[l]]++;
  }
  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) {
        for (l = 0; l < datasize; l++) {
          if (rmap[l] == ir || rmap[l] == jr)
            rmap1[l] = 1;
          else
            rmap1[l] = 0;
        }
        gettotalJS(cmap, N, ny, nx, rmap1, 1, mergeJ, unused, 0);
        distJ[ir][jr] =
            mergeJ[1] - (npt[ir] * currentJ[ir] + npt[jr] * currentJ[jr]) /
                            (npt[ir] + npt[jr]);
        distJ[jr][ir] = distJ[ir][jr];
        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;
        }
        if (debug > 1)
          printf("%d %d %f \n", ir, jr, distJ[ir][jr]);
      }
    }
  }
  convert = (int *)calloc(TR + 1, sizeof(int));
  for (i = 1; i <= TR; i++)
    convert[i] = i;
  newtr = TR;
  while (mindist < threshcolor) {
    if (debug > 1)
      printf("min %d %d %f %f %f\n", mini, minj, currentJ[mini], currentJ[minj],
             mindist);
    overallJ =
        overallJ -
        (npt[mini] * currentJ[mini] + npt[minj] * currentJ[minj]) / datasize;
    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;
    }
    currentJ[mini] =
        (npt[mini] * currentJ[mini] + npt[minj] * currentJ[minj]) / npttotal +
        distJ[mini][minj];
    npt[mini] = npttotal;
    overallJ = overallJ + npt[mini] * currentJ[mini] / datasize;
    if (debug)
      printf("%d %f %f\n", newtr - 1, mindist, overallJ);
    if (overallJ <= oldoverallJ) {
      oldoverallJ = overallJ;
      threshtr = newtr - 1;
    }
    for (i = 1; i <= TR; i++) {
      if (convert[i] == minj)
        convert[i] = mini;
    }
    for (ir = 1; ir <= newtr; ir++) {
      if (ir != mini && ir != minj) {
        if (distnpt[mini][ir] != 0.0 || distnpt[minj][ir] != 0.0) {
          for (l = 0; l < datasize; l++) {
            if (convert[rmap[l]] == mini || convert[rmap[l]] == ir)
              rmap1[l] = 1;
            else
              rmap1[l] = 0;
          }
          gettotalJS(cmap, N, ny, nx, rmap1, 1, mergeJ, unused, 0);
          distJ[mini][ir] = mergeJ[1] - (npt[mini] * currentJ[mini] +
                                         npt[ir] * currentJ[ir]) /
                                            (npt[mini] + npt[ir]);
          distJ[ir][mini] = distJ[mini][ir];
          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];
          if (debug > 1)
            printf("%d %d %f %f %f %f\n", mini, ir, distJ[mini][ir],
                   currentJ[mini], currentJ[ir], mergeJ[1]);
        }
      }
    }
    for (i = 1; i <= TR; i++) {
      if (convert[i] > minj)
        convert[i]--;
    }
    for (ir = minj + 1; ir <= newtr; ir++) {
      npt[ir - 1] = npt[ir];
      currentJ[ir - 1] = currentJ[ir];
      for (i = 0; i < N; i++)
        P[ir - 1][i] = P[ir][i];
    }
    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];
        distJ[ir][jr - 1] = distJ[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];
        distJ[ir - 1][jr] = distJ[ir][jr];
      }
    }
    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;
          }
        }
      }
    }
  }
  free(rmap1);
  free(currentJ);
  free(mergeJ);
  free(npt);
  free_fmatrix(P, TR + 1);
  free(convert);
  free_fmatrix(distnpt, TR + 1);
  free_fmatrix(distJ, TR + 1);
  free_fmatrix(distcolor, TR + 1);
  TR = merge(rmap, cmap, N, nt, ny, nx, TR, threshcolor, threshtr);
  return TR;
}


x86 assembly (clang, -O0):
<merge1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0xe4(%rbp)
movss  -0x2c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1209 <merge1+0x89>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    0x10(%rbp),%eax
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xor    %r10d,%r10d
mov    %eax,(%rsp)
movl   $0x0,0x8(%rsp)
mov    $0x1,%al
call   1070 <merge@plt>
mov    %eax,0x10(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    250a <merge1+0x138a>
movss  0x1def(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x20(%rbp),%eax
imul   -0xb4(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    0x10(%rbp),%edi
add    $0x1,%edi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1080 <fmatrix@plt>
cltq
mov    %rax,-0x80(%rbp)
mov    0x10(%rbp),%edi
add    $0x1,%edi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1080 <fmatrix@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    0x10(%rbp),%edi
add    $0x1,%edi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1080 <fmatrix@plt>
cltq
mov    %rax,-0x88(%rbp)
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13c7 <merge1+0x247>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13b4 <merge1+0x234>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13a1 <merge1+0x221>
mov    -0xa4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1384 <merge1+0x204>
mov    -0x10(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  0x1cb8(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d3 <merge1+0x153>
jmp    13a6 <merge1+0x226>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b1 <merge1+0x131>
jmp    13b9 <merge1+0x239>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    129e <merge1+0x11e>
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1501 <merge1+0x381>
mov    -0x28(%rbp),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14ee <merge1+0x36e>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14db <merge1+0x35b>
mov    -0xa4(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     14be <merge1+0x33e>
mov    -0x10(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  0x1b7e(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    140d <merge1+0x28d>
jmp    14e0 <merge1+0x360>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13fa <merge1+0x27a>
jmp    14f3 <merge1+0x373>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13d8 <merge1+0x258>
movslq -0xb0(%rbp),%rdi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,-0xd0(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x68(%rbp)
mov    $0x2,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    0x10(%rbp),%r9d
mov    -0x68(%rbp),%r10
mov    -0x98(%rbp),%rax
xor    %r11d,%r11d
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1090 <gettotalJS@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
cmpl   $0x0,-0xe4(%rbp)
je     15c4 <merge1+0x444>
mov    0x10(%rbp),%esi
movss  -0xe0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x1a4f(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0x10(%rbp),%edi
add    $0x1,%edi
mov    -0x1c(%rbp),%esi
mov    $0x0,%al
call   1080 <fmatrix@plt>
cltq
mov    %rax,-0xa0(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    167b <merge1+0x4fb>
mov    -0xa0(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  0x19c7(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    15fe <merge1+0x47e>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     16f0 <merge1+0x570>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16dd <merge1+0x55d>
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1695 <merge1+0x515>
jmp    16e2 <merge1+0x562>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1682 <merge1+0x502>
movss  0x190c(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    19e6 <merge1+0x866>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     19d3 <merge1+0x853>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1756 <merge1+0x5d6>
jp     1756 <merge1+0x5d6>
jmp    19c0 <merge1+0x840>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    17e4 <merge1+0x664>
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    -0x3c(%rbp),%eax
je     17a2 <merge1+0x622>
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    -0x40(%rbp),%eax
jne    17b9 <merge1+0x639>
mov    -0xd0(%rbp),%rax
movslq -0xac(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    17cb <merge1+0x64b>
mov    -0xd0(%rbp),%rax
movslq -0xac(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    17d0 <merge1+0x650>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1760 <merge1+0x5e0>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0xd0(%rbp),%r8
mov    -0x70(%rbp),%r10
mov    -0x98(%rbp),%rax
mov    $0x1,%r9d
xor    %r11d,%r11d
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1090 <gettotalJS@plt>
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x58(%rbp),%rcx
movslq -0x40(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cvtsi2ss %eax,%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0xa0(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x1c(%rbp),%edx
mov    $0x0,%al
call   10a0 <distance@plt>
cvtsi2ss %eax,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x74(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    197e <merge1+0x7fe>
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x1,-0xe4(%rbp)
jle    19bb <merge1+0x83b>
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x165f(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    19c0 <merge1+0x840>
jmp    19c5 <merge1+0x845>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1719 <merge1+0x599>
jmp    19d8 <merge1+0x858>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1704 <merge1+0x584>
mov    0x10(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0xc0(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1a32 <merge1+0x8b2>
mov    -0x44(%rbp),%edx
mov    -0xc0(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1a07 <merge1+0x887>
mov    0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
movss  -0x74(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    2449 <merge1+0x12c9>
cmpl   $0x1,-0xe4(%rbp)
jle    1a97 <merge1+0x917>
mov    -0x48(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x74(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0x158e(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
movss  -0xe0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
cvtsi2ssl -0xb0(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x58(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1ba4 <merge1+0xa24>
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b13 <merge1+0x993>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0xb0(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
cmpl   $0x0,-0xe4(%rbp)
je     1c8c <merge1+0xb0c>
mov    -0x50(%rbp),%esi
sub    $0x1,%esi
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xe0(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0x13ad(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movss  -0xe0(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     1cc1 <merge1+0xb41>
movss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc4(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1d0f <merge1+0xb8f>
mov    -0xc0(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x4c(%rbp),%eax
jne    1cfc <merge1+0xb7c>
mov    -0x48(%rbp),%edx
mov    -0xc0(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1d01 <merge1+0xb81>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1cc8 <merge1+0xb48>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     208e <merge1+0xf0e>
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     207b <merge1+0xefb>
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     207b <merge1+0xefb>
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d97 <merge1+0xc17>
jp     1d97 <merge1+0xc17>
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d97 <merge1+0xc17>
jp     1d97 <merge1+0xc17>
jmp    2076 <merge1+0xef6>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1e39 <merge1+0xcb9>
mov    -0xc0(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x48(%rbp),%eax
je     1df7 <merge1+0xc77>
mov    -0xc0(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    1e0e <merge1+0xc8e>
mov    -0xd0(%rbp),%rax
movslq -0xac(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    1e20 <merge1+0xca0>
mov    -0xd0(%rbp),%rax
movslq -0xac(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1e25 <merge1+0xca5>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1da1 <merge1+0xc21>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0xd0(%rbp),%r8
mov    -0x70(%rbp),%r10
mov    -0x98(%rbp),%rax
mov    $0x1,%r9d
xor    %r11d,%r11d
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1090 <gettotalJS@plt>
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cvtsi2ss %eax,%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x1c(%rbp),%edx
mov    $0x0,%al
call   10a0 <distance@plt>
cvtsi2ss %eax,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x1,-0xe4(%rbp)
jle    2071 <merge1+0xef1>
mov    -0x48(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x90(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xfd2(%rip),%rdi
mov    $0x4,%al
call   1040 <printf@plt>
jmp    2076 <merge1+0xef6>
jmp    207b <merge1+0xefb>
jmp    2080 <merge1+0xf00>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d16 <merge1+0xb96>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     20df <merge1+0xf5f>
mov    -0xc0(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x4c(%rbp),%eax
jle    20cc <merge1+0xf4c>
mov    -0xc0(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    20d1 <merge1+0xf51>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2095 <merge1+0xf15>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2197 <merge1+0x1017>
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2184 <merge1+0x1004>
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2135 <merge1+0xfb5>
jmp    2189 <merge1+0x1009>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    20e8 <merge1+0xf68>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2279 <merge1+0x10f9>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2266 <merge1+0x10e6>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    21b3 <merge1+0x1033>
jmp    226b <merge1+0x10eb>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    219e <merge1+0x101e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2360 <merge1+0x11e0>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     234d <merge1+0x11cd>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x90(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    2295 <merge1+0x1115>
jmp    2352 <merge1+0x11d2>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2282 <merge1+0x1102>
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
movss  0xc93(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    2444 <merge1+0x12c4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2431 <merge1+0x12b1>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    23ca <merge1+0x124a>
jp     23ca <merge1+0x124a>
jmp    241e <merge1+0x129e>
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x74(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    2419 <merge1+0x1299>
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    241e <merge1+0x129e>
jmp    2423 <merge1+0x12a3>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    2392 <merge1+0x1212>
jmp    2436 <merge1+0x12b6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    237d <merge1+0x11fd>
jmp    1a38 <merge1+0x8b8>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1050 <free_fmatrix@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1050 <free_fmatrix@plt>
mov    -0x90(%rbp),%rdi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1050 <free_fmatrix@plt>
mov    -0x88(%rbp),%rdi
mov    0x10(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1050 <free_fmatrix@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%r9d
mov    0x10(%rbp),%r10d
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0xc4(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x1,%al
call   1070 <merge@plt>
mov    %eax,0x10(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %r9d,%r13d
mov    %rdi,%r12
mov    0x200(%rsp),%eax
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jae    12a9 <merge1+0x139>
mov    %rsi,0x88(%rsp)
mov    %edx,0x34(%rsp)
mov    %r8d,0x24(%rsp)
imul   %ecx,%r8d
imul   %r13d,%r8d
mov    %r8d,0x20(%rsp)
lea    0x1(%rax),%ebx
xor    %r15d,%r15d
mov    %ebx,%edi
mov    %ebx,%esi
xor    %eax,%eax
mov    %ecx,0x7c(%rsp)
call   1070 <fmatrix@plt>
movslq %eax,%r14
mov    %ebx,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <fmatrix@plt>
mov    %eax,0x3c(%rsp)
mov    %ebx,%edi
mov    %ebx,0x40(%rsp)
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <fmatrix@plt>
mov    0x7c(%rsp),%r10d
mov    %eax,0x38(%rsp)
test   %r10d,%r10d
jle    1363 <merge1+0x1f3>
lea    -0x1(%r13),%eax
movss  0x1df4(%rip),%xmm0
xor    %ecx,%ecx
mov    0x24(%rsp),%r9d
jmp    1231 <merge1+0xc1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,%esi
add    $0x1,%r15d
mov    %esi,%ecx
cmp    %r10d,%r15d
je     12c3 <merge1+0x153>
test   %r9d,%r9d
jle    1220 <merge1+0xb0>
xor    %r8d,%r8d
jmp    1250 <merge1+0xe0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ecx
mov    %ecx,%esi
add    $0x1,%r8d
mov    %esi,%ecx
cmp    %r9d,%r8d
je     1222 <merge1+0xb2>
lea    0x1(%rcx),%esi
cmp    $0x2,%r13d
jl     1245 <merge1+0xd5>
movslq %esi,%rsi
add    %r12,%rsi
xor    %edi,%edi
jmp    127b <merge1+0x10b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ecx
add    $0x1,%rdi
cmp    %edi,%eax
je     1240 <merge1+0xd0>
movslq %ecx,%rbp
movzbl (%r12,%rbp,1),%ebx
movzbl (%rsi,%rdi,1),%ebp
cmp    %bpl,%bl
je     1270 <merge1+0x100>
mov    (%r14,%rbx,8),%rdx
movss  (%rdx,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rbp,4)
mov    (%r14,%rbp,8),%rdx
movss  %xmm1,(%rdx,%rbx,4)
jmp    1270 <merge1+0x100>
cvtss2sd %xmm0,%xmm0
mov    %eax,(%rsp)
movl   $0x0,0x8(%rsp)
mov    %r12,%rdi
mov    %r13d,%r9d
jmp    2aaa <merge1+0x193a>
test   %r10d,%r10d
jle    1363 <merge1+0x1f3>
movslq %r13d,%rax
mov    %r12,%r9
sub    %rax,%r9
mov    %r13d,%ecx
xor    %r8d,%r8d
xor    %r10d,%r10d
jmp    12eb <merge1+0x17b>
add    $0x1,%r8d
cmp    0x7c(%rsp),%r8d
je     1363 <merge1+0x1f3>
add    %r13d,%r10d
cmpl   $0x2,0x24(%rsp)
jl     12e0 <merge1+0x170>
mov    $0x1,%r11d
jmp    130e <merge1+0x19e>
nopl   (%rax)
add    %edx,%r10d
add    $0x1,%r11d
cmp    0x24(%rsp),%r11d
je     12e0 <merge1+0x170>
test   %r13d,%r13d
jle    1303 <merge1+0x193>
movslq %r10d,%rbp
lea    (%r9,%rbp,1),%rbx
add    %r12,%rbp
xor    %edx,%edx
jmp    1338 <merge1+0x1c8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %edx,%ecx
je     1300 <merge1+0x190>
movzbl (%rbx,%rdx,1),%eax
movzbl 0x0(%rbp,%rdx,1),%esi
cmp    %sil,%al
je     1330 <merge1+0x1c0>
mov    (%r14,%rax,8),%rdi
movss  (%rdi,%rsi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rsi,4)
mov    (%r14,%rsi,8),%rsi
movss  %xmm1,(%rsi,%rax,4)
jmp    1330 <merge1+0x1c0>
movslq 0x20(%rsp),%rdi
mov    %rdi,0x28(%rsp)
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,0x50(%rsp)
movslq 0x40(%rsp),%r15
mov    $0x4,%esi
mov    %r15,%rdi
call   1050 <calloc@plt>
mov    %rax,%rbx
mov    $0x2,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,0xf8(%rsp)
mov    %rbx,0xb0(%rsp)
mov    %rbx,(%rsp)
movl   $0x0,0x10(%rsp)
mov    0x88(%rsp),%rbp
mov    %rbp,%rdi
mov    0x34(%rsp),%ebx
mov    %ebx,%esi
mov    0x24(%rsp),%edx
mov    %r13,0x100(%rsp)
mov    %r13d,%ecx
mov    %r12,%r8
mov    0x200(%rsp),%r9d
xor    %eax,%eax
call   1080 <gettotalJS@plt>
mov    %eax,0x90(%rsp)
mov    0x40(%rsp),%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <fmatrix@plt>
cltq
mov    %rax,0x60(%rsp)
mov    $0x4,%esi
mov    %r15,0x48(%rsp)
mov    %r15,%rdi
call   1050 <calloc@plt>
mov    %rax,0x68(%rsp)
cmpl   $0x0,0x28(%rsp)
mov    %rbp,%r13
jle    14f3 <merge1+0x383>
mov    0x20(%rsp),%eax
mov    %eax,%r8d
cmp    $0x1,%eax
jne    143e <merge1+0x2ce>
xor    %eax,%eax
jmp    14b9 <merge1+0x349>
mov    %r8d,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
movss  0x1bb2(%rip),%xmm0
mov    0x60(%rsp),%rbp
mov    0x68(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rax,1),%esi
mov    0x0(%rbp,%rsi,8),%rsi
movzbl 0x0(%r13,%rax,1),%edi
movss  (%rsi,%rdi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movzbl (%r12,%rax,1),%esi
addl   $0x1,(%rcx,%rsi,4)
movzbl 0x1(%r12,%rax,1),%esi
mov    0x0(%rbp,%rsi,8),%rsi
movzbl 0x1(%r13,%rax,1),%edi
movss  (%rsi,%rdi,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movzbl 0x1(%r12,%rax,1),%esi
addl   $0x1,(%rcx,%rsi,4)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1460 <merge1+0x2f0>
test   $0x1,%r8b
je     14f3 <merge1+0x383>
movzbl (%r12,%rax,1),%ecx
mov    0x60(%rsp),%rdx
mov    (%rdx,%rcx,8),%rcx
movzbl 0x0(%r13,%rax,1),%edx
movss  (%rcx,%rdx,4),%xmm0
addss  0x1b20(%rip),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
movzbl (%r12,%rax,1),%eax
mov    0x68(%rsp),%rcx
addl   $0x1,(%rcx,%rax,4)
movslq 0x3c(%rsp),%rax
mov    %rax,0x98(%rsp)
movslq 0x38(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    0x200(%rsp),%r15d
test   %r15d,%r15d
mov    0x24(%rsp),%edx
jle    18d0 <merge1+0x760>
xorps  %xmm0,%xmm0
cvtsi2ssl 0x90(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x110(%rsp)
mov    0x40(%rsp),%ebx
mov    0x34(%rsp),%r13d
mov    %r13d,%ebp
mov    %ebp,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rax
mov    %rax,0x120(%rsp)
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%rax
mov    %r8,0xe0(%rsp)
and    $0xfffffffffffffffe,%r8
mov    $0x1,%eax
mov    0x60(%rsp),%r9
mov    0x68(%rsp),%r10
jmp    15ad <merge1+0x43d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rbx,%rax
je     166a <merge1+0x4fa>
test   %r13d,%r13d
jle    15a0 <merge1+0x430>
xorps  %xmm0,%xmm0
cvtsi2ssl (%r10,%rax,4),%xmm0
mov    (%r9,%rax,8),%rsi
cmp    $0x4,%r13d
jae    15d0 <merge1+0x460>
xor    %ecx,%ecx
jmp    1640 <merge1+0x4d0>
nopl   0x0(%rax)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x120(%rsp)
je     165c <merge1+0x4ec>
mov    %r8,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rdi,4),%xmm2
movups 0x10(%rsi,%rdi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rdi,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%rsi,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    15f0 <merge1+0x480>
testb  $0x1,0xe0(%rsp)
01
je     1627 <merge1+0x4b7>
movups (%rsi,%rdi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rdi,4)
mov    %r11,%rcx
cmp    %rbp,%r11
je     15a0 <merge1+0x430>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rsi,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1640 <merge1+0x4d0>
jmp    15a0 <merge1+0x430>
xor    %edi,%edi
testb  $0x1,0xe0(%rsp)
01
jne    161c <merge1+0x4ac>
jmp    1627 <merge1+0x4b7>
cmp    $0x2,%r15d
mov    %rbx,0x90(%rsp)
mov    %rbp,0xc8(%rsp)
jl     18f4 <merge1+0x784>
mov    %r15d,%eax
mov    %rax,0xa0(%rsp)
mov    0x20(%rsp),%r13d
mov    %r13,0x80(%rsp)
and    $0xfffffffe,%r13d
movss  0x195c(%rip),%xmm0
movss  %xmm0,0x28(%rsp)
mov    $0x2,%ebp
mov    $0x1,%r15d
mov    0x50(%rsp),%rsi
mov    %r12,0x1c0(%rsp)
jmp    16ef <merge1+0x57f>
nopl   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rbp
add    $0x1,%rbp
mov    0xa8(%rsp),%r15
cmp    0xa0(%rsp),%r15
je     1902 <merge1+0x792>
lea    0x1(%r15),%rax
mov    %rax,0xa8(%rsp)
mov    %rbp,0x70(%rsp)
jmp    183e <merge1+0x6ce>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%r12
mov    0xf8(%rsp),%r14
mov    %r14,(%rsp)
movl   $0x0,0x10(%rsp)
mov    0x88(%rsp),%rdi
mov    0x34(%rsp),%ebx
mov    %ebx,%esi
mov    0x100(%rsp),%rcx
mov    0x50(%rsp),%r8
mov    $0x1,%r9d
xor    %eax,%eax
call   1080 <gettotalJS@plt>
mov    0x68(%rsp),%rcx
mov    (%rcx,%r15,4),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%rcx,%rbp,4),%ecx
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
mov    0xb0(%rsp),%rdx
mulss  (%rdx,%rbp,4),%xmm1
movss  0x4(%r14),%xmm2
mov    %r12,%r14
mov    0x1c0(%rsp),%r12
mulss  (%rdx,%r15,4),%xmm0
addss  %xmm1,%xmm0
add    %eax,%ecx
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
subss  %xmm0,%xmm2
mov    0x98(%rsp),%rcx
mov    (%rcx,%r15,8),%rax
movss  %xmm2,(%rax,%rbp,4)
mov    (%rcx,%rbp,8),%rax
movss  %xmm2,(%rax,%r15,4)
mov    0x60(%rsp),%rax
mov    (%rax,%r15,8),%rdi
mov    (%rax,%rbp,8),%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <distance@plt>
mov    0x50(%rsp),%rsi
mov    0x24(%rsp),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0xb8(%rsp),%rcx
mov    (%rcx,%r15,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    (%rcx,%rbp,8),%rcx
movss  %xmm0,(%rcx,%r15,4)
movss  (%rax,%rbp,4),%xmm0
movss  0x28(%rsp),%xmm1
ucomiss %xmm0,%xmm1
mov    0x38(%rsp),%eax
cmova  %ebp,%eax
mov    %eax,0x38(%rsp)
minss  %xmm1,%xmm0
mov    0x3c(%rsp),%ecx
cmova  %r15d,%ecx
movss  %xmm0,0x28(%rsp)
mov    0x90(%rsp),%rbx
add    $0x1,%rbp
cmp    %rbx,%rbp
je     16d0 <merge1+0x560>
mov    (%r14,%r15,8),%rax
movss  (%rax,%rbp,4),%xmm0
ucomiss 0x17be(%rip),%xmm0
jne    1852 <merge1+0x6e2>
jnp    1831 <merge1+0x6c1>
mov    %ecx,0x3c(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    1710 <merge1+0x5a0>
cmpl   $0x1,0x20(%rsp)
jne    186c <merge1+0x6fc>
xor    %eax,%eax
jmp    18a7 <merge1+0x737>
xor    %eax,%eax
xchg   %ax,%ax
movzbl (%r12,%rax,1),%ecx
cmp    %rcx,%r15
sete   %bl
cmp    %rcx,%rbp
sete   %cl
or     %bl,%cl
mov    %cl,(%rsi,%rax,1)
movzbl 0x1(%r12,%rax,1),%ecx
cmp    %rcx,%r15
sete   %bl
cmp    %rcx,%rbp
sete   %cl
or     %bl,%cl
mov    %cl,0x1(%rsi,%rax,1)
add    $0x2,%rax
cmp    %rax,%r13
jne    1870 <merge1+0x700>
testb  $0x1,0x80(%rsp)
01
je     1710 <merge1+0x5a0>
movzbl (%r12,%rax,1),%ecx
cmp    %rcx,%r15
sete   %bl
cmp    %rcx,%rbp
sete   %cl
or     %bl,%cl
mov    %cl,(%rsi,%rax,1)
jmp    1710 <merge1+0x5a0>
mov    $0x4,%esi
mov    0x48(%rsp),%rdi
call   1050 <calloc@plt>
mov    %rax,%rbx
mov    %r15d,%eax
mov    %r15d,0x44(%rsp)
mov    0x50(%rsp),%rdi
jmp    2a0a <merge1+0x189a>
movss  0x1708(%rip),%xmm0
movss  %xmm0,0x28(%rsp)
mov    $0x4,%esi
mov    0x48(%rsp),%rdi
mov    %ecx,%ebp
call   1050 <calloc@plt>
mov    %ebp,%r11d
mov    0x90(%rsp),%rcx
mov    0x50(%rsp),%rdi
mov    %rax,%rsi
mov    0x200(%rsp),%r15d
mov    %r15,%r9
test   %r15d,%r15d
mov    0x88(%rsp),%r13
mov    %rax,0x48(%rsp)
mov    %rcx,%rbp
jle    1acc <merge1+0x95c>
lea    -0x1(%rcx),%r8
mov    $0x1,%eax
cmp    $0x8,%r8
jb     1ab9 <merge1+0x949>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1992 <merge1+0x822>
movdqa 0x168a(%rip),%xmm0
xor    %esi,%esi
mov    0x48(%rsp),%rbx
jmp    1a69 <merge1+0x8f9>
and    $0xfffffffffffffffc,%rdx
movdqa 0x1672(%rip),%xmm0
xor    %esi,%esi
movdqa 0x1677(%rip),%xmm8
movdqa 0x167e(%rip),%xmm9
movdqa 0x1685(%rip),%xmm10
movdqa 0x168d(%rip),%xmm4
movdqa 0x1695(%rip),%xmm5
movdqa 0x169d(%rip),%xmm6
movdqa 0x16a5(%rip),%xmm7
movdqa 0x16ad(%rip),%xmm1
mov    0x48(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x4(%rbx,%rsi,4)
movdqu %xmm2,0x14(%rbx,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x24(%rbx,%rsi,4)
movdqu %xmm3,0x34(%rbx,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x44(%rbx,%rsi,4)
movdqu %xmm3,0x54(%rbx,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x64(%rbx,%rsi,4)
movdqu %xmm3,0x74(%rbx,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    19f0 <merge1+0x880>
test   %rcx,%rcx
je     1aad <merge1+0x93d>
movdqa 0x15aa(%rip),%xmm1
movdqa 0x15b2(%rip),%xmm2
xchg   %ax,%ax
lea    0x0(,%rsi,4),%rdx
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
or     $0x4,%rdx
movdqu %xmm0,(%rbx,%rdx,1)
movdqu %xmm3,0x10(%rbx,%rdx,1)
add    $0x8,%rsi
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rcx
jne    1a80 <merge1+0x910>
cmp    %rax,%r8
mov    %rbx,%rsi
je     1acc <merge1+0x95c>
or     $0x1,%rax
mov    %rbp,%rcx
nopl   0x0(%rax)
mov    %eax,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1ac0 <merge1+0x950>
movss  0x1534(%rip),%xmm0
ucomiss 0x28(%rsp),%xmm0
jbe    29ce <merge1+0x185e>
mov    0x20(%rsp),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  %xmm0,0x10c(%rsp)
mov    %r9,%r8
movslq %r8d,%r15
mov    %ecx,%r9d
lea    0x1(%r15),%rcx
mov    %rcx,0x178(%rsp)
mov    %rbp,%r13
lea    -0x1(%rbp),%rax
mov    0xc8(%rsp),%rcx
mov    %ecx,%edx
and    $0xfffffff8,%edx
mov    %rdx,0x1a0(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x198(%rsp)
mov    %rdx,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ecx,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x168(%rsp)
mov    0xe0(%rsp),%rdx
and    %rdx,0x110(%rsp)
mov    %rcx,%rdx
neg    %rdx
mov    %rdx,0x170(%rsp)
mov    %rax,0xd0(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %r9,0x1b0(%rsp)
and    $0xfffffffe,%r9d
mov    %r9,0x1b8(%rsp)
mov    %ebx,%edx
and    $0x3,%edx
and    $0xfffffffffffffffc,%rbx
mov    %rbx,0x180(%rsp)
and    $0x3,%ecx
mov    %rdx,0x190(%rsp)
shl    $0x5,%rdx
pxor   %xmm4,%xmm4
movaps 0x130(%rsp),%xmm0
movaps %xmm0,0x140(%rsp)
mov    %rax,0x80(%rsp)
add    $0x1,%rax
mov    %rax,0x118(%rsp)
xor    %eax,%eax
mov    %rax,0x128(%rsp)
mov    0x40(%rsp),%eax
mov    %eax,0xc4(%rsp)
mov    %r8d,%eax
mov    %r8d,0x44(%rsp)
mov    %rcx,0xa0(%rsp)
mov    %rdx,0x188(%rsp)
jmp    1c41 <merge1+0xad1>
nopl   (%rax)
addl   $0xffffffff,0xc4(%rsp)
ff
addq   $0x1,0x128(%rsp)
movss  0x13ef(%rip),%xmm1
ucomiss %xmm0,%xmm1
mov    0xe8(%rsp),%r15
mov    0x50(%rsp),%rdi
mov    0x90(%rsp),%r13
mov    0x3c(%rsp),%r11d
mov    0x48(%rsp),%rsi
jbe    29f7 <merge1+0x1887>
movslq %r11d,%rbp
mov    0x68(%rsp),%r8
mov    (%r8,%rbp,4),%eax
mov    0x38(%rsp),%r10d
movslq %r10d,%rbx
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%r8,%rbx,4),%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
lea    -0x1(%r15),%rdx
mov    %rdx,0xe8(%rsp)
add    %eax,%ecx
mov    0xb0(%rsp),%r9
movss  (%r9,%rbx,4),%xmm3
mulss  %xmm2,%xmm3
movss  (%r9,%rbp,4),%xmm8
mulss  %xmm0,%xmm8
addss  %xmm3,%xmm8
mov    0x34(%rsp),%edx
test   %edx,%edx
mov    %rbx,0x28(%rsp)
mov    %rbp,0xd8(%rsp)
mov    %ecx,0x5c(%rsp)
jle    1ce0 <merge1+0xb70>
mov    %ecx,%esi
mov    0x60(%rsp),%rcx
mov    (%rcx,%rbp,8),%rax
mov    (%rcx,%rbx,8),%rcx
cvtsi2ss %esi,%xmm5
cmp    $0x4,%edx
jae    1cf0 <merge1+0xb80>
xor    %esi,%esi
mov    0xc8(%rsp),%rbx
jmp    1dd0 <merge1+0xc60>
nopw   0x0(%rax,%rax,1)
cvtsi2ss %ecx,%xmm5
movaps %xmm8,%xmm0
jmp    1e80 <merge1+0xd10>
nopl   (%rax)
mov    0xc8(%rsp),%rbx
lea    (%rcx,%rbx,4),%rdx
cmp    %rdx,%rax
jae    1d11 <merge1+0xba1>
lea    (%rax,%rbx,4),%rdx
cmp    %rdx,%rcx
jae    1d11 <merge1+0xba1>
xor    %esi,%esi
jmp    1dd0 <merge1+0xc60>
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
movaps %xmm0,%xmm10
shufps $0x0,%xmm0,%xmm10
movaps %xmm5,%xmm9
shufps $0x0,%xmm5,%xmm9
cmpq   $0x0,0x120(%rsp)
je     29b9 <merge1+0x1849>
mov    0x110(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rcx,%rdx,4),%xmm6
mulps  %xmm3,%xmm6
movups (%rax,%rdx,4),%xmm7
movups 0x10(%rax,%rdx,4),%xmm1
mulps  %xmm10,%xmm7
addps  %xmm6,%xmm7
divps  %xmm9,%xmm7
movups %xmm7,(%rax,%rdx,4)
movups 0x10(%rcx,%rdx,4),%xmm6
mulps  %xmm3,%xmm6
mulps  %xmm10,%xmm1
addps  %xmm6,%xmm1
divps  %xmm9,%xmm1
movups %xmm1,0x10(%rax,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1d50 <merge1+0xbe0>
testb  $0x1,0xe0(%rsp)
01
je     1db5 <merge1+0xc45>
movups (%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm6
mulps  %xmm3,%xmm6
mulps  %xmm10,%xmm1
addps  %xmm6,%xmm1
divps  %xmm9,%xmm1
movups %xmm1,(%rax,%rdx,4)
mov    0x168(%rsp),%rdx
mov    %rdx,%rsi
cmp    %rbx,%rdx
je     1e5a <merge1+0xcea>
nopl   0x0(%rax)
mov    %rsi,%rdx
test   $0x1,%bl
je     1dfe <merge1+0xc8e>
movss  (%rcx,%rsi,4),%xmm1
mulss  %xmm2,%xmm1
movss  (%rax,%rsi,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
divss  %xmm5,%xmm3
movss  %xmm3,(%rax,%rsi,4)
mov    %rsi,%rdx
or     $0x1,%rdx
not    %rsi
cmp    0x170(%rsp),%rsi
je     1e5a <merge1+0xcea>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm1
movss  (%rax,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
divss  %xmm5,%xmm3
movss  %xmm3,(%rax,%rdx,4)
movss  0x4(%rcx,%rdx,4),%xmm1
mulss  %xmm2,%xmm1
movss  0x4(%rax,%rdx,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
divss  %xmm5,%xmm3
movss  %xmm3,0x4(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    1e10 <merge1+0xca0>
mov    0x28(%rsp),%rbx
mulss  (%r9,%rbx,4),%xmm2
mov    0xd8(%rsp),%rbp
mulss  (%r9,%rbp,4),%xmm0
addss  %xmm2,%xmm0
mov    0x48(%rsp),%rsi
mov    0x5c(%rsp),%ecx
movss  0x10c(%rsp),%xmm3
divss  %xmm3,%xmm8
movaps 0x130(%rsp),%xmm1
divss  %xmm5,%xmm0
mov    0x98(%rsp),%rax
mov    (%rax,%rbp,8),%rax
addss  (%rax,%rbx,4),%xmm0
subss  %xmm8,%xmm1
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
divss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movaps %xmm2,0x130(%rsp)
movaps 0x140(%rsp),%xmm1
ucomiss %xmm2,%xmm1
mov    0x44(%rsp),%edx
cmovae 0xe8(%rsp),%edx
movss  %xmm0,(%r9,%rbp,4)
mov    %ecx,(%r8,%rbp,4)
mov    0x200(%rsp),%eax
test   %eax,%eax
jle    1ff0 <merge1+0xe80>
mov    $0x1,%eax
cmpq   $0x8,0xd0(%rsp)
jb     2049 <merge1+0xed9>
movd   %r10d,%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %eax,%eax
jmp    1f32 <merge1+0xdc2>
nopl   0x0(%rax)
add    $0x8,%rax
cmp    %rax,0x80(%rsp)
je     1fd0 <merge1+0xe60>
movdqu 0x4(%rsi,%rax,4),%xmm1
pcmpeqd %xmm0,%xmm1
movd   %xmm1,%ecx
test   $0x1,%cl
je     1f4a <merge1+0xdda>
mov    %r11d,0x4(%rsi,%rax,4)
pextrw $0x2,%xmm1,%ecx
test   $0x1,%cl
je     1f59 <merge1+0xde9>
mov    %r11d,0x8(%rsi,%rax,4)
pextrw $0x4,%xmm1,%ecx
test   $0x1,%cl
je     1f68 <merge1+0xdf8>
mov    %r11d,0xc(%rsi,%rax,4)
pextrw $0x6,%xmm1,%ecx
test   $0x1,%cl
je     1f77 <merge1+0xe07>
mov    %r11d,0x10(%rsi,%rax,4)
movdqu 0x14(%rsi,%rax,4),%xmm1
pcmpeqd %xmm0,%xmm1
movd   %xmm1,%ecx
test   $0x1,%cl
je     1f8f <merge1+0xe1f>
mov    %r11d,0x14(%rsi,%rax,4)
pextrw $0x2,%xmm1,%ecx
test   $0x1,%cl
je     1f9e <merge1+0xe2e>
mov    %r11d,0x18(%rsi,%rax,4)
pextrw $0x4,%xmm1,%ecx
test   $0x1,%cl
je     1fad <merge1+0xe3d>
mov    %r11d,0x1c(%rsi,%rax,4)
pextrw $0x6,%xmm1,%ecx
test   $0x1,%cl
je     1f20 <merge1+0xdb0>
mov    %r11d,0x20(%rsi,%rax,4)
jmp    1f20 <merge1+0xdb0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x118(%rsp),%rax
mov    0x80(%rsp),%rcx
cmp    %rcx,0xd0(%rsp)
jne    2049 <merge1+0xed9>
nopw   0x0(%rax,%rax,1)
mov    %r13,%r9
mov    %edx,0x44(%rsp)
mov    0xc4(%rsp),%ebx
test   %r15,%r15
mov    %r11d,0x3c(%rsp)
mov    0x28(%rsp),%rdx
mov    %rbx,0xa8(%rsp)
jle    2260 <merge1+0x10f0>
mov    0x38(%rsp),%eax
mov    %rax,0x70(%rsp)
mov    %r11d,%ecx
mov    $0x1,%r13d
movaps %xmm5,0x150(%rsp)
mov    %rcx,0xf0(%rsp)
jmp    219e <merge1+0x102e>
add    $0x1,%rax
cmp    %rax,%r13
je     1ff0 <merge1+0xe80>
cmp    %r10d,(%rsi,%rax,4)
jne    2040 <merge1+0xed0>
mov    %r11d,(%rsi,%rax,4)
jmp    2040 <merge1+0xed0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xf8(%rsp),%rbp
mov    %rbp,(%rsp)
movl   $0x0,0x10(%rsp)
mov    0x88(%rsp),%rdi
mov    0x34(%rsp),%ebx
mov    %ebx,%esi
mov    0x100(%rsp),%rcx
mov    0x50(%rsp),%r8
mov    $0x1,%r9d
xor    %eax,%eax
call   1080 <gettotalJS@plt>
mov    0x68(%rsp),%rax
mov    (%rax,%r13,4),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0xb0(%rsp),%rcx
mulss  (%rcx,%r13,4),%xmm0
movss  0x4(%rbp),%xmm1
mov    0xd8(%rsp),%rbp
movss  (%rcx,%rbp,4),%xmm2
mulss  0x150(%rsp),%xmm2
addss  %xmm0,%xmm2
add    0x5c(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm2
subss  %xmm2,%xmm1
mov    0x98(%rsp),%rcx
mov    (%rcx,%rbp,8),%rax
movss  %xmm1,(%rax,%r13,4)
mov    (%rcx,%r13,8),%rax
movss  %xmm1,(%rax,%rbp,4)
mov    0x60(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
mov    (%rax,%r13,8),%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <distance@plt>
mov    0x48(%rsp),%rsi
mov    0x3c(%rsp),%r11d
mov    0x50(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0xb8(%rsp),%rcx
mov    (%rcx,%rbp,8),%rax
movss  %xmm0,(%rax,%r13,4)
mov    (%rcx,%r13,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    (%r14,%rbp,8),%rax
movss  (%rax,%r13,4),%xmm0
mov    0x28(%rsp),%rdx
mov    (%r14,%rdx,8),%rcx
addss  (%rcx,%r13,4),%xmm0
movss  %xmm0,(%rax,%r13,4)
mov    (%r14,%r13,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    0x90(%rsp),%r9
xorps  %xmm4,%xmm4
mov    0xa8(%rsp),%rbx
mov    0xf0(%rsp),%rcx
add    $0x1,%r13
cmp    %rbx,%r13
je     2260 <merge1+0x10f0>
cmp    %rcx,%r13
je     2191 <merge1+0x1021>
cmp    0x70(%rsp),%r13
je     2191 <merge1+0x1021>
mov    (%r14,%rbp,8),%rax
movss  (%rax,%r13,4),%xmm0
ucomiss %xmm4,%xmm0
jne    21cc <merge1+0x105c>
jp     21cc <merge1+0x105c>
mov    (%r14,%rdx,8),%rax
movss  (%rax,%r13,4),%xmm0
ucomiss %xmm4,%xmm0
jne    21cc <merge1+0x105c>
jnp    2191 <merge1+0x1021>
cmpl   $0x0,0x20(%rsp)
mov    0x24(%rsp),%edx
mov    0x1b8(%rsp),%rbp
jle    2060 <merge1+0xef0>
cmpl   $0x1,0x20(%rsp)
jne    21ee <merge1+0x107e>
xor    %eax,%eax
jmp    222d <merge1+0x10bd>
xor    %eax,%eax
movzbl (%r12,%rax,1),%ecx
mov    (%rsi,%rcx,4),%ecx
cmp    %r11d,%ecx
sete   %bl
cmp    %rcx,%r13
sete   %cl
or     %bl,%cl
mov    %cl,(%rdi,%rax,1)
movzbl 0x1(%r12,%rax,1),%ecx
mov    (%rsi,%rcx,4),%ecx
cmp    %r11d,%ecx
sete   %bl
cmp    %rcx,%r13
sete   %cl
or     %bl,%cl
mov    %cl,0x1(%rdi,%rax,1)
add    $0x2,%rax
cmp    %rax,%rbp
jne    21f0 <merge1+0x1080>
testb  $0x1,0x1b0(%rsp)
01
je     2060 <merge1+0xef0>
movzbl (%r12,%rax,1),%ecx
mov    (%rsi,%rcx,4),%ecx
cmp    %r11d,%ecx
sete   %bl
cmp    %rcx,%r13
sete   %cl
or     %bl,%cl
mov    %cl,(%rdi,%rax,1)
jmp    2060 <merge1+0xef0>
nopl   0x0(%rax)
mov    0x200(%rsp),%eax
test   %eax,%eax
mov    0x34(%rsp),%r8d
mov    0xb0(%rsp),%r10
mov    0x60(%rsp),%r13
mov    0x68(%rsp),%r11
mov    0xc8(%rsp),%rbx
mov    0x38(%rsp),%edx
mov    0xa0(%rsp),%rbp
jle    23e0 <merge1+0x1270>
mov    $0x1,%eax
cmpq   $0x8,0xd0(%rsp)
jb     27ad <merge1+0x163d>
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %eax,%eax
jmp    22d2 <merge1+0x1162>
nopl   0x0(%rax,%rax,1)
add    $0x8,%rax
cmp    %rax,0x80(%rsp)
je     23c0 <merge1+0x1250>
movdqu 0x4(%rsi,%rax,4),%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
movd   %xmm2,%ecx
test   $0x1,%cl
je     22f4 <merge1+0x1184>
movd   %xmm1,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x4(%rsi,%rax,4)
pextrw $0x2,%xmm2,%ecx
test   $0x1,%cl
je     230e <merge1+0x119e>
pshufd $0x55,%xmm1,%xmm3
movd   %xmm3,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x8(%rsi,%rax,4)
pextrw $0x4,%xmm2,%ecx
test   $0x1,%cl
je     2328 <merge1+0x11b8>
pshufd $0xee,%xmm1,%xmm3
movd   %xmm3,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0xc(%rsi,%rax,4)
pextrw $0x6,%xmm2,%ecx
test   $0x1,%cl
je     2342 <merge1+0x11d2>
pshufd $0xff,%xmm1,%xmm1
movd   %xmm1,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x10(%rsi,%rax,4)
movdqu 0x14(%rsi,%rax,4),%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
movd   %xmm2,%ecx
test   $0x1,%cl
je     2364 <merge1+0x11f4>
movd   %xmm1,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x14(%rsi,%rax,4)
pextrw $0x2,%xmm2,%ecx
test   $0x1,%cl
je     237e <merge1+0x120e>
pshufd $0x55,%xmm1,%xmm3
movd   %xmm3,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x18(%rsi,%rax,4)
pextrw $0x4,%xmm2,%ecx
test   $0x1,%cl
je     2398 <merge1+0x1228>
pshufd $0xee,%xmm1,%xmm3
movd   %xmm3,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x1c(%rsi,%rax,4)
pextrw $0x6,%xmm2,%ecx
test   $0x1,%cl
je     22c0 <merge1+0x1150>
pshufd $0xff,%xmm1,%xmm1
movd   %xmm1,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x20(%rsi,%rax,4)
jmp    22c0 <merge1+0x1150>
nopl   0x0(%rax,%rax,1)
mov    0x118(%rsp),%rax
mov    0x80(%rsp),%rcx
cmp    %rcx,0xd0(%rsp)
jne    27ad <merge1+0x163d>
xchg   %ax,%ax
mov    %r15,%rdx
mov    0x28(%rsp),%rax
mov    %rax,%rcx
sub    %rax,%rdx
mov    %rdx,0x70(%rsp)
mov    %r13,%r9
jg     25e9 <merge1+0x1479>
test   %r15,%r15
mov    0x28(%rsp),%r10
mov    0xa8(%rsp),%r9
jle    27c0 <merge1+0x1650>
mov    0x178(%rsp),%rax
sub    0x128(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0x70(%rsp),%r11
and    $0xfffffffffffffff8,%r11
lea    (%r11,%r10,1),%rax
mov    %rax,0x1a8(%rsp)
mov    $0x1,%r13d
jmp    245d <merge1+0x12ed>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r9,%r13
je     27c0 <merge1+0x1650>
cmp    %r10,%r15
jle    2450 <merge1+0x12e0>
mov    (%r14,%r13,8),%rbp
mov    0xb8(%rsp),%rax
mov    (%rax,%r13,8),%rsi
mov    0x98(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    %r10,%rbx
cmpq   $0x8,0x70(%rsp)
jae    24c0 <merge1+0x1350>
nopl   0x0(%rax)
movss  0x4(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
movss  0x4(%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
movss  0x4(%rax,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
lea    0x1(%rbx),%rcx
mov    %rcx,%rbx
cmp    %r15,%rcx
jl     2490 <merge1+0x1320>
jmp    2450 <merge1+0x12e0>
lea    0x0(,%r10,4),%rcx
add    %rbp,%rcx
mov    0xf0(%rsp),%r8
lea    0x0(%rbp,%r8,4),%rdi
lea    (%rsi,%r10,4),%rbx
lea    (%rsi,%r8,4),%r9
mov    0x28(%rsp),%rdx
lea    (%rax,%rdx,4),%r10
lea    (%rax,%r8,4),%r8
cmp    %r9,%rcx
setb   0xd8(%rsp)
cmp    %rdi,%rbx
setb   0x5c(%rsp)
cmp    %r8,%rcx
setb   %dl
cmp    %rdi,%r10
setb   %dil
cmp    %r8,%rbx
setb   %cl
cmp    %r9,%r10
mov    0xa8(%rsp),%r9
mov    0x28(%rsp),%r10
setb   0x150(%rsp)
mov    %r10,%rbx
mov    0x5c(%rsp),%r8b
test   %r8b,0xd8(%rsp)
jne    2490 <merge1+0x1320>
mov    %r10,%rbx
and    %dil,%dl
jne    2490 <merge1+0x1320>
mov    %r10,%rbx
and    0x150(%rsp),%cl
jne    2490 <merge1+0x1320>
lea    (%rax,%r10,4),%rbx
add    $0x14,%rbx
lea    (%rsi,%r10,4),%rcx
add    $0x14,%rcx
lea    0x14(,%r10,4),%rdx
add    %rbp,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rdi,4),%xmm0
movups (%rdx,%rdi,4),%xmm1
movups %xmm0,-0x14(%rdx,%rdi,4)
movups %xmm1,-0x4(%rdx,%rdi,4)
movups -0x10(%rcx,%rdi,4),%xmm0
movups (%rcx,%rdi,4),%xmm1
movups %xmm0,-0x14(%rcx,%rdi,4)
movups %xmm1,-0x4(%rcx,%rdi,4)
movups -0x10(%rbx,%rdi,4),%xmm0
movups (%rbx,%rdi,4),%xmm1
movups %xmm0,-0x14(%rbx,%rdi,4)
movups %xmm1,-0x4(%rbx,%rdi,4)
add    $0x8,%rdi
cmp    %rdi,%r11
jne    2580 <merge1+0x1410>
mov    0x1a8(%rsp),%rbx
cmp    %r11,0x70(%rsp)
jne    2490 <merge1+0x1320>
jmp    2450 <merge1+0x12e0>
nopw   0x0(%rax,%rax,1)
cmp    %r15,%rcx
jge    23fc <merge1+0x128c>
mov    %rcx,%rax
add    $0x1,%rcx
mov    0x4(%r11,%rax,4),%edx
mov    %edx,(%r11,%rax,4)
movss  0x4(%r10,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
test   %r8d,%r8d
jle    25e0 <merge1+0x1470>
mov    (%r9,%rcx,8),%rdx
mov    (%r9,%rax,8),%rsi
cmp    $0x8,%r8d
jb     2633 <merge1+0x14c3>
lea    (%rdx,%rbx,4),%rax
cmp    %rax,%rsi
jae    26bc <merge1+0x154c>
lea    (%rsi,%rbx,4),%rax
cmp    %rax,%rdx
jae    26bc <merge1+0x154c>
xor    %eax,%eax
mov    %rax,%rdi
not    %rdi
add    %rbx,%rdi
test   %rbp,%rbp
je     2664 <merge1+0x14f4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
jne    2650 <merge1+0x14e0>
cmp    $0x3,%rdi
mov    0xa0(%rsp),%rbp
jb     25e0 <merge1+0x1470>
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
movss  0x8(%rdx,%rax,4),%xmm0
movss  %xmm0,0x8(%rsi,%rax,4)
movss  0xc(%rdx,%rax,4),%xmm0
movss  %xmm0,0xc(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbx
jne    2680 <merge1+0x1510>
jmp    25e0 <merge1+0x1470>
cmpq   $0x18,0x198(%rsp)
jae    26cb <merge1+0x155b>
xor    %eax,%eax
jmp    2738 <merge1+0x15c8>
mov    0x180(%rsp),%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdx,%rax,4),%xmm0
movups 0x50(%rdx,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdx,%rax,4),%xmm0
movups 0x70(%rdx,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdi
jne    26e0 <merge1+0x1570>
cmpq   $0x0,0x190(%rsp)
mov    0x188(%rsp),%r13
je     277b <merge1+0x160b>
lea    (%rsi,%rax,4),%rdi
add    $0x10,%rdi
lea    (%rdx,%rax,4),%rax
add    $0x10,%rax
xor    %ebp,%ebp
nopl   (%rax)
movups -0x10(%rax,%rbp,1),%xmm0
movups (%rax,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r13
jne    2760 <merge1+0x15f0>
mov    0x1a0(%rsp),%rdi
mov    %rdi,%rax
cmp    %rbx,%rdi
mov    0xa0(%rsp),%rbp
je     25e0 <merge1+0x1470>
jmp    2635 <merge1+0x14c5>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%r9
je     23e0 <merge1+0x1270>
mov    (%rsi,%rax,4),%ecx
cmp    %edx,%ecx
jle    27a0 <merge1+0x1630>
add    $0xffffffff,%ecx
mov    %ecx,(%rsi,%rax,4)
jmp    27a0 <merge1+0x1630>
nopl   0x0(%rax)
cmp    %r10,%r15
mov    0xb8(%rsp),%r11
jle    28d0 <merge1+0x1760>
mov    %r15d,%r9d
add    $0xffffffffffffffff,%r9
mov    %r9,0x28(%rsp)
and    $0xfffffffffffffffe,%r9
neg    %r9
jmp    27fc <merge1+0x168c>
cs nopw 0x0(%rax,%rax,1)
cmp    %r15,%r13
mov    %r13,%r10
jge    28d0 <merge1+0x1760>
lea    0x1(%r10),%r13
cmp    $0x2,%r15
jl     27f0 <merge1+0x1680>
mov    %r10,%rcx
mov    (%r14,%r13,8),%rdx
mov    (%r14,%r10,8),%rsi
mov    (%r11,%r13,8),%rdi
mov    (%r11,%r10,8),%rbp
mov    0x98(%rsp),%rax
mov    %r13,%r8
mov    (%rax,%r13,8),%r10
mov    (%rax,%rcx,8),%rbx
mov    $0x1,%ecx
cmp    $0x2,%r15d
je     2897 <merge1+0x1727>
mov    $0x1,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  (%r10,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x4(%rdi,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbp,%rcx,4)
movss  0x4(%r10,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
lea    (%r9,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x1,%rax
jne    2840 <merge1+0x16d0>
testb  $0x1,0x28(%rsp)
mov    %r8,%r13
je     27f0 <merge1+0x1680>
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  (%r10,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
jmp    27f0 <merge1+0x1680>
nopw   0x0(%rax,%rax,1)
cmp    $0x3,%r15
jl     29db <merge1+0x186b>
movaps 0x130(%rsp),%xmm2
movaps %xmm2,%xmm0
movaps 0x140(%rsp),%xmm3
cmpnless %xmm3,%xmm0
movaps %xmm0,%xmm1
andnps %xmm2,%xmm1
andps  %xmm3,%xmm0
orps   %xmm1,%xmm0
movaps %xmm0,0x140(%rsp)
mov    0xe8(%rsp),%r8d
mov    $0x2,%r10d
mov    $0x1,%r9d
movabs $0x300000000,%rsi
movss  0x6d8(%rip),%xmm0
jmp    294a <merge1+0x17da>
xchg   %ax,%ax
add    $0x1,%r10
movabs $0x100000000,%rax
add    %rax,%rsi
cmp    %r8,%r9
je     1c00 <merge1+0xa90>
mov    %r9,%rdi
add    $0x1,%r9
cmp    %r15,%r9
jge    2930 <merge1+0x17c0>
mov    (%r14,%rdi,8),%rbp
mov    %rsi,%rax
mov    %r10,%rcx
jmp    298d <merge1+0x181d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
mov    %rax,%rdx
sar    $0x20,%rdx
movabs $0x100000000,%rbx
add    %rbx,%rax
cmp    %r15,%rdx
jge    2930 <merge1+0x17c0>
movss  0x0(%rbp,%rcx,4),%xmm1
ucomiss %xmm4,%xmm1
jne    299a <merge1+0x182a>
jnp    2970 <merge1+0x1800>
mov    (%r11,%rdi,8),%rbx
movss  (%rbx,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
jbe    2970 <merge1+0x1800>
mov    %ecx,%edx
mov    %ecx,0x38(%rsp)
movaps %xmm1,%xmm0
mov    %edi,%edx
mov    %edi,0x3c(%rsp)
jmp    2970 <merge1+0x1800>
xor    %edx,%edx
testb  $0x1,0xe0(%rsp)
01
jne    1d9b <merge1+0xc2b>
jmp    1db5 <merge1+0xc45>
mov    %r9,%r15
mov    %r15d,%eax
mov    %r15d,0x44(%rsp)
jmp    2a07 <merge1+0x1897>
mov    0x88(%rsp),%r13
mov    0x200(%rsp),%r15d
mov    0x50(%rsp),%rdi
mov    0x48(%rsp),%rbx
jmp    2a0a <merge1+0x189a>
mov    0x88(%rsp),%r13
mov    0x200(%rsp),%r15d
mov    %rsi,%rbx
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    0xf8(%rsp),%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
mov    0x40(%rsp),%ebp
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <free_fmatrix@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <free_fmatrix@plt>
mov    0x98(%rsp),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <free_fmatrix@plt>
mov    0xb8(%rsp),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <free_fmatrix@plt>
mov    0x44(%rsp),%eax
mov    %eax,0x8(%rsp)
mov    %r15d,(%rsp)
movsd  0x611(%rip),%xmm0
mov    %r12,%rdi
mov    %r13,%rsi
mov    0x34(%rsp),%edx
mov    0x7c(%rsp),%ecx
mov    0x24(%rsp),%r8d
mov    0x100(%rsp),%r9
mov    $0x1,%al
call   1060 <merge@plt>
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [7 x i8] c"%d %f\0A\00"
@.str.1 = [11 x i8] c"%d %d %f \0A\00"
@.str.2 = [20 x i8] c"min %d %d %f %f %f\0A\00"
@.str.3 = [10 x i8] c"%d %f %f\0A\00"
@.str.4 = [19 x i8] c"%d %d %f %f %f %f\0A\00"
define i32 @merge1(i8* %0, i8* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, float %7) {
%9 = alloca i32
%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 float*
%30 = alloca float*
%31 = alloca float
%32 = alloca float**
%33 = alloca float**
%34 = alloca float**
%35 = alloca float**
%36 = alloca float**
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32*
%43 = alloca i32
%44 = alloca i8*
%45 = alloca i8*
%46 = alloca float
%47 = alloca float
%48 = 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 0, i32* %48
%49 = load float, float* %17
%50 = fcmp oge float %49, 0.000000e+00
br i1 %50, label %51, label %63
51: ; preds = %8
%52 = load i8*, i8** %10
%53 = load i8*, i8** %11
%54 = load i32, i32* %12
%55 = load i32, i32* %13
%56 = load i32, i32* %14
%57 = load i32, i32* %15
%58 = load i32, i32* %16
%59 = load float, float* %17
%60 = fpext float %59 to double
%61 = call i32 (i8*, i8*, i32, i32, i32, i32, i32, double, i32, ...) bitcast (i32 (...)* @merge to i32 (i8*, i8*, i32, i32, i32, i32, i32, double, i32, ...)*)(i8* %52, i8* %53, i32 %54, i32 %55, i32 %56, i32 %57, i32 %58, double %60, i32 0)
store i32 %61, i32* %16
%62 = load i32, i32* %16
store i32 %62, i32* %9
br label %1438
63: ; preds = %8
store float 5.000000e-01, float* %17
%64 = load i32, i32* %16
store i32 %64, i32* %43
%65 = load i32, i32* %14
%66 = load i32, i32* %15
%67 = mul nsw i32 %65, %66
store i32 %67, i32* %41
%68 = load i32, i32* %13
%69 = load i32, i32* %41
%70 = mul nsw i32 %68, %69
store i32 %70, i32* %40
%71 = load i32, i32* %16
%72 = add nsw i32 %71, 1
%73 = load i32, i32* %16
%74 = add nsw i32 %73, 1
%75 = call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %72, i32 %74)
%76 = sext i32 %75 to i64
%77 = inttoptr i64 %76 to float**
store float** %77, float*** %32
%78 = load i32, i32* %16
%79 = add nsw i32 %78, 1
%80 = load i32, i32* %16
%81 = add nsw i32 %80, 1
%82 = call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %79, i32 %81)
%83 = sext i32 %82 to i64
%84 = inttoptr i64 %83 to float**
store float** %84, float*** %34
%85 = load i32, i32* %16
%86 = add nsw i32 %85, 1
%87 = load i32, i32* %16
%88 = add nsw i32 %87, 1
%89 = call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %86, i32 %88)
%90 = sext i32 %89 to i64
%91 = inttoptr i64 %90 to float**
store float** %91, float*** %33
store i32 0, i32* %37
store i32 0, i32* %18
br label %92
92: ; preds = %175, %63
%93 = load i32, i32* %18
%94 = load i32, i32* %13
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %178
96: ; preds = %92
store i32 0, i32* %19
br label %97
97: ; preds = %171, %96
%98 = load i32, i32* %19
%99 = load i32, i32* %14
%100 = icmp slt i32 %98, %99
br i1 %100, label %101, label %174
101: ; preds = %97
%102 = load i32, i32* %37
%103 = add nsw i32 %102, 1
store i32 %103, i32* %37
store i32 1, i32* %20
br label %104
104: ; preds = %167, %101
%105 = load i32, i32* %20
%106 = load i32, i32* %15
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %170
108: ; preds = %104
%109 = load i32, i32* %37
%110 = sub nsw i32 %109, 1
store i32 %110, i32* %38
%111 = load i8*, i8** %10
%112 = load i32, i32* %38
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %111, i64 %113
%115 = load i8, i8* %114
%116 = zext i8 %115 to i32
%117 = load i8*, i8** %10
%118 = load i32, i32* %37
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %117, i64 %119
%121 = load i8, i8* %120
%122 = zext i8 %121 to i32
%123 = icmp ne i32 %116, %122
br i1 %123, label %124, label %164
124: ; preds = %108
%125 = load i8*, i8** %10
%126 = load i32, i32* %38
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %125, i64 %127
%129 = load i8, i8* %128
%130 = zext i8 %129 to i32
store i32 %130, i32* %21
%131 = load i8*, i8** %10
%132 = load i32, i32* %37
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %131, i64 %133
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
store i32 %136, i32* %22
%137 = load float**, float*** %32
%138 = load i32, i32* %21
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds float*, float** %137, i64 %139
%141 = load float*, float** %140
%142 = load i32, i32* %22
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %141, i64 %143
%145 = load float, float* %144
%146 = fadd float %145, 1.000000e+00
store float %146, float* %144
%147 = load float**, float*** %32
%148 = load i32, i32* %21
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float*, float** %147, i64 %149
%151 = load float*, float** %150
%152 = load i32, i32* %22
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %151, i64 %153
%155 = load float, float* %154
%156 = load float**, float*** %32
%157 = load i32, i32* %22
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float*, float** %156, i64 %158
%160 = load float*, float** %159
%161 = load i32, i32* %21
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %160, i64 %162
store float %155, float* %163
br label %164
164: ; preds = %124, %108
%165 = load i32, i32* %37
%166 = add nsw i32 %165, 1
store i32 %166, i32* %37
br label %167
167: ; preds = %164
%168 = load i32, i32* %20
%169 = add nsw i32 %168, 1
store i32 %169, i32* %20
br label %104
170: ; preds = %104
br label %171
171: ; preds = %170
%172 = load i32, i32* %19
%173 = add nsw i32 %172, 1
store i32 %173, i32* %19
br label %97
174: ; preds = %97
br label %175
175: ; preds = %174
%176 = load i32, i32* %18
%177 = add nsw i32 %176, 1
store i32 %177, i32* %18
br label %92
178: ; preds = %92
store i32 0, i32* %37
store i32 0, i32* %18
br label %179
179: ; preds = %264, %178
%180 = load i32, i32* %18
%181 = load i32, i32* %13
%182 = icmp slt i32 %180, %181
br i1 %182, label %183, label %267
183: ; preds = %179
%184 = load i32, i32* %15
%185 = load i32, i32* %37
%186 = add nsw i32 %185, %184
store i32 %186, i32* %37
store i32 1, i32* %19
br label %187
187: ; preds = %260, %183
%188 = load i32, i32* %19
%189 = load i32, i32* %14
%190 = icmp slt i32 %188, %189
br i1 %190, label %191, label %263
191: ; preds = %187
store i32 0, i32* %20
br label %192
192: ; preds = %256, %191
%193 = load i32, i32* %20
%194 = load i32, i32* %15
%195 = icmp slt i32 %193, %194
br i1 %195, label %196, label %259
196: ; preds = %192
%197 = load i32, i32* %37
%198 = load i32, i32* %15
%199 = sub nsw i32 %197, %198
store i32 %199, i32* %38
%200 = load i8*, i8** %10
%201 = load i32, i32* %38
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %200, i64 %202
%204 = load i8, i8* %203
%205 = zext i8 %204 to i32
%206 = load i8*, i8** %10
%207 = load i32, i32* %37
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i8, i8* %206, i64 %208
%210 = load i8, i8* %209
%211 = zext i8 %210 to i32
%212 = icmp ne i32 %205, %211
br i1 %212, label %213, label %253
213: ; preds = %196
%214 = load i8*, i8** %10
%215 = load i32, i32* %38
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i8, i8* %214, i64 %216
%218 = load i8, i8* %217
%219 = zext i8 %218 to i32
store i32 %219, i32* %21
%220 = load i8*, i8** %10
%221 = load i32, i32* %37
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %220, i64 %222
%224 = load i8, i8* %223
%225 = zext i8 %224 to i32
store i32 %225, i32* %22
%226 = load float**, float*** %32
%227 = load i32, i32* %21
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float*, float** %226, i64 %228
%230 = load float*, float** %229
%231 = load i32, i32* %22
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %230, i64 %232
%234 = load float, float* %233
%235 = fadd float %234, 1.000000e+00
store float %235, float* %233
%236 = load float**, float*** %32
%237 = load i32, i32* %21
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds float*, float** %236, i64 %238
%240 = load float*, float** %239
%241 = load i32, i32* %22
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float, float* %240, i64 %242
%244 = load float, float* %243
%245 = load float**, float*** %32
%246 = load i32, i32* %22
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float*, float** %245, i64 %247
%249 = load float*, float** %248
%250 = load i32, i32* %21
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds float, float* %249, i64 %251
store float %244, float* %252
br label %253
253: ; preds = %213, %196
%254 = load i32, i32* %37
%255 = add nsw i32 %254, 1
store i32 %255, i32* %37
br label %256
256: ; preds = %253
%257 = load i32, i32* %20
%258 = add nsw i32 %257, 1
store i32 %258, i32* %20
br label %192
259: ; preds = %192
br label %260
260: ; preds = %259
%261 = load i32, i32* %19
%262 = add nsw i32 %261, 1
store i32 %262, i32* %19
br label %187
263: ; preds = %187
br label %264
264: ; preds = %263
%265 = load i32, i32* %18
%266 = add nsw i32 %265, 1
store i32 %266, i32* %18
br label %179
267: ; preds = %179
%268 = load i32, i32* %40
%269 = sext i32 %268 to i64
%270 = call i8* @calloc(i64 %269, i64 1)
store i8* %270, i8** %44
%271 = load i32, i32* %16
%272 = add nsw i32 %271, 1
%273 = sext i32 %272 to i64
%274 = call i8* @calloc(i64 %273, i64 4)
%275 = bitcast i8* %274 to float*
store float* %275, float** %29
%276 = call i8* @calloc(i64 2, i64 4)
%277 = bitcast i8* %276 to float*
store float* %277, float** %30
%278 = load i8*, i8** %11
%279 = load i32, i32* %12
%280 = load i32, i32* %14
%281 = load i32, i32* %15
%282 = load i8*, i8** %10
%283 = load i32, i32* %16
%284 = load float*, float** %29
%285 = load float**, float*** %35
%286 = call i32 (i8*, i32, i32, i32, i8*, i32, float*, float**, i32, ...) bitcast (i32 (...)* @gettotalJS to i32 (i8*, i32, i32, i32, i8*, i32, float*, float**, i32, ...)*)(i8* %278, i32 %279, i32 %280, i32 %281, i8* %282, i32 %283, float* %284, float** %285, i32 0)
%287 = sitofp i32 %286 to float
store float %287, float* %47
%288 = load float, float* %47
store float %288, float* %46
%289 = load i32, i32* %48
%290 = icmp ne i32 %289, 0
br i1 %290, label %291, label %296
291: ; preds = %267
%292 = load i32, i32* %16
%293 = load float, float* %47
%294 = fpext float %293 to double
%295 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %292, double %294)
br label %296
296: ; preds = %291, %267
%297 = load i32, i32* %16
%298 = add nsw i32 %297, 1
%299 = load i32, i32* %12
%300 = call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %298, i32 %299)
%301 = sext i32 %300 to i64
%302 = inttoptr i64 %301 to float**
store float** %302, float*** %36
%303 = load i32, i32* %16
%304 = add nsw i32 %303, 1
%305 = sext i32 %304 to i64
%306 = call i8* @calloc(i64 %305, i64 4)
%307 = bitcast i8* %306 to i32*
store i32* %307, i32** %27
store i32 0, i32* %39
br label %308
308: ; preds = %341, %296
%309 = load i32, i32* %39
%310 = load i32, i32* %40
%311 = icmp slt i32 %309, %310
br i1 %311, label %312, label %344
312: ; preds = %308
%313 = load float**, float*** %36
%314 = load i8*, i8** %10
%315 = load i32, i32* %39
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i8, i8* %314, i64 %316
%318 = load i8, i8* %317
%319 = zext i8 %318 to i64
%320 = getelementptr inbounds float*, float** %313, i64 %319
%321 = load float*, float** %320
%322 = load i8*, i8** %11
%323 = load i32, i32* %39
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i8, i8* %322, i64 %324
%326 = load i8, i8* %325
%327 = zext i8 %326 to i64
%328 = getelementptr inbounds float, float* %321, i64 %327
%329 = load float, float* %328
%330 = fadd float %329, 1.000000e+00
store float %330, float* %328
%331 = load i32*, i32** %27
%332 = load i8*, i8** %10
%333 = load i32, i32* %39
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i8, i8* %332, i64 %334
%336 = load i8, i8* %335
%337 = zext i8 %336 to i64
%338 = getelementptr inbounds i32, i32* %331, i64 %337
%339 = load i32, i32* %338
%340 = add nsw i32 %339, 1
store i32 %340, i32* %338
br label %341
341: ; preds = %312
%342 = load i32, i32* %39
%343 = add nsw i32 %342, 1
store i32 %343, i32* %39
br label %308
344: ; preds = %308
store i32 1, i32* %21
br label %345
345: ; preds = %375, %344
%346 = load i32, i32* %21
%347 = load i32, i32* %16
%348 = icmp sle i32 %346, %347
br i1 %348, label %349, label %378
349: ; preds = %345
store i32 0, i32* %23
br label %350
350: ; preds = %371, %349
%351 = load i32, i32* %23
%352 = load i32, i32* %12
%353 = icmp slt i32 %351, %352
br i1 %353, label %354, label %374
354: ; preds = %350
%355 = load i32*, i32** %27
%356 = load i32, i32* %21
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i32, i32* %355, i64 %357
%359 = load i32, i32* %358
%360 = sitofp i32 %359 to float
%361 = load float**, float*** %36
%362 = load i32, i32* %21
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds float*, float** %361, i64 %363
%365 = load float*, float** %364
%366 = load i32, i32* %23
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds float, float* %365, i64 %367
%369 = load float, float* %368
%370 = fdiv float %369, %360
store float %370, float* %368
br label %371
371: ; preds = %354
%372 = load i32, i32* %23
%373 = add nsw i32 %372, 1
store i32 %373, i32* %23
br label %350
374: ; preds = %350
br label %375
375: ; preds = %374
%376 = load i32, i32* %21
%377 = add nsw i32 %376, 1
store i32 %377, i32* %21
br label %345
378: ; preds = %345
store float 1.000000e+04, float* %31
store i32 1, i32* %21
br label %379
379: ; preds = %589, %378
%380 = load i32, i32* %21
%381 = load i32, i32* %16
%382 = icmp slt i32 %380, %381
br i1 %382, label %383, label %592
383: ; preds = %379
%384 = load i32, i32* %21
%385 = add nsw i32 %384, 1
store i32 %385, i32* %22
br label %386
386: ; preds = %585, %383
%387 = load i32, i32* %22
%388 = load i32, i32* %16
%389 = icmp sle i32 %387, %388
br i1 %389, label %390, label %588
390: ; preds = %386
%391 = load float**, float*** %32
%392 = load i32, i32* %21
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds float*, float** %391, i64 %393
%395 = load float*, float** %394
%396 = load i32, i32* %22
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds float, float* %395, i64 %397
%399 = load float, float* %398
%400 = fpext float %399 to double
%401 = fcmp une double %400, 0.000000e+00
br i1 %401, label %402, label %584
402: ; preds = %390
store i32 0, i32* %39
br label %403
403: ; preds = %436, %402
%404 = load i32, i32* %39
%405 = load i32, i32* %40
%406 = icmp slt i32 %404, %405
br i1 %406, label %407, label %439
407: ; preds = %403
%408 = load i8*, i8** %10
%409 = load i32, i32* %39
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds i8, i8* %408, i64 %410
%412 = load i8, i8* %411
%413 = zext i8 %412 to i32
%414 = load i32, i32* %21
%415 = icmp eq i32 %413, %414
br i1 %415, label %425, label %416
416: ; preds = %407
%417 = load i8*, i8** %10
%418 = load i32, i32* %39
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds i8, i8* %417, i64 %419
%421 = load i8, i8* %420
%422 = zext i8 %421 to i32
%423 = load i32, i32* %22
%424 = icmp eq i32 %422, %423
br i1 %424, label %425, label %430
425: ; preds = %416, %407
%426 = load i8*, i8** %44
%427 = load i32, i32* %39
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds i8, i8* %426, i64 %428
store i8 1, i8* %429
br label %435
430: ; preds = %416
%431 = load i8*, i8** %44
%432 = load i32, i32* %39
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds i8, i8* %431, i64 %433
store i8 0, i8* %434
br label %435
435: ; preds = %430, %425
br label %436
436: ; preds = %435
%437 = load i32, i32* %39
%438 = add nsw i32 %437, 1
store i32 %438, i32* %39
br label %403
439: ; preds = %403
%440 = load i8*, i8** %11
%441 = load i32, i32* %12
%442 = load i32, i32* %14
%443 = load i32, i32* %15
%444 = load i8*, i8** %44
%445 = load float*, float** %30
%446 = load float**, float*** %35
%447 = call i32 (i8*, i32, i32, i32, i8*, i32, float*, float**, i32, ...) bitcast (i32 (...)* @gettotalJS to i32 (i8*, i32, i32, i32, i8*, i32, float*, float**, i32, ...)*)(i8* %440, i32 %441, i32 %442, i32 %443, i8* %444, i32 1, float* %445, float** %446, i32 0)
%448 = load float*, float** %30
%449 = getelementptr inbounds float, float* %448, i64 1
%450 = load float, float* %449
%451 = load i32*, i32** %27
%452 = load i32, i32* %21
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds i32, i32* %451, i64 %453
%455 = load i32, i32* %454
%456 = sitofp i32 %455 to float
%457 = load float*, float** %29
%458 = load i32, i32* %21
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float, float* %457, i64 %459
%461 = load float, float* %460
%462 = load i32*, i32** %27
%463 = load i32, i32* %22
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i32, i32* %462, i64 %464
%466 = load i32, i32* %465
%467 = sitofp i32 %466 to float
%468 = load float*, float** %29
%469 = load i32, i32* %22
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds float, float* %468, i64 %470
%472 = load float, float* %471
%473 = fmul float %467, %472
%474 = call float @llvm.fmuladd.f32(float %456, float %461, float %473)
%475 = load i32*, i32** %27
%476 = load i32, i32* %21
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds i32, i32* %475, i64 %477
%479 = load i32, i32* %478
%480 = load i32*, i32** %27
%481 = load i32, i32* %22
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds i32, i32* %480, i64 %482
%484 = load i32, i32* %483
%485 = add nsw i32 %479, %484
%486 = sitofp i32 %485 to float
%487 = fdiv float %474, %486
%488 = fsub float %450, %487
%489 = load float**, float*** %34
%490 = load i32, i32* %21
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds float*, float** %489, i64 %491
%493 = load float*, float** %492
%494 = load i32, i32* %22
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds float, float* %493, i64 %495
store float %488, float* %496
%497 = load float**, float*** %34
%498 = load i32, i32* %21
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds float*, float** %497, i64 %499
%501 = load float*, float** %500
%502 = load i32, i32* %22
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds float, float* %501, i64 %503
%505 = load float, float* %504
%506 = load float**, float*** %34
%507 = load i32, i32* %22
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float*, float** %506, i64 %508
%510 = load float*, float** %509
%511 = load i32, i32* %21
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds float, float* %510, i64 %512
store float %505, float* %513
%514 = load float**, float*** %36
%515 = load i32, i32* %21
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds float*, float** %514, i64 %516
%518 = load float*, float** %517
%519 = load float**, float*** %36
%520 = load i32, i32* %22
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds float*, float** %519, i64 %521
%523 = load float*, float** %522
%524 = load i32, i32* %12
%525 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @distance to i32 (float*, float*, i32, ...)*)(float* %518, float* %523, i32 %524)
%526 = sitofp i32 %525 to float
%527 = load float**, float*** %33
%528 = load i32, i32* %21
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds float*, float** %527, i64 %529
%531 = load float*, float** %530
%532 = load i32, i32* %22
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds float, float* %531, i64 %533
store float %526, float* %534
%535 = load float**, float*** %33
%536 = load i32, i32* %22
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds float*, float** %535, i64 %537
%539 = load float*, float** %538
%540 = load i32, i32* %21
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds float, float* %539, i64 %541
store float %526, float* %542
%543 = load float**, float*** %33
%544 = load i32, i32* %21
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds float*, float** %543, i64 %545
%547 = load float*, float** %546
%548 = load i32, i32* %22
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds float, float* %547, i64 %549
%551 = load float, float* %550
%552 = load float, float* %31
%553 = fcmp olt float %551, %552
br i1 %553, label %554, label %566
554: ; preds = %439
%555 = load float**, float*** %33
%556 = load i32, i32* %21
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds float*, float** %555, i64 %557
%559 = load float*, float** %558
%560 = load i32, i32* %22
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds float, float* %559, i64 %561
%563 = load float, float* %562
store float %563, float* %31
%564 = load i32, i32* %21
store i32 %564, i32* %24
%565 = load i32, i32* %22
store i32 %565, i32* %25
br label %566
566: ; preds = %554, %439
%567 = load i32, i32* %48
%568 = icmp sgt i32 %567, 1
br i1 %568, label %569, label %583
569: ; preds = %566
%570 = load i32, i32* %21
%571 = load i32, i32* %22
%572 = load float**, float*** %34
%573 = load i32, i32* %21
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds float*, float** %572, i64 %574
%576 = load float*, float** %575
%577 = load i32, i32* %22
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds float, float* %576, i64 %578
%580 = load float, float* %579
%581 = fpext float %580 to double
%582 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0), i32 %570, i32 %571, double %581)
br label %583
583: ; preds = %569, %566
br label %584
584: ; preds = %583, %390
br label %585
585: ; preds = %584
%586 = load i32, i32* %22
%587 = add nsw i32 %586, 1
store i32 %587, i32* %22
br label %386
588: ; preds = %386
br label %589
589: ; preds = %588
%590 = load i32, i32* %21
%591 = add nsw i32 %590, 1
store i32 %591, i32* %21
br label %379
592: ; preds = %379
%593 = load i32, i32* %16
%594 = add nsw i32 %593, 1
%595 = sext i32 %594 to i64
%596 = call i8* @calloc(i64 %595, i64 4)
%597 = bitcast i8* %596 to i32*
store i32* %597, i32** %42
store i32 1, i32* %23
br label %598
598: ; preds = %608, %592
%599 = load i32, i32* %23
%600 = load i32, i32* %16
%601 = icmp sle i32 %599, %600
br i1 %601, label %602, label %611
602: ; preds = %598
%603 = load i32, i32* %23
%604 = load i32*, i32** %42
%605 = load i32, i32* %23
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds i32, i32* %604, i64 %606
store i32 %603, i32* %607
br label %608
608: ; preds = %602
%609 = load i32, i32* %23
%610 = add nsw i32 %609, 1
store i32 %610, i32* %23
br label %598
611: ; preds = %598
%612 = load i32, i32* %16
store i32 %612, i32* %26
br label %613
613: ; preds = %1399, %611
%614 = load float, float* %31
%615 = load float, float* %17
%616 = fcmp olt float %614, %615
br i1 %616, label %617, label %1400
617: ; preds = %613
%618 = load i32, i32* %48
%619 = icmp sgt i32 %618, 1
br i1 %619, label %620, label %638
620: ; preds = %617
%621 = load i32, i32* %24
%622 = load i32, i32* %25
%623 = load float*, float** %29
%624 = load i32, i32* %24
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds float, float* %623, i64 %625
%627 = load float, float* %626
%628 = fpext float %627 to double
%629 = load float*, float** %29
%630 = load i32, i32* %25
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds float, float* %629, i64 %631
%633 = load float, float* %632
%634 = fpext float %633 to double
%635 = load float, float* %31
%636 = fpext float %635 to double
%637 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i32 %621, i32 %622, double %628, double %634, double %636)
br label %638
638: ; preds = %620, %617
%639 = load float, float* %47
%640 = load i32*, i32** %27
%641 = load i32, i32* %24
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds i32, i32* %640, i64 %642
%644 = load i32, i32* %643
%645 = sitofp i32 %644 to float
%646 = load float*, float** %29
%647 = load i32, i32* %24
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds float, float* %646, i64 %648
%650 = load float, float* %649
%651 = load i32*, i32** %27
%652 = load i32, i32* %25
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds i32, i32* %651, i64 %653
%655 = load i32, i32* %654
%656 = sitofp i32 %655 to float
%657 = load float*, float** %29
%658 = load i32, i32* %25
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds float, float* %657, i64 %659
%661 = load float, float* %660
%662 = fmul float %656, %661
%663 = call float @llvm.fmuladd.f32(float %645, float %650, float %662)
%664 = load i32, i32* %40
%665 = sitofp i32 %664 to float
%666 = fdiv float %663, %665
%667 = fsub float %639, %666
store float %667, float* %47
%668 = load i32*, i32** %27
%669 = load i32, i32* %24
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds i32, i32* %668, i64 %670
%672 = load i32, i32* %671
%673 = load i32*, i32** %27
%674 = load i32, i32* %25
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds i32, i32* %673, i64 %675
%677 = load i32, i32* %676
%678 = add nsw i32 %672, %677
store i32 %678, i32* %28
store i32 0, i32* %23
br label %679
679: ; preds = %727, %638
%680 = load i32, i32* %23
%681 = load i32, i32* %12
%682 = icmp slt i32 %680, %681
br i1 %682, label %683, label %730
683: ; preds = %679
%684 = load float**, float*** %36
%685 = load i32, i32* %24
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds float*, float** %684, i64 %686
%688 = load float*, float** %687
%689 = load i32, i32* %23
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds float, float* %688, i64 %690
%692 = load float, float* %691
%693 = load i32*, i32** %27
%694 = load i32, i32* %24
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds i32, i32* %693, i64 %695
%697 = load i32, i32* %696
%698 = sitofp i32 %697 to float
%699 = load float**, float*** %36
%700 = load i32, i32* %25
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds float*, float** %699, i64 %701
%703 = load float*, float** %702
%704 = load i32, i32* %23
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds float, float* %703, i64 %705
%707 = load float, float* %706
%708 = load i32*, i32** %27
%709 = load i32, i32* %25
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds i32, i32* %708, i64 %710
%712 = load i32, i32* %711
%713 = sitofp i32 %712 to float
%714 = fmul float %707, %713
%715 = call float @llvm.fmuladd.f32(float %692, float %698, float %714)
%716 = load i32, i32* %28
%717 = sitofp i32 %716 to float
%718 = fdiv float %715, %717
%719 = load float**, float*** %36
%720 = load i32, i32* %24
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds float*, float** %719, i64 %721
%723 = load float*, float** %722
%724 = load i32, i32* %23
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds float, float* %723, i64 %725
store float %718, float* %726
br label %727
727: ; preds = %683
%728 = load i32, i32* %23
%729 = add nsw i32 %728, 1
store i32 %729, i32* %23
br label %679
730: ; preds = %679
%731 = load i32*, i32** %27
%732 = load i32, i32* %24
%733 = sext i32 %732 to i64
%734 = getelementptr inbounds i32, i32* %731, i64 %733
%735 = load i32, i32* %734
%736 = sitofp i32 %735 to float
%737 = load float*, float** %29
%738 = load i32, i32* %24
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds float, float* %737, i64 %739
%741 = load float, float* %740
%742 = load i32*, i32** %27
%743 = load i32, i32* %25
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds i32, i32* %742, i64 %744
%746 = load i32, i32* %745
%747 = sitofp i32 %746 to float
%748 = load float*, float** %29
%749 = load i32, i32* %25
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds float, float* %748, i64 %750
%752 = load float, float* %751
%753 = fmul float %747, %752
%754 = call float @llvm.fmuladd.f32(float %736, float %741, float %753)
%755 = load i32, i32* %28
%756 = sitofp i32 %755 to float
%757 = fdiv float %754, %756
%758 = load float**, float*** %34
%759 = load i32, i32* %24
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds float*, float** %758, i64 %760
%762 = load float*, float** %761
%763 = load i32, i32* %25
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds float, float* %762, i64 %764
%766 = load float, float* %765
%767 = fadd float %757, %766
%768 = load float*, float** %29
%769 = load i32, i32* %24
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds float, float* %768, i64 %770
store float %767, float* %771
%772 = load i32, i32* %28
%773 = load i32*, i32** %27
%774 = load i32, i32* %24
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds i32, i32* %773, i64 %775
store i32 %772, i32* %776
%777 = load float, float* %47
%778 = load i32*, i32** %27
%779 = load i32, i32* %24
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds i32, i32* %778, i64 %780
%782 = load i32, i32* %781
%783 = sitofp i32 %782 to float
%784 = load float*, float** %29
%785 = load i32, i32* %24
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds float, float* %784, i64 %786
%788 = load float, float* %787
%789 = fmul float %783, %788
%790 = load i32, i32* %40
%791 = sitofp i32 %790 to float
%792 = fdiv float %789, %791
%793 = fadd float %777, %792
store float %793, float* %47
%794 = load i32, i32* %48
%795 = icmp ne i32 %794, 0
br i1 %795, label %796, label %804
796: ; preds = %730
%797 = load i32, i32* %26
%798 = sub nsw i32 %797, 1
%799 = load float, float* %31
%800 = fpext float %799 to double
%801 = load float, float* %47
%802 = fpext float %801 to double
%803 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), i32 %798, double %800, double %802)
br label %804
804: ; preds = %796, %730
%805 = load float, float* %47
%806 = load float, float* %46
%807 = fcmp ole float %805, %806
br i1 %807, label %808, label %812
808: ; preds = %804
%809 = load float, float* %47
store float %809, float* %46
%810 = load i32, i32* %26
%811 = sub nsw i32 %810, 1
store i32 %811, i32* %43
br label %812
812: ; preds = %808, %804
store i32 1, i32* %23
br label %813
813: ; preds = %832, %812
%814 = load i32, i32* %23
%815 = load i32, i32* %16
%816 = icmp sle i32 %814, %815
br i1 %816, label %817, label %835
817: ; preds = %813
%818 = load i32*, i32** %42
%819 = load i32, i32* %23
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds i32, i32* %818, i64 %820
%822 = load i32, i32* %821
%823 = load i32, i32* %25
%824 = icmp eq i32 %822, %823
br i1 %824, label %825, label %831
825: ; preds = %817
%826 = load i32, i32* %24
%827 = load i32*, i32** %42
%828 = load i32, i32* %23
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds i32, i32* %827, i64 %829
store i32 %826, i32* %830
br label %831
831: ; preds = %825, %817
br label %832
832: ; preds = %831
%833 = load i32, i32* %23
%834 = add nsw i32 %833, 1
store i32 %834, i32* %23
br label %813
835: ; preds = %813
store i32 1, i32* %21
br label %836
836: ; preds = %1107, %835
%837 = load i32, i32* %21
%838 = load i32, i32* %26
%839 = icmp sle i32 %837, %838
br i1 %839, label %840, label %1110
840: ; preds = %836
%841 = load i32, i32* %21
%842 = load i32, i32* %24
%843 = icmp ne i32 %841, %842
br i1 %843, label %844, label %1106
844: ; preds = %840
%845 = load i32, i32* %21
%846 = load i32, i32* %25
%847 = icmp ne i32 %845, %846
br i1 %847, label %848, label %1106
848: ; preds = %844
%849 = load float**, float*** %32
%850 = load i32, i32* %24
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds float*, float** %849, i64 %851
%853 = load float*, float** %852
%854 = load i32, i32* %21
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds float, float* %853, i64 %855
%857 = load float, float* %856
%858 = fpext float %857 to double
%859 = fcmp une double %858, 0.000000e+00
br i1 %859, label %872, label %860
860: ; preds = %848
%861 = load float**, float*** %32
%862 = load i32, i32* %25
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds float*, float** %861, i64 %863
%865 = load float*, float** %864
%866 = load i32, i32* %21
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds float, float* %865, i64 %867
%869 = load float, float* %868
%870 = fpext float %869 to double
%871 = fcmp une double %870, 0.000000e+00
br i1 %871, label %872, label %1105
872: ; preds = %860, %848
store i32 0, i32* %39
br label %873
873: ; preds = %912, %872
%874 = load i32, i32* %39
%875 = load i32, i32* %40
%876 = icmp slt i32 %874, %875
br i1 %876, label %877, label %915
877: ; preds = %873
%878 = load i32*, i32** %42
%879 = load i8*, i8** %10
%880 = load i32, i32* %39
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds i8, i8* %879, i64 %881
%883 = load i8, i8* %882
%884 = zext i8 %883 to i64
%885 = getelementptr inbounds i32, i32* %878, i64 %884
%886 = load i32, i32* %885
%887 = load i32, i32* %24
%888 = icmp eq i32 %886, %887
br i1 %888, label %901, label %889
889: ; preds = %877
%890 = load i32*, i32** %42
%891 = load i8*, i8** %10
%892 = load i32, i32* %39
%893 = sext i32 %892 to i64
%894 = getelementptr inbounds i8, i8* %891, i64 %893
%895 = load i8, i8* %894
%896 = zext i8 %895 to i64
%897 = getelementptr inbounds i32, i32* %890, i64 %896
%898 = load i32, i32* %897
%899 = load i32, i32* %21
%900 = icmp eq i32 %898, %899
br i1 %900, label %901, label %906
901: ; preds = %889, %877
%902 = load i8*, i8** %44
%903 = load i32, i32* %39
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds i8, i8* %902, i64 %904
store i8 1, i8* %905
br label %911
906: ; preds = %889
%907 = load i8*, i8** %44
%908 = load i32, i32* %39
%909 = sext i32 %908 to i64
%910 = getelementptr inbounds i8, i8* %907, i64 %909
store i8 0, i8* %910
br label %911
911: ; preds = %906, %901
br label %912
912: ; preds = %911
%913 = load i32, i32* %39
%914 = add nsw i32 %913, 1
store i32 %914, i32* %39
br label %873
915: ; preds = %873
%916 = load i8*, i8** %11
%917 = load i32, i32* %12
%918 = load i32, i32* %14
%919 = load i32, i32* %15
%920 = load i8*, i8** %44
%921 = load float*, float** %30
%922 = load float**, float*** %35
%923 = call i32 (i8*, i32, i32, i32, i8*, i32, float*, float**, i32, ...) bitcast (i32 (...)* @gettotalJS to i32 (i8*, i32, i32, i32, i8*, i32, float*, float**, i32, ...)*)(i8* %916, i32 %917, i32 %918, i32 %919, i8* %920, i32 1, float* %921, float** %922, i32 0)
%924 = load float*, float** %30
%925 = getelementptr inbounds float, float* %924, i64 1
%926 = load float, float* %925
%927 = load i32*, i32** %27
%928 = load i32, i32* %24
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds i32, i32* %927, i64 %929
%931 = load i32, i32* %930
%932 = sitofp i32 %931 to float
%933 = load float*, float** %29
%934 = load i32, i32* %24
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds float, float* %933, i64 %935
%937 = load float, float* %936
%938 = load i32*, i32** %27
%939 = load i32, i32* %21
%940 = sext i32 %939 to i64
%941 = getelementptr inbounds i32, i32* %938, i64 %940
%942 = load i32, i32* %941
%943 = sitofp i32 %942 to float
%944 = load float*, float** %29
%945 = load i32, i32* %21
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds float, float* %944, i64 %946
%948 = load float, float* %947
%949 = fmul float %943, %948
%950 = call float @llvm.fmuladd.f32(float %932, float %937, float %949)
%951 = load i32*, i32** %27
%952 = load i32, i32* %24
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds i32, i32* %951, i64 %953
%955 = load i32, i32* %954
%956 = load i32*, i32** %27
%957 = load i32, i32* %21
%958 = sext i32 %957 to i64
%959 = getelementptr inbounds i32, i32* %956, i64 %958
%960 = load i32, i32* %959
%961 = add nsw i32 %955, %960
%962 = sitofp i32 %961 to float
%963 = fdiv float %950, %962
%964 = fsub float %926, %963
%965 = load float**, float*** %34
%966 = load i32, i32* %24
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds float*, float** %965, i64 %967
%969 = load float*, float** %968
%970 = load i32, i32* %21
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds float, float* %969, i64 %971
store float %964, float* %972
%973 = load float**, float*** %34
%974 = load i32, i32* %24
%975 = sext i32 %974 to i64
%976 = getelementptr inbounds float*, float** %973, i64 %975
%977 = load float*, float** %976
%978 = load i32, i32* %21
%979 = sext i32 %978 to i64
%980 = getelementptr inbounds float, float* %977, i64 %979
%981 = load float, float* %980
%982 = load float**, float*** %34
%983 = load i32, i32* %21
%984 = sext i32 %983 to i64
%985 = getelementptr inbounds float*, float** %982, i64 %984
%986 = load float*, float** %985
%987 = load i32, i32* %24
%988 = sext i32 %987 to i64
%989 = getelementptr inbounds float, float* %986, i64 %988
store float %981, float* %989
%990 = load float**, float*** %36
%991 = load i32, i32* %24
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds float*, float** %990, i64 %992
%994 = load float*, float** %993
%995 = load float**, float*** %36
%996 = load i32, i32* %21
%997 = sext i32 %996 to i64
%998 = getelementptr inbounds float*, float** %995, i64 %997
%999 = load float*, float** %998
%1000 = load i32, i32* %12
%1001 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @distance to i32 (float*, float*, i32, ...)*)(float* %994, float* %999, i32 %1000)
%1002 = sitofp i32 %1001 to float
%1003 = load float**, float*** %33
%1004 = load i32, i32* %24
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds float*, float** %1003, i64 %1005
%1007 = load float*, float** %1006
%1008 = load i32, i32* %21
%1009 = sext i32 %1008 to i64
%1010 = getelementptr inbounds float, float* %1007, i64 %1009
store float %1002, float* %1010
%1011 = load float**, float*** %33
%1012 = load i32, i32* %24
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds float*, float** %1011, i64 %1013
%1015 = load float*, float** %1014
%1016 = load i32, i32* %21
%1017 = sext i32 %1016 to i64
%1018 = getelementptr inbounds float, float* %1015, i64 %1017
%1019 = load float, float* %1018
%1020 = load float**, float*** %33
%1021 = load i32, i32* %21
%1022 = sext i32 %1021 to i64
%1023 = getelementptr inbounds float*, float** %1020, i64 %1022
%1024 = load float*, float** %1023
%1025 = load i32, i32* %24
%1026 = sext i32 %1025 to i64
%1027 = getelementptr inbounds float, float* %1024, i64 %1026
store float %1019, float* %1027
%1028 = load float**, float*** %32
%1029 = load i32, i32* %24
%1030 = sext i32 %1029 to i64
%1031 = getelementptr inbounds float*, float** %1028, i64 %1030
%1032 = load float*, float** %1031
%1033 = load i32, i32* %21
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds float, float* %1032, i64 %1034
%1036 = load float, float* %1035
%1037 = load float**, float*** %32
%1038 = load i32, i32* %25
%1039 = sext i32 %1038 to i64
%1040 = getelementptr inbounds float*, float** %1037, i64 %1039
%1041 = load float*, float** %1040
%1042 = load i32, i32* %21
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds float, float* %1041, i64 %1043
%1045 = load float, float* %1044
%1046 = fadd float %1036, %1045
%1047 = load float**, float*** %32
%1048 = load i32, i32* %24
%1049 = sext i32 %1048 to i64
%1050 = getelementptr inbounds float*, float** %1047, i64 %1049
%1051 = load float*, float** %1050
%1052 = load i32, i32* %21
%1053 = sext i32 %1052 to i64
%1054 = getelementptr inbounds float, float* %1051, i64 %1053
store float %1046, float* %1054
%1055 = load float**, float*** %32
%1056 = load i32, i32* %24
%1057 = sext i32 %1056 to i64
%1058 = getelementptr inbounds float*, float** %1055, i64 %1057
%1059 = load float*, float** %1058
%1060 = load i32, i32* %21
%1061 = sext i32 %1060 to i64
%1062 = getelementptr inbounds float, float* %1059, i64 %1061
%1063 = load float, float* %1062
%1064 = load float**, float*** %32
%1065 = load i32, i32* %21
%1066 = sext i32 %1065 to i64
%1067 = getelementptr inbounds float*, float** %1064, i64 %1066
%1068 = load float*, float** %1067
%1069 = load i32, i32* %24
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds float, float* %1068, i64 %1070
store float %1063, float* %1071
%1072 = load i32, i32* %48
%1073 = icmp sgt i32 %1072, 1
br i1 %1073, label %1074, label %1104
1074: ; preds = %915
%1075 = load i32, i32* %24
%1076 = load i32, i32* %21
%1077 = load float**, float*** %34
%1078 = load i32, i32* %24
%1079 = sext i32 %1078 to i64
%1080 = getelementptr inbounds float*, float** %1077, i64 %1079
%1081 = load float*, float** %1080
%1082 = load i32, i32* %21
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds float, float* %1081, i64 %1083
%1085 = load float, float* %1084
%1086 = fpext float %1085 to double
%1087 = load float*, float** %29
%1088 = load i32, i32* %24
%1089 = sext i32 %1088 to i64
%1090 = getelementptr inbounds float, float* %1087, i64 %1089
%1091 = load float, float* %1090
%1092 = fpext float %1091 to double
%1093 = load float*, float** %29
%1094 = load i32, i32* %21
%1095 = sext i32 %1094 to i64
%1096 = getelementptr inbounds float, float* %1093, i64 %1095
%1097 = load float, float* %1096
%1098 = fpext float %1097 to double
%1099 = load float*, float** %30
%1100 = getelementptr inbounds float, float* %1099, i64 1
%1101 = load float, float* %1100
%1102 = fpext float %1101 to double
%1103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.4, i64 0, i64 0), i32 %1075, i32 %1076, double %1086, double %1092, double %1098, double %1102)
br label %1104
1104: ; preds = %1074, %915
br label %1105
1105: ; preds = %1104, %860
br label %1106
1106: ; preds = %1105, %844, %840
br label %1107
1107: ; preds = %1106
%1108 = load i32, i32* %21
%1109 = add nsw i32 %1108, 1
store i32 %1109, i32* %21
br label %836
1110: ; preds = %836
store i32 1, i32* %23
br label %1111
1111: ; preds = %1131, %1110
%1112 = load i32, i32* %23
%1113 = load i32, i32* %16
%1114 = icmp sle i32 %1112, %1113
br i1 %1114, label %1115, label %1134
1115: ; preds = %1111
%1116 = load i32*, i32** %42
%1117 = load i32, i32* %23
%1118 = sext i32 %1117 to i64
%1119 = getelementptr inbounds i32, i32* %1116, i64 %1118
%1120 = load i32, i32* %1119
%1121 = load i32, i32* %25
%1122 = icmp sgt i32 %1120, %1121
br i1 %1122, label %1123, label %1130
1123: ; preds = %1115
%1124 = load i32*, i32** %42
%1125 = load i32, i32* %23
%1126 = sext i32 %1125 to i64
%1127 = getelementptr inbounds i32, i32* %1124, i64 %1126
%1128 = load i32, i32* %1127
%1129 = add nsw i32 %1128, -1
store i32 %1129, i32* %1127
br label %1130
1130: ; preds = %1123, %1115
br label %1131
1131: ; preds = %1130
%1132 = load i32, i32* %23
%1133 = add nsw i32 %1132, 1
store i32 %1133, i32* %23
br label %1111
1134: ; preds = %1111
%1135 = load i32, i32* %25
%1136 = add nsw i32 %1135, 1
store i32 %1136, i32* %21
br label %1137
1137: ; preds = %1189, %1134
%1138 = load i32, i32* %21
%1139 = load i32, i32* %26
%1140 = icmp sle i32 %1138, %1139
br i1 %1140, label %1141, label %1192
1141: ; preds = %1137
%1142 = load i32*, i32** %27
%1143 = load i32, i32* %21
%1144 = sext i32 %1143 to i64
%1145 = getelementptr inbounds i32, i32* %1142, i64 %1144
%1146 = load i32, i32* %1145
%1147 = load i32*, i32** %27
%1148 = load i32, i32* %21
%1149 = sub nsw i32 %1148, 1
%1150 = sext i32 %1149 to i64
%1151 = getelementptr inbounds i32, i32* %1147, i64 %1150
store i32 %1146, i32* %1151
%1152 = load float*, float** %29
%1153 = load i32, i32* %21
%1154 = sext i32 %1153 to i64
%1155 = getelementptr inbounds float, float* %1152, i64 %1154
%1156 = load float, float* %1155
%1157 = load float*, float** %29
%1158 = load i32, i32* %21
%1159 = sub nsw i32 %1158, 1
%1160 = sext i32 %1159 to i64
%1161 = getelementptr inbounds float, float* %1157, i64 %1160
store float %1156, float* %1161
store i32 0, i32* %23
br label %1162
1162: ; preds = %1185, %1141
%1163 = load i32, i32* %23
%1164 = load i32, i32* %12
%1165 = icmp slt i32 %1163, %1164
br i1 %1165, label %1166, label %1188
1166: ; preds = %1162
%1167 = load float**, float*** %36
%1168 = load i32, i32* %21
%1169 = sext i32 %1168 to i64
%1170 = getelementptr inbounds float*, float** %1167, i64 %1169
%1171 = load float*, float** %1170
%1172 = load i32, i32* %23
%1173 = sext i32 %1172 to i64
%1174 = getelementptr inbounds float, float* %1171, i64 %1173
%1175 = load float, float* %1174
%1176 = load float**, float*** %36
%1177 = load i32, i32* %21
%1178 = sub nsw i32 %1177, 1
%1179 = sext i32 %1178 to i64
%1180 = getelementptr inbounds float*, float** %1176, i64 %1179
%1181 = load float*, float** %1180
%1182 = load i32, i32* %23
%1183 = sext i32 %1182 to i64
%1184 = getelementptr inbounds float, float* %1181, i64 %1183
store float %1175, float* %1184
br label %1185
1185: ; preds = %1166
%1186 = load i32, i32* %23
%1187 = add nsw i32 %1186, 1
store i32 %1187, i32* %23
br label %1162
1188: ; preds = %1162
br label %1189
1189: ; preds = %1188
%1190 = load i32, i32* %21
%1191 = add nsw i32 %1190, 1
store i32 %1191, i32* %21
br label %1137
1192: ; preds = %1137
store i32 1, i32* %21
br label %1193
1193: ; preds = %1263, %1192
%1194 = load i32, i32* %21
%1195 = load i32, i32* %26
%1196 = icmp sle i32 %1194, %1195
br i1 %1196, label %1197, label %1266
1197: ; preds = %1193
%1198 = load i32, i32* %25
%1199 = add nsw i32 %1198, 1
store i32 %1199, i32* %22
br label %1200
1200: ; preds = %1259, %1197
%1201 = load i32, i32* %22
%1202 = load i32, i32* %26
%1203 = icmp sle i32 %1201, %1202
br i1 %1203, label %1204, label %1262
1204: ; preds = %1200
%1205 = load float**, float*** %32
%1206 = load i32, i32* %21
%1207 = sext i32 %1206 to i64
%1208 = getelementptr inbounds float*, float** %1205, i64 %1207
%1209 = load float*, float** %1208
%1210 = load i32, i32* %22
%1211 = sext i32 %1210 to i64
%1212 = getelementptr inbounds float, float* %1209, i64 %1211
%1213 = load float, float* %1212
%1214 = load float**, float*** %32
%1215 = load i32, i32* %21
%1216 = sext i32 %1215 to i64
%1217 = getelementptr inbounds float*, float** %1214, i64 %1216
%1218 = load float*, float** %1217
%1219 = load i32, i32* %22
%1220 = sub nsw i32 %1219, 1
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds float, float* %1218, i64 %1221
store float %1213, float* %1222
%1223 = load float**, float*** %33
%1224 = load i32, i32* %21
%1225 = sext i32 %1224 to i64
%1226 = getelementptr inbounds float*, float** %1223, i64 %1225
%1227 = load float*, float** %1226
%1228 = load i32, i32* %22
%1229 = sext i32 %1228 to i64
%1230 = getelementptr inbounds float, float* %1227, i64 %1229
%1231 = load float, float* %1230
%1232 = load float**, float*** %33
%1233 = load i32, i32* %21
%1234 = sext i32 %1233 to i64
%1235 = getelementptr inbounds float*, float** %1232, i64 %1234
%1236 = load float*, float** %1235
%1237 = load i32, i32* %22
%1238 = sub nsw i32 %1237, 1
%1239 = sext i32 %1238 to i64
%1240 = getelementptr inbounds float, float* %1236, i64 %1239
store float %1231, float* %1240
%1241 = load float**, float*** %34
%1242 = load i32, i32* %21
%1243 = sext i32 %1242 to i64
%1244 = getelementptr inbounds float*, float** %1241, i64 %1243
%1245 = load float*, float** %1244
%1246 = load i32, i32* %22
%1247 = sext i32 %1246 to i64
%1248 = getelementptr inbounds float, float* %1245, i64 %1247
%1249 = load float, float* %1248
%1250 = load float**, float*** %34
%1251 = load i32, i32* %21
%1252 = sext i32 %1251 to i64
%1253 = getelementptr inbounds float*, float** %1250, i64 %1252
%1254 = load float*, float** %1253
%1255 = load i32, i32* %22
%1256 = sub nsw i32 %1255, 1
%1257 = sext i32 %1256 to i64
%1258 = getelementptr inbounds float, float* %1254, i64 %1257
store float %1249, float* %1258
br label %1259
1259: ; preds = %1204
%1260 = load i32, i32* %22
%1261 = add nsw i32 %1260, 1
store i32 %1261, i32* %22
br label %1200
1262: ; preds = %1200
br label %1263
1263: ; preds = %1262
%1264 = load i32, i32* %21
%1265 = add nsw i32 %1264, 1
store i32 %1265, i32* %21
br label %1193
1266: ; preds = %1193
%1267 = load i32, i32* %25
%1268 = add nsw i32 %1267, 1
store i32 %1268, i32* %21
br label %1269
1269: ; preds = %1338, %1266
%1270 = load i32, i32* %21
%1271 = load i32, i32* %26
%1272 = icmp sle i32 %1270, %1271
br i1 %1272, label %1273, label %1341
1273: ; preds = %1269
store i32 1, i32* %22
br label %1274
1274: ; preds = %1334, %1273
%1275 = load i32, i32* %22
%1276 = load i32, i32* %26
%1277 = sub nsw i32 %1276, 1
%1278 = icmp sle i32 %1275, %1277
br i1 %1278, label %1279, label %1337
1279: ; preds = %1274
%1280 = load float**, float*** %32
%1281 = load i32, i32* %21
%1282 = sext i32 %1281 to i64
%1283 = getelementptr inbounds float*, float** %1280, i64 %1282
%1284 = load float*, float** %1283
%1285 = load i32, i32* %22
%1286 = sext i32 %1285 to i64
%1287 = getelementptr inbounds float, float* %1284, i64 %1286
%1288 = load float, float* %1287
%1289 = load float**, float*** %32
%1290 = load i32, i32* %21
%1291 = sub nsw i32 %1290, 1
%1292 = sext i32 %1291 to i64
%1293 = getelementptr inbounds float*, float** %1289, i64 %1292
%1294 = load float*, float** %1293
%1295 = load i32, i32* %22
%1296 = sext i32 %1295 to i64
%1297 = getelementptr inbounds float, float* %1294, i64 %1296
store float %1288, float* %1297
%1298 = load float**, float*** %33
%1299 = load i32, i32* %21
%1300 = sext i32 %1299 to i64
%1301 = getelementptr inbounds float*, float** %1298, i64 %1300
%1302 = load float*, float** %1301
%1303 = load i32, i32* %22
%1304 = sext i32 %1303 to i64
%1305 = getelementptr inbounds float, float* %1302, i64 %1304
%1306 = load float, float* %1305
%1307 = load float**, float*** %33
%1308 = load i32, i32* %21
%1309 = sub nsw i32 %1308, 1
%1310 = sext i32 %1309 to i64
%1311 = getelementptr inbounds float*, float** %1307, i64 %1310
%1312 = load float*, float** %1311
%1313 = load i32, i32* %22
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds float, float* %1312, i64 %1314
store float %1306, float* %1315
%1316 = load float**, float*** %34
%1317 = load i32, i32* %21
%1318 = sext i32 %1317 to i64
%1319 = getelementptr inbounds float*, float** %1316, i64 %1318
%1320 = load float*, float** %1319
%1321 = load i32, i32* %22
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds float, float* %1320, i64 %1322
%1324 = load float, float* %1323
%1325 = load float**, float*** %34
%1326 = load i32, i32* %21
%1327 = sub nsw i32 %1326, 1
%1328 = sext i32 %1327 to i64
%1329 = getelementptr inbounds float*, float** %1325, i64 %1328
%1330 = load float*, float** %1329
%1331 = load i32, i32* %22
%1332 = sext i32 %1331 to i64
%1333 = getelementptr inbounds float, float* %1330, i64 %1332
store float %1324, float* %1333
br label %1334
1334: ; preds = %1279
%1335 = load i32, i32* %22
%1336 = add nsw i32 %1335, 1
store i32 %1336, i32* %22
br label %1274
1337: ; preds = %1274
br label %1338
1338: ; preds = %1337
%1339 = load i32, i32* %21
%1340 = add nsw i32 %1339, 1
store i32 %1340, i32* %21
br label %1269
1341: ; preds = %1269
%1342 = load i32, i32* %26
%1343 = add nsw i32 %1342, -1
store i32 %1343, i32* %26
store float 1.000000e+04, float* %31
store i32 1, i32* %21
br label %1344
1344: ; preds = %1396, %1341
%1345 = load i32, i32* %21
%1346 = load i32, i32* %26
%1347 = icmp slt i32 %1345, %1346
br i1 %1347, label %1348, label %1399
1348: ; preds = %1344
%1349 = load i32, i32* %21
%1350 = add nsw i32 %1349, 1
store i32 %1350, i32* %22
br label %1351
1351: ; preds = %1392, %1348
%1352 = load i32, i32* %22
%1353 = load i32, i32* %26
%1354 = icmp sle i32 %1352, %1353
br i1 %1354, label %1355, label %1395
1355: ; preds = %1351
%1356 = load float**, float*** %32
%1357 = load i32, i32* %21
%1358 = sext i32 %1357 to i64
%1359 = getelementptr inbounds float*, float** %1356, i64 %1358
%1360 = load float*, float** %1359
%1361 = load i32, i32* %22
%1362 = sext i32 %1361 to i64
%1363 = getelementptr inbounds float, float* %1360, i64 %1362
%1364 = load float, float* %1363
%1365 = fcmp une float %1364, 0.000000e+00
br i1 %1365, label %1366, label %1391
1366: ; preds = %1355
%1367 = load float**, float*** %33
%1368 = load i32, i32* %21
%1369 = sext i32 %1368 to i64
%1370 = getelementptr inbounds float*, float** %1367, i64 %1369
%1371 = load float*, float** %1370
%1372 = load i32, i32* %22
%1373 = sext i32 %1372 to i64
%1374 = getelementptr inbounds float, float* %1371, i64 %1373
%1375 = load float, float* %1374
%1376 = load float, float* %31
%1377 = fcmp olt float %1375, %1376
br i1 %1377, label %1378, label %1390
1378: ; preds = %1366
%1379 = load float**, float*** %33
%1380 = load i32, i32* %21
%1381 = sext i32 %1380 to i64
%1382 = getelementptr inbounds float*, float** %1379, i64 %1381
%1383 = load float*, float** %1382
%1384 = load i32, i32* %22
%1385 = sext i32 %1384 to i64
%1386 = getelementptr inbounds float, float* %1383, i64 %1385
%1387 = load float, float* %1386
store float %1387, float* %31
%1388 = load i32, i32* %21
store i32 %1388, i32* %24
%1389 = load i32, i32* %22
store i32 %1389, i32* %25
br label %1390
1390: ; preds = %1378, %1366
br label %1391
1391: ; preds = %1390, %1355
br label %1392
1392: ; preds = %1391
%1393 = load i32, i32* %22
%1394 = add nsw i32 %1393, 1
store i32 %1394, i32* %22
br label %1351
1395: ; preds = %1351
br label %1396
1396: ; preds = %1395
%1397 = load i32, i32* %21
%1398 = add nsw i32 %1397, 1
store i32 %1398, i32* %21
br label %1344
1399: ; preds = %1344
br label %613
1400: ; preds = %613
%1401 = load i8*, i8** %44
%1402 = load float*, float** %29
%1403 = bitcast float* %1402 to i8*
%1404 = load float*, float** %30
%1405 = bitcast float* %1404 to i8*
%1406 = load i32*, i32** %27
%1407 = bitcast i32* %1406 to i8*
%1408 = load float**, float*** %36
%1409 = load i32, i32* %16
%1410 = add nsw i32 %1409, 1
%1411 = call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %1408, i32 %1410)
%1412 = load i32*, i32** %42
%1413 = bitcast i32* %1412 to i8*
%1414 = load float**, float*** %32
%1415 = load i32, i32* %16
%1416 = add nsw i32 %1415, 1
%1417 = call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %1414, i32 %1416)
%1418 = load float**, float*** %34
%1419 = load i32, i32* %16
%1420 = add nsw i32 %1419, 1
%1421 = call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %1418, i32 %1420)
%1422 = load float**, float*** %33
%1423 = load i32, i32* %16
%1424 = add nsw i32 %1423, 1
%1425 = call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %1422, i32 %1424)
%1426 = load i8*, i8** %10
%1427 = load i8*, i8** %11
%1428 = load i32, i32* %12
%1429 = load i32, i32* %13
%1430 = load i32, i32* %14
%1431 = load i32, i32* %15
%1432 = load i32, i32* %16
%1433 = load float, float* %17
%1434 = fpext float %1433 to double
%1435 = load i32, i32* %43
%1436 = call i32 (i8*, i8*, i32, i32, i32, i32, i32, double, i32, ...) bitcast (i32 (...)* @merge to i32 (i8*, i8*, i32, i32, i32, i32, i32, double, i32, ...)*)(i8* %1426, i8* %1427, i32 %1428, i32 %1429, i32 %1430, i32 %1431, i32 %1432, double %1434, i32 %1435)
store i32 %1436, i32* %16
%1437 = load i32, i32* %16
store i32 %1437, i32* %9
br label %1438
1438: ; preds = %1400, %51
%1439 = load i32, i32* %9
ret i32 %1439
}

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