float pga(float *B, float *A, int ny, int nx, int offset, float *weight,
          int dim) {
  int iy, ix, jy, jx, npeer, window, j, k, winarea, *index, *index2;
  float *peer, *dif, *dif2, avg = 0.0, *D, D1, D2, **A1, mean1, mean2;
  int J1, J2, nnoise, J;
  float *difdif, difmean, difvar, difdift;
  float *vec;
  int ej, ej2, ey, ex, nx2, loc;
  peer = (float *)calloc(dim, sizeof(float));
  window = 2 * offset + 1;
  winarea = ((window) * (window));
  nnoise = offset + 1;
  A1 = (float **)malloc(winarea * sizeof(float *));
  dif = (float *)calloc(winarea, sizeof(float));
  index = (int *)calloc(winarea, sizeof(int));
  D = (float *)calloc(winarea, sizeof(float));
  index2 = (int *)calloc(winarea, sizeof(int));
  difdif = (float *)calloc(winarea - 1, sizeof(int));
  nx2 = nx + 2 * offset;
  ej = winarea - 1;
  for (iy = 0; iy < ny; iy++) {
    for (ix = 0; ix < nx; ix++) {
      j = 0;
      ey = iy + window;
      ex = ix + window;
      for (jy = iy; jy < ey; jy++) {
        for (jx = ix; jx < ex; jx++) {
          A1[j] = A + LOC(jy, jx, 0, nx2, dim);
          dif[j] = distance(B, A1[j], dim);
          j++;
        }
      }
      piksrtS2B(winarea, dif, index);
      for (j = 0; j < ej; j++)
        difdif[j] = dif[j + 1] - dif[j];
      difdift = 12.0 * sqrt(dim / 3.0);
      J1 = 0;
      for (j = nnoise - 1; j >= 0; j--) {
        if (difdif[j] > difdift) {
          J1 = j + 1;
          break;
        }
      }
      J2 = winarea - 1;
      for (j = winarea - 1 - nnoise; j < ej; j++) {
        if (difdif[j] > difdift) {
          J2 = j;
          break;
        }
      }
      J = J2 - 2;
      if (distance2(A1[index[J1]], A1[index[J2]], dim) == 0.0) {
        for (k = 0; k < dim; k++)
          B[k] = A1[index[J1]][k];
      } else {
        for (j = J1; j <= J; j++) {
          D1 = 0;
          D2 = 0;
          mean1 = 0;
          mean2 = 0;
          for (k = J1; k <= j; k++)
            mean1 += dif[k];
          mean1 /= (j - J1 + 1);
          for (k = J1; k <= j; k++)
            D1 += ((dif[k] - mean1) * (dif[k] - mean1));
          for (k = j + 1; k <= J2; k++)
            mean2 += dif[k];
          mean2 /= (J2 - j);
          for (k = j + 1; k <= J2; k++)
            D2 += ((dif[k] - mean2) * (dif[k] - mean2));
          D[j - J1] = (D1 + D2) / ((mean2 - mean1) * (mean2 - mean1));
        }
        piksrtS2B(J - J1 + 1, D, index2);
        *weight = dif[index2[0] + J1] - dif[J1];
        avg += (*weight);
        for (k = 0; k < dim; k++)
          peer[k] = 0;
        ej2 = index2[0] + J1;
        for (j = J1; j <= ej2; j++) {
          for (k = 0; k < dim; k++)
            peer[k] += A1[index[j]][k];
        }
        for (k = 0; k < dim; k++)
          B[k] = peer[k] / (index2[0] + 1);
      }
      B += dim;
      weight++;
    }
  }
  avg = avg / (ny * nx);
  free(dif);
  free(index);
  free(index2);
  free(difdif);
  free(D);
  free(A1);
  free(peer);
  return avg;
}


x86 assembly (clang, -O0):
<pga>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movslq 0x10(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x40(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
movslq -0x4c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x4c(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x4c(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x4c(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x4c(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd4(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1987 <pga+0x807>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1974 <pga+0x7f4>
movl   $0x0,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x30(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    1380 <pga+0x200>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jge    136d <pga+0x1ed>
mov    -0x10(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x34(%rbp),%edi
mov    -0x38(%rbp),%esi
mov    -0xe4(%rbp),%ecx
mov    0x10(%rbp),%r8d
xor    %edx,%edx
mov    $0x0,%al
call   1060 <LOC@plt>
mov    -0xf0(%rbp),%rdx
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rdi
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x10(%rbp),%edx
mov    $0x0,%al
call   10a0 <distance@plt>
cvtsi2ss %eax,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d6 <pga+0x156>
jmp    1372 <pga+0x1f2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c1 <pga+0x141>
mov    -0x4c(%rbp),%edi
mov    -0x70(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    $0x0,%al
call   1080 <piksrtS2B@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jge    13e5 <pga+0x265>
mov    -0x70(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1399 <pga+0x219>
cvtsi2sdl 0x10(%rbp),%xmm0
movsd  0xc16(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xbfa(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movl   $0x0,-0xa4(%rbp)
mov    -0xac(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1477 <pga+0x2f7>
mov    -0xb8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0xc4(%rbp),%xmm0
jbe    1464 <pga+0x2e4>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1477 <pga+0x2f7>
jmp    1469 <pga+0x2e9>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    142c <pga+0x2ac>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
sub    -0xac(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jge    14df <pga+0x35f>
mov    -0xb8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0xc4(%rbp),%xmm0
jbe    14cc <pga+0x34c>
mov    -0x44(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    14df <pga+0x35f>
jmp    14d1 <pga+0x351>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1492 <pga+0x312>
mov    -0xa8(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x98(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x10(%rbp),%edx
mov    $0x0,%al
call   1040 <distance2@plt>
cvtsi2sd %eax,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1599 <pga+0x419>
jp     1599 <pga+0x419>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1594 <pga+0x414>
mov    -0x98(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0xa4(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    154a <pga+0x3ca>
jmp    1945 <pga+0x7c5>
mov    -0xa4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jg     17d0 <pga+0x650>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0xa4(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     161d <pga+0x49d>
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    15e6 <pga+0x466>
mov    -0x44(%rbp),%eax
sub    -0xa4(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0xa4(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     16a6 <pga+0x526>
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x9c(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0x9c(%rbp),%xmm2
ff
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    164a <pga+0x4ca>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jg     16e9 <pga+0x569>
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    16af <pga+0x52f>
mov    -0xa8(%rbp),%eax
sub    -0x44(%rbp),%eax
cvtsi2ss %eax,%xmm1
movss  -0xa0(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jg     1772 <pga+0x5f2>
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0xa0(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0xa0(%rbp),%xmm2
ff
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1713 <pga+0x593>
movss  -0x8c(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
movss  -0xa0(%rbp),%xmm1
ff
subss  -0x9c(%rbp),%xmm1
ff
movss  -0xa0(%rbp),%xmm2
ff
subss  -0x9c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
divss  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0xa4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    15a2 <pga+0x422>
mov    -0xb0(%rbp),%edi
sub    -0xa4(%rbp),%edi
add    $0x1,%edi
mov    -0x88(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    $0x0,%al
call   1080 <piksrtS2B@plt>
mov    -0x70(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rcx),%ecx
add    -0xa4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xa4(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1864 <pga+0x6e4>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    183a <pga+0x6ba>
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jg     18f4 <pga+0x774>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18e1 <pga+0x761>
mov    -0x98(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1895 <pga+0x715>
jmp    18e6 <pga+0x766>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    187f <pga+0x6ff>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1940 <pga+0x7c0>
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    18fb <pga+0x77b>
jmp    1945 <pga+0x7c5>
mov    0x10(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1290 <pga+0x110>
jmp    1979 <pga+0x7f9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    127d <pga+0xfd>
movss  -0x7c(%rbp),%xmm0
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movss  -0x7c(%rbp),%xmm0
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pga>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r9,0xf0(%rsp)
mov    %r8d,%r13d
mov    %ecx,%r14d
mov    %edx,%r15d
mov    %rsi,0x1a0(%rsp)
mov    %rdi,0x60(%rsp)
mov    0x1e0(%rsp),%edx
movslq %edx,%rdi
mov    $0x4,%esi
mov    %rdi,0xd0(%rsp)
call   1060 <calloc@plt>
mov    %rax,%rbx
lea    0x1(%r13,%r13,1),%ecx
mov    %rcx,0x88(%rsp)
mov    %ecx,%ebp
imul   %ebp,%ebp
lea    0x0(,%rbp,8),%rdi
call   1080 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <calloc@plt>
mov    %rax,(%rsp)
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <calloc@plt>
mov    %rax,0x80(%rsp)
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <calloc@plt>
mov    %rax,0x10(%rsp)
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <calloc@plt>
mov    %rax,0xb8(%rsp)
mov    %rbp,0xe0(%rsp)
lea    -0x1(%rbp),%r12d
mov    $0x4,%esi
mov    %r12,%rdi
call   1060 <calloc@plt>
mov    %r15d,0x4c(%rsp)
test   %r15d,%r15d
mov    %rax,0x78(%rsp)
jle    210c <pga+0xf7c>
mov    %r13d,%r8d
not    %r8d
mov    0xd0(%rsp),%rbp
cvtsi2sd %ebp,%xmm0
divsd  0x1d6b(%rip),%xmm0
add    %r12d,%r8d
mov    %ebp,%r15d
mov    %r12,0x98(%rsp)
and    $0x7ffffff8,%r12d
mov    %r12,0xb0(%rsp)
lea    -0x8(%r12),%rdx
mov    %rdx,0x148(%rsp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %r15d,%r9d
and    $0xfffffff8,%r9d
lea    -0x8(%r9),%r10
mov    %r10,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r15d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x130(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x128(%rsp)
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rsi,%rdx
mov    %rsi,0x140(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x138(%rsp)
mov    %rdi,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x190(%rsp)
mov    %r15d,%r11d
and    $0x3,%r11d
mov    %rcx,%rdx
mov    %rcx,0x120(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x118(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x150(%rsp)
mov    %edi,%esi
and    $0x3,%esi
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
mov    %rdi,%rdx
mov    %rdi,0x198(%rsp)
and    %rdi,%rcx
mov    %rcx,0x100(%rsp)
mov    %r13d,%ecx
add    $0x1,%rcx
mov    %rcx,0x168(%rsp)
mov    %r8d,0xa4(%rsp)
movslq %r8d,%rcx
lea    (%rax,%rcx,4),%rax
mov    %rax,0x160(%rsp)
mov    %rsi,0x110(%rsp)
mov    %rsi,%r8
shl    $0x5,%r8
xorps  %xmm1,%xmm1
movss  %xmm1,0xc(%rsp)
movsd  %xmm0,0xe8(%rsp)
sqrtsd %xmm0,%xmm0
movsd  %xmm0,0x178(%rsp)
lea    (%r14,%r13,2),%eax
mov    %eax,0xac(%rsp)
lea    0x0(,%r15,4),%rax
mov    %rax,0x158(%rsp)
lea    (%rbx,%r15,4),%rax
mov    %rax,0xf8(%rsp)
mov    %r13,0x180(%rsp)
lea    0x2(%r13),%eax
mov    %eax,0xa0(%rsp)
lea    0x0(,%rbp,4),%rax
mov    %rax,0x170(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
mov    0x10(%rsp),%r13
mov    (%rsp),%rsi
mov    %rbx,0x188(%rsp)
mov    %r14,0x20(%rsp)
mov    %r15,0x68(%rsp)
mov    %r9,0xc8(%rsp)
mov    %r10,0xc0(%rsp)
mov    %r11,0x58(%rsp)
mov    %r8,0x108(%rsp)
jmp    1481 <pga+0x2f1>
nop
mov    0x60(%rsp),%rdx
mov    0x50(%rsp),%rax
add    $0x1,%eax
mov    %rdx,0x60(%rsp)
mov    %rax,0x50(%rsp)
cmp    0x4c(%rsp),%eax
je     211f <pga+0xf8f>
test   %r14d,%r14d
jle    1460 <pga+0x2d0>
mov    0x88(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %ecx,%eax
mov    %eax,0xa8(%rsp)
mov    0x60(%rsp),%rdx
xor    %eax,%eax
mov    %rax,0x38(%rsp)
jmp    14de <pga+0x34e>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%rdx
add    0x170(%rsp),%rdx
addq   $0x4,0xf0(%rsp)
mov    0x38(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x38(%rsp)
cmp    %r14d,%eax
je     1465 <pga+0x2d5>
mov    %rdx,0x28(%rsp)
cmpl   $0x0,0x88(%rsp)
jle    159a <pga+0x40a>
mov    0x88(%rsp),%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,1),%ebx
mov    0x50(%rsp),%rax
mov    %eax,%ebp
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
movslq %r12d,%r12
mov    0x38(%rsp),%rax
mov    %eax,%r13d
mov    0x1e0(%rsp),%r15d
mov    0x28(%rsp),%r14
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    %r13d,%esi
xor    %edx,%edx
mov    0xac(%rsp),%ecx
mov    %r15d,%r8d
xor    %eax,%eax
call   1070 <LOC@plt>
cltq
mov    0x1a0(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
mov    0x40(%rsp),%rax
mov    %rsi,(%rax,%r12,8)
mov    %r14,%rdi
mov    %r15d,%edx
xor    %eax,%eax
call   10b0 <distance@plt>
mov    (%rsp),%rsi
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rsi,%r12,4)
add    $0x1,%r12
add    $0x1,%r13d
cmp    %ebx,%r13d
jl     1530 <pga+0x3a0>
add    $0x1,%ebp
cmp    0xa8(%rsp),%ebp
jl     1510 <pga+0x380>
mov    0xe0(%rsp),%rdi
mov    0x80(%rsp),%r12
mov    %r12,%rdx
xor    %eax,%eax
call   1090 <piksrtS2B@plt>
mov    (%rsp),%rdx
mov    0x98(%rsp),%rdi
test   %edi,%edi
mov    0x180(%rsp),%r14
mov    0xd0(%rsp),%rbx
mov    0x78(%rsp),%rsi
je     1701 <pga+0x571>
movss  (%rdx),%xmm0
cmp    $0x8,%edi
jae    15f0 <pga+0x460>
xor    %eax,%eax
jmp    16e0 <pga+0x550>
nopl   (%rax)
shufps $0x0,%xmm0,%xmm0
cmpq   $0x0,0x148(%rsp)
je     1e66 <pga+0xcd6>
mov    0x138(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movups 0x4(%rdx,%rax,4),%xmm1
movups 0x14(%rdx,%rax,4),%xmm2
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movaps %xmm1,%xmm3
shufps $0x3,%xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
subps  %xmm0,%xmm1
movaps %xmm2,%xmm0
subps  %xmm3,%xmm0
movups %xmm1,(%rsi,%rax,4)
movups %xmm0,0x10(%rsi,%rax,4)
movups 0x24(%rdx,%rax,4),%xmm1
movups 0x34(%rdx,%rax,4),%xmm0
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
movaps %xmm1,%xmm3
shufps $0x3,%xmm0,%xmm3
shufps $0x98,%xmm0,%xmm3
subps  %xmm2,%xmm1
movaps %xmm0,%xmm2
subps  %xmm3,%xmm2
movups %xmm1,0x20(%rsi,%rax,4)
movups %xmm2,0x30(%rsi,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1610 <pga+0x480>
testb  $0x1,0x140(%rsp)
01
je     16bd <pga+0x52d>
lea    0x0(,%rax,4),%rcx
or     $0x4,%rcx
movups (%rdx,%rcx,1),%xmm1
movups 0x10(%rdx,%rcx,1),%xmm2
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movaps %xmm1,%xmm3
shufps $0x3,%xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
subps  %xmm0,%xmm1
movaps %xmm2,%xmm0
subps  %xmm3,%xmm2
movups %xmm1,(%rsi,%rax,4)
movups %xmm2,0x10(%rsi,%rax,4)
cmp    %rdi,0xb0(%rsp)
je     1701 <pga+0x571>
shufps $0xff,%xmm0,%xmm0
mov    0xb0(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x4(%rdx,%rax,4),%xmm1
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,(%rsi,%rax,4)
lea    0x1(%rax),%rcx
movaps %xmm1,%xmm0
mov    %rcx,%rax
cmp    %rcx,%rdi
jne    16e0 <pga+0x550>
movsd  0xe8(%rsp),%xmm0
ucomisd 0x18fe(%rip),%xmm0
movsd  0x178(%rsp),%xmm0
jae    1730 <pga+0x5a0>
movsd  0xe8(%rsp),%xmm0
call   10a0 <sqrt@plt>
mov    0x78(%rsp),%rsi
mov    0x38(%rsp),%rax
imul   %rbx,%rax
xor    %r15d,%r15d
mulsd  0x18c4(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
test   %r14d,%r14d
mov    0x188(%rsp),%rbx
js     1783 <pga+0x5f3>
mov    0x168(%rsp),%rcx
nopl   (%rax)
movss  -0x4(%rsi,%rcx,4),%xmm1
ucomiss %xmm0,%xmm1
ja     1780 <pga+0x5f0>
add    $0xffffffffffffffff,%rcx
jg     1760 <pga+0x5d0>
jmp    1783 <pga+0x5f3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%r15d
add    0x68(%rsp),%rax
mov    0x98(%rsp),%rcx
mov    %ecx,%r13d
cmp    %ecx,0xa4(%rsp)
jge    17ee <pga+0x65e>
mov    0x160(%rsp),%rdx
mov    0xa0(%rsp),%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rdx),%xmm1
ucomiss %xmm0,%xmm1
ja     17e0 <pga+0x650>
add    $0xffffffff,%ecx
add    $0x4,%rdx
cmp    $0x1,%ecx
jne    17b0 <pga+0x620>
mov    0x98(%rsp),%rcx
mov    %ecx,%r13d
jmp    17ee <pga+0x65e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xe0(%rsp),%rdx
mov    %edx,%r13d
sub    %ecx,%r13d
mov    0x60(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0xd8(%rsp)
movslq %r15d,%rax
mov    %rax,0x18(%rsp)
movslq (%r12,%rax,4),%rax
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
movslq %r13d,%r14
movslq (%r12,%r14,4),%rax
mov    (%rcx,%rax,8),%rsi
mov    0x1e0(%rsp),%ebp
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <distance2@plt>
test   %eax,%eax
je     1b20 <pga+0x990>
lea    -0x2(%r13),%eax
mov    %r15,0x90(%rsp)
cmp    %eax,%r15d
mov    0x18(%rsp),%r12
mov    %r13,%rdi
mov    0x10(%rsp),%r13
jle    1b70 <pga+0x9e0>
mov    0x90(%rsp),%r14
mov    %r14d,%eax
not    %eax
add    %eax,%edi
mov    %r13,%rsi
mov    0xb8(%rsp),%rbp
mov    %rbp,%rdx
xor    %eax,%eax
call   1090 <piksrtS2B@plt>
mov    0x18(%rsp),%rdi
mov    0x0(%rbp),%ebp
add    %ebp,%r14d
movslq %r14d,%rax
mov    (%rsp),%rsi
movss  (%rsi,%rax,4),%xmm4
subss  (%rsi,%rdi,4),%xmm4
mov    0xf0(%rsp),%rax
movss  %xmm4,(%rax)
cmpl   $0x0,0x1e0(%rsp)
mov    0x68(%rsp),%r15
jle    18db <pga+0x74b>
mov    %rbx,%rdi
xor    %esi,%esi
mov    0x158(%rsp),%rdx
movss  %xmm4,0x34(%rsp)
call   1050 <memset@plt>
movss  0x34(%rsp),%xmm4
mov    0x18(%rsp),%rdi
mov    (%rsp),%rsi
mov    %rbp,0x18(%rsp)
test   %ebp,%ebp
mov    0x80(%rsp),%r8
mov    0xc8(%rsp),%r9
mov    0xc0(%rsp),%r10
mov    0x58(%rsp),%r11
mov    0x1e0(%rsp),%r12d
js     1ad0 <pga+0x940>
mov    0x90(%rsp),%rax
cmp    %r14d,%eax
cmovg  %eax,%r14d
add    $0x1,%r14d
jmp    193d <pga+0x7ad>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdi
cmp    %edi,%r14d
je     1ad0 <pga+0x940>
test   %r12d,%r12d
jle    1930 <pga+0x7a0>
movslq (%r8,%rdi,4),%rax
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
cmp    $0x8,%r12d
jb     1970 <pga+0x7e0>
lea    (%rax,%r15,4),%rcx
cmp    %rcx,%rbx
jae    1a13 <pga+0x883>
cmp    %rax,0xf8(%rsp)
jbe    1a13 <pga+0x883>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r15,%rdx
mov    %rdi,%rbp
test   %r11,%r11
je     19a9 <pga+0x819>
mov    %r11,%rdi
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1990 <pga+0x800>
cmp    $0x3,%rdx
mov    %rbp,%rdi
jb     1930 <pga+0x7a0>
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm0
addss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
movss  0x8(%rax,%rcx,4),%xmm0
addss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbx,%rcx,4)
movss  0xc(%rax,%rcx,4),%xmm0
addss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    19c0 <pga+0x830>
jmp    1930 <pga+0x7a0>
test   %r10,%r10
je     1abb <pga+0x92b>
mov    0x190(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rcx,4),%xmm0
movups 0x10(%rax,%rcx,4),%xmm1
movups (%rbx,%rcx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rbx,%rcx,4),%xmm1
movups 0x30(%rbx,%rcx,4),%xmm3
movups %xmm2,(%rbx,%rcx,4)
movups %xmm0,0x10(%rbx,%rcx,4)
movups 0x20(%rax,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x30(%rax,%rcx,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rbx,%rcx,4)
movups %xmm1,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1a30 <pga+0x8a0>
testb  $0x1,0x198(%rsp)
01
je     1aaa <pga+0x91a>
movups (%rax,%rcx,4),%xmm0
movups 0x10(%rax,%rcx,4),%xmm1
movups (%rbx,%rcx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbx,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rbx,%rcx,4)
movups %xmm0,0x10(%rbx,%rcx,4)
mov    %r9,%rcx
cmp    %r15,%r9
je     1930 <pga+0x7a0>
jmp    1972 <pga+0x7e2>
xor    %ecx,%ecx
testb  $0x1,0x198(%rsp)
01
jne    1a89 <pga+0x8f9>
jmp    1aaa <pga+0x91a>
nopl   0x0(%rax)
movss  0xc(%rsp),%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0xc(%rsp)
test   %r12d,%r12d
jle    14b0 <pga+0x320>
mov    0x18(%rsp),%rax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
cmp    $0x4,%r12d
jae    1e25 <pga+0xc95>
xor    %ecx,%ecx
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%rdx
jmp    1f30 <pga+0xda0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %ebp,%ebp
jle    1e4e <pga+0xcbe>
mov    0x18(%rsp),%rax
movslq (%r12,%rax,4),%rax
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
cmp    $0x8,%ebp
jae    1e7b <pga+0xceb>
xor    %ecx,%ecx
mov    0x20(%rsp),%r14
mov    (%rsp),%rsi
mov    0x68(%rsp),%r15
mov    0x58(%rsp),%r11
mov    0x28(%rsp),%rdx
mov    0x10(%rsp),%r13
jmp    2090 <pga+0xf00>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rdi),%eax
mov    %eax,0x34(%rsp)
mov    0x90(%rsp),%rax
lea    0x1(%rax),%r11d
xor    %r9d,%r9d
mov    $0x1,%al
mov    %r11,%rsi
mov    %r12,%r10
mov    %rdi,0x70(%rsp)
jmp    1be2 <pga+0xa52>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edi,%ecx
sub    %r15d,%ecx
xorps  %xmm4,%xmm4
cvtsi2ss %ecx,%xmm4
xorps  %xmm3,%xmm3
xorps  %xmm2,%xmm2
divss  %xmm4,%xmm2
subss  %xmm0,%xmm2
addss  %xmm3,%xmm1
mulss  %xmm2,%xmm2
divss  %xmm2,%xmm1
movss  %xmm1,0x0(%r13,%r8,4)
add    $0x1,%al
add    $0x1,%rsi
add    $0x1,%r11d
cmp    %r10d,0x34(%rsp)
je     1859 <pga+0x6c9>
mov    %r10,%r15
mov    %r9d,%r10d
movzbl %al,%edx
mov    %edx,%eax
and    $0x7,%eax
lea    0x1(%r10),%r9d
mov    %r15,%r8
sub    %r12,%r8
jge    1c20 <pga+0xa90>
lea    0x1(%r8),%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
divss  %xmm2,%xmm0
mov    (%rsp),%rbp
jmp    1db0 <pga+0xc20>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
test   $0x7,%r9b
je     1d1f <pga+0xb8f>
mov    %eax,%ecx
mov    (%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  0x0(%rbp,%r12,4),%xmm0
add    $0x1,%r12
add    $0xffffffff,%ecx
jne    1c40 <pga+0xab0>
cmp    $0x7,%r10d
jb     1ca1 <pga+0xb11>
cs nopw 0x0(%rax,%rax,1)
addss  0x0(%rbp,%r12,4),%xmm0
addss  0x4(%rbp,%r12,4),%xmm0
addss  0x8(%rbp,%r12,4),%xmm0
addss  0xc(%rbp,%r12,4),%xmm0
addss  0x10(%rbp,%r12,4),%xmm0
addss  0x14(%rbp,%r12,4),%xmm0
addss  0x18(%rbp,%r12,4),%xmm0
addss  0x1c(%rbp,%r12,4),%xmm0
add    $0x8,%r12
cmp    %r12d,%esi
jne    1c60 <pga+0xad0>
mov    %r8d,%ecx
add    $0x1,%ecx
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
mov    %r15,%r8
divss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
mov    0x18(%rsp),%r12
sub    %r12,%r8
jge    1cd0 <pga+0xb40>
mov    (%rsp),%rbp
jmp    1db0 <pga+0xc20>
nopl   0x0(%rax,%rax,1)
test   $0x3,%r9b
je     1d32 <pga+0xba2>
and    $0x3,%edx
xorps  %xmm1,%xmm1
mov    %r12,%r13
mov    (%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rcx,%r13,4),%xmm2
subss  %xmm0,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm1
add    $0x1,%r13
add    $0xffffffff,%edx
jne    1cf0 <pga+0xb60>
cmp    $0x3,%r10d
jae    1d3e <pga+0xbae>
mov    0x10(%rsp),%r13
mov    (%rsp),%rbp
jmp    1db0 <pga+0xc20>
mov    (%rsp),%rbp
cmp    $0x7,%r10d
jae    1c60 <pga+0xad0>
jmp    1ca1 <pga+0xb11>
xorps  %xmm1,%xmm1
mov    %r12,%r13
cmp    $0x3,%r10d
jb     1d11 <pga+0xb81>
mov    (%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp,%r13,4),%xmm2
movss  0x4(%rbp,%r13,4),%xmm3
subss  %xmm0,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
subss  %xmm0,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
movss  0x8(%rbp,%r13,4),%xmm2
subss  %xmm0,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm3,%xmm2
movss  0xc(%rbp,%r13,4),%xmm1
subss  %xmm0,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
add    $0x4,%r13
cmp    %r13d,%esi
jne    1d50 <pga+0xbc0>
mov    0x10(%rsp),%r13
nopw   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rdi
lea    0x1(%r15),%r10
cmp    %r14,%r15
jge    1ba0 <pga+0xa10>
movslq %r11d,%rdx
add    $0xffffffffffffffff,%rdx
xorps  %xmm2,%xmm2
mov    %rdx,%rcx
nop
addss  0x4(%rbp,%rcx,4),%xmm2
add    $0x1,%rcx
cmp    %r14,%rcx
jl     1dd0 <pga+0xc40>
mov    %edi,%ecx
sub    %r15d,%ecx
xorps  %xmm3,%xmm3
cvtsi2ss %ecx,%xmm3
divss  %xmm3,%xmm2
xorps  %xmm3,%xmm3
cmp    %r14,%r15
jge    1e1b <pga+0xc8b>
xorps  %xmm3,%xmm3
nopw   0x0(%rax,%rax,1)
movss  0x4(%rbp,%rdx,4),%xmm4
subss  %xmm2,%xmm4
mulss  %xmm4,%xmm4
addss  %xmm4,%xmm3
add    $0x1,%rdx
cmp    %r14,%rdx
jl     1e00 <pga+0xc70>
mov    0x18(%rsp),%r12
jmp    1bb6 <pga+0xa26>
mov    0x28(%rsp),%rdx
cmp    %rdx,0xf8(%rsp)
jbe    1eba <pga+0xd2a>
cmp    0xd8(%rsp),%rbx
jae    1eba <pga+0xd2a>
xor    %ecx,%ecx
mov    0x20(%rsp),%r14
jmp    1f30 <pga+0xda0>
mov    0x20(%rsp),%r14
mov    (%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x10(%rsp),%r13
jmp    14ba <pga+0x32a>
xor    %eax,%eax
testb  $0x1,0x140(%rsp)
01
jne    1683 <pga+0x4f3>
jmp    16bd <pga+0x52d>
mov    0x68(%rsp),%r15
lea    (%rax,%r15,4),%rcx
mov    0x28(%rsp),%rdx
cmp    %rcx,%rdx
jae    1f8c <pga+0xdfc>
cmp    0xd8(%rsp),%rax
jae    1f8c <pga+0xdfc>
xor    %ecx,%ecx
mov    0x20(%rsp),%r14
mov    (%rsp),%rsi
mov    0x58(%rsp),%r11
mov    0x10(%rsp),%r13
jmp    2090 <pga+0xf00>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x128(%rsp)
mov    0x20(%rsp),%r14
je     1fc1 <pga+0xe31>
mov    0x118(%rsp),%rcx
xor    %eax,%eax
nop
movups (%rbx,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rax,4)
movups 0x10(%rbx,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x10(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1ee0 <pga+0xd50>
testb  $0x1,0x120(%rsp)
01
je     1f17 <pga+0xd87>
movups (%rbx,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rax,4)
mov    0x130(%rsp),%rax
mov    %rax,%rcx
cmp    %r15,%rax
je     14ba <pga+0x32a>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rax
test   $0x1,%r15b
je     1f4e <pga+0xdbe>
movss  (%rbx,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x150(%rsp),%rcx
je     14ba <pga+0x32a>
nop
movss  (%rbx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r15
jne    1f60 <pga+0xdd0>
jmp    14ba <pga+0x32a>
mov    0xc0(%rsp),%r10
cmp    $0x18,%r10
mov    0x20(%rsp),%r14
mov    (%rsp),%rsi
mov    0xc8(%rsp),%r9
mov    0x58(%rsp),%r11
mov    0x108(%rsp),%r8
mov    0x10(%rsp),%r13
jae    1fd6 <pga+0xe46>
xor    %ecx,%ecx
jmp    2038 <pga+0xea8>
xor    %eax,%eax
testb  $0x1,0x120(%rsp)
01
jne    1f0c <pga+0xd7c>
jmp    1f17 <pga+0xd87>
mov    0x100(%rsp),%rdi
xor    %ecx,%ecx
movups (%rax,%rcx,4),%xmm0
movups 0x10(%rax,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rax,%rcx,4),%xmm0
movups 0x30(%rax,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x40(%rax,%rcx,4),%xmm0
movups 0x50(%rax,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movups 0x60(%rax,%rcx,4),%xmm0
movups 0x70(%rax,%rcx,4),%xmm1
movups %xmm0,0x60(%rdx,%rcx,4)
movups %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1fe0 <pga+0xe50>
cmpq   $0x0,0x110(%rsp)
je     207d <pga+0xeed>
lea    (%rdx,%rcx,4),%r12
lea    (%rax,%rcx,4),%rcx
add    $0x10,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,(%r12,%rdi,1)
movups %xmm1,0x10(%r12,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    2060 <pga+0xed0>
mov    %r9,%rcx
cmp    %r15,%r9
je     14ba <pga+0x32a>
nopl   0x0(%rax)
mov    %rcx,%r12
not    %r12
add    %r15,%r12
test   $0x3,%r15b
je     20c4 <pga+0xf34>
mov    %r11,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    20b0 <pga+0xf20>
cmp    $0x3,%r12
jb     14ba <pga+0x32a>
xchg   %ax,%ax
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdx,%rcx,4)
movss  0x8(%rax,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdx,%rcx,4)
movss  0xc(%rax,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    20d0 <pga+0xf40>
jmp    14ba <pga+0x32a>
xorpd  %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
mov    0x10(%rsp),%r13
mov    (%rsp),%rsi
imul   0x4c(%rsp),%r14d
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
movss  0xc(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
mov    %rsi,%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
movss  0xc(%rsp),%xmm0
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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