float gettotalJS(unsigned char *cmap, int N, int ny, int nx,
                 unsigned char *rmap, int TR, float *totalJ, float **mapmatrix,
                 int oldTR) {
  int iy, ix, i, j, *StN, **avgN, l;
  float *St, *Sb, *Sw, *Stmeanx, *Stmeany, **avgy, **avgx, overallJ, **var;
  int debug = 0;
  St = (float *)calloc(TR + 1, sizeof(float));
  Sb = (float *)calloc(TR + 1, sizeof(float));
  Sw = (float *)calloc(TR + 1, sizeof(float));
  Stmeanx = (float *)calloc(TR + 1, sizeof(float));
  Stmeany = (float *)calloc(TR + 1, sizeof(float));
  StN = (int *)calloc(TR + 1, sizeof(int));
  avgy = (float **)fmatrix(TR + 1, N);
  avgx = (float **)fmatrix(TR + 1, N);
  avgN = (int **)imatrix(TR + 1, N);
  var = (float **)fmatrix(TR + 1, N);
  l = 0;
  for (iy = 0; iy < ny; iy++) {
    for (ix = 0; ix < nx; ix++) {
      if (rmap[l] > 0) {
        i = rmap[l];
        j = cmap[l];
        Stmeanx[i] += ix;
        Stmeany[i] += iy;
        StN[i]++;
        avgx[i][j] += ix;
        avgy[i][j] += iy;
        avgN[i][j]++;
      }
      l++;
    }
  }
  for (i = 1; i <= TR; i++) {
    Stmeanx[i] /= StN[i];
    Stmeany[i] /= StN[i];
    for (j = 0; j < N; j++) {
      if (avgN[i][j] > 0) {
        avgx[i][j] /= avgN[i][j];
        avgy[i][j] /= avgN[i][j];
      }
    }
  }
  l = 0;
  for (iy = 0; iy < ny; iy++) {
    for (ix = 0; ix < nx; ix++) {
      if (rmap[l] > 0) {
        i = rmap[l];
        j = cmap[l];
        St[i] += ((iy - Stmeany[i]) * (iy - Stmeany[i])) +
                 ((ix - Stmeanx[i]) * (ix - Stmeanx[i]));
        var[i][j] += ((iy - avgy[i][j]) * (iy - avgy[i][j])) +
                     ((ix - avgx[i][j]) * (ix - avgx[i][j]));
      }
      l++;
    }
  }
  for (i = 1; i <= TR; i++) {
    for (j = 0; j < N; j++)
      Sw[i] += var[i][j];
  }
  overallJ = 0;
  for (i = 1; i <= TR; i++) {
    if (Sw[i] == 0)
      printf("Sw[%d]=0\n", i);
    else {
      Sb[i] = St[i] - Sw[i];
      totalJ[i] = Sb[i] / Sw[i];
      overallJ += StN[i] * totalJ[i];
    }
  }
  overallJ = overallJ / ny / nx;
  if (debug)
    printf("\n%5.3f\n", overallJ);
  if (oldTR > 0) {
    for (i = 1; i <= TR; i++) {
      for (j = 0; j < N; j++)
        mapmatrix[i][j] = var[i][j];
      mapmatrix[i][N] = St[i];
    }
  }
  free(Stmeanx);
  free(Stmeany);
  free(StN);
  free(St);
  free(Sb);
  free(Sw);
  free_fmatrix(avgx, TR + 1);
  free_fmatrix(avgy, TR + 1);
  free_imatrix(avgN, TR + 1);
  free_fmatrix(var, TR + 1);
  return overallJ;
}


x86 assembly (clang, -O0):
<gettotalJS>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%edi
add    $0x1,%edi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1090 <fmatrix@plt>
cltq
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%edi
add    $0x1,%edi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1090 <fmatrix@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0x24(%rbp),%edi
add    $0x1,%edi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1040 <imatrix@plt>
cltq
mov    %rax,-0x48(%rbp)
mov    -0x24(%rbp),%edi
add    $0x1,%edi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1090 <fmatrix@plt>
cltq
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13b0 <gettotalJS+0x240>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    139d <gettotalJS+0x22d>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jle    1386 <gettotalJS+0x216>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
cvtsi2ssl -0x2c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
cvtsi2ssl -0x2c(%rbp),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl -0x28(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ae <gettotalJS+0x13e>
jmp    13a2 <gettotalJS+0x232>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    129b <gettotalJS+0x12b>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14c5 <gettotalJS+0x355>
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14b2 <gettotalJS+0x342>
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    149f <gettotalJS+0x32f>
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    14a4 <gettotalJS+0x334>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1410 <gettotalJS+0x2a0>
jmp    14b7 <gettotalJS+0x347>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b7 <gettotalJS+0x247>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    164c <gettotalJS+0x4dc>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1639 <gettotalJS+0x4c9>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jle    1622 <gettotalJS+0x4b2>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
cvtsi2ssl -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x28(%rbp),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtsi2ssl -0x2c(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x2c(%rbp),%xmm3
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl -0x28(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x28(%rbp),%xmm2
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtsi2ssl -0x2c(%rbp),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x2c(%rbp),%xmm3
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14e6 <gettotalJS+0x376>
jmp    163e <gettotalJS+0x4ce>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14d3 <gettotalJS+0x363>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     16bd <gettotalJS+0x54d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16aa <gettotalJS+0x53a>
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1666 <gettotalJS+0x4f6>
jmp    16af <gettotalJS+0x53f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1653 <gettotalJS+0x4e3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     17a3 <gettotalJS+0x633>
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1710 <gettotalJS+0x5a0>
jp     1710 <gettotalJS+0x5a0>
mov    -0x30(%rbp),%esi
lea    0x8fc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1790 <gettotalJS+0x620>
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
jmp    1795 <gettotalJS+0x625>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16cf <gettotalJS+0x55f>
movss  -0x8c(%rbp),%xmm0
ff
cvtsi2ssl -0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
cmpl   $0x0,-0x9c(%rbp)
je     17ec <gettotalJS+0x67c>
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x825(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
cmpl   $0x0,0x20(%rbp)
jle    188c <gettotalJS+0x71c>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1887 <gettotalJS+0x717>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1857 <gettotalJS+0x6e7>
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1810 <gettotalJS+0x6a0>
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17fd <gettotalJS+0x68d>
jmp    188c <gettotalJS+0x71c>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
mov    -0x24(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1060 <free_fmatrix@plt>
mov    -0x80(%rbp),%rdi
mov    -0x24(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1060 <free_fmatrix@plt>
mov    -0x48(%rbp),%rdi
mov    -0x24(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1080 <free_imatrix@plt>
mov    -0x98(%rbp),%rdi
mov    -0x24(%rbp),%esi
add    $0x1,%esi
mov    $0x0,%al
call   1060 <free_fmatrix@plt>
movss  -0x8c(%rbp),%xmm0
ff
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gettotalJS>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,0x8(%rsp)
mov    %ecx,0x24(%rsp)
mov    %edx,0x4(%rsp)
mov    %esi,%ebp
mov    %rdi,0x40(%rsp)
mov    %r9,0x28(%rsp)
lea    0x1(%r9),%eax
mov    %eax,0x14(%rsp)
movslq %eax,%rbx
mov    $0x4,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,0x30(%rsp)
mov    $0x4,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,0x38(%rsp)
mov    $0x4,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,%r15
mov    $0x4,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,%r12
mov    $0x4,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,0x48(%rsp)
xor    %r13d,%r13d
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1090 <fmatrix@plt>
cltq
mov    %rax,0x60(%rsp)
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1090 <fmatrix@plt>
movslq %eax,%r14
mov    %ebx,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <imatrix@plt>
cltq
mov    %rax,0x68(%rsp)
mov    %ebx,%edi
mov    %ebp,(%rsp)
mov    %ebp,%esi
xor    %eax,%eax
call   1090 <fmatrix@plt>
mov    0x24(%rsp),%r10d
mov    %r10d,%r9d
cmpl   $0x0,0x4(%rsp)
jle    1316 <gettotalJS+0x1a6>
xor    %r8d,%r8d
mov    0x48(%rsp),%r11
jmp    1272 <gettotalJS+0x102>
nopl   0x0(%rax,%rax,1)
add    %edx,%r8d
add    $0x1,%r13d
cmp    0x4(%rsp),%r13d
je     1316 <gettotalJS+0x1a6>
test   %r10d,%r10d
jle    1263 <gettotalJS+0xf3>
xorps  %xmm0,%xmm0
cvtsi2ss %r13d,%xmm0
movslq %r8d,%rsi
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,1),%rdi
add    0x40(%rsp),%rsi
xor    %edx,%edx
jmp    12a9 <gettotalJS+0x139>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
cmp    %edx,%r9d
je     1260 <gettotalJS+0xf0>
movzbl (%rdi,%rdx,1),%ebx
test   %rbx,%rbx
je     12a0 <gettotalJS+0x130>
movzbl (%rsi,%rdx,1),%ebp
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
movss  (%r15,%rbx,4),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%r15,%rbx,4)
movss  (%r12,%rbx,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%r12,%rbx,4)
addl   $0x1,(%r11,%rbx,4)
mov    (%r14,%rbx,8),%rcx
addss  (%rcx,%rbp,4),%xmm1
movss  %xmm1,(%rcx,%rbp,4)
mov    0x60(%rsp),%rcx
mov    (%rcx,%rbx,8),%rcx
movss  (%rcx,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rbp,4)
mov    0x68(%rsp),%rcx
mov    (%rcx,%rbx,8),%rcx
addl   $0x1,(%rcx,%rbp,4)
jmp    12a0 <gettotalJS+0x130>
mov    0x14(%rsp),%r13d
mov    %r13d,%ecx
mov    %rcx,0x50(%rsp)
mov    (%rsp),%r8d
mov    %r8d,%ebp
cmpl   $0x0,0x28(%rsp)
mov    0x30(%rsp),%r11
jle    13e2 <gettotalJS+0x272>
mov    $0x1,%edx
jmp    135f <gettotalJS+0x1ef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    0x50(%rsp),%rdx
je     13e2 <gettotalJS+0x272>
mov    0x48(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2ssl (%rcx,%rdx,4),%xmm0
movss  (%r15,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rdx,4)
movss  (%r12,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rdx,4)
test   %r8d,%r8d
jle    1350 <gettotalJS+0x1e0>
mov    0x68(%rsp),%rcx
mov    (%rcx,%rdx,8),%rsi
xor    %edi,%edi
jmp    13a9 <gettotalJS+0x239>
xchg   %ax,%ax
add    $0x1,%rdi
cmp    %rdi,%rbp
je     1350 <gettotalJS+0x1e0>
mov    (%rsi,%rdi,4),%ebx
test   %ebx,%ebx
jle    13a0 <gettotalJS+0x230>
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mov    (%r14,%rdx,8),%rcx
movss  (%rcx,%rdi,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rdi,4)
mov    0x60(%rsp),%rcx
mov    (%rcx,%rdx,8),%rcx
movss  (%rcx,%rdi,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rdi,4)
jmp    13a0 <gettotalJS+0x230>
mov    %rbp,0x18(%rsp)
cltq
mov    %rax,0x58(%rsp)
cmpl   $0x0,0x4(%rsp)
jle    14cb <gettotalJS+0x35b>
xor    %eax,%eax
xor    %r8d,%r8d
jmp    1410 <gettotalJS+0x2a0>
add    %edx,%r8d
add    $0x1,%eax
cmp    0x4(%rsp),%eax
je     14cb <gettotalJS+0x35b>
test   %r10d,%r10d
jle    1403 <gettotalJS+0x293>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movslq %r8d,%rsi
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,1),%rdi
add    0x40(%rsp),%rsi
xor    %edx,%edx
jmp    1449 <gettotalJS+0x2d9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %edx,%r9d
je     1400 <gettotalJS+0x290>
movzbl (%rdi,%rdx,1),%ebx
test   %rbx,%rbx
je     1440 <gettotalJS+0x2d0>
movaps %xmm0,%xmm1
subss  (%r12,%rbx,4),%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
movzbl (%rsi,%rdx,1),%ecx
movaps %xmm2,%xmm3
subss  (%r15,%rbx,4),%xmm3
mulss  %xmm3,%xmm3
mulss  %xmm1,%xmm1
addss  %xmm3,%xmm1
addss  (%r11,%rbx,4),%xmm1
movss  %xmm1,(%r11,%rbx,4)
mov    0x60(%rsp),%rbp
mov    0x0(%rbp,%rbx,8),%rbp
movaps %xmm0,%xmm1
subss  0x0(%rbp,%rcx,4),%xmm1
mov    (%r14,%rbx,8),%rbp
subss  0x0(%rbp,%rcx,4),%xmm2
mulss  %xmm2,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
mov    0x58(%rsp),%rbp
mov    0x0(%rbp,%rbx,8),%rbp
addss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
jmp    1440 <gettotalJS+0x2d0>
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
cmpl   $0x0,0x28(%rsp)
jle    187a <gettotalJS+0x70a>
mov    0xc0(%rsp),%ebx
mov    0x18(%rsp),%rdx
lea    -0x1(%rdx),%r8
mov    %edx,%ecx
and    $0x7,%ecx
and    $0xfffffff8,%edx
mov    $0x1,%esi
mov    0x38(%rsp),%rbp
jmp    1525 <gettotalJS+0x3b5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm0,0x0(%rbp,%rsi,4)
add    $0x1,%rsi
cmp    0x50(%rsp),%rsi
je     15b3 <gettotalJS+0x443>
cmpl   $0x0,(%rsp)
jle    1516 <gettotalJS+0x3a6>
mov    0x58(%rsp),%rax
mov    (%rax,%rsi,8),%rdi
movss  0x0(%rbp,%rsi,4),%xmm0
xor    %eax,%eax
cmp    $0x7,%r8
jb     1588 <gettotalJS+0x418>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addss  (%rdi,%rax,4),%xmm0
addss  0x4(%rdi,%rax,4),%xmm0
addss  0x8(%rdi,%rax,4),%xmm0
addss  0xc(%rdi,%rax,4),%xmm0
addss  0x10(%rdi,%rax,4),%xmm0
addss  0x14(%rdi,%rax,4),%xmm0
addss  0x18(%rdi,%rax,4),%xmm0
addss  0x1c(%rdi,%rax,4),%xmm0
add    $0x8,%rax
cmp    %rax,%rdx
jne    1550 <gettotalJS+0x3e0>
test   %rcx,%rcx
je     1510 <gettotalJS+0x3a0>
lea    (%rdi,%rax,4),%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rax,%rdi,4),%xmm0
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    15a0 <gettotalJS+0x430>
jmp    1510 <gettotalJS+0x3a0>
cmpl   $0x0,0x28(%rsp)
jle    1897 <gettotalJS+0x727>
mov    $0x1,%r13d
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
mov    (%rsp),%eax
mov    0x18(%rsp),%r9
jmp    1629 <gettotalJS+0x4b9>
nopw   0x0(%rax,%rax,1)
movss  (%r11,%r13,4),%xmm1
subss  %xmm0,%xmm1
divss  %xmm0,%xmm1
mov    0xb0(%rsp),%rcx
movss  %xmm1,(%rcx,%r13,4)
mov    0x48(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2ssl (%rcx,%r13,4),%xmm0
mulss  %xmm1,%xmm0
movss  0x8(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
add    $0x1,%r13
cmp    %r13,0x50(%rsp)
je     1665 <gettotalJS+0x4f5>
movss  0x0(%rbp,%r13,4),%xmm0
ucomiss 0x9c9(%rip),%xmm0
jne    15e0 <gettotalJS+0x470>
jp     15e0 <gettotalJS+0x470>
lea    0x9c2(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18(%rsp),%r9
mov    (%rsp),%eax
mov    0x24(%rsp),%r10d
mov    0x38(%rsp),%rbp
mov    0x30(%rsp),%r11
jmp    161e <gettotalJS+0x4ae>
test   %ebx,%ebx
jle    1881 <gettotalJS+0x711>
cmpl   $0x0,0x28(%rsp)
jle    1881 <gettotalJS+0x711>
movslq %eax,%r13
mov    %r9d,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rax
mov    %rax,0x40(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x70(%rsp)
and    $0x3,%r9d
mov    %r10,0x28(%rsp)
shl    $0x5,%r10
mov    $0x1,%esi
mov    0xb8(%rsp),%rbp
jmp    16e0 <gettotalJS+0x570>
nop
mov    0x0(%rbp,%rsi,8),%rcx
movss  (%r11,%rsi,4),%xmm0
movss  %xmm0,(%rcx,%r13,4)
add    $0x1,%rsi
cmp    0x50(%rsp),%rsi
je     1888 <gettotalJS+0x718>
mov    (%rsp),%edx
test   %edx,%edx
jle    16c0 <gettotalJS+0x550>
mov    0x58(%rsp),%rax
mov    (%rax,%rsi,8),%rax
mov    0x0(%rbp,%rsi,8),%rcx
cmp    $0x8,%edx
jb     1719 <gettotalJS+0x5a9>
mov    0x18(%rsp),%rdi
lea    (%rax,%rdi,4),%rdx
cmp    %rdx,%rcx
jae    17a4 <gettotalJS+0x634>
lea    (%rcx,%rdi,4),%rdx
cmp    %rdx,%rax
jae    17a4 <gettotalJS+0x634>
xor    %r11d,%r11d
mov    %r11,%rdx
not    %rdx
add    0x18(%rsp),%rdx
test   %r9,%r9
je     1746 <gettotalJS+0x5d6>
mov    %r9,%rbx
nop
movss  (%rax,%r11,4),%xmm0
movss  %xmm0,(%rcx,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbx
jne    1730 <gettotalJS+0x5c0>
cmp    $0x3,%rdx
jb     1870 <gettotalJS+0x700>
mov    0x18(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rax,%r11,4),%xmm0
movss  %xmm0,(%rcx,%r11,4)
movss  0x4(%rax,%r11,4),%xmm0
movss  %xmm0,0x4(%rcx,%r11,4)
movss  0x8(%rax,%r11,4),%xmm0
movss  %xmm0,0x8(%rcx,%r11,4)
movss  0xc(%rax,%r11,4),%xmm0
movss  %xmm0,0xc(%rcx,%r11,4)
add    $0x4,%r11
cmp    %r11,%rdx
jne    1760 <gettotalJS+0x5f0>
jmp    1870 <gettotalJS+0x700>
cmpq   $0x18,0x40(%rsp)
jae    17b0 <gettotalJS+0x640>
xor    %edx,%edx
jmp    1818 <gettotalJS+0x6a8>
mov    0x70(%rsp),%rbx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups %xmm0,(%rcx,%rdx,4)
movups %xmm1,0x10(%rcx,%rdx,4)
movups 0x20(%rax,%rdx,4),%xmm0
movups 0x30(%rax,%rdx,4),%xmm1
movups %xmm0,0x20(%rcx,%rdx,4)
movups %xmm1,0x30(%rcx,%rdx,4)
movups 0x40(%rax,%rdx,4),%xmm0
movups 0x50(%rax,%rdx,4),%xmm1
movups %xmm0,0x40(%rcx,%rdx,4)
movups %xmm1,0x50(%rcx,%rdx,4)
movups 0x60(%rax,%rdx,4),%xmm0
movups 0x70(%rax,%rdx,4),%xmm1
movups %xmm0,0x60(%rcx,%rdx,4)
movups %xmm1,0x70(%rcx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbx
jne    17c0 <gettotalJS+0x650>
cmpq   $0x0,0x28(%rsp)
je     185b <gettotalJS+0x6eb>
lea    (%rcx,%rdx,4),%rbx
add    $0x10,%rbx
lea    (%rax,%rdx,4),%rdx
add    $0x10,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,1)
movups %xmm1,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    1840 <gettotalJS+0x6d0>
mov    %r8,%r11
cmp    0x18(%rsp),%r8
jne    171c <gettotalJS+0x5ac>
nopl   0x0(%rax)
mov    0x30(%rsp),%r11
jmp    16c5 <gettotalJS+0x555>
mov    0x38(%rsp),%rbp
jmp    1897 <gettotalJS+0x727>
mov    0x14(%rsp),%r13d
jmp    1897 <gettotalJS+0x727>
mov    0x14(%rsp),%r13d
mov    0x38(%rsp),%rbp
mov    0x24(%rsp),%r10d
xorps  %xmm0,%xmm0
cvtsi2ssl 0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
divss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %r10d,%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
mov    %r15,%rdi
mov    %r11,%rbx
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1060 <free_fmatrix@plt>
mov    0x60(%rsp),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1060 <free_fmatrix@plt>
mov    0x68(%rsp),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1080 <free_imatrix@plt>
mov    0x58(%rsp),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1060 <free_fmatrix@plt>
movss  0x8(%rsp),%xmm0
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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