void normals(float ptGRID[], int xdim, int ydim, int zdim, float VX[],
             float VY[], float VZ[], float NX[], float NY[], float NZ[],
             int nvertex, int npolygons, float Pnx[], float Pny[], float Pnz[],
             float NxA[], float NxB[], float NyA[], float NyB[], float NzA[],
             float NzB[], double arX, double arY, double arZ, int Pol_f_Vert[],
             int Vert_f_Pol[]) {
  int i, k, iv[3], n;
  int i1, i2, ix, iy, iz, ixb, iyb, izb, *pVP;
  int max_vert_per_pol, swap_flag;
  float x, y, z, a, minimum_area, len;
  int xdim_x_ydim = xdim * ydim;
  ixb = xdim - 1;
  iyb = ydim - 1;
  izb = zdim - 1;
  minimum_area = ((1.e-4 > 1.0e-5) ? 1.e-4 : 1.0e-5);
  k = 6;
  n = 7 * npolygons;
  while ((1 == 1)) {
    for (i = k + 7; i < n; i += 7)
      if (Vert_f_Pol[i] > Vert_f_Pol[k])
        break;
    if (i >= n)
      break;
    k = i;
  }
  max_vert_per_pol = Vert_f_Pol[k];
  pVP = Vert_f_Pol;
  for (i = 0; i < npolygons; i++) {
    if (pVP[6] > 0) {
      NxA[i] = VX[pVP[1]] - VX[pVP[0]];
      NyA[i] = VY[pVP[1]] - VY[pVP[0]];
      NzA[i] = VZ[pVP[1]] - VZ[pVP[0]];
    }
    pVP += 7;
  }
  swap_flag = 0;
  for (k = 2; k < max_vert_per_pol; k++) {
    pVP = Vert_f_Pol;
    if (swap_flag == 0) {
      for (i = 0; i < npolygons; i++) {
        if (pVP[k] >= 0) {
          NxB[i] = VX[pVP[k]] - VX[pVP[0]];
          NyB[i] = VY[pVP[k]] - VY[pVP[0]];
          NzB[i] = VZ[pVP[k]] - VZ[pVP[0]];
          Pnx[i] = NyA[i] * NzB[i] - NzA[i] * NyB[i];
          Pny[i] = NzA[i] * NxB[i] - NxA[i] * NzB[i];
          Pnz[i] = NxA[i] * NyB[i] - NyA[i] * NxB[i];
          NxA[i] = Pnx[i] * Pnx[i] + Pny[i] * Pny[i] + Pnz[i] * Pnz[i];
          if (NxA[i] > minimum_area) {
            Pnx[i] /= NxA[i];
            Pny[i] /= NxA[i];
            Pnz[i] /= NxA[i];
          }
        }
        pVP += 7;
      }
    } else {
      for (i = 0; i < npolygons; i++) {
        if (pVP[k] >= 0) {
          NxA[i] = VX[pVP[k]] - VX[pVP[0]];
          NyA[i] = VY[pVP[k]] - VY[pVP[0]];
          NzA[i] = VZ[pVP[k]] - VZ[pVP[0]];
          Pnx[i] = NyB[i] * NzA[i] - NzB[i] * NyA[i];
          Pny[i] = NzB[i] * NxA[i] - NxB[i] * NzA[i];
          Pnz[i] = NxB[i] * NyA[i] - NyB[i] * NxA[i];
          NxB[i] = Pnx[i] * Pnx[i] + Pny[i] * Pny[i] + Pnz[i] * Pnz[i];
          if (NxB[i] > minimum_area) {
            Pnx[i] /= NxB[i];
            Pny[i] /= NxB[i];
            Pnz[i] /= NxB[i];
          }
        }
        pVP += 7;
      }
    }
    pVP = Vert_f_Pol;
    for (i = 0; i < npolygons; i++) {
      if (pVP[k] >= 0) {
        iv[0] = pVP[0];
        iv[1] = pVP[k - 1];
        iv[2] = pVP[k];
        if (NxA[i] > minimum_area) {
          x = Pnx[i];
          y = Pny[i];
          z = Pnz[i];
        } else {
          if (VX[iv[0]] == VX[iv[1]] || VX[iv[0]] == VX[iv[2]])
            ix = (int)VX[iv[0]];
          else
            ix = (int)VX[iv[1]];
          if (VY[iv[0]] == VY[iv[1]] || VY[iv[0]] == VY[iv[2]])
            iy = (int)VY[iv[0]];
          else
            iy = (int)VY[iv[1]];
          if (VZ[iv[0]] == VZ[iv[1]] || VZ[iv[0]] == VZ[iv[2]])
            iz = (int)VZ[iv[0]];
          else
            iz = (int)VZ[iv[1]];
          i1 = ix;
          if (i1 != ixb)
            i2 = i1 + 1;
          else {
            i2 = i1;
            i1--;
          }
          if (ptGRID[(int)iy + (int)i2 * ydim + (int)iz * xdim_x_ydim] >=
              1.0e30) {
            i2--;
            i1--;
          }
          x = ptGRID[(int)iy + (int)i2 * ydim + (int)iz * xdim_x_ydim] -
              ptGRID[(int)iy + (int)i1 * ydim + (int)iz * xdim_x_ydim];
          i1 = iy;
          if (i1 != iyb)
            i2 = i1 + 1;
          else {
            i2 = i1;
            i1--;
          }
          if (ptGRID[(int)i2 + (int)ix * ydim + (int)iz * xdim_x_ydim] >=
              1.0e30) {
            i2--;
            i1--;
          }
          y = ptGRID[(int)i2 + (int)ix * ydim + (int)iz * xdim_x_ydim] -
              ptGRID[(int)i1 + (int)ix * ydim + (int)iz * xdim_x_ydim];
          i1 = iz;
          if (i1 != izb)
            i2 = i1 + 1;
          else {
            i2 = i1;
            i1--;
          }
          if (ptGRID[(int)iy + (int)ix * ydim + (int)i2 * xdim_x_ydim] >=
              1.0e30) {
            i2--;
            i1--;
          }
          z = ptGRID[(int)iy + (int)ix * ydim + (int)i2 * xdim_x_ydim] -
              ptGRID[(int)iy + (int)ix * ydim + (int)i1 * xdim_x_ydim];
          a = (x * x + y * y + z * z);
          if (a > 0.) {
            x /= a;
            y /= a;
            z /= a;
          }
        };
        NX[iv[0]] += x;
        NY[iv[0]] += y;
        NZ[iv[0]] += z;
        NX[iv[1]] += x;
        NY[iv[1]] += y;
        NZ[iv[1]] += z;
        NX[iv[2]] += x;
        NY[iv[2]] += y;
        NZ[iv[2]] += z;
      }
      pVP += 7;
    }
    swap_flag = (swap_flag ? 0 : 1);
  }
  if (arX != 1.0)
    for (i = 0; i < nvertex; i++)
      NX[i] /= arX;
  if (arY != 1.0)
    for (i = 0; i < nvertex; i++)
      NY[i] /= arY;
  if (arZ != 1.0)
    for (i = 0; i < nvertex; i++)
      NZ[i] /= arZ;
  for (i = 0; i < nvertex; i++) {
    len = sqrt(NX[i] * NX[i] + NY[i] * NY[i] + NZ[i] * NZ[i]);
    if (len > 1.0e-5) {
      NX[i] /= len;
      NY[i] /= len;
      NZ[i] /= len;
    }
  }
}


x86 assembly (clang, -O0):
<normals>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
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    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movsd  %xmm2,-0x40(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
movss  0x1e46(%rip),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movl   $0x6,-0x48(%rbp)
imul   $0x7,0x38(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x48(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    121f <normals+0x10f>
mov    0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x90(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    120c <normals+0xfc>
jmp    121f <normals+0x10f>
jmp    1211 <normals+0x101>
mov    -0x44(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x44(%rbp)
jmp    11d9 <normals+0xc9>
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jl     1230 <normals+0x120>
jmp    123b <normals+0x12b>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    11d0 <normals+0xc0>
mov    0x90(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    0x90(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    131f <normals+0x20f>
mov    -0x80(%rbp),%rax
cmpl   $0x0,0x18(%rax)
jle    1305 <normals+0x1f5>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq 0x4(%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
add    $0x1c,%rax
mov    %rax,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1261 <normals+0x151>
movl   $0x0,-0x88(%rbp)
movl   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1f5e <normals+0xe4e>
mov    0x90(%rbp),%rax
mov    %rax,-0x80(%rbp)
cmpl   $0x0,-0x88(%rbp)
jne    162f <normals+0x51f>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    162a <normals+0x51a>
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1610 <normals+0x500>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x9c(%rbp),%xmm0
jbe    160b <normals+0x4fb>
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1610 <normals+0x500>
mov    -0x80(%rbp),%rax
add    $0x1c,%rax
mov    %rax,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    135e <normals+0x24e>
jmp    1904 <normals+0x7f4>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    18ff <normals+0x7ef>
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     18e5 <normals+0x7d5>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq (%rcx),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x9c(%rbp),%xmm0
jbe    18e0 <normals+0x7d0>
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    18e5 <normals+0x7d5>
mov    -0x80(%rbp),%rax
add    $0x1c,%rax
mov    %rax,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1636 <normals+0x526>
jmp    1904 <normals+0x7f4>
mov    0x90(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1f37 <normals+0xe27>
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1f1d <normals+0xe0d>
mov    -0x80(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x9c(%rbp),%xmm0
jbe    19bc <normals+0x8ac>
mov    0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
jmp    1e33 <normals+0xd23>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    19e6 <normals+0x8d6>
jp     19e6 <normals+0x8d6>
jmp    1a0b <normals+0x8fb>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    1a20 <normals+0x910>
jp     1a20 <normals+0x910>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
jmp    1a30 <normals+0x920>
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    1a5a <normals+0x94a>
jp     1a5a <normals+0x94a>
jmp    1a7f <normals+0x96f>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    1a94 <normals+0x984>
jp     1a94 <normals+0x984>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    1aa4 <normals+0x994>
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    1ace <normals+0x9be>
jp     1ace <normals+0x9be>
jmp    1af3 <normals+0x9e3>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    1b08 <normals+0x9f8>
jp     1b08 <normals+0x9f8>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
jmp    1b18 <normals+0xa08>
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
je     1b38 <normals+0xa28>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1b47 <normals+0xa37>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x6c(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x14a1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1b93 <normals+0xa83>
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x6c(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x5c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x6c(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x68(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x74(%rbp),%eax
je     1c03 <normals+0xaf3>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1c12 <normals+0xb02>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x6c(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x13d6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1c5e <normals+0xb4e>
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x6c(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x6c(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x6c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x78(%rbp),%eax
je     1cce <normals+0xbbe>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1cdd <normals+0xbcd>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x60(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x130b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1d29 <normals+0xc19>
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x60(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x90(%rbp),%xmm0
ff
mulss  -0x90(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x94(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1e2e <normals+0xd1e>
movss  -0x98(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0x90(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0x94(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
jmp    1e33 <normals+0xd23>
movss  -0x8c(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
add    $0x1c,%rax
mov    %rax,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1916 <normals+0x806>
mov    -0x88(%rbp),%edx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1330 <normals+0x220>
movsd  -0x30(%rbp),%xmm0
movsd  0x109d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1f80 <normals+0xe70>
jp     1f80 <normals+0xe70>
jmp    1fc9 <normals+0xeb9>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1fc4 <normals+0xeb4>
movsd  -0x30(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1f87 <normals+0xe77>
jmp    1fc9 <normals+0xeb9>
movsd  -0x38(%rbp),%xmm0
movsd  0x1032(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1feb <normals+0xedb>
jp     1feb <normals+0xedb>
jmp    2034 <normals+0xf24>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    202f <normals+0xf1f>
movsd  -0x38(%rbp),%xmm1
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1ff2 <normals+0xee2>
jmp    2034 <normals+0xf24>
movsd  -0x40(%rbp),%xmm0
movsd  0xfc7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2056 <normals+0xf46>
jp     2056 <normals+0xf46>
jmp    209f <normals+0xf8f>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    209a <normals+0xf8a>
movsd  -0x40(%rbp),%xmm1
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    205d <normals+0xf4d>
jmp    209f <normals+0xf8f>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    21b0 <normals+0x10a0>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xed7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    219d <normals+0x108d>
movss  -0xa0(%rbp),%xmm1
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa0(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    21a2 <normals+0x1092>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    20a6 <normals+0xf96>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<normals>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8,%r10
mov    %ecx,0xc(%rsp)
mov    %rdi,0x58(%rsp)
mov    0x120(%rsp),%rbp
mov    0x108(%rsp),%r8
mov    0xf8(%rsp),%r11
mov    0xc8(%rsp),%ecx
mov    %edx,%eax
mov    %esi,0x8(%rsp)
imul   %esi,%eax
mov    %eax,0x1c(%rsp)
lea    0x0(,%rcx,8),%eax
sub    %ecx,%eax
cltq
mov    0xe8(%rsp),%rbx
mov    0xb8(%rsp),%r12
mov    0xb0(%rsp),%r13
mov    0xa8(%rsp),%rdi
mov    %rdx,0x60(%rsp)
lea    -0x1(%rdx),%ecx
mov    %ecx,0x18(%rsp)
mov    $0x6,%ecx
movslq %ecx,%rdx
mov    %rdx,%rcx
nopl   0x0(%rax,%rax,1)
add    $0x7,%rcx
cmp    %rax,%rcx
jge    11b5 <normals+0xa5>
mov    0x0(%rbp,%rcx,4),%esi
cmp    0x0(%rbp,%rdx,4),%esi
jle    11a0 <normals+0x90>
jmp    1192 <normals+0x82>
mov    0x0(%rbp,%rdx,4),%eax
mov    %rax,0x20(%rsp)
mov    0xc8(%rsp),%eax
mov    %eax,%ecx
mov    %rcx,(%rsp)
test   %eax,%eax
jle    123a <normals+0x12a>
xor    %eax,%eax
mov    %rbp,%rcx
jmp    11ee <normals+0xde>
cs nopw 0x0(%rax,%rax,1)
add    $0x1c,%rcx
add    $0x1,%rax
cmp    %rax,(%rsp)
je     123a <normals+0x12a>
cmpl   $0x0,0x18(%rcx)
jle    11e0 <normals+0xd0>
movslq 0x4(%rcx),%rdx
movss  (%r10,%rdx,4),%xmm3
movslq (%rcx),%rsi
subss  (%r10,%rsi,4),%xmm3
movss  %xmm3,(%rbx,%rax,4)
movss  (%r9,%rdx,4),%xmm3
subss  (%r9,%rsi,4),%xmm3
movss  %xmm3,(%r11,%rax,4)
mov    0xa0(%rsp),%rbp
movss  0x0(%rbp,%rdx,4),%xmm3
subss  0x0(%rbp,%rsi,4),%xmm3
movss  %xmm3,(%r8,%rax,4)
jmp    11e0 <normals+0xd0>
cmpl   $0x3,0x20(%rsp)
mov    (%rsp),%rax
jl     191f <normals+0x80f>
addl   $0xffffffff,0x8(%rsp)
addl   $0xffffffff,0xc(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    $0x2,%ecx
mov    $0x8,%esi
movss  0xd8b(%rip),%xmm10
movsd  0xd8a(%rip),%xmm9
xorps  %xmm8,%xmm8
mov    %r9,0x30(%rsp)
mov    %r10,0x28(%rsp)
jmp    12b0 <normals+0x1a0>
xchg   %ax,%ax
mov    0x50(%rsp),%rax
xor    $0x1,%eax
mov    0x48(%rsp),%rcx
add    $0x1,%rcx
add    $0x4,%rsi
cmp    0x20(%rsp),%rcx
je     191f <normals+0x80f>
mov    %rcx,0x48(%rsp)
mov    %rax,0x50(%rsp)
test   %eax,%eax
mov    %rsi,0x10(%rsp)
mov    0xc8(%rsp),%eax
je     1460 <normals+0x350>
test   %eax,%eax
jle    1290 <normals+0x180>
xor    %eax,%eax
mov    0x120(%rsp),%rdx
mov    0x110(%rsp),%r8
mov    0x108(%rsp),%r11
mov    0x100(%rsp),%r14
mov    0xf8(%rsp),%r15
mov    0xf0(%rsp),%rbp
mov    0xe8(%rsp),%rbx
jmp    1323 <normals+0x213>
xchg   %ax,%ax
add    $0x1c,%rdx
add    $0x4,%rax
cmp    %rax,0x40(%rsp)
je     15f0 <normals+0x4e0>
mov    (%rdx,%rsi,1),%ecx
test   %ecx,%ecx
js     1310 <normals+0x200>
movss  (%r10,%rcx,4),%xmm4
movslq (%rdx),%rsi
subss  (%r10,%rsi,4),%xmm4
movss  %xmm4,(%rbx,%rax,1)
movss  (%r9,%rcx,4),%xmm4
subss  (%r9,%rsi,4),%xmm4
movss  %xmm4,(%r15,%rax,1)
mov    0xa0(%rsp),%rdi
movss  (%rdi,%rcx,4),%xmm4
subss  (%rdi,%rsi,4),%xmm4
movss  %xmm4,(%r11,%rax,1)
movss  (%r15,%rax,1),%xmm5
mulss  (%r8,%rax,1),%xmm5
mulss  (%r14,%rax,1),%xmm4
subss  %xmm5,%xmm4
mov    0xd0(%rsp),%rdi
movss  %xmm4,(%rdi,%rax,1)
movss  (%r8,%rax,1),%xmm4
movss  (%r11,%rax,1),%xmm5
mulss  0x0(%rbp,%rax,1),%xmm5
mulss  (%rbx,%rax,1),%xmm4
subss  %xmm5,%xmm4
mov    0xd8(%rsp),%rsi
movss  %xmm4,(%rsi,%rax,1)
movss  0x0(%rbp,%rax,1),%xmm6
movss  (%rbx,%rax,1),%xmm4
mulss  (%r14,%rax,1),%xmm4
mulss  (%r15,%rax,1),%xmm6
subss  %xmm4,%xmm6
mov    0xe0(%rsp),%rcx
movss  %xmm6,(%rcx,%rax,1)
movss  (%rdi,%rax,1),%xmm4
movss  (%rsi,%rax,1),%xmm5
mov    0x10(%rsp),%rsi
mulss  %xmm5,%xmm5
mulss  %xmm4,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm6,%xmm6
addss  %xmm4,%xmm6
movss  %xmm6,0x0(%rbp,%rax,1)
ucomiss %xmm10,%xmm6
jbe    1310 <normals+0x200>
mov    0xd0(%rsp),%rcx
movss  (%rcx,%rax,1),%xmm4
divss  %xmm6,%xmm4
movss  %xmm4,(%rcx,%rax,1)
mov    0xd8(%rsp),%rcx
movss  (%rcx,%rax,1),%xmm4
divss  0x0(%rbp,%rax,1),%xmm4
movss  %xmm4,(%rcx,%rax,1)
mov    0xe0(%rsp),%rcx
movss  (%rcx,%rax,1),%xmm4
divss  0x0(%rbp,%rax,1),%xmm4
movss  %xmm4,(%rcx,%rax,1)
jmp    1310 <normals+0x200>
nopl   0x0(%rax)
test   %eax,%eax
jle    1290 <normals+0x180>
xor    %eax,%eax
mov    0x120(%rsp),%rdx
mov    0x108(%rsp),%r11
mov    0x100(%rsp),%r8
mov    0xf8(%rsp),%r14
mov    0xf0(%rsp),%rdi
mov    0xe8(%rsp),%rbx
jmp    14b3 <normals+0x3a3>
nopl   0x0(%rax)
add    $0x1c,%rdx
add    $0x4,%rax
cmp    %rax,0x40(%rsp)
je     15f0 <normals+0x4e0>
mov    (%rdx,%rsi,1),%ecx
test   %ecx,%ecx
js     14a0 <normals+0x390>
movss  (%r10,%rcx,4),%xmm4
movslq (%rdx),%rsi
subss  (%r10,%rsi,4),%xmm4
movss  %xmm4,(%rdi,%rax,1)
movss  (%r9,%rcx,4),%xmm4
subss  (%r9,%rsi,4),%xmm4
movss  %xmm4,(%r8,%rax,1)
mov    0xa0(%rsp),%rbp
movss  0x0(%rbp,%rcx,4),%xmm4
subss  0x0(%rbp,%rsi,4),%xmm4
mov    0x110(%rsp),%rsi
movss  %xmm4,(%rsi,%rax,1)
movss  (%r8,%rax,1),%xmm5
mulss  (%r11,%rax,1),%xmm5
mulss  (%r14,%rax,1),%xmm4
subss  %xmm5,%xmm4
mov    0xd0(%rsp),%r15
movss  %xmm4,(%r15,%rax,1)
movss  (%r11,%rax,1),%xmm4
movss  (%rsi,%rax,1),%xmm5
mulss  (%rbx,%rax,1),%xmm5
mulss  (%rdi,%rax,1),%xmm4
subss  %xmm5,%xmm4
mov    0xd8(%rsp),%rsi
movss  %xmm4,(%rsi,%rax,1)
movss  (%rbx,%rax,1),%xmm6
movss  (%rdi,%rax,1),%xmm4
mulss  (%r14,%rax,1),%xmm4
mulss  (%r8,%rax,1),%xmm6
subss  %xmm4,%xmm6
mov    0xe0(%rsp),%rcx
movss  %xmm6,(%rcx,%rax,1)
movss  (%r15,%rax,1),%xmm4
movss  (%rsi,%rax,1),%xmm5
mov    0x10(%rsp),%rsi
mulss  %xmm5,%xmm5
mulss  %xmm4,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm6,%xmm6
addss  %xmm4,%xmm6
movss  %xmm6,(%rbx,%rax,1)
ucomiss %xmm10,%xmm6
jbe    14a0 <normals+0x390>
mov    0xd0(%rsp),%rcx
movss  (%rcx,%rax,1),%xmm4
divss  %xmm6,%xmm4
movss  %xmm4,(%rcx,%rax,1)
mov    0xd8(%rsp),%rcx
movss  (%rcx,%rax,1),%xmm4
divss  (%rbx,%rax,1),%xmm4
movss  %xmm4,(%rcx,%rax,1)
mov    0xe0(%rsp),%rcx
movss  (%rcx,%rax,1),%xmm4
divss  (%rbx,%rax,1),%xmm4
movss  %xmm4,(%rcx,%rax,1)
jmp    14a0 <normals+0x390>
xchg   %ax,%ax
mov    0xc8(%rsp),%eax
test   %eax,%eax
mov    0xa8(%rsp),%rdi
mov    (%rsp),%rcx
jle    1290 <normals+0x180>
xor    %edx,%edx
mov    0x120(%rsp),%r14
jmp    16ee <normals+0x5de>
nopw   0x0(%rax,%rax,1)
mov    0xd0(%rsp),%rax
movss  (%rax,%rdx,4),%xmm3
mov    0xe0(%rsp),%rax
movss  (%rax,%rdx,4),%xmm4
mov    0xd8(%rsp),%rax
movss  (%rax,%rdx,4),%xmm5
unpcklps %xmm4,%xmm5
movss  (%rdi,%r8,4),%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%r8,4)
movss  0x0(%r13,%r8,4),%xmm4
addss  %xmm5,%xmm4
movss  %xmm4,0x0(%r13,%r8,4)
movaps %xmm5,%xmm4
shufps $0x55,%xmm5,%xmm4
movss  (%r12,%r8,4),%xmm6
addss  %xmm4,%xmm6
movss  %xmm6,(%r12,%r8,4)
movss  (%rdi,%rbp,4),%xmm6
addss  %xmm3,%xmm6
movss  %xmm6,(%rdi,%rbp,4)
movss  0x0(%r13,%rbp,4),%xmm6
addss  %xmm5,%xmm6
movss  %xmm6,0x0(%r13,%rbp,4)
movss  (%r12,%rbp,4),%xmm6
addss  %xmm4,%xmm6
movss  %xmm6,(%r12,%rbp,4)
addss  (%rdi,%r15,4),%xmm3
movss  %xmm3,(%rdi,%r15,4)
movss  0x0(%r13,%r15,4),%xmm3
addss  %xmm5,%xmm3
movss  %xmm3,0x0(%r13,%r15,4)
addss  (%r12,%r15,4),%xmm4
movss  %xmm4,(%r12,%r15,4)
add    $0x1c,%r14
add    $0x1,%rdx
cmp    %rdx,%rcx
je     1290 <normals+0x180>
mov    (%r14,%rsi,1),%r15d
test   %r15d,%r15d
js     16dd <normals+0x5cd>
movslq (%r14),%r8
movslq -0x4(%r14,%rsi,1),%rbp
mov    0xe8(%rsp),%rax
movss  (%rax,%rdx,4),%xmm4
ucomiss %xmm10,%xmm4
ja     1620 <normals+0x510>
movss  (%r10,%r8,4),%xmm5
movss  (%r10,%rbp,4),%xmm6
ucomiss %xmm6,%xmm5
jne    1729 <normals+0x619>
jnp    1732 <normals+0x622>
ucomiss (%r10,%r15,4),%xmm5
jne    1735 <normals+0x625>
jp     1735 <normals+0x625>
movaps %xmm5,%xmm6
movss  (%r9,%r8,4),%xmm5
movss  (%r9,%rbp,4),%xmm7
ucomiss %xmm7,%xmm5
jne    1748 <normals+0x638>
jnp    1751 <normals+0x641>
ucomiss (%r9,%r15,4),%xmm5
jne    1754 <normals+0x644>
jp     1754 <normals+0x644>
movaps %xmm5,%xmm7
mov    0xa0(%rsp),%rax
movss  (%rax,%r8,4),%xmm4
mov    %rbp,0x38(%rsp)
movss  (%rax,%rbp,4),%xmm5
ucomiss %xmm5,%xmm4
jne    1773 <normals+0x663>
jnp    1784 <normals+0x674>
mov    0xa0(%rsp),%rax
ucomiss (%rax,%r15,4),%xmm4
jne    1787 <normals+0x677>
jp     1787 <normals+0x677>
movaps %xmm4,%xmm5
cvttss2si %xmm6,%r11d
cvttss2si %xmm7,%r13d
cvttss2si %xmm5,%esi
xor    %ecx,%ecx
xor    %r12d,%r12d
cmp    %r11d,0x8(%rsp)
sete   %cl
setne  %r12b
add    %r11d,%r12d
mov    %r11d,%eax
sub    %ecx,%eax
mov    %r12d,%edi
mov    0x60(%rsp),%rbx
imul   %ebx,%edi
mov    0x1c(%rsp),%ebp
mov    %ebp,%ecx
imul   %esi,%ecx
lea    (%rcx,%r13,1),%r10d
add    %r10d,%edi
movslq %edi,%rdi
mov    0x58(%rsp),%r9
movss  (%r9,%rdi,4),%xmm4
cvtss2sd %xmm4,%xmm4
xor    %edi,%edi
ucomisd %xmm9,%xmm4
setae  %dil
sub    %edi,%r12d
sub    %edi,%eax
imul   %ebx,%r12d
add    %r10d,%r12d
movslq %r12d,%rdi
movss  (%r9,%rdi,4),%xmm3
imul   %ebx,%eax
add    %r10d,%eax
cltq
subss  (%r9,%rax,4),%xmm3
xor    %eax,%eax
xor    %edi,%edi
cmp    %r13d,0x18(%rsp)
sete   %al
setne  %dil
add    %r13d,%edi
imul   %ebx,%r11d
add    %r11d,%ecx
add    %edi,%ecx
movslq %ecx,%rcx
movss  (%r9,%rcx,4),%xmm4
cvtss2sd %xmm4,%xmm4
xor    %edi,%edi
ucomisd %xmm9,%xmm4
setae  %dil
sub    %edi,%ecx
movslq %ecx,%r12
add    %r11d,%r10d
sub    %eax,%r10d
sub    %edi,%r10d
movslq %r10d,%r10
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %esi,0xc(%rsp)
sete   %al
setne  %cl
add    %esi,%ecx
sub    %eax,%esi
add    %r13d,%r11d
mov    %ecx,%eax
imul   %ebp,%eax
add    %r11d,%eax
cltq
movss  (%r9,%rax,4),%xmm4
cvtss2sd %xmm4,%xmm4
xor    %eax,%eax
ucomisd %xmm9,%xmm4
setae  %al
sub    %eax,%ecx
sub    %eax,%esi
imul   %ebp,%ecx
add    %r11d,%ecx
movslq %ecx,%rax
imul   %ebp,%esi
add    %r11d,%esi
movslq %esi,%rcx
movss  (%r9,%r12,4),%xmm5
movss  (%r9,%rax,4),%xmm4
unpcklps %xmm4,%xmm5
movss  (%r9,%r10,4),%xmm4
movss  (%r9,%rcx,4),%xmm7
unpcklps %xmm7,%xmm4
subps  %xmm4,%xmm5
movaps %xmm5,%xmm7
shufps $0x55,%xmm5,%xmm7
movaps %xmm5,%xmm4
mulss  %xmm5,%xmm4
movaps %xmm3,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm7,%xmm7
addss  %xmm6,%xmm7
ucomiss %xmm8,%xmm7
jbe    18ea <normals+0x7da>
divss  %xmm7,%xmm3
shufps $0x0,%xmm7,%xmm7
divps  %xmm7,%xmm5
mov    0xb8(%rsp),%r12
mov    0xb0(%rsp),%r13
mov    0xa8(%rsp),%rdi
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%r10
mov    (%rsp),%rcx
mov    0x10(%rsp),%rsi
mov    0x38(%rsp),%rbp
jmp    164a <normals+0x53a>
ucomisd 0x6e9(%rip),%xmm0
mov    0xc0(%rsp),%ebx
mov    %ebx,%ebp
jne    1938 <normals+0x828>
jnp    1a1f <normals+0x90f>
test   %ebx,%ebx
jle    1a1f <normals+0x90f>
cmp    $0x4,%ebx
jae    194c <normals+0x83c>
xor    %eax,%eax
jmp    1a00 <normals+0x8f0>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1d09 <normals+0xbf9>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
cvtps2pd 0x8(%rdi,%rcx,4),%xmm4
cvtps2pd (%rdi,%rcx,4),%xmm5
divpd  %xmm3,%xmm5
divpd  %xmm3,%xmm4
cvtpd2ps %xmm4,%xmm4
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm4,%xmm5
movupd %xmm5,(%rdi,%rcx,4)
cvtps2pd 0x18(%rdi,%rcx,4),%xmm4
cvtps2pd 0x10(%rdi,%rcx,4),%xmm5
divpd  %xmm3,%xmm5
divpd  %xmm3,%xmm4
cvtpd2ps %xmm4,%xmm4
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm4,%xmm5
movupd %xmm5,0x10(%rdi,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1980 <normals+0x870>
test   $0x1,%dl
je     19f7 <normals+0x8e7>
cvtps2pd 0x8(%rdi,%rcx,4),%xmm4
cvtps2pd (%rdi,%rcx,4),%xmm5
divpd  %xmm3,%xmm5
divpd  %xmm3,%xmm4
cvtpd2ps %xmm4,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm3,%xmm4
movupd %xmm4,(%rdi,%rcx,4)
cmp    %rbp,%rax
je     1a1f <normals+0x90f>
nopl   0x0(%rax)
movss  (%rdi,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm0,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,(%rdi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1a00 <normals+0x8f0>
ucomisd 0x5e9(%rip),%xmm1
jne    1a2f <normals+0x91f>
jnp    1b33 <normals+0xa23>
test   %ebx,%ebx
jle    1b33 <normals+0xa23>
cmp    $0x4,%ebx
jae    1a43 <normals+0x933>
xor    %eax,%eax
jmp    1b10 <normals+0xa00>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1d19 <normals+0xc09>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtps2pd 0x8(%r13,%rcx,4),%xmm3
cvtps2pd 0x0(%r13,%rcx,4),%xmm4
divpd  %xmm0,%xmm4
divpd  %xmm0,%xmm3
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm3,%xmm4
movupd %xmm4,0x0(%r13,%rcx,4)
cvtps2pd 0x18(%r13,%rcx,4),%xmm3
cvtps2pd 0x10(%r13,%rcx,4),%xmm4
divpd  %xmm0,%xmm4
divpd  %xmm0,%xmm3
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm3,%xmm4
movupd %xmm4,0x10(%r13,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1a80 <normals+0x970>
test   $0x1,%dl
je     1b04 <normals+0x9f4>
cvtps2pd 0x8(%r13,%rcx,4),%xmm3
cvtps2pd 0x0(%r13,%rcx,4),%xmm4
divpd  %xmm0,%xmm4
divpd  %xmm0,%xmm3
cvtpd2ps %xmm3,%xmm0
cvtpd2ps %xmm4,%xmm3
unpcklpd %xmm0,%xmm3
movupd %xmm3,0x0(%r13,%rcx,4)
cmp    %rbp,%rax
je     1b33 <normals+0xa23>
nopl   0x0(%rax)
movss  0x0(%r13,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1b10 <normals+0xa00>
ucomisd 0x4d5(%rip),%xmm2
jne    1b43 <normals+0xa33>
jnp    1c41 <normals+0xb31>
test   %ebx,%ebx
jle    1c41 <normals+0xb31>
cmp    $0x4,%ebx
jae    1b57 <normals+0xa47>
xor    %eax,%eax
jmp    1c20 <normals+0xb10>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1d29 <normals+0xc19>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
cvtps2pd 0x8(%r12,%rcx,4),%xmm1
cvtps2pd (%r12,%rcx,4),%xmm3
divpd  %xmm0,%xmm3
divpd  %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm3
movupd %xmm3,(%r12,%rcx,4)
cvtps2pd 0x18(%r12,%rcx,4),%xmm1
cvtps2pd 0x10(%r12,%rcx,4),%xmm3
divpd  %xmm0,%xmm3
divpd  %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm3
movupd %xmm3,0x10(%r12,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1b90 <normals+0xa80>
test   $0x1,%dl
je     1c10 <normals+0xb00>
cvtps2pd 0x8(%r12,%rcx,4),%xmm1
cvtps2pd (%r12,%rcx,4),%xmm3
divpd  %xmm0,%xmm3
divpd  %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm0
cvtpd2ps %xmm3,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%r12,%rcx,4)
cmp    %rbp,%rax
je     1c41 <normals+0xb31>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1c20 <normals+0xb10>
test   %ebx,%ebx
jle    1cfa <normals+0xbea>
xor    %ebx,%ebx
xorpd  %xmm2,%xmm2
movsd  0x3c1(%rip),%xmm3
jmp    1c6d <normals+0xb5d>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    %rbx,%rbp
je     1cfa <normals+0xbea>
movss  (%rdi,%rbx,4),%xmm1
movss  0x0(%r13,%rbx,4),%xmm0
mulss  %xmm0,%xmm0
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  (%r12,%rbx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm2,%xmm0
jb     1ca0 <normals+0xb90>
sqrtss %xmm0,%xmm0
jmp    1cb8 <normals+0xba8>
xchg   %ax,%ax
call   1030 <sqrtf@plt>
movsd  0x36b(%rip),%xmm3
xorps  %xmm2,%xmm2
mov    0xa8(%rsp),%rdi
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd %xmm3,%xmm1
jbe    1c60 <normals+0xb50>
movss  (%rdi,%rbx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rbx,4)
movss  0x0(%r13,%rbx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rbx,4)
movss  (%r12,%rbx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rbx,4)
jmp    1c60 <normals+0xb50>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    19d5 <normals+0x8c5>
jmp    19f7 <normals+0x8e7>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1add <normals+0x9cd>
jmp    1b04 <normals+0x9f4>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1beb <normals+0xadb>
jmp    1c10 <normals+0xb00>

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

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