void getJT(unsigned char *cmap, int N, int ny, int nx, float *JT, int offset,
           int step, short *rmap, unsigned char *rmap0, int TR) {
  int iy, ix, jy, jx, i, *p, StN, StN1, corner[3];
  float St1, St, Sb, Sw, Stmeant, *avgt, *Jtmp, total, **weight;
  unsigned char *cmap1;
  int l, imgsize, imgsize2, ny2, nx2, loc, loc1, sy, ey, sx, ex, cornerI,
      cornerT[6];
  imgsize = ny * nx;
  ny2 = ny + 2 * offset;
  nx2 = nx + 2 * offset;
  imgsize2 = ny2 * nx2;
  cmap1 = (unsigned char *)calloc(2 * imgsize2, sizeof(unsigned char));
  extendbounduc(cmap, cmap1, ny, nx, offset, 1);
  extendbounduc(cmap + imgsize, cmap1 + imgsize2, ny, nx, offset, 1);
  corner[0] = 0;
  corner[1] = step;
  corner[2] = 3 * step;
  cornerT[0] = -offset;
  cornerT[1] = offset;
  cornerT[2] = -offset + step;
  cornerT[3] = offset - step;
  cornerT[4] = -offset + 2 * step;
  cornerT[5] = offset - 2 * step;
  StN1 = 2 * (((2 * offset / step + 1) * (2 * offset / step + 1)) - 20);
  St1 = StN1 * ((1) * (1));
  for (l = 0; l < imgsize; l++)
    JT[l] = 0;
  avgt = (float *)calloc(N, sizeof(float));
  p = (int *)calloc(N, sizeof(int));
  loc = 0;
  for (iy = 0; iy < ny; iy++) {
    for (ix = 0; ix < nx; ix++) {
      if (rmap[loc] != 0 && rmap[loc + imgsize] != 0)
        JT[loc] = 2;
      else {
        cornerT[0] = iy - offset;
        cornerT[1] = iy + offset;
        cornerT[2] = iy - offset + step;
        cornerT[3] = iy + offset - step;
        cornerT[4] = iy - offset + 2 * step;
        cornerT[5] = iy + offset - 2 * step;
        St = St1;
        Stmeant = 0;
        StN = StN1;
        for (i = 0; i < N; i++) {
          avgt[i] = 0;
          p[i] = 0;
        }
        sy = iy - offset;
        ey = iy + offset;
        for (jy = sy; jy <= ey; jy += step) {
          if (jy == cornerT[0] || jy == cornerT[1])
            cornerI = 2;
          else if (jy == cornerT[2] || jy == cornerT[3])
            cornerI = 1;
          else if (jy == cornerT[4] || jy == cornerT[5])
            cornerI = 1;
          else
            cornerI = 0;
          sx = ix - offset + corner[cornerI];
          ex = ix + offset - corner[cornerI];
          for (jx = sx; jx <= ex; jx += step) {
            loc1 = LOC2(jy + offset, jx + offset, nx2);
            p[cmap1[loc1]]++;
            avgt[cmap1[loc1]] -= 1;
            p[cmap1[loc1 + imgsize2]]++;
            avgt[cmap1[loc1 + imgsize2]] += 1;
          }
        }
        for (i = 0; i < N; i++) {
          if (p[i] > 0)
            avgt[i] /= p[i];
        }
        Sw = 0;
        sy = iy - offset;
        ey = iy + offset;
        for (jy = sy; jy <= ey; jy += step) {
          if (jy == cornerT[0] || jy == cornerT[1])
            cornerI = 2;
          else if (jy == cornerT[2] || jy == cornerT[3])
            cornerI = 1;
          else if (jy == cornerT[4] || jy == cornerT[5])
            cornerI = 1;
          else
            cornerI = 0;
          sx = ix - offset + corner[cornerI];
          ex = ix + offset - corner[cornerI];
          for (jx = sx; jx <= ex; jx += step) {
            loc1 = LOC2(jy + offset, jx + offset, nx2);
            Sw += ((-1 - avgt[cmap1[loc1]]) * (-1 - avgt[cmap1[loc1]]));
            Sw += ((1 - avgt[cmap1[loc1 + imgsize2]]) *
                   (1 - avgt[cmap1[loc1 + imgsize2]]));
          }
        }
        if (Sw == 0)
          JT[loc] = 2;
        else {
          Sb = St - Sw;
          if (Sb < 0)
            Sb = 0;
          JT[loc] = Sb / Sw;
          if (JT[loc] > 2)
            JT[loc] = 2;
        }
      }
      loc++;
    }
  }
  free(cmap1);
  free(avgt);
  free(p);
  if (step > 1) {
    step /= 2;
    Jtmp = (float *)calloc(imgsize, sizeof(float));
    weight = (float **)fmatrix(2 * step + 1, 2 * step + 1);
    genwindow(weight, 2 * step + 1);
    for (i = 0; i < 2; i++) {
      for (l = 0; l < imgsize; l++)
        Jtmp[l] = JT[l];
      loc = 0;
      for (iy = 0; iy < ny; iy++) {
        for (ix = 0; ix < nx; ix++) {
          if (rmap[loc] == 0) {
            JT[loc] = 0;
            total = 0;
            for (jy = iy - step; jy <= iy + step; jy++) {
              for (jx = ix - step; jx <= ix + step; jx++) {
                if (jy >= 0 && jy < ny && jx >= 0 && jx < nx) {
                  loc1 = LOC2(jy, jx, nx);
                  if (rmap0[loc] == rmap0[loc1]) {
                    JT[loc] +=
                        weight[jy - iy + step][jx - ix + step] * Jtmp[loc1];
                    total += weight[jy - iy + step][jx - ix + step];
                  }
                }
              }
            }
            JT[loc] /= total;
          }
          loc++;
        }
      }
    }
    free(Jtmp);
    free_fmatrix(weight, 2 * step + 1);
  }
}


x86 assembly (clang, -O0):
<getJT>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x10(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%eax
imul   -0xa4(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x1,%eax
movslq %eax,%rdi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    $0x1,%r9d
mov    $0x0,%al
call   1090 <extendbounduc@plt>
mov    -0x8(%rbp),%rdi
movslq -0x98(%rbp),%rax
add    %rax,%rdi
mov    -0x90(%rbp),%rsi
movslq -0x9c(%rbp),%rax
add    %rax,%rsi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x24(%rbp),%r8d
mov    $0x1,%r9d
mov    $0x0,%al
call   1090 <extendbounduc@plt>
movl   $0x0,-0x54(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
imul   $0x3,0x10(%rbp),%eax
mov    %eax,-0x4c(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xdc(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
add    0x10(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x24(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0xd4(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
cltd
idivl  0x10(%rbp)
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
cltd
idivl  0x10(%rbp)
mov    %eax,%ecx
mov    -0xe4(%rbp),%eax
add    $0x1,%ecx
imul   %ecx,%eax
sub    $0x14,%eax
shl    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x0,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1341 <getJT+0x1d1>
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1308 <getJT+0x198>
movslq -0xc(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0xc(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19ec <getJT+0x87c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19d9 <getJT+0x869>
mov    0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
je     13ea <getJT+0x27a>
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
je     13ea <getJT+0x27a>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  0xc20(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    19bc <getJT+0x84c>
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
add    0x10(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0xcc(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14a0 <getJT+0x330>
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1467 <getJT+0x2f7>
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb0(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jg     1693 <getJT+0x523>
mov    -0x30(%rbp),%eax
cmp    -0xe0(%rbp),%eax
je     14ee <getJT+0x37e>
mov    -0x30(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jne    14fd <getJT+0x38d>
movl   $0x2,-0xc0(%rbp)
jmp    156b <getJT+0x3fb>
mov    -0x30(%rbp),%eax
cmp    -0xd8(%rbp),%eax
je     151b <getJT+0x3ab>
mov    -0x30(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jne    152a <getJT+0x3ba>
movl   $0x1,-0xc0(%rbp)
jmp    1566 <getJT+0x3f6>
mov    -0x30(%rbp),%eax
cmp    -0xd0(%rbp),%eax
je     1548 <getJT+0x3d8>
mov    -0x30(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jne    1557 <getJT+0x3e7>
movl   $0x1,-0xc0(%rbp)
jmp    1561 <getJT+0x3f1>
movl   $0x0,-0xc0(%rbp)
jmp    1566 <getJT+0x3f6>
jmp    156b <getJT+0x3fb>
mov    -0x2c(%rbp),%eax
sub    -0x24(%rbp),%eax
movslq -0xc0(%rbp),%rcx
add    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xb8(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
movslq -0xc0(%rbp),%rcx
sub    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jg     1680 <getJT+0x510>
mov    -0x30(%rbp),%edi
add    -0x24(%rbp),%edi
mov    -0x34(%rbp),%esi
add    -0x24(%rbp),%esi
mov    -0xa4(%rbp),%edx
mov    $0x0,%al
call   1070 <LOC2@plt>
mov    %eax,-0xac(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x90(%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    -0x70(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  0x9f2(%rip),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0xac(%rbp),%edx
add    -0x9c(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0xac(%rbp),%edx
add    -0x9c(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  0x99c(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    15a2 <getJT+0x432>
jmp    1685 <getJT+0x515>
mov    0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    14c1 <getJT+0x351>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16ee <getJT+0x57e>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    16db <getJT+0x56b>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    16e0 <getJT+0x570>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    169a <getJT+0x52a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb0(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jg     1907 <getJT+0x797>
mov    -0x30(%rbp),%eax
cmp    -0xe0(%rbp),%eax
je     1744 <getJT+0x5d4>
mov    -0x30(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jne    1753 <getJT+0x5e3>
movl   $0x2,-0xc0(%rbp)
jmp    17c1 <getJT+0x651>
mov    -0x30(%rbp),%eax
cmp    -0xd8(%rbp),%eax
je     1771 <getJT+0x601>
mov    -0x30(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jne    1780 <getJT+0x610>
movl   $0x1,-0xc0(%rbp)
jmp    17bc <getJT+0x64c>
mov    -0x30(%rbp),%eax
cmp    -0xd0(%rbp),%eax
je     179e <getJT+0x62e>
mov    -0x30(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jne    17ad <getJT+0x63d>
movl   $0x1,-0xc0(%rbp)
jmp    17b7 <getJT+0x647>
movl   $0x0,-0xc0(%rbp)
jmp    17bc <getJT+0x64c>
jmp    17c1 <getJT+0x651>
mov    -0x2c(%rbp),%eax
sub    -0x24(%rbp),%eax
movslq -0xc0(%rbp),%rcx
add    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xb8(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
movslq -0xc0(%rbp),%rcx
sub    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jg     18f4 <getJT+0x784>
mov    -0x30(%rbp),%edi
add    -0x24(%rbp),%edi
mov    -0x34(%rbp),%esi
add    -0x24(%rbp),%esi
mov    -0xa4(%rbp),%edx
mov    $0x0,%al
call   1070 <LOC2@plt>
mov    %eax,-0xac(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  0x7c4(%rip),%xmm0
subss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  0x7a1(%rip),%xmm2
subss  (%rax,%rcx,4),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0xac(%rbp),%edx
add    -0x9c(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  0x760(%rip),%xmm0
subss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0xac(%rbp),%edx
add    -0x9c(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movss  0x735(%rip),%xmm2
subss  (%rax,%rcx,4),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x10(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    17f8 <getJT+0x688>
jmp    18f9 <getJT+0x789>
mov    0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1717 <getJT+0x5a7>
movss  -0x64(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    193b <getJT+0x7cb>
jp     193b <getJT+0x7cb>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  0x6cf(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    19b7 <getJT+0x847>
movss  -0x5c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x60(%rbp),%xmm0
jbe    195f <getJT+0x7ef>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
divss  -0x64(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x66f(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    19b2 <getJT+0x842>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  0x653(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    19b7 <getJT+0x847>
jmp    19bc <getJT+0x84c>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1389 <getJT+0x219>
jmp    19de <getJT+0x86e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1376 <getJT+0x206>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,0x10(%rbp)
jle    1d03 <getJT+0xb93>
mov    0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,0x10(%rbp)
movslq -0x98(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x78(%rbp)
mov    0x10(%rbp),%edi
shl    $0x1,%edi
add    $0x1,%edi
mov    0x10(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
mov    $0x0,%al
call   1060 <fmatrix@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rdi
mov    0x10(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
mov    $0x0,%al
call   1080 <genwindow@plt>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1ce3 <getJT+0xb73>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1ad1 <getJT+0x961>
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1a8b <getJT+0x91b>
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1cd0 <getJT+0xb60>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1cbd <getJT+0xb4d>
mov    0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1ca0 <getJT+0xb30>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x28(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jg     1c82 <getJT+0xb12>
mov    -0x2c(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jg     1c6f <getJT+0xaff>
cmpl   $0x0,-0x30(%rbp)
jl     1c5c <getJT+0xaec>
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c5c <getJT+0xaec>
cmpl   $0x0,-0x34(%rbp)
jl     1c5c <getJT+0xaec>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c5c <getJT+0xaec>
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    $0x0,%al
call   1070 <LOC2@plt>
mov    %eax,-0xac(%rbp)
mov    0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    0x20(%rbp),%rcx
movslq -0xac(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1c57 <getJT+0xae7>
mov    -0x88(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    1c5c <getJT+0xaec>
jmp    1c61 <getJT+0xaf1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b57 <getJT+0x9e7>
jmp    1c74 <getJT+0xb04>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b3d <getJT+0x9cd>
movss  -0x7c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1af5 <getJT+0x985>
jmp    1cc2 <getJT+0xb52>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1ae2 <getJT+0x972>
jmp    1cd5 <getJT+0xb65>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a77 <getJT+0x907>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
mov    0x10(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
mov    $0x0,%al
call   1040 <free_fmatrix@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getJT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9d,%r14d
mov    %r8,0x58(%rsp)
mov    %edx,%ebp
mov    %esi,0x1c(%rsp)
mov    %rdi,%r12
mov    0x170(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0xd8(%rsp)
mov    0x160(%rsp),%eax
mov    %rax,0x10(%rsp)
mov    %rcx,0x60(%rsp)
mov    %ecx,%r13d
imul   %edx,%r13d
lea    (%r14,%r14,1),%eax
mov    %eax,0x28(%rsp)
lea    0x0(%rbp,%r14,2),%r15d
lea    (%rcx,%r14,2),%eax
mov    %eax,0xa0(%rsp)
imul   %eax,%r15d
lea    (%r15,%r15,1),%eax
movslq %eax,%rdi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
mov    %r12,%rdi
mov    %rax,%rsi
mov    %ebp,%edx
mov    0x60(%rsp),%rcx
mov    %r14d,%r8d
mov    $0x1,%r9d
xor    %eax,%eax
call   10b0 <extendbounduc@plt>
movslq %r13d,%rax
mov    %r12,%rdi
add    %rax,%rdi
mov    %rax,%r12
mov    %r15,0xa8(%rsp)
movslq %r15d,%rsi
mov    %rbx,0x68(%rsp)
add    %rbx,%rsi
mov    %rbp,0x88(%rsp)
mov    %ebp,%edx
mov    0x60(%rsp),%rcx
mov    %r14,0x40(%rsp)
mov    %r14d,%r8d
mov    0x58(%rsp),%rbp
mov    $0x1,%r9d
xor    %eax,%eax
call   10b0 <extendbounduc@plt>
movl   $0x0,0xec(%rsp)
mov    0x10(%rsp),%rcx
mov    %ecx,0xf0(%rsp)
lea    (%rcx,%rcx,2),%eax
mov    %eax,0xf4(%rsp)
mov    0x28(%rsp),%eax
cltd
idiv   %ecx
mov    %eax,%ebx
mov    %r12,%rcx
mov    %r12,%rax
mov    %r12,0xf8(%rsp)
test   %ecx,%ecx
jle    12cc <getJT+0x13c>
mov    %r13d,%edx
shl    $0x2,%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movslq 0x1c(%rsp),%rbp
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <calloc@plt>
mov    %rax,%r9
cmpl   $0x0,0x88(%rsp)
mov    %r13d,0x74(%rsp)
mov    0x10(%rsp),%r8
mov    0x68(%rsp),%rdi
jle    1898 <getJT+0x708>
add    $0x1,%ebx
imul   %ebx,%ebx
lea    (%rbx,%rbx,1),%eax
add    $0xffffffd8,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,0xe8(%rsp)
lea    (%r8,%r8,1),%eax
mov    %rax,0x100(%rsp)
mov    0x1c(%rsp),%eax
lea    0x0(,%rax,4),%rcx
mov    %rcx,0x110(%rsp)
mov    %rax,0x118(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0xe0(%rsp)
mov    0x40(%rsp),%rax
mov    0x68(%rsp),%rdi
neg    %eax
xor    %ecx,%ecx
xor    %esi,%esi
mov    %r9,0x80(%rsp)
mov    %rax,0xc8(%rsp)
jmp    13a0 <getJT+0x210>
xchg   %ax,%ax
mov    %rax,%rcx
mov    0x68(%rsp),%rdi
mov    0x108(%rsp),%rsi
add    $0x1,%esi
cmp    0x88(%rsp),%esi
je     1898 <getJT+0x708>
cmpl   $0x0,0x60(%rsp)
jle    1390 <getJT+0x200>
mov    %esi,%edi
mov    0x40(%rsp),%rax
sub    %eax,%edi
mov    %rsi,0x108(%rsp)
add    %eax,%esi
lea    (%rdi,%r8,1),%eax
mov    %eax,0x78(%rsp)
mov    %esi,%eax
sub    %r8d,%eax
mov    %eax,0x90(%rsp)
mov    0x100(%rsp),%rax
mov    %rdi,0x30(%rsp)
add    %eax,%edi
mov    %edi,0xb8(%rsp)
mov    %esi,0x20(%rsp)
sub    %eax,%esi
mov    %esi,0x3c(%rsp)
mov    %rcx,%rax
cltq
xor    %ecx,%ecx
mov    %rcx,0x48(%rsp)
mov    0x28(%rsp),%rsi
nop
mov    0xd8(%rsp),%rcx
cmpw   $0x0,(%rcx,%rax,2)
mov    %rax,0xd0(%rsp)
je     1440 <getJT+0x2b0>
mov    %rax,%rdi
mov    0xf8(%rsp),%rax
add    %rdi,%rax
cmpw   $0x0,(%rcx,%rax,2)
je     1440 <getJT+0x2b0>
mov    0x58(%rsp),%rax
lea    (%rax,%rdi,4),%rax
jmp    17c9 <getJT+0x639>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x1c(%rsp)
jle    1482 <getJT+0x2f2>
mov    0x28(%rsp),%rdi
xor    %esi,%esi
mov    0x110(%rsp),%rbx
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x80(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x80(%rsp),%r9
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%eax
cmp    %eax,0x30(%rsp)
jle    1640 <getJT+0x4b0>
cmpl   $0x0,0x1c(%rsp)
mov    0x74(%rsp),%r13d
jle    14d0 <getJT+0x340>
cmpl   $0x1,0x1c(%rsp)
jne    17f7 <getJT+0x667>
xor    %eax,%eax
testb  $0x1,0x118(%rsp)
01
je     14d0 <getJT+0x340>
mov    (%r9,%rax,4),%ecx
test   %ecx,%ecx
jle    14d0 <getJT+0x340>
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  (%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rax,4)
mov    0x20(%rsp),%eax
cmp    %eax,0x30(%rsp)
jg     17b8 <getJT+0x628>
mov    0x48(%rsp),%rcx
mov    %ecx,%edi
mov    0x40(%rsp),%rax
sub    %eax,%edi
mov    %rdi,0x98(%rsp)
add    %ecx,%eax
mov    %eax,0xc0(%rsp)
xorps  %xmm2,%xmm2
mov    0x30(%rsp),%rax
mov    %eax,%edi
jmp    152d <getJT+0x39d>
nopl   0x0(%rax)
mov    0xb0(%rsp),%rdi
add    %r8d,%edi
cmp    0x20(%rsp),%edi
mov    0x80(%rsp),%r9
jg     17a0 <getJT+0x610>
mov    $0x2,%eax
cmp    0x30(%rsp),%edi
je     1568 <getJT+0x3d8>
cmp    0x20(%rsp),%edi
je     1568 <getJT+0x3d8>
mov    $0x1,%eax
cmp    0x78(%rsp),%edi
je     1568 <getJT+0x3d8>
cmp    0x90(%rsp),%edi
je     1568 <getJT+0x3d8>
cmp    0xb8(%rsp),%edi
sete   %al
cmp    0x3c(%rsp),%edi
sete   %cl
or     %al,%cl
movzbl %cl,%eax
mov    0xec(%rsp,%rax,4),%ebx
mov    0x98(%rsp),%rax
add    %ebx,%eax
mov    0xc0(%rsp),%r15d
sub    %ebx,%r15d
cmp    %r15d,%eax
mov    %rdi,0xb0(%rsp)
jg     1510 <getJT+0x380>
mov    0x40(%rsp),%rax
add    %edi,%eax
mov    %eax,0x50(%rsp)
add    0x48(%rsp),%ebx
mov    0xa8(%rsp),%r13
mov    0xa0(%rsp),%r12d
mov    0x68(%rsp),%rbp
mov    0xc8(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm2,0xc(%rsp)
mov    0x50(%rsp),%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1090 <LOC2@plt>
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%r8
cltq
movzbl 0x0(%rbp,%rax,1),%ecx
movss  0xa01(%rip),%xmm0
subss  (%rsi,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
addss  0xc(%rsp),%xmm0
add    %r13d,%eax
cltq
movzbl 0x0(%rbp,%rax,1),%eax
movss  0x9e4(%rip),%xmm2
subss  (%rsi,%rax,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
add    %r8d,%ebx
lea    (%r14,%rbx,1),%eax
cmp    %r15d,%eax
jle    15d0 <getJT+0x440>
jmp    1510 <getJT+0x380>
xchg   %ax,%ax
mov    0x48(%rsp),%rcx
mov    %ecx,%edi
mov    0x40(%rsp),%rax
sub    %eax,%edi
mov    %rdi,0xb0(%rsp)
add    %ecx,%eax
mov    %eax,0x98(%rsp)
mov    0x30(%rsp),%rax
mov    %eax,%edi
jmp    1682 <getJT+0x4f2>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rdi
add    %r8d,%edi
cmp    0x20(%rsp),%edi
jg     1490 <getJT+0x300>
mov    $0x2,%eax
cmp    0x30(%rsp),%edi
je     16bd <getJT+0x52d>
cmp    0x20(%rsp),%edi
je     16bd <getJT+0x52d>
mov    $0x1,%eax
cmp    0x78(%rsp),%edi
je     16bd <getJT+0x52d>
cmp    0x90(%rsp),%edi
je     16bd <getJT+0x52d>
cmp    0xb8(%rsp),%edi
sete   %al
cmp    0x3c(%rsp),%edi
sete   %cl
or     %al,%cl
movzbl %cl,%eax
mov    %rdi,0x50(%rsp)
mov    0xec(%rsp,%rax,4),%ebx
mov    0xb0(%rsp),%rax
add    %ebx,%eax
mov    0x98(%rsp),%r14d
sub    %ebx,%r14d
cmp    %r14d,%eax
mov    0xa8(%rsp),%r13
mov    0xa0(%rsp),%r12d
mov    0x68(%rsp),%r15
mov    0xc8(%rsp),%rbp
jg     1670 <getJT+0x4e0>
mov    0x40(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %ecx,%eax
mov    %eax,0xc(%rsp)
add    0x48(%rsp),%ebx
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1090 <LOC2@plt>
mov    0x80(%rsp),%r9
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%r8
cltq
movzbl (%r15,%rax,1),%ecx
addl   $0x1,(%r9,%rcx,4)
movss  (%rsi,%rcx,4),%xmm0
add    %r13d,%eax
cltq
movzbl (%r15,%rax,1),%eax
addl   $0x1,(%r9,%rax,4)
addss  0x896(%rip),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  (%rsi,%rax,4),%xmm0
addss  0x888(%rip),%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    %r8d,%ebx
lea    (%rbx,%rbp,1),%eax
cmp    %r14d,%eax
jle    1720 <getJT+0x590>
jmp    1670 <getJT+0x4e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomiss 0x869(%rip),%xmm2
mov    0x74(%rsp),%r13d
jne    1851 <getJT+0x6c1>
jp     1851 <getJT+0x6c1>
mov    0x58(%rsp),%rax
mov    0xd0(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
movl   $0x40000000,(%rax)
mov    0xd0(%rsp),%rax
add    $0x1,%rax
mov    0x48(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x48(%rsp)
cmp    0x60(%rsp),%ecx
jne    1400 <getJT+0x270>
jmp    1380 <getJT+0x1f0>
xor    %eax,%eax
jmp    1812 <getJT+0x682>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rax
cmp    %rax,0xe0(%rsp)
je     14a9 <getJT+0x319>
mov    (%r9,%rax,4),%ecx
test   %ecx,%ecx
jle    182f <getJT+0x69f>
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  (%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rax,4)
mov    0x4(%r9,%rax,4),%ecx
test   %ecx,%ecx
jle    1800 <getJT+0x670>
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  0x4(%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsi,%rax,4)
jmp    1800 <getJT+0x670>
movss  0xe8(%rsp),%xmm0
subss  %xmm2,%xmm0
xorps  %xmm1,%xmm1
maxss  %xmm0,%xmm1
divss  %xmm2,%xmm1
mov    0x58(%rsp),%rax
mov    0xd0(%rsp),%rcx
movss  %xmm1,(%rax,%rcx,4)
mov    %rcx,%rax
ucomiss 0x783(%rip),%xmm1
jbe    17d7 <getJT+0x647>
mov    %rax,%rcx
mov    0x58(%rsp),%rax
jmp    17c5 <getJT+0x635>
mov    %r9,%rbp
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rbx
cmp    $0x2,%ebx
jl     1bce <getJT+0xa3e>
mov    %ebx,%r14d
shr    %r14d
mov    $0x4,%esi
mov    0xf8(%rsp),%r15
mov    %r15,%rdi
call   1060 <calloc@plt>
mov    %rax,0x20(%rsp)
mov    %ebx,%ebp
or     $0x1,%ebp
mov    %ebp,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1080 <fmatrix@plt>
movslq %eax,%rdi
mov    %rdi,0x30(%rsp)
mov    %ebp,0x3c(%rsp)
mov    %ebp,%esi
xor    %eax,%eax
call   10a0 <genwindow@plt>
mov    %r15d,%eax
shl    $0x2,%rax
mov    %rax,0xb8(%rsp)
mov    %r14d,%eax
neg    %eax
cltq
mov    %rax,0x90(%rsp)
movslq 0x60(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    %r14,0x50(%rsp)
lea    0x1(%r14),%r15d
movslq 0x88(%rsp),%rbp
mov    %ebx,%eax
shr    %rax
neg    %eax
mov    %rax,0x48(%rsp)
mov    $0x1,%al
mov    0x58(%rsp),%r14
mov    0xd8(%rsp),%r12
jmp    1973 <getJT+0x7e3>
nopl   0x0(%rax,%rax,1)
testb  $0x1,0xe0(%rsp)
01
mov    $0x0,%eax
je     1be0 <getJT+0xa50>
mov    %eax,0xe0(%rsp)
test   %r13d,%r13d
jle    1994 <getJT+0x804>
mov    0x20(%rsp),%rdi
mov    %r14,%rsi
mov    0xb8(%rsp),%rdx
call   1070 <memcpy@plt>
cmpl   $0x0,0x88(%rsp)
jle    1960 <getJT+0x7d0>
xor    %ebx,%ebx
mov    %r15d,0xa8(%rsp)
mov    0x90(%rsp),%rax
mov    %rax,0xc0(%rsp)
xor    %eax,%eax
mov    %rax,0x78(%rsp)
jmp    19fb <getJT+0x86b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x78(%rsp),%rax
add    $0x1,%eax
addq   $0x1,0xc0(%rsp)
addl   $0x1,0xa8(%rsp)
01
mov    %rax,0x78(%rsp)
cmp    0x88(%rsp),%eax
je     1960 <getJT+0x7d0>
cmpl   $0x0,0x60(%rsp)
jle    19d0 <getJT+0x840>
mov    0x78(%rsp),%rcx
mov    %ecx,%edx
mov    0x50(%rsp),%rax
sub    %eax,%edx
mov    %edx,0x40(%rsp)
lea    (%rcx,%rax,1),%edx
mov    %edx,0x98(%rsp)
sub    %ecx,%eax
mov    %rax,0xc8(%rsp)
movslq %ebx,%rbx
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    0x90(%rsp),%rax
mov    %rax,0xa0(%rsp)
jmp    1a87 <getJT+0x8f7>
mov    0x58(%rsp),%r14
movss  (%r14,%rbx,4),%xmm0
divss  0xc(%rsp),%xmm0
mov    0xd8(%rsp),%r12
movss  %xmm0,(%r14,%rbx,4)
add    $0x1,%rbx
mov    0x10(%rsp),%rax
add    $0x1,%eax
addq   $0x1,0xa0(%rsp)
mov    %rax,0x10(%rsp)
cmp    0x60(%rsp),%eax
je     19d0 <getJT+0x840>
cmpw   $0x0,(%r12,%rbx,2)
jne    1a63 <getJT+0x8d3>
movl   $0x0,(%r14,%rbx,4)
movss  0x56d(%rip),%xmm0
mov    0x98(%rsp),%eax
cmp    %eax,0x40(%rsp)
jg     1a5d <getJT+0x8cd>
mov    0x10(%rsp),%rcx
mov    %ecx,%edx
mov    0x50(%rsp),%rax
sub    %eax,%edx
mov    %edx,0xb0(%rsp)
add    %ecx,%eax
mov    %eax,0x68(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
mov    0xc0(%rsp),%r12
jmp    1af7 <getJT+0x967>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %r12d,0xa8(%rsp)
mov    0x74(%rsp),%r13d
je     1a44 <getJT+0x8b4>
mov    0x68(%rsp),%eax
cmp    %eax,0xb0(%rsp)
jg     1ae0 <getJT+0x950>
mov    0xc8(%rsp),%rax
add    %r12d,%eax
cltq
mov    %rax,0x80(%rsp)
mov    0x48(%rsp),%r14
mov    0xa0(%rsp),%r13
jmp    1b3d <getJT+0x9ad>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x1,%r14d
cmp    %r14d,%r15d
je     1ae0 <getJT+0x950>
test   %r12,%r12
js     1b30 <getJT+0x9a0>
cmp    %rbp,%r12
jge    1b30 <getJT+0x9a0>
test   %r13,%r13
js     1b30 <getJT+0x9a0>
cmp    0x28(%rsp),%r13
jge    1b30 <getJT+0x9a0>
mov    0x10(%rsp),%rax
lea    (%rax,%r14,1),%esi
mov    %r12d,%edi
mov    0x60(%rsp),%rdx
xor    %eax,%eax
call   1090 <LOC2@plt>
mov    0x120(%rsp),%rdx
movzbl (%rdx,%rbx,1),%ecx
cltq
cmp    (%rdx,%rax,1),%cl
jne    1b30 <getJT+0x9a0>
mov    0x30(%rsp),%rcx
mov    0x80(%rsp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    0x50(%rsp),%rdx
add    %r14d,%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    0x20(%rsp),%rsi
mulss  (%rsi,%rax,4),%xmm0
mov    0x58(%rsp),%rax
addss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  0xc(%rsp),%xmm0
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rsp)
jmp    1b30 <getJT+0x9a0>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
mov    0x3c(%rsp),%esi
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <free_fmatrix@plt>

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

LLVM IR (-O2):
define void @getJT(i8* %0, i32 %1, i32 %2, i32 %3, float* nocapture %4, i32 %5, i32 %6, i16* nocapture %7, i8* nocapture %8, i32 %9) {
%11 = bitcast float* %4 to i8*
%12 = alloca [3 x i32]
%13 = bitcast [3 x i32]* %12 to i8*
%14 = mul i32 %3, %2
%15 = shl nsw i32 %5, 1
%16 = add nsw i32 %15, %2
%17 = add nsw i32 %15, %3
%18 = mul nsw i32 %16, %17
%19 = shl nsw i32 %18, 1
%20 = sext i32 %19 to i64
%21 = tail call i8* @calloc(i64 %20, i64 1)
%22 = tail call i32 (i8*, i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @extendbounduc to i32 (i8*, i8*, i32, i32, i32, i32, ...)*)(i8* %0, i8* %21, i32 %2, i32 %3, i32 %5, i32 1)
%23 = sext i32 %14 to i64
%24 = getelementptr inbounds i8, i8* %0, i64 %23
%25 = sext i32 %18 to i64
%26 = getelementptr inbounds i8, i8* %21, i64 %25
%27 = tail call i32 (i8*, i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @extendbounduc to i32 (i8*, i8*, i32, i32, i32, i32, ...)*)(i8* %24, i8* %26, i32 %2, i32 %3, i32 %5, i32 1)
%28 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 0
store i32 0, i32* %28
%29 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 1
store i32 %6, i32* %29
%30 = mul nsw i32 %6, 3
%31 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 2
store i32 %30, i32* %31
%32 = shl nsw i32 %6, 1
%33 = sdiv i32 %15, %6
%34 = add nsw i32 %33, 1
%35 = shl i32 %34, 1
%36 = mul i32 %35, %34
%37 = add i32 %36, -40
%38 = sitofp i32 %37 to float
%39 = icmp sgt i32 %14, 0
br i1 %39, label %40, label %43
40: ; preds = %10
%41 = zext i32 %14 to i64
%42 = shl nuw nsw i64 %41, 2
br label %43
43: ; preds = %40, %10
%44 = sext i32 %1 to i64
%45 = tail call i8* @calloc(i64 %44, i64 4)
%46 = bitcast i8* %45 to float*
%47 = tail call i8* @calloc(i64 %44, i64 4)
%48 = bitcast i8* %47 to i32*
%49 = icmp sgt i32 %2, 0
br i1 %49, label %50, label %260
50: ; preds = %43
%51 = icmp sgt i32 %3, 0
%52 = icmp sgt i32 %1, 0
%53 = zext i32 %1 to i64
%54 = shl nuw nsw i64 %53, 2
%55 = and i64 %53, 1
%56 = icmp eq i32 %1, 1
%57 = and i64 %53, 4294967294
%58 = icmp eq i64 %55, 0
br label %59
59: ; preds = %50, %256
%60 = phi i32 [ 0, %50 ], [ %257, %256 ]
%61 = phi i32 [ 0, %50 ], [ %258, %256 ]
br i1 %51, label %62, label %256
62: ; preds = %59
%63 = sub nsw i32 %61, %5
%64 = add nsw i32 %61, %5
%65 = add nsw i32 %63, %6
%66 = sub nsw i32 %64, %6
%67 = add nsw i32 %63, %32
%68 = sub nsw i32 %64, %32
%69 = icmp sgt i32 %63, %64
%70 = sext i32 %60 to i64
br label %71
71: ; preds = %62, %250
%72 = phi i64 [ %70, %62 ], [ %251, %250 ]
%73 = phi i32 [ 0, %62 ], [ %252, %250 ]
%74 = getelementptr inbounds i16, i16* %7, i64 %72
%75 = load i16, i16* %74
%76 = icmp eq i16 %75, 0
br i1 %76, label %84, label %77
77: ; preds = %71
%78 = add nsw i64 %72, %23
%79 = getelementptr inbounds i16, i16* %7, i64 %78
%80 = load i16, i16* %79
%81 = icmp eq i16 %80, 0
br i1 %81, label %84, label %82
82: ; preds = %77
%83 = getelementptr inbounds float, float* %4, i64 %72
br label %248
84: ; preds = %77, %71
br i1 %52, label %85, label %86
85: ; preds = %84
br label %86
86: ; preds = %85, %84
br i1 %69, label %90, label %87
87: ; preds = %86
%88 = sub i32 %73, %5
%89 = add nsw i32 %73, %5
br label %92
90: ; preds = %142, %86
br i1 %52, label %91, label %156
91: ; preds = %90
br i1 %56, label %145, label %160
92: ; preds = %87, %142
%93 = phi i32 [ %63, %87 ], [ %143, %142 ]
%94 = icmp eq i32 %93, %63
%95 = icmp eq i32 %93, %64
%96 = select i1 %94, i1 true, i1 %95
br i1 %96, label %106, label %97
97: ; preds = %92
%98 = icmp eq i32 %93, %65
%99 = icmp eq i32 %93, %66
%100 = select i1 %98, i1 true, i1 %99
br i1 %100, label %106, label %101
101: ; preds = %97
%102 = icmp eq i32 %93, %67
%103 = icmp eq i32 %93, %68
%104 = select i1 %102, i1 true, i1 %103
%105 = zext i1 %104 to i64
br label %106
106: ; preds = %101, %97, %92
%107 = phi i64 [ 2, %92 ], [ 1, %97 ], [ %105, %101 ]
%108 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 %107
%109 = load i32, i32* %108
%110 = add nsw i32 %88, %109
%111 = sub i32 %89, %109
%112 = icmp sgt i32 %110, %111
br i1 %112, label %142, label %113
113: ; preds = %106
%114 = add nsw i32 %93, %5
br label %115
115: ; preds = %113, %115
%116 = phi i32 [ %110, %113 ], [ %140, %115 ]
%117 = add nsw i32 %116, %5
%118 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @LOC2 to i32 (i32, i32, i32, ...)*)(i32 %114, i32 %117, i32 %17)
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %21, i64 %119
%121 = load i8, i8* %120
%122 = zext i8 %121 to i64
%123 = getelementptr inbounds i32, i32* %48, i64 %122
%124 = load i32, i32* %123
%125 = add nsw i32 %124, 1
store i32 %125, i32* %123
%126 = getelementptr inbounds float, float* %46, i64 %122
%127 = load float, float* %126
%128 = fadd float %127, -1.000000e+00
store float %128, float* %126
%129 = add nsw i32 %118, %18
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i8, i8* %21, i64 %130
%132 = load i8, i8* %131
%133 = zext i8 %132 to i64
%134 = getelementptr inbounds i32, i32* %48, i64 %133
%135 = load i32, i32* %134
%136 = add nsw i32 %135, 1
store i32 %136, i32* %134
%137 = getelementptr inbounds float, float* %46, i64 %133
%138 = load float, float* %137
%139 = fadd float %138, 1.000000e+00
store float %139, float* %137
%140 = add nsw i32 %116, %6
%141 = icmp sgt i32 %140, %111
br i1 %141, label %142, label %115
142: ; preds = %115, %106
%143 = add nsw i32 %93, %6
%144 = icmp sgt i32 %143, %64
br i1 %144, label %90, label %92
145: ; preds = %181, %91
%146 = phi i64 [ 0, %91 ], [ %182, %181 ]
br i1 %58, label %156, label %147
147: ; preds = %145
%148 = getelementptr inbounds i32, i32* %48, i64 %146
%149 = load i32, i32* %148
%150 = icmp sgt i32 %149, 0
br i1 %150, label %151, label %156
151: ; preds = %147
%152 = sitofp i32 %149 to float
%153 = getelementptr inbounds float, float* %46, i64 %146
%154 = load float, float* %153
%155 = fdiv float %154, %152
store float %155, float* %153
br label %156
156: ; preds = %145, %151, %147, %90
br i1 %69, label %239, label %157
157: ; preds = %156
%158 = sub i32 %73, %5
%159 = add nsw i32 %73, %5
br label %185
160: ; preds = %91, %181
%161 = phi i64 [ %182, %181 ], [ 0, %91 ]
%162 = phi i64 [ %183, %181 ], [ 0, %91 ]
%163 = getelementptr inbounds i32, i32* %48, i64 %161
%164 = load i32, i32* %163
%165 = icmp sgt i32 %164, 0
br i1 %165, label %166, label %171
166: ; preds = %160
%167 = sitofp i32 %164 to float
%168 = getelementptr inbounds float, float* %46, i64 %161
%169 = load float, float* %168
%170 = fdiv float %169, %167
store float %170, float* %168
br label %171
171: ; preds = %160, %166
%172 = or i64 %161, 1
%173 = getelementptr inbounds i32, i32* %48, i64 %172
%174 = load i32, i32* %173
%175 = icmp sgt i32 %174, 0
br i1 %175, label %176, label %181
176: ; preds = %171
%177 = sitofp i32 %174 to float
%178 = getelementptr inbounds float, float* %46, i64 %172
%179 = load float, float* %178
%180 = fdiv float %179, %177
store float %180, float* %178
br label %181
181: ; preds = %176, %171
%182 = add nuw nsw i64 %161, 2
%183 = add i64 %162, 2
%184 = icmp eq i64 %183, %57
br i1 %184, label %145, label %160
185: ; preds = %157, %233
%186 = phi i32 [ %63, %157 ], [ %235, %233 ]
%187 = phi float [ 0.000000e+00, %157 ], [ %234, %233 ]
%188 = icmp eq i32 %186, %63
%189 = icmp eq i32 %186, %64
%190 = select i1 %188, i1 true, i1 %189
br i1 %190, label %200, label %191
191: ; preds = %185
%192 = icmp eq i32 %186, %65
%193 = icmp eq i32 %186, %66
%194 = select i1 %192, i1 true, i1 %193
br i1 %194, label %200, label %195
195: ; preds = %191
%196 = icmp eq i32 %186, %67
%197 = icmp eq i32 %186, %68
%198 = select i1 %196, i1 true, i1 %197
%199 = zext i1 %198 to i64
br label %200
200: ; preds = %195, %191, %185
%201 = phi i64 [ 2, %185 ], [ 1, %191 ], [ %199, %195 ]
%202 = getelementptr inbounds [3 x i32], [3 x i32]* %12, i64 0, i64 %201
%203 = load i32, i32* %202
%204 = add nsw i32 %158, %203
%205 = sub i32 %159, %203
%206 = icmp sgt i32 %204, %205
br i1 %206, label %233, label %207
207: ; preds = %200
%208 = add nsw i32 %186, %5
br label %209
209: ; preds = %207, %209
%210 = phi i32 [ %204, %207 ], [ %231, %209 ]
%211 = phi float [ %187, %207 ], [ %230, %209 ]
%212 = add nsw i32 %210, %5
%213 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @LOC2 to i32 (i32, i32, i32, ...)*)(i32 %208, i32 %212, i32 %17)
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i8, i8* %21, i64 %214
%216 = load i8, i8* %215
%217 = zext i8 %216 to i64
%218 = getelementptr inbounds float, float* %46, i64 %217
%219 = load float, float* %218
%220 = fsub float -1.000000e+00, %219
%221 = tail call float @llvm.fmuladd.f32(float %220, float %220, float %211)
%222 = add nsw i32 %213, %18
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %21, i64 %223
%225 = load i8, i8* %224
%226 = zext i8 %225 to i64
%227 = getelementptr inbounds float, float* %46, i64 %226
%228 = load float, float* %227
%229 = fsub float 1.000000e+00, %228
%230 = tail call float @llvm.fmuladd.f32(float %229, float %229, float %221)
%231 = add nsw i32 %210, %6
%232 = icmp sgt i32 %231, %205
br i1 %232, label %233, label %209
233: ; preds = %209, %200
%234 = phi float [ %187, %200 ], [ %230, %209 ]
%235 = add nsw i32 %186, %6
%236 = icmp sgt i32 %235, %64
br i1 %236, label %237, label %185
237: ; preds = %233
%238 = fcmp oeq float %234, 0.000000e+00
br i1 %238, label %239, label %241
239: ; preds = %156, %237
%240 = getelementptr inbounds float, float* %4, i64 %72
br label %248
241: ; preds = %237
%242 = fsub float %38, %234
%243 = fcmp olt float %242, 0.000000e+00
%244 = select i1 %243, float 0.000000e+00, float %242
%245 = fdiv float %244, %234
%246 = getelementptr inbounds float, float* %4, i64 %72
store float %245, float* %246
%247 = fcmp ogt float %245, 2.000000e+00
br i1 %247, label %248, label %250
248: ; preds = %241, %82, %239
%249 = phi float* [ %240, %239 ], [ %83, %82 ], [ %246, %241 ]
store float 2.000000e+00, float* %249
br label %250
250: ; preds = %248, %241
%251 = add nsw i64 %72, 1
%252 = add nuw nsw i32 %73, 1
%253 = icmp eq i32 %252, %3
br i1 %253, label %254, label %71
254: ; preds = %250
%255 = trunc i64 %251 to i32
br label %256
256: ; preds = %254, %59
%257 = phi i32 [ %60, %59 ], [ %255, %254 ]
%258 = add nuw nsw i32 %61, 1
%259 = icmp eq i32 %258, %2
br i1 %259, label %260, label %59
260: ; preds = %256, %43
tail call void @free(i8* %21)
tail call void @free(i8* %45)
tail call void @free(i8* %47)
%261 = icmp sgt i32 %6, 1
br i1 %261, label %262, label %380
262: ; preds = %260
%263 = lshr i32 %6, 1
%264 = tail call i8* @calloc(i64 %23, i64 4)
%265 = bitcast i8* %264 to float*
%266 = or i32 %6, 1
%267 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %266, i32 %266)
%268 = sext i32 %267 to i64
%269 = inttoptr i64 %268 to float**
%270 = tail call i32 (float**, i32, ...) bitcast (i32 (...)* @genwindow to i32 (float**, i32, ...)*)(float** %269, i32 %266)
%271 = icmp sgt i32 %3, 0
%272 = zext i32 %14 to i64
%273 = shl nuw nsw i64 %272, 2
%274 = sub nsw i32 0, %263
%275 = sext i32 %274 to i64
%276 = sext i32 %3 to i64
%277 = add nuw nsw i32 %263, 1
%278 = sext i32 %2 to i64
br label %279
279: ; preds = %262, %377
%280 = phi i1 [ true, %262 ], [ false, %377 ]
br i1 %39, label %281, label %282
281: ; preds = %279
br label %282
282: ; preds = %281, %279
br i1 %49, label %283, label %377
283: ; preds = %282, %371
%284 = phi i32 [ %375, %371 ], [ %277, %282 ]
%285 = phi i64 [ %374, %371 ], [ %275, %282 ]
%286 = phi i32 [ %372, %371 ], [ 0, %282 ]
%287 = phi i32 [ %373, %371 ], [ 0, %282 ]
br i1 %271, label %288, label %371
288: ; preds = %283
%289 = sub nsw i32 %287, %263
%290 = add nuw nsw i32 %287, %263
%291 = icmp sgt i32 %289, %290
%292 = sub nsw i32 %263, %287
%293 = sext i32 %286 to i64
br label %294
294: ; preds = %288, %363
%295 = phi i64 [ %293, %288 ], [ %364, %363 ]
%296 = phi i32 [ %277, %288 ], [ %367, %363 ]
%297 = phi i64 [ %275, %288 ], [ %366, %363 ]
%298 = phi i32 [ 0, %288 ], [ %365, %363 ]
%299 = getelementptr inbounds i16, i16* %7, i64 %295
%300 = load i16, i16* %299
%301 = icmp eq i16 %300, 0
br i1 %301, label %302, label %363
302: ; preds = %294
%303 = getelementptr inbounds float, float* %4, i64 %295
store float 0.000000e+00, float* %303
br i1 %291, label %361, label %304
304: ; preds = %302
%305 = sub nsw i32 %298, %263
%306 = add nuw nsw i32 %298, %263
%307 = icmp sgt i32 %305, %306
%308 = getelementptr inbounds i8, i8* %8, i64 %295
%309 = sub nsw i32 %263, %298
br label %310
310: ; preds = %304, %353
%311 = phi i64 [ %285, %304 ], [ %355, %353 ]
%312 = phi float [ 0.000000e+00, %304 ], [ %354, %353 ]
br i1 %307, label %353, label %313
313: ; preds = %310
%314 = icmp sgt i64 %311, -1
%315 = icmp slt i64 %311, %278
%316 = trunc i64 %311 to i32
%317 = add i32 %292, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float*, float** %269, i64 %318
br label %320
320: ; preds = %313, %348
%321 = phi i64 [ %297, %313 ], [ %350, %348 ]
%322 = phi float [ %312, %313 ], [ %349, %348 ]
br i1 %314, label %323, label %348
323: ; preds = %320
%324 = icmp sgt i64 %321, -1
%325 = select i1 %315, i1 %324, i1 false
%326 = icmp slt i64 %321, %276
%327 = select i1 %325, i1 %326, i1 false
br i1 %327, label %328, label %348
328: ; preds = %323
%329 = trunc i64 %321 to i32
%330 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @LOC2 to i32 (i32, i32, i32, ...)*)(i32 %316, i32 %329, i32 %3)
%331 = load i8, i8* %308
%332 = sext i32 %330 to i64
%333 = getelementptr inbounds i8, i8* %8, i64 %332
%334 = load i8, i8* %333
%335 = icmp eq i8 %331, %334
br i1 %335, label %336, label %348
336: ; preds = %328
%337 = load float*, float** %319
%338 = add i32 %309, %329
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds float, float* %337, i64 %339
%341 = load float, float* %340
%342 = getelementptr inbounds float, float* %265, i64 %332
%343 = load float, float* %342
%344 = load float, float* %303
%345 = tail call float @llvm.fmuladd.f32(float %341, float %343, float %344)
store float %345, float* %303
%346 = load float, float* %340
%347 = fadd float %322, %346
br label %348
348: ; preds = %320, %323, %336, %328
%349 = phi float [ %347, %336 ], [ %322, %328 ], [ %322, %323 ], [ %322, %320 ]
%350 = add nsw i64 %321, 1
%351 = trunc i64 %350 to i32
%352 = icmp eq i32 %296, %351
br i1 %352, label %353, label %320
353: ; preds = %348, %310
%354 = phi float [ %312, %310 ], [ %349, %348 ]
%355 = add nsw i64 %311, 1
%356 = trunc i64 %355 to i32
%357 = icmp eq i32 %284, %356
br i1 %357, label %358, label %310
358: ; preds = %353
%359 = load float, float* %303
%360 = fdiv float %359, %354
br label %361
361: ; preds = %358, %302
%362 = phi float [ %360, %358 ], [ 0x7FF8000000000000, %302 ]
store float %362, float* %303
br label %363
363: ; preds = %361, %294
%364 = add nsw i64 %295, 1
%365 = add nuw nsw i32 %298, 1
%366 = add nsw i64 %297, 1
%367 = add nuw i32 %296, 1
%368 = icmp eq i32 %365, %3
br i1 %368, label %369, label %294
369: ; preds = %363
%370 = trunc i64 %364 to i32
br label %371
371: ; preds = %369, %283
%372 = phi i32 [ %286, %283 ], [ %370, %369 ]
%373 = add nuw nsw i32 %287, 1
%374 = add nsw i64 %285, 1
%375 = add nuw i32 %284, 1
%376 = icmp eq i32 %373, %2
br i1 %376, label %377, label %283
377: ; preds = %371, %282
br i1 %280, label %279, label %378
378: ; preds = %377
tail call void @free(i8* %264)
%379 = tail call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %269, i32 %266)
br label %380
380: ; preds = %378, %260
ret void
}