void getJ(unsigned char *cmap, int N, int ny, int nx, float *J, 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, Stmeanx, Stmeany, *avgy, *avgx, *Jtmp, total, **weight;
  unsigned char *cmap1, *rmap1;
  int l, imgsize, imgsize2, ny2, nx2, loc, loc1, loc2, 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(imgsize2, sizeof(unsigned char));
  rmap1 = (unsigned char *)calloc(imgsize2, sizeof(unsigned char));
  extendbounduc(cmap, cmap1, ny, nx, offset, 1);
  extendbounduc(rmap0, rmap1, 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 * offset / step + 1) * (2 * offset / step + 1)) - 20;
  St1 = 0;
  for (jy = -offset; jy <= offset; 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 = -offset + corner[cornerI];
    ex = offset - corner[cornerI];
    for (jx = sx; jx <= ex; jx += step)
      St1 += ((jy) * (jy)) + ((jx) * (jx));
  }
  for (l = 0; l < imgsize; l++)
    J[l] = 0;
  avgy = (float *)calloc(N, sizeof(float));
  avgx = (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++) {
      loc2 = LOC2(iy + offset, ix + offset, nx2);
      if (rmap[loc] == 0) {
        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;
        Stmeanx = 0;
        Stmeany = 0;
        StN = StN1;
        for (i = 0; i < N; i++) {
          avgy[i] = 0;
          avgx[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);
            if (rmap1[loc1] == rmap1[loc2]) {
              avgy[cmap1[loc1]] += jy - iy;
              avgx[cmap1[loc1]] += jx - ix;
              p[cmap1[loc1]]++;
            } else {
              St -= (((jy - iy - Stmeany) * (jy - iy - Stmeany)) +
                     ((jx - ix - Stmeanx) * (jx - ix - Stmeanx))) *
                    StN / (StN - 1);
              Stmeany -= (jy - iy - Stmeany) / (StN - 1);
              Stmeanx -= (jx - ix - Stmeanx) / (StN - 1);
              StN--;
            }
          }
        }
        for (i = 0; i < N; i++) {
          if (p[i] > 0) {
            avgy[i] /= p[i];
            avgx[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);
            if (rmap1[loc1] == rmap1[loc2])
              Sw += ((jy - iy - avgy[cmap1[loc1]]) *
                     (jy - iy - avgy[cmap1[loc1]])) +
                    ((jx - ix - avgx[cmap1[loc1]]) *
                     (jx - ix - avgx[cmap1[loc1]]));
          }
        }
        if (Sw == 0)
          J[loc] = 2;
        else {
          Sb = St - Sw;
          if (Sb < 0)
            Sb = 0;
          J[loc] = Sb / Sw;
          if (J[loc] > 2)
            J[loc] = 2;
        }
      }
      loc++;
    }
  }
  free(cmap1);
  free(rmap1);
  free(avgy);
  free(avgx);
  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] = J[l];
      loc = 0;
      for (iy = 0; iy < ny; iy++) {
        for (ix = 0; ix < nx; ix++) {
          if (rmap[loc] == 0) {
            J[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]) {
                    J[loc] +=
                        weight[jy - iy + step][jx - ix + step] * Jtmp[loc1];
                    total += weight[jy - iy + step][jx - ix + step];
                  }
                }
              }
            }
            J[loc] /= total;
          }
          loc++;
        }
      }
    }
    free(Jtmp);
    free_fmatrix(weight, 2 * step + 1);
  }
}


x86 assembly (clang, -O0):
<getJ>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%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,-0xb0(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xb8(%rbp),%eax
imul   -0xbc(%rbp),%eax
mov    %eax,-0xb4(%rbp)
movslq -0xb4(%rbp),%rdi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0xb4(%rbp),%rdi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xa0(%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    0x20(%rbp),%rdi
mov    -0xa8(%rbp),%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,-0x100(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xfc(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
add    0x10(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0x24(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0xf4(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
cltd
idivl  0x10(%rbp)
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
cltd
idivl  0x10(%rbp)
mov    %eax,%ecx
mov    -0x104(%rbp),%eax
add    $0x1,%ecx
imul   %ecx,%eax
sub    $0x14,%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1423 <getJ+0x2b3>
mov    -0x30(%rbp),%eax
cmp    -0x100(%rbp),%eax
je     1325 <getJ+0x1b5>
mov    -0x30(%rbp),%eax
cmp    -0xfc(%rbp),%eax
jne    1334 <getJ+0x1c4>
movl   $0x2,-0xdc(%rbp)
jmp    13a2 <getJ+0x232>
mov    -0x30(%rbp),%eax
cmp    -0xf8(%rbp),%eax
je     1352 <getJ+0x1e2>
mov    -0x30(%rbp),%eax
cmp    -0xf4(%rbp),%eax
jne    1361 <getJ+0x1f1>
movl   $0x1,-0xdc(%rbp)
jmp    139d <getJ+0x22d>
mov    -0x30(%rbp),%eax
cmp    -0xf0(%rbp),%eax
je     137f <getJ+0x20f>
mov    -0x30(%rbp),%eax
cmp    -0xec(%rbp),%eax
jne    138e <getJ+0x21e>
movl   $0x1,-0xdc(%rbp)
jmp    1398 <getJ+0x228>
movl   $0x0,-0xdc(%rbp)
jmp    139d <getJ+0x22d>
jmp    13a2 <getJ+0x232>
xor    %eax,%eax
sub    -0x24(%rbp),%eax
movslq -0xdc(%rbp),%rcx
add    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x24(%rbp),%eax
movslq -0xdc(%rbp),%rcx
sub    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jg     1410 <getJ+0x2a0>
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    %ecx,%eax
cvtsi2ss %eax,%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    0x10(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    13d5 <getJ+0x265>
jmp    1415 <getJ+0x2a5>
mov    0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    12fb <getJ+0x18b>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1466 <getJ+0x2f6>
mov    -0x20(%rbp),%rax
movslq -0xac(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    142d <getJ+0x2bd>
movslq -0xc(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0xc(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0xc(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0xc0(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c2e <getJ+0xabe>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c1b <getJ+0xaab>
mov    -0x28(%rbp),%edi
add    -0x24(%rbp),%edi
mov    -0x2c(%rbp),%esi
add    -0x24(%rbp),%esi
mov    -0xbc(%rbp),%edx
mov    $0x0,%al
call   1070 <LOC2@plt>
mov    %eax,-0xc8(%rbp)
mov    0x18(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1bfe <getJ+0xa8e>
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
add    0x10(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    0x10(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15d1 <getJ+0x461>
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%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    1588 <getJ+0x418>
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jg     1897 <getJ+0x727>
mov    -0x30(%rbp),%eax
cmp    -0x100(%rbp),%eax
je     161f <getJ+0x4af>
mov    -0x30(%rbp),%eax
cmp    -0xfc(%rbp),%eax
jne    162e <getJ+0x4be>
movl   $0x2,-0xdc(%rbp)
jmp    169c <getJ+0x52c>
mov    -0x30(%rbp),%eax
cmp    -0xf8(%rbp),%eax
je     164c <getJ+0x4dc>
mov    -0x30(%rbp),%eax
cmp    -0xf4(%rbp),%eax
jne    165b <getJ+0x4eb>
movl   $0x1,-0xdc(%rbp)
jmp    1697 <getJ+0x527>
mov    -0x30(%rbp),%eax
cmp    -0xf0(%rbp),%eax
je     1679 <getJ+0x509>
mov    -0x30(%rbp),%eax
cmp    -0xec(%rbp),%eax
jne    1688 <getJ+0x518>
movl   $0x1,-0xdc(%rbp)
jmp    1692 <getJ+0x522>
movl   $0x0,-0xdc(%rbp)
jmp    1697 <getJ+0x527>
jmp    169c <getJ+0x52c>
mov    -0x2c(%rbp),%eax
sub    -0x24(%rbp),%eax
movslq -0xdc(%rbp),%rcx
add    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
movslq -0xdc(%rbp),%rcx
sub    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jg     1884 <getJ+0x714>
mov    -0x30(%rbp),%edi
add    -0x24(%rbp),%edi
mov    -0x34(%rbp),%esi
add    -0x24(%rbp),%esi
mov    -0xbc(%rbp),%edx
mov    $0x0,%al
call   1070 <LOC2@plt>
mov    %eax,-0xc4(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0xa8(%rbp),%rcx
movslq -0xc8(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    17a5 <getJ+0x635>
mov    -0x30(%rbp),%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov    -0x80(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1871 <getJ+0x701>
mov    -0x30(%rbp),%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm1
subss  -0x6c(%rbp),%xmm1
mov    -0x30(%rbp),%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm2
subss  -0x6c(%rbp),%xmm2
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm0
subss  -0x68(%rbp),%xmm0
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm3
subss  -0x68(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
mulss  %xmm0,%xmm1
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm1
subss  -0x6c(%rbp),%xmm1
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm1
movss  -0x6c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm1
subss  -0x68(%rbp),%xmm1
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm1
movss  -0x68(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1876 <getJ+0x706>
mov    0x10(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    16d3 <getJ+0x563>
jmp    1889 <getJ+0x719>
mov    0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    15f2 <getJ+0x482>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1915 <getJ+0x7a5>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1902 <getJ+0x792>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1907 <getJ+0x797>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    189e <getJ+0x72e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jg     1b49 <getJ+0x9d9>
mov    -0x30(%rbp),%eax
cmp    -0x100(%rbp),%eax
je     196b <getJ+0x7fb>
mov    -0x30(%rbp),%eax
cmp    -0xfc(%rbp),%eax
jne    197a <getJ+0x80a>
movl   $0x2,-0xdc(%rbp)
jmp    19e8 <getJ+0x878>
mov    -0x30(%rbp),%eax
cmp    -0xf8(%rbp),%eax
je     1998 <getJ+0x828>
mov    -0x30(%rbp),%eax
cmp    -0xf4(%rbp),%eax
jne    19a7 <getJ+0x837>
movl   $0x1,-0xdc(%rbp)
jmp    19e3 <getJ+0x873>
mov    -0x30(%rbp),%eax
cmp    -0xf0(%rbp),%eax
je     19c5 <getJ+0x855>
mov    -0x30(%rbp),%eax
cmp    -0xec(%rbp),%eax
jne    19d4 <getJ+0x864>
movl   $0x1,-0xdc(%rbp)
jmp    19de <getJ+0x86e>
movl   $0x0,-0xdc(%rbp)
jmp    19e3 <getJ+0x873>
jmp    19e8 <getJ+0x878>
mov    -0x2c(%rbp),%eax
sub    -0x24(%rbp),%eax
movslq -0xdc(%rbp),%rcx
add    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
movslq -0xdc(%rbp),%rcx
sub    -0x54(%rbp,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jg     1b36 <getJ+0x9c6>
mov    -0x30(%rbp),%edi
add    -0x24(%rbp),%edi
mov    -0x34(%rbp),%esi
add    -0x24(%rbp),%esi
mov    -0xbc(%rbp),%edx
mov    $0x0,%al
call   1070 <LOC2@plt>
mov    %eax,-0xc4(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0xa8(%rbp),%rcx
movslq -0xc8(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1b23 <getJ+0x9b3>
mov    -0x30(%rbp),%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
subss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm2
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
subss  (%rax,%rcx,4),%xmm2
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm1
mov    -0x80(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
subss  (%rax,%rcx,4),%xmm1
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm3
mov    -0x80(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1b28 <getJ+0x9b8>
mov    0x10(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1a1f <getJ+0x8af>
jmp    1b3b <getJ+0x9cb>
mov    0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    193e <getJ+0x7ce>
movss  -0x64(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1b7d <getJ+0xa0d>
jp     1b7d <getJ+0xa0d>
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  0x48d(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1bf9 <getJ+0xa89>
movss  -0x5c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x60(%rbp),%xmm0
jbe    1ba1 <getJ+0xa31>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
divss  -0x64(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x42d(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    1bf4 <getJ+0xa84>
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  0x411(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1bf9 <getJ+0xa89>
jmp    1bfe <getJ+0xa8e>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14c0 <getJ+0x350>
jmp    1c20 <getJ+0xab0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14ad <getJ+0x33d>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,0x10(%rbp)
jle    1f72 <getJ+0xe02>
mov    0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,0x10(%rbp)
movslq -0xb0(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x88(%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,-0x98(%rbp)
mov    -0x98(%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    1f4f <getJ+0xddf>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1d2e <getJ+0xbbe>
mov    -0x20(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1ce5 <getJ+0xb75>
movl   $0x0,-0xc0(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1f3c <getJ+0xdcc>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1f29 <getJ+0xdb9>
mov    0x18(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1f0c <getJ+0xd9c>
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
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     1eeb <getJ+0xd7b>
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     1ed8 <getJ+0xd68>
cmpl   $0x0,-0x30(%rbp)
jl     1ec5 <getJ+0xd55>
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1ec5 <getJ+0xd55>
cmpl   $0x0,-0x34(%rbp)
jl     1ec5 <getJ+0xd55>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ec5 <getJ+0xd55>
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    $0x0,%al
call   1070 <LOC2@plt>
mov    %eax,-0xc4(%rbp)
mov    0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    0x20(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1ec0 <getJ+0xd50>
mov    -0x98(%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    -0x88(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%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  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
jmp    1ec5 <getJ+0xd55>
jmp    1eca <getJ+0xd5a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1db7 <getJ+0xc47>
jmp    1edd <getJ+0xd6d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d9d <getJ+0xc2d>
movss  -0x8c(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d52 <getJ+0xbe2>
jmp    1f2e <getJ+0xdbe>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1d3f <getJ+0xbcf>
jmp    1f41 <getJ+0xdd1>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1cd1 <getJ+0xb61>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
mov    0x10(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
mov    $0x0,%al
call   1040 <free_fmatrix@plt>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getJ>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9d,%r15d
mov    %r8,0xa0(%rsp)
mov    %ecx,%r12d
mov    %edx,%ebp
mov    %esi,0x40(%rsp)
mov    %rdi,0x50(%rsp)
mov    0x1b0(%rsp),%rax
mov    %rax,0x128(%rsp)
mov    0x1a8(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    0x1a0(%rsp),%eax
mov    %rax,0x10(%rsp)
mov    %r9d,%r14d
neg    %r14d
mov    %ecx,%eax
imul   %edx,%eax
mov    %eax,0x74(%rsp)
lea    (%r15,%r15,1),%eax
mov    %eax,0x38(%rsp)
lea    0x0(%rbp,%r15,2),%eax
lea    (%r12,%r15,2),%ecx
mov    %ecx,0xa8(%rsp)
imul   %ecx,%eax
movslq %eax,%rbx
mov    $0x1,%esi
mov    %rbx,%rdi
call   1060 <calloc@plt>
mov    %rax,%r13
mov    $0x1,%esi
mov    %rbx,%rdi
call   1060 <calloc@plt>
mov    %rax,%rbx
mov    0x50(%rsp),%rdi
mov    %r13,0x78(%rsp)
mov    %r13,%rsi
mov    %ebp,%edx
mov    %r12d,%ecx
mov    %r15d,%r8d
mov    $0x1,%r9d
xor    %eax,%eax
call   10b0 <extendbounduc@plt>
mov    0x128(%rsp),%rdi
mov    %rbx,0x68(%rsp)
mov    %rbx,%rsi
mov    %rbp,0x88(%rsp)
mov    %ebp,%edx
mov    %r12,0x50(%rsp)
mov    %r12d,%ecx
mov    %r15d,%r8d
mov    $0x1,%r9d
xor    %eax,%eax
call   10b0 <extendbounduc@plt>
mov    0x10(%rsp),%rsi
movl   $0x0,0x10c(%rsp)
mov    %esi,0x110(%rsp)
lea    (%rsi,%rsi,2),%eax
mov    %eax,0x114(%rsp)
lea    (%rsi,%rsi,1),%eax
mov    %rax,0x118(%rsp)
mov    0x38(%rsp),%eax
cltd
idiv   %esi
mov    %eax,%r12d
xorps  %xmm1,%xmm1
mov    %r15,0x8(%rsp)
mov    %r14,0xd8(%rsp)
cmp    %r15d,%r14d
jle    1c84 <getJ+0xaf4>
movaps %xmm1,0x130(%rsp)
mov    0x74(%rsp),%eax
mov    %eax,%ebx
test   %eax,%eax
mov    0xa0(%rsp),%r15
jle    1302 <getJ+0x172>
lea    0x0(,%rbx,4),%rdx
mov    %r15,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    %rbx,0xe0(%rsp)
movslq 0x40(%rsp),%rbx
mov    $0x4,%esi
mov    %rbx,%rdi
call   1060 <calloc@plt>
mov    %rax,0x30(%rsp)
mov    $0x4,%esi
mov    %rbx,%rdi
call   1060 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    $0x4,%esi
mov    %rbx,%rdi
call   1060 <calloc@plt>
mov    %rax,0x60(%rsp)
cmpl   $0x0,0x88(%rsp)
movdqa 0x130(%rsp),%xmm0
jle    1960 <getJ+0x7d0>
add    $0x1,%r12d
imul   %r12d,%r12d
add    $0xffffffec,%r12d
mov    %r12d,0x104(%rsp)
mov    0x40(%rsp),%eax
mov    %rax,0xf8(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x148(%rsp)
movq   %xmm0,%xmm1
pxor   %xmm0,%xmm0
shufps $0xe2,%xmm0,%xmm1
movaps %xmm1,0x150(%rsp)
xor    %ecx,%ecx
xor    %eax,%eax
mov    %rax,0x58(%rsp)
jmp    13ca <getJ+0x23a>
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x58(%rsp)
cmp    0x88(%rsp),%eax
je     1960 <getJ+0x7d0>
cmpl   $0x0,0x50(%rsp)
jle    13b0 <getJ+0x220>
mov    0x8(%rsp),%rax
mov    0x58(%rsp),%rdx
lea    (%rdx,%rax,1),%esi
sub    %eax,%edx
mov    0x10(%rsp),%rax
lea    (%rdx,%rax,1),%edi
mov    %edi,0xbc(%rsp)
mov    %esi,%edi
sub    %eax,%edi
mov    %edi,0xb8(%rsp)
mov    0x118(%rsp),%rax
mov    %rdx,0x48(%rsp)
add    %eax,%edx
mov    %edx,0xb4(%rsp)
mov    %esi,0x20(%rsp)
sub    %eax,%esi
mov    %esi,0xb0(%rsp)
movslq %ecx,%rcx
xor    %ebx,%ebx
jmp    1467 <getJ+0x2d7>
ucomiss 0xbdd(%rip),%xmm2
mov    0xa0(%rsp),%r15
jne    1924 <getJ+0x794>
jp     1924 <getJ+0x794>
mov    0xe8(%rsp),%rcx
lea    (%r15,%rcx,4),%rax
movl   $0x40000000,(%rax)
mov    0x18(%rsp),%rbx
add    $0x1,%rcx
add    $0x1,%ebx
cmp    0x50(%rsp),%ebx
je     13b0 <getJ+0x220>
mov    %rcx,0xe8(%rsp)
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,1),%r12d
mov    0x20(%rsp),%edi
mov    %r12d,%esi
mov    0xa8(%rsp),%edx
xor    %eax,%eax
call   1090 <LOC2@plt>
mov    0xe8(%rsp),%rcx
movaps 0x130(%rsp),%xmm0
mov    %eax,%ebp
mov    0x120(%rsp),%rax
cmpw   $0x0,(%rax,%rcx,2)
jne    1456 <getJ+0x2c6>
mov    %rbx,0x18(%rsp)
cmpl   $0x0,0x40(%rsp)
jle    14f7 <getJ+0x367>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
mov    0x148(%rsp),%rbx
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x28(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x60(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
movaps 0x130(%rsp),%xmm0
movaps %xmm0,0xc0(%rsp)
mov    0x48(%rsp),%rax
cmp    0x20(%rsp),%eax
mov    0x10(%rsp),%rdx
mov    %r12d,0x44(%rsp)
jg     1748 <getJ+0x5b8>
mov    0x18(%rsp),%rax
sub    0x8(%rsp),%eax
mov    %rax,0xf0(%rsp)
mov    %ebp,0x108(%rsp)
movslq %ebp,%rax
mov    %rax,0x98(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x80(%rsp)
mov    0x48(%rsp),%rax
mov    %eax,%esi
mov    0x104(%rsp),%r14d
movaps 0x150(%rsp),%xmm0
movaps %xmm0,0xc0(%rsp)
jmp    1591 <getJ+0x401>
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rsi
add    %edx,%esi
cmp    0x20(%rsp),%esi
mov    0xa0(%rsp),%r15
mov    0x44(%rsp),%r12d
jg     172d <getJ+0x59d>
mov    $0x2,%eax
cmp    0x48(%rsp),%esi
je     15d2 <getJ+0x442>
cmp    0x20(%rsp),%esi
je     15d2 <getJ+0x442>
mov    $0x1,%eax
cmp    0xbc(%rsp),%esi
je     15d2 <getJ+0x442>
cmp    0xb8(%rsp),%esi
je     15d2 <getJ+0x442>
cmp    0xb4(%rsp),%esi
sete   %al
cmp    0xb0(%rsp),%esi
sete   %cl
or     %al,%cl
movzbl %cl,%eax
mov    0x10c(%rsp,%rax,4),%r13d
mov    0xf0(%rsp),%rax
lea    (%rax,%r13,1),%ebx
sub    %r13d,%r12d
cmp    %r12d,%ebx
mov    %rsi,0x90(%rsp)
jg     1570 <getJ+0x3e0>
mov    %esi,%eax
sub    0x58(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x38(%rsp)
mov    0x8(%rsp),%rax
lea    (%rsi,%rax,1),%r15d
mov    0xd8(%rsp),%rax
lea    (%rax,%r13,1),%ebp
add    0x18(%rsp),%r13d
jmp    16bb <getJ+0x52b>
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
movss  0x38(%rsp),%xmm1
movaps 0xc0(%rsp),%xmm6
subss  %xmm6,%xmm1
movss  0x80(%rsp),%xmm7
subss  %xmm7,%xmm0
movaps %xmm0,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulss  %xmm1,%xmm3
xorps  %xmm4,%xmm4
cvtsi2ss %r14d,%xmm4
add    $0xffffffff,%r14d
xorps  %xmm5,%xmm5
cvtsi2ss %r14d,%xmm5
addss  %xmm2,%xmm3
mulss  %xmm3,%xmm4
unpcklps %xmm4,%xmm1
divss  %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm5
divps  %xmm5,%xmm1
subps  %xmm1,%xmm6
movaps %xmm6,0xc0(%rsp)
subss  %xmm0,%xmm7
movss  %xmm7,0x80(%rsp)
mov    0x10(%rsp),%rdx
add    %edx,%ebx
add    %edx,%ebp
add    %edx,%r13d
cmp    %r12d,%ebx
jg     1570 <getJ+0x3e0>
mov    %r15d,%edi
mov    %r13d,%esi
mov    0xa8(%rsp),%edx
xor    %eax,%eax
call   1090 <LOC2@plt>
cltq
mov    0x68(%rsp),%rdx
movzbl (%rdx,%rax,1),%ecx
mov    0x98(%rsp),%rsi
cmp    (%rdx,%rsi,1),%cl
jne    1630 <getJ+0x4a0>
mov    0x78(%rsp),%rcx
movzbl (%rcx,%rax,1),%eax
mov    0x30(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %ebp,%xmm1
addss  0x38(%rsp),%xmm0
movss  %xmm0,(%rcx,%rax,4)
mov    0x28(%rsp),%rcx
addss  (%rcx,%rax,4),%xmm1
movss  %xmm1,(%rcx,%rax,4)
mov    0x60(%rsp),%rcx
addl   $0x1,(%rcx,%rax,4)
jmp    16a6 <getJ+0x516>
movaps 0xc0(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,0xc0(%rsp)
mov    0x108(%rsp),%ebp
cmpl   $0x0,0x40(%rsp)
jle    17b0 <getJ+0x620>
xor    %eax,%eax
jmp    176e <getJ+0x5de>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
cmp    %rax,0xf8(%rsp)
je     17b0 <getJ+0x620>
mov    0x60(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
test   %ecx,%ecx
jle    1760 <getJ+0x5d0>
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mov    0x30(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rax,4)
mov    0x28(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rax,4)
jmp    1760 <getJ+0x5d0>
nopl   0x0(%rax)
mov    0x48(%rsp),%rax
cmp    0x20(%rsp),%eax
jg     143f <getJ+0x2af>
mov    0x18(%rsp),%rax
sub    0x8(%rsp),%eax
mov    %rax,0x90(%rsp)
movslq %ebp,%r15
xorps  %xmm2,%xmm2
mov    0x48(%rsp),%rax
mov    %eax,%esi
jmp    17f9 <getJ+0x669>
nop
mov    0x80(%rsp),%rsi
add    %edx,%esi
cmp    0x20(%rsp),%esi
mov    0x44(%rsp),%r12d
jg     1424 <getJ+0x294>
mov    $0x2,%eax
cmp    0x48(%rsp),%esi
je     183a <getJ+0x6aa>
cmp    0x20(%rsp),%esi
je     183a <getJ+0x6aa>
mov    $0x1,%eax
cmp    0xbc(%rsp),%esi
je     183a <getJ+0x6aa>
cmp    0xb8(%rsp),%esi
je     183a <getJ+0x6aa>
cmp    0xb4(%rsp),%esi
sete   %al
cmp    0xb0(%rsp),%esi
sete   %cl
or     %al,%cl
movzbl %cl,%eax
mov    0x10c(%rsp,%rax,4),%ebp
mov    0x90(%rsp),%rax
lea    (%rax,%rbp,1),%ebx
mov    %r12d,%r14d
sub    %ebp,%r14d
cmp    %r14d,%ebx
mov    %rsi,0x80(%rsp)
jg     17e0 <getJ+0x650>
mov    %esi,%eax
sub    0x58(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x98(%rsp)
mov    0x8(%rsp),%rax
lea    (%rsi,%rax,1),%r13d
mov    0xd8(%rsp),%rax
lea    (%rax,%rbp,1),%r12d
add    0x18(%rsp),%ebp
jmp    18e9 <getJ+0x759>
mov    0x78(%rsp),%rcx
movzbl (%rcx,%rax,1),%eax
movss  0x98(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %r12d,%xmm1
mov    0x30(%rsp),%rcx
subss  (%rcx,%rax,4),%xmm0
mov    0x28(%rsp),%rcx
subss  (%rcx,%rax,4),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x38(%rsp),%xmm2
addss  %xmm0,%xmm2
mov    0x10(%rsp),%rdx
add    %edx,%ebx
add    %edx,%r12d
add    %edx,%ebp
cmp    %r14d,%ebx
jg     17e0 <getJ+0x650>
movss  %xmm2,0x38(%rsp)
mov    %r13d,%edi
mov    %ebp,%esi
mov    0xa8(%rsp),%edx
xor    %eax,%eax
call   1090 <LOC2@plt>
cltq
mov    0x68(%rsp),%rdx
movzbl (%rdx,%rax,1),%ecx
cmp    (%rdx,%r15,1),%cl
je     1890 <getJ+0x700>
mov    0x10(%rsp),%rdx
movss  0x38(%rsp),%xmm2
jmp    18d9 <getJ+0x749>
movaps 0xc0(%rsp),%xmm1
subss  %xmm2,%xmm1
xorps  %xmm0,%xmm0
maxss  %xmm1,%xmm0
divss  %xmm2,%xmm0
mov    0xe8(%rsp),%rcx
movss  %xmm0,(%r15,%rcx,4)
ucomiss 0x6b0(%rip),%xmm0
mov    0x18(%rsp),%rbx
ja     1447 <getJ+0x2b7>
jmp    1456 <getJ+0x2c6>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rbp
cmp    $0x2,%ebp
mov    0xe0(%rsp),%r14
jl     1d3a <getJ+0xbaa>
mov    %ebp,%r12d
shr    %r12d
movslq 0x74(%rsp),%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebp,%ebx
or     $0x1,%ebx
mov    %ebx,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1080 <fmatrix@plt>
movslq %eax,%rdi
mov    %rdi,0xc0(%rsp)
mov    %ebx,0x58(%rsp)
mov    %ebx,%esi
xor    %eax,%eax
call   10a0 <genwindow@plt>
shl    $0x2,%r14
mov    %r14,0xe0(%rsp)
mov    %r12d,%eax
neg    %eax
cltq
mov    %rax,0x18(%rsp)
movslq 0x50(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    %r12,0x30(%rsp)
lea    0x1(%r12),%r13d
movslq 0x88(%rsp),%rbx
mov    %ebp,%eax
shr    %rax
neg    %eax
mov    %rax,0x48(%rsp)
mov    $0x1,%al
jmp    1a53 <getJ+0x8c3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
testb  $0x1,0xf0(%rsp)
01
mov    $0x0,%eax
je     1d4c <getJ+0xbbc>
mov    %eax,0xf0(%rsp)
cmpl   $0x0,0x74(%rsp)
jle    1a76 <getJ+0x8e6>
mov    0x28(%rsp),%rdi
mov    %r15,%rsi
mov    0xe0(%rsp),%rdx
call   1070 <memcpy@plt>
cmpl   $0x0,0x88(%rsp)
jle    1a40 <getJ+0x8b0>
xor    %ebp,%ebp
mov    %r13d,0x78(%rsp)
mov    0x18(%rsp),%rax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
jmp    1abf <getJ+0x92f>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xf8(%rsp),%rax
add    $0x1,%eax
addq   $0x1,0x8(%rsp)
addl   $0x1,0x78(%rsp)
cmp    0x88(%rsp),%eax
je     1a40 <getJ+0x8b0>
cmpl   $0x0,0x50(%rsp)
jle    1aa8 <getJ+0x918>
mov    %eax,%edx
mov    %rax,%rcx
mov    0x30(%rsp),%rax
sub    %eax,%edx
mov    %edx,0x44(%rsp)
lea    (%rcx,%rax,1),%edx
mov    %edx,0x90(%rsp)
mov    %rcx,0xf8(%rsp)
sub    %ecx,%eax
mov    %rax,0x20(%rsp)
movslq %ebp,%rbp
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    0x18(%rsp),%rax
mov    %rax,0x60(%rsp)
jmp    1b40 <getJ+0x9b0>
mov    0xa0(%rsp),%r15
movss  (%r15,%rbp,4),%xmm0
divss  0x68(%rsp),%xmm0
movss  %xmm0,(%r15,%rbp,4)
add    $0x1,%rbp
mov    0x10(%rsp),%rax
add    $0x1,%eax
addq   $0x1,0x60(%rsp)
mov    %rax,0x10(%rsp)
cmp    0x50(%rsp),%eax
je     1aa0 <getJ+0x910>
mov    0x120(%rsp),%rax
cmpw   $0x0,(%rax,%rbp,2)
jne    1b1f <getJ+0x98f>
movl   $0x0,(%r15,%rbp,4)
movss  0x4a5(%rip),%xmm0
mov    0x90(%rsp),%eax
cmp    %eax,0x44(%rsp)
jg     1b19 <getJ+0x989>
mov    0x10(%rsp),%rcx
mov    %ecx,%edx
mov    0x30(%rsp),%rax
sub    %eax,%edx
mov    %edx,0x98(%rsp)
add    %ecx,%eax
mov    %eax,0x80(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x68(%rsp)
mov    0x8(%rsp),%r15
jmp    1baf <getJ+0xa1f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    %r15d,0x78(%rsp)
je     1b05 <getJ+0x975>
mov    0x80(%rsp),%eax
cmp    %eax,0x98(%rsp)
jg     1ba0 <getJ+0xa10>
mov    0x20(%rsp),%rax
add    %r15d,%eax
cltq
mov    %rax,0x38(%rsp)
mov    0x48(%rsp),%r14
mov    0x60(%rsp),%r12
jmp    1bed <getJ+0xa5d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0x1,%r14d
cmp    %r14d,%r13d
je     1ba0 <getJ+0xa10>
test   %r15,%r15
js     1be0 <getJ+0xa50>
cmp    %rbx,%r15
jge    1be0 <getJ+0xa50>
test   %r12,%r12
js     1be0 <getJ+0xa50>
cmp    0xa8(%rsp),%r12
jge    1be0 <getJ+0xa50>
mov    0x10(%rsp),%rax
lea    (%rax,%r14,1),%esi
mov    %r15d,%edi
mov    0x50(%rsp),%rdx
xor    %eax,%eax
call   1090 <LOC2@plt>
mov    0x128(%rsp),%rdx
movzbl (%rdx,%rbp,1),%ecx
cltq
cmp    (%rdx,%rax,1),%cl
jne    1be0 <getJ+0xa50>
mov    0xc0(%rsp),%rcx
mov    0x38(%rsp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    0x30(%rsp),%rdx
add    %r14d,%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    0x28(%rsp),%rsi
mulss  (%rsi,%rax,4),%xmm0
mov    0xa0(%rsp),%rax
addss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
movss  0x68(%rsp),%xmm0
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0x68(%rsp)
jmp    1be0 <getJ+0xa50>
mov    %esi,%eax
mov    0x8(%rsp),%rcx
sub    %ecx,%eax
mov    %ecx,%r10d
sub    %esi,%r10d
mov    0x118(%rsp),%rdx
mov    %edx,%r8d
sub    %ecx,%r8d
mov    %ecx,%r9d
sub    %edx,%r9d
xorps  %xmm1,%xmm1
mov    0xd8(%rsp),%rcx
mov    %ecx,%edx
jmp    1ccc <getJ+0xb3c>
cs nopw 0x0(%rax,%rax,1)
add    %esi,%edx
cmp    0x8(%rsp),%edx
jg     12d6 <getJ+0x146>
mov    $0x2,%ebp
cmp    0xd8(%rsp),%edx
je     1cff <getJ+0xb6f>
cmp    0x8(%rsp),%edx
je     1cff <getJ+0xb6f>
mov    $0x1,%ebp
cmp    %eax,%edx
je     1cff <getJ+0xb6f>
cmp    %r10d,%edx
je     1cff <getJ+0xb6f>
cmp    %r8d,%edx
sete   %bl
cmp    %r9d,%edx
sete   %cl
or     %bl,%cl
movzbl %cl,%ebp
mov    0x10c(%rsp,%rbp,4),%ebp
mov    0x8(%rsp),%rcx
mov    %ecx,%ebx
sub    %ebp,%ebx
sub    %ecx,%ebp
cmp    %ebx,%ebp
jg     1cc0 <getJ+0xb30>
mov    %edx,%edi
imul   %edx,%edi
nopw   0x0(%rax,%rax,1)
mov    %ebp,%ecx
imul   %ebp,%ecx
add    %edi,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
addss  %xmm0,%xmm1
add    %esi,%ebp
cmp    %ebx,%ebp
jle    1d20 <getJ+0xb90>
jmp    1cc0 <getJ+0xb30>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0xc0(%rsp),%rdi
mov    0x58(%rsp),%esi
xor    %eax,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <free_fmatrix@plt>

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

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