void somworker(int nrows, int ncolumns, double **data, int **mask,
               const double weights[], int transpose, int nxgrid, int nygrid,
               double inittau, double ***celldata, int niter, char dist) {
  const int nelements = (transpose == 0) ? nrows : ncolumns;
  const int ndata = (transpose == 0) ? ncolumns : nrows;
  int i, j;
  int **dummymask;
  int ix, iy;
  int *index;
  int iter;
  double maxradius = sqrt(nxgrid * nxgrid + nygrid * nygrid);
  double *stddata = calloc(nelements, sizeof(double));
  double (*metric)(int, double **, double **, int **, int **, const double[],
                   int, int, int) = setmetric(dist);
  if (transpose == 0) {
    for (i = 0; i < nelements; i++) {
      int n = 0;
      for (j = 0; j < ndata; j++) {
        if (mask[i][j]) {
          double term = data[i][j];
          term = term * term;
          stddata[i] += term;
          n++;
        }
      }
      if (stddata[i] > 0)
        stddata[i] = sqrt(stddata[i] / n);
      else
        stddata[i] = 1;
    }
  } else {
    for (i = 0; i < nelements; i++) {
      int n = 0;
      for (j = 0; j < ndata; j++) {
        if (mask[j][i]) {
          double term = data[j][i];
          term = term * term;
          stddata[i] += term;
          n++;
        }
      }
      if (stddata[i] > 0)
        stddata[i] = sqrt(stddata[i] / n);
      else
        stddata[i] = 1;
    }
  }
  if (transpose == 0) {
    dummymask = malloc(nygrid * sizeof(int *));
    for (i = 0; i < nygrid; i++) {
      dummymask[i] = malloc(ndata * sizeof(int));
      for (j = 0; j < ndata; j++)
        dummymask[i][j] = 1;
    }
  } else {
    dummymask = malloc(ndata * sizeof(int *));
    for (i = 0; i < ndata; i++) {
      dummymask[i] = malloc(sizeof(int));
      dummymask[i][0] = 1;
    }
  }
  for (ix = 0; ix < nxgrid; ix++) {
    for (iy = 0; iy < nygrid; iy++) {
      double sum = 0.;
      for (i = 0; i < ndata; i++) {
        double term = -1.0 + 2.0 * uniform();
        celldata[ix][iy][i] = term;
        sum += term * term;
      }
      sum = sqrt(sum / ndata);
      for (i = 0; i < ndata; i++)
        celldata[ix][iy][i] /= sum;
    }
  }
  index = malloc(nelements * sizeof(int));
  for (i = 0; i < nelements; i++)
    index[i] = i;
  for (i = 0; i < nelements; i++) {
    j = (int)(i + (nelements - i) * uniform());
    ix = index[j];
    index[j] = index[i];
    index[i] = ix;
  }
  for (iter = 0; iter < niter; iter++) {
    int ixbest = 0;
    int iybest = 0;
    int iobject = iter % nelements;
    iobject = index[iobject];
    if (transpose == 0) {
      double closest = metric(ndata, data, celldata[ixbest], mask, dummymask,
                              weights, iobject, iybest, transpose);
      double radius = maxradius * (1. - ((double)iter) / ((double)niter));
      double tau = inittau * (1. - ((double)iter) / ((double)niter));
      for (ix = 0; ix < nxgrid; ix++) {
        for (iy = 0; iy < nygrid; iy++) {
          double distance = metric(ndata, data, celldata[ix], mask, dummymask,
                                   weights, iobject, iy, transpose);
          if (distance < closest) {
            ixbest = ix;
            iybest = iy;
            closest = distance;
          }
        }
      }
      for (ix = 0; ix < nxgrid; ix++) {
        for (iy = 0; iy < nygrid; iy++) {
          if (sqrt((ix - ixbest) * (ix - ixbest) +
                   (iy - iybest) * (iy - iybest)) < radius) {
            double sum = 0.;
            for (i = 0; i < ndata; i++) {
              if (mask[iobject][i] == 0)
                continue;
              celldata[ix][iy][i] +=
                  tau *
                  (data[iobject][i] / stddata[iobject] - celldata[ix][iy][i]);
            }
            for (i = 0; i < ndata; i++) {
              double term = celldata[ix][iy][i];
              term = term * term;
              sum += term;
            }
            if (sum > 0) {
              sum = sqrt(sum / ndata);
              for (i = 0; i < ndata; i++)
                celldata[ix][iy][i] /= sum;
            }
          }
        }
      }
    } else {
      double closest;
      double **celldatavector = malloc(ndata * sizeof(double *));
      double radius = maxradius * (1. - ((double)iter) / ((double)niter));
      double tau = inittau * (1. - ((double)iter) / ((double)niter));
      for (i = 0; i < ndata; i++)
        celldatavector[i] = &(celldata[ixbest][iybest][i]);
      closest = metric(ndata, data, celldatavector, mask, dummymask, weights,
                       iobject, 0, transpose);
      for (ix = 0; ix < nxgrid; ix++) {
        for (iy = 0; iy < nygrid; iy++) {
          double distance;
          for (i = 0; i < ndata; i++)
            celldatavector[i] = &(celldata[ixbest][iybest][i]);
          distance = metric(ndata, data, celldatavector, mask, dummymask,
                            weights, iobject, 0, transpose);
          if (distance < closest) {
            ixbest = ix;
            iybest = iy;
            closest = distance;
          }
        }
      }
      free(celldatavector);
      for (ix = 0; ix < nxgrid; ix++) {
        for (iy = 0; iy < nygrid; iy++) {
          if (sqrt((ix - ixbest) * (ix - ixbest) +
                   (iy - iybest) * (iy - iybest)) < radius) {
            double sum = 0.;
            for (i = 0; i < ndata; i++) {
              if (mask[i][iobject] == 0)
                continue;
              celldata[ix][iy][i] +=
                  tau *
                  (data[i][iobject] / stddata[iobject] - celldata[ix][iy][i]);
            }
            for (i = 0; i < ndata; i++) {
              double term = celldata[ix][iy][i];
              term = term * term;
              sum += term;
            }
            if (sum > 0) {
              sum = sqrt(sum / ndata);
              for (i = 0; i < ndata; i++)
                celldata[ix][iy][i] /= sum;
            }
          }
        }
      }
    }
  }
  if (transpose == 0)
    for (i = 0; i < nygrid; i++)
      free(dummymask[i]);
  else
    for (i = 0; i < ndata; i++)
      free(dummymask[i]);
  free(dummymask);
  free(stddata);
  free(index);
}


x86 assembly (clang, -O0):
<somworker>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x148,%rsp
mov    0x30(%rbp),%al
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movsd  %xmm0,-0x38(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    11af <somworker+0x4f>
mov    -0xc(%rbp),%eax
mov    %eax,-0x12c(%rbp)
jmp    11b8 <somworker+0x58>
mov    -0x10(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    11d9 <somworker+0x79>
mov    -0x10(%rbp),%eax
mov    %eax,-0x130(%rbp)
jmp    11e2 <somworker+0x82>
mov    -0xc(%rbp),%eax
mov    %eax,-0x130(%rbp)
mov    -0x130(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x70(%rbp)
movslq -0x3c(%rbp),%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x78(%rbp)
movsbl 0x30(%rbp),%edi
mov    $0x0,%al
call   1060 <setmetric@plt>
cltq
mov    %rax,-0x80(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    1368 <somworker+0x208>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1363 <somworker+0x203>
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12f1 <somworker+0x191>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12de <somworker+0x17e>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12e3 <somworker+0x183>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    125a <somworker+0xfa>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    133b <somworker+0x1db>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x84(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1350 <somworker+0x1f0>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x1cb5(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1355 <somworker+0x1f5>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    123d <somworker+0xdd>
jmp    149a <somworker+0x33a>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1495 <somworker+0x335>
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1423 <somworker+0x2c3>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1410 <somworker+0x2b0>
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1415 <somworker+0x2b5>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    138c <somworker+0x22c>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    146d <somworker+0x30d>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x94(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1482 <somworker+0x322>
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x1b83(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1487 <somworker+0x327>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    136f <somworker+0x20f>
jmp    149a <somworker+0x33a>
cmpl   $0x0,-0x2c(%rbp)
jne    1534 <somworker+0x3d4>
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    152f <somworker+0x3cf>
movslq -0x40(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    151c <somworker+0x3bc>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    14eb <somworker+0x38b>
jmp    1521 <somworker+0x3c1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14bc <somworker+0x35c>
jmp    1596 <somworker+0x436>
movslq -0x40(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1591 <somworker+0x431>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x1,(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    154c <somworker+0x3ec>
jmp    1596 <somworker+0x436>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    16eb <somworker+0x58b>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16d8 <somworker+0x578>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1658 <somworker+0x4f8>
mov    $0x0,%al
call   1030 <uniform@plt>
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm0
movsd  0x1a17(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    15ce <somworker+0x46e>
movsd  -0xa8(%rbp),%xmm0
ff
cvtsi2sdl -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    16c5 <somworker+0x565>
movsd  -0xa8(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    167d <somworker+0x51d>
jmp    16ca <somworker+0x56a>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15b0 <somworker+0x450>
jmp    16dd <somworker+0x57d>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    159d <somworker+0x43d>
movslq -0x3c(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    172b <somworker+0x5cb>
mov    -0x44(%rbp),%edx
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1703 <somworker+0x5a3>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    17b0 <somworker+0x650>
mov    -0x44(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x138(%rbp)
mov    $0x0,%al
call   1030 <uniform@plt>
mov    -0x138(%rbp),%ecx
mov    %eax,%edx
mov    -0x134(%rbp),%eax
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%edx
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1732 <somworker+0x5d2>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    2081 <somworker+0xf21>
movl   $0x0,-0xb4(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0x64(%rbp),%eax
cltd
idivl  -0x3c(%rbp)
mov    %edx,-0xbc(%rbp)
mov    -0x60(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xbc(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    1bd8 <somworker+0xa78>
mov    -0x80(%rbp),%rax
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    0x20(%rbp),%rcx
movslq -0xb4(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xbc(%rbp),%ebx
mov    -0xb8(%rbp),%r11d
mov    -0x2c(%rbp),%r10d
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
call   *%rax
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
cvtsi2sdl -0x64(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x1795(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x64(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x176a(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1976 <somworker+0x816>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1963 <somworker+0x803>
mov    -0x80(%rbp),%rax
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    0x20(%rbp),%rcx
movslq -0x54(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xbc(%rbp),%ebx
mov    -0x58(%rbp),%r11d
mov    -0x2c(%rbp),%r10d
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
call   *%rax
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1950 <somworker+0x7f0>
mov    -0x54(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1955 <somworker+0x7f5>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    18c0 <somworker+0x760>
jmp    1968 <somworker+0x808>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    18ad <somworker+0x74d>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1bd3 <somworker+0xa73>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1bc0 <somworker+0xa60>
mov    -0x54(%rbp),%eax
sub    -0xb4(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    -0xb4(%rbp),%ecx
imul   %ecx,%eax
mov    -0x58(%rbp),%ecx
sub    -0xb8(%rbp),%ecx
mov    -0x58(%rbp),%edx
sub    -0xb8(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   1080 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1bad <somworker+0xa4d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1aab <somworker+0x94b>
mov    -0x20(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1a26 <somworker+0x8c6>
jmp    1a9d <somworker+0x93d>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    19f8 <somworker+0x898>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1b21 <somworker+0x9c1>
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1ab2 <somworker+0x952>
movsd  -0xe8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ba8 <somworker+0xa48>
movsd  -0xe8(%rbp),%xmm0
ff
cvtsi2sdl -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1ba3 <somworker+0xa43>
movsd  -0xe8(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b5b <somworker+0x9fb>
jmp    1ba8 <somworker+0xa48>
jmp    1bad <somworker+0xa4d>
jmp    1bb2 <somworker+0xa52>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1990 <somworker+0x830>
jmp    1bc5 <somworker+0xa65>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    197d <somworker+0x81d>
jmp    206e <somworker+0xf0e>
movslq -0x40(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x100(%rbp)
movsd  -0x70(%rbp),%xmm0
cvtsi2sdl -0x64(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x13f9(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x64(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x13ce(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1c97 <somworker+0xb37>
mov    0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x100(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1c49 <somworker+0xae9>
mov    -0x80(%rbp),%rax
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x100(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xbc(%rbp),%r11d
mov    -0x2c(%rbp),%r10d
xor    %ebx,%ebx
mov    %r11d,(%rsp)
movl   $0x0,0x8(%rsp)
mov    %r10d,0x10(%rsp)
call   *%rax
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1e00 <somworker+0xca0>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1ded <somworker+0xc8d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1d58 <somworker+0xbf8>
mov    0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x100(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1d0a <somworker+0xbaa>
mov    -0x80(%rbp),%rax
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x100(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xbc(%rbp),%r11d
mov    -0x2c(%rbp),%r10d
xor    %ebx,%ebx
mov    %r11d,(%rsp)
movl   $0x0,0x8(%rsp)
mov    %r10d,0x10(%rsp)
call   *%rax
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1dda <somworker+0xc7a>
mov    -0x54(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1ddf <somworker+0xc7f>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1cf7 <somworker+0xb97>
jmp    1df2 <somworker+0xc92>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1ce4 <somworker+0xb84>
mov    -0x100(%rbp),%rdi
call   1040 <free@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    2069 <somworker+0xf09>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    2056 <somworker+0xef6>
mov    -0x54(%rbp),%eax
sub    -0xb4(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    -0xb4(%rbp),%ecx
imul   %ecx,%eax
mov    -0x58(%rbp),%ecx
sub    -0xb8(%rbp),%ecx
mov    -0x58(%rbp),%edx
sub    -0xb8(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   1080 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2043 <somworker+0xee3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1f41 <somworker+0xde1>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1ebc <somworker+0xd5c>
jmp    1f33 <somworker+0xdd3>
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1e8e <somworker+0xd2e>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1fb7 <somworker+0xe57>
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mulsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
addsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1f48 <somworker+0xde8>
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    203e <somworker+0xede>
movsd  -0x120(%rbp),%xmm0
ff
cvtsi2sdl -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    2039 <somworker+0xed9>
movsd  -0x120(%rbp),%xmm1
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1ff1 <somworker+0xe91>
jmp    203e <somworker+0xede>
jmp    2043 <somworker+0xee3>
jmp    2048 <somworker+0xee8>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1e26 <somworker+0xcc6>
jmp    205b <somworker+0xefb>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1e13 <somworker+0xcb3>
jmp    206e <somworker+0xf0e>
jmp    2073 <somworker+0xf13>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17b7 <somworker+0x657>
cmpl   $0x0,-0x2c(%rbp)
jne    20c2 <somworker+0xf62>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    20bd <somworker+0xf5d>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1040 <free@plt>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2092 <somworker+0xf32>
jmp    20f9 <somworker+0xf99>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    20f4 <somworker+0xf94>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1040 <free@plt>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    20c9 <somworker+0xf69>
jmp    20f9 <somworker+0xf99>
mov    -0x50(%rbp),%rdi
call   1040 <free@plt>
mov    -0x78(%rbp),%rdi
call   1040 <free@plt>
mov    -0x60(%rbp),%rdi
call   1040 <free@plt>
add    $0x148,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<somworker>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
movsd  %xmm0,0xe8(%rsp)
mov    %r8,%r14
mov    %rcx,0x58(%rsp)
mov    %rdx,0x18(%rsp)
mov    0x1a0(%rsp),%bl
mov    0x198(%rsp),%eax
mov    %eax,0x6c(%rsp)
mov    0x188(%rsp),%ebp
mov    %r9,0x78(%rsp)
test   %r9d,%r9d
mov    %esi,%r12d
cmove  %edi,%r12d
mov    0x180(%rsp),%eax
cmove  %esi,%edi
mov    %edi,(%rsp)
mov    %eax,0x2c(%rsp)
imul   %eax,%eax
mov    %ebp,%ecx
imul   %ebp,%ecx
add    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mov    0x190(%rsp),%rax
mov    %rax,0x30(%rsp)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     11ee <somworker+0x8e>
sqrtsd %xmm0,%xmm0
jmp    11f3 <somworker+0x93>
call   1080 <sqrt@plt>
movsd  %xmm0,0xb8(%rsp)
movslq %r12d,%rdi
mov    $0x8,%esi
mov    %rdi,0xa8(%rsp)
call   1050 <calloc@plt>
mov    %rax,0x10(%rsp)
movsbl %bl,%edi
xor    %eax,%eax
call   1060 <setmetric@plt>
mov    %eax,0x38(%rsp)
mov    (%rsp),%r8d
movslq %r8d,%rax
mov    %rax,0x90(%rsp)
mov    %r8d,%edi
mov    %r12d,%r9d
cmpl   $0x0,0x78(%rsp)
mov    %ebp,0x4(%rsp)
mov    %r14,0xb0(%rsp)
mov    %rdi,0x8(%rsp)
mov    %r9,0x70(%rsp)
mov    %r12d,0x8c(%rsp)
je     1355 <somworker+0x1f5>
test   %r12d,%r12d
mov    0x58(%rsp),%rbp
mov    0x18(%rsp),%rsi
jle    14b6 <somworker+0x356>
xor    %ebx,%ebx
movsd  0x1d81(%rip),%xmm2
xorpd  %xmm3,%xmm3
jmp    12cf <somworker+0x16f>
cs nopw 0x0(%rax,%rax,1)
nop
call   1080 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x1d5f(%rip),%xmm2
mov    0x70(%rsp),%r9
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    (%rsp),%r8d
movapd %xmm0,%xmm1
mov    0x10(%rsp),%rcx
movsd  %xmm1,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %r9,%rbx
je     14ab <somworker+0x34b>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1320 <somworker+0x1c0>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    12e9 <somworker+0x189>
nop
add    $0x1,%rcx
cmp    %rcx,%rdi
je     1320 <somworker+0x1c0>
mov    0x0(%rbp,%rcx,8),%rdx
cmpl   $0x0,(%rdx,%rbx,4)
je     12e0 <somworker+0x180>
mov    (%rsi,%rcx,8),%rdx
movsd  (%rdx,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x10(%rsp),%rdx
addsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
add    $0x1,%eax
jmp    12e0 <somworker+0x180>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm0
ucomisd %xmm3,%xmm0
movapd %xmm2,%xmm1
jbe    12bd <somworker+0x15d>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1290 <somworker+0x130>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    12b8 <somworker+0x158>
test   %r12d,%r12d
mov    0x58(%rsp),%r14
mov    0x18(%rsp),%rbx
jle    1518 <somworker+0x3b8>
mov    %edi,%r15d
and    $0xfffffffe,%r15d
xor    %ebp,%ebp
movsd  0x1c87(%rip),%xmm2
xorpd  %xmm3,%xmm3
jmp    13bf <somworker+0x25f>
nop
call   1080 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x1c6f(%rip),%xmm2
mov    0x70(%rsp),%r9
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%rbx
mov    (%rsp),%r8d
movapd %xmm0,%xmm1
mov    0x10(%rsp),%rcx
movsd  %xmm1,(%rcx,%rbp,8)
add    $0x1,%rbp
cmp    %r9,%rbp
je     14ab <somworker+0x34b>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1410 <somworker+0x2b0>
mov    (%r14,%rbp,8),%rcx
xor    %edx,%edx
xor    %eax,%eax
cmp    $0x1,%r8d
jne    145d <somworker+0x2fd>
test   $0x1,%dil
je     1410 <somworker+0x2b0>
cmpl   $0x0,(%rcx,%rdx,4)
je     1410 <somworker+0x2b0>
mov    (%rbx,%rbp,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x10(%rsp),%rcx
addsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm0
ucomisd %xmm3,%xmm0
movapd %xmm2,%xmm1
jbe    13ad <somworker+0x24d>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1380 <somworker+0x220>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    13a8 <somworker+0x248>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rdx
cmp    %rdx,%r15
je     13db <somworker+0x27b>
cmpl   $0x0,(%rcx,%rdx,4)
je     1482 <somworker+0x322>
mov    (%rbx,%rbp,8),%rsi
movsd  (%rsi,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x10(%rsp),%rsi
addsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
add    $0x1,%eax
cmpl   $0x0,0x4(%rcx,%rdx,4)
je     1450 <somworker+0x2f0>
mov    (%rbx,%rbp,8),%rsi
movsd  0x8(%rsi,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x10(%rsp),%rsi
addsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
add    $0x1,%eax
jmp    1450 <somworker+0x2f0>
cmpl   $0x0,0x78(%rsp)
mov    0x4(%rsp),%ebp
je     1518 <somworker+0x3b8>
mov    0x90(%rsp),%rax
lea    0x0(,%rax,8),%rdi
call   1070 <malloc@plt>
mov    (%rsp),%esi
test   %esi,%esi
mov    %rax,0x50(%rsp)
jle    16b8 <somworker+0x558>
mov    %rax,%r14
xor    %ebx,%ebx
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
movl   $0x1,(%rax)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    14f0 <somworker+0x390>
mov    (%rsp),%esi
mov    %rbp,%rdi
jmp    16bd <somworker+0x55d>
movslq %ebp,%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,0x50(%rsp)
test   %ebp,%ebp
jle    16b5 <somworker+0x555>
mov    0x90(%rsp),%rax
lea    0x0(,%rax,4),%r15
mov    %ebp,%ebx
mov    0x8(%rsp),%rbp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%r12
mov    %r12,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r13d
and    $0x7,%r13d
and    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rsp)
mov    %r13,0x20(%rsp)
shl    $0x5,%r13
xor    %r14d,%r14d
jmp    158d <somworker+0x42d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %rbx,%r14
je     16bd <somworker+0x55d>
mov    %r15,%rdi
call   1070 <malloc@plt>
movapd 0x1a83(%rip),%xmm0
mov    0x8(%rsp),%rdi
mov    (%rsp),%esi
mov    0x50(%rsp),%rcx
mov    %rax,(%rcx,%r14,8)
test   %esi,%esi
jle    1580 <somworker+0x420>
cmp    $0x8,%esi
jae    15c0 <somworker+0x460>
xor    %ecx,%ecx
jmp    16a0 <somworker+0x540>
xchg   %ax,%ax
cmp    $0x38,%r12
jae    15cd <somworker+0x46d>
xor    %ecx,%ecx
jmp    1665 <somworker+0x505>
mov    0x40(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd %xmm0,(%rax,%rcx,4)
movupd %xmm0,0x10(%rax,%rcx,4)
movupd %xmm0,0x20(%rax,%rcx,4)
movupd %xmm0,0x30(%rax,%rcx,4)
movupd %xmm0,0x40(%rax,%rcx,4)
movupd %xmm0,0x50(%rax,%rcx,4)
movupd %xmm0,0x60(%rax,%rcx,4)
movupd %xmm0,0x70(%rax,%rcx,4)
movupd %xmm0,0x80(%rax,%rcx,4)
movupd %xmm0,0x90(%rax,%rcx,4)
movupd %xmm0,0xa0(%rax,%rcx,4)
movupd %xmm0,0xb0(%rax,%rcx,4)
movupd %xmm0,0xc0(%rax,%rcx,4)
movupd %xmm0,0xd0(%rax,%rcx,4)
movupd %xmm0,0xe0(%rax,%rcx,4)
movupd %xmm0,0xf0(%rax,%rcx,4)
add    $0x40,%rcx
add    $0xfffffffffffffff8,%rdx
jne    15e0 <somworker+0x480>
cmpq   $0x0,0x20(%rsp)
je     1694 <somworker+0x534>
lea    (%rax,%rcx,4),%rcx
add    $0x10,%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r13
jne    1680 <somworker+0x520>
mov    %rbp,%rcx
cmp    %rdi,%rbp
je     1580 <somworker+0x420>
movl   $0x1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    16a0 <somworker+0x540>
jmp    1580 <somworker+0x420>
mov    (%rsp),%esi
mov    0x8(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0x2c(%rsp),%eax
mov    %eax,%ecx
mov    %rcx,0x98(%rsp)
test   %eax,%eax
jle    18e6 <somworker+0x786>
mov    0x4(%rsp),%ebp
xorpd  %xmm0,%xmm0
divsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    %edi,%ebx
and    $0xfffffffe,%ebx
lea    -0x2(%rbx),%rax
mov    %rax,0x48(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,%r12
and    $0xfffffffffffffffe,%rax
mov    %rax,0x80(%rsp)
xor    %r14d,%r14d
jmp    1742 <somworker+0x5e2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
cmp    0x98(%rsp),%r14
je     18e6 <somworker+0x786>
cmpl   $0x0,0x4(%rsp)
jle    1730 <somworker+0x5d0>
xor    %r15d,%r15d
jmp    1759 <somworker+0x5f9>
xchg   %ax,%ax
add    $0x1,%r15
cmp    %rbp,%r15
je     1730 <somworker+0x5d0>
test   %esi,%esi
jle    17f0 <somworker+0x690>
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x20(%rsp)
xor    %eax,%eax
call   1030 <uniform@plt>
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm0
addsd  0x186e(%rip),%xmm0
mov    (%rcx,%r14,8),%rax
mov    (%rax,%r15,8),%rax
movsd  %xmm0,(%rax,%r13,8)
mulsd  %xmm0,%xmm0
movsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  0x20(%rsp),%xmm0
add    $0x1,%r13
cmp    %r13,%rdi
jne    1770 <somworker+0x610>
divsd  0xa0(%rsp),%xmm0
ucomisd 0x1834(%rip),%xmm0
jb     1820 <somworker+0x6c0>
sqrtsd %xmm0,%xmm0
jmp    182f <somworker+0x6cf>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x40(%rsp),%xmm0
ucomisd 0x1812(%rip),%xmm0
jae    1750 <somworker+0x5f0>
movsd  0x40(%rsp),%xmm0
call   1080 <sqrt@plt>
mov    (%rsp),%esi
jmp    1750 <somworker+0x5f0>
nopw   0x0(%rax,%rax,1)
call   1080 <sqrt@plt>
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%rcx
mov    (%rsp),%esi
test   %esi,%esi
jle    1750 <somworker+0x5f0>
mov    (%rcx,%r14,8),%rax
mov    (%rax,%r15,8),%rax
cmp    $0x1,%esi
jne    184b <somworker+0x6eb>
xor    %ecx,%ecx
jmp    18c0 <somworker+0x760>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x48(%rsp)
je     18dc <somworker+0x77c>
mov    0x80(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1870 <somworker+0x710>
test   $0x1,%r12b
je     18ac <somworker+0x74c>
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
mov    %rbx,%rcx
cmp    %rdi,%rbx
je     1750 <somworker+0x5f0>
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    18c0 <somworker+0x760>
jmp    1750 <somworker+0x5f0>
xor    %ecx,%ecx
test   $0x1,%r12b
jne    189e <somworker+0x73e>
jmp    18ac <somworker+0x74c>
mov    0xa8(%rsp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    0x8c(%rsp),%r12d
test   %r12d,%r12d
mov    0x4(%rsp),%r14d
mov    0x70(%rsp),%rdi
jle    1ade <somworker+0x97e>
cmp    $0x8,%r12d
jae    1922 <somworker+0x7c2>
xor    %eax,%eax
jmp    1a90 <somworker+0x930>
mov    %edi,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1950 <somworker+0x7f0>
movdqa 0x16e7(%rip),%xmm0
xor    %esi,%esi
jmp    1a30 <somworker+0x8d0>
movabs $0x3ffffffffffffff8,%rsi
ff ff 3f
or     $0x4,%rsi
and    %rsi,%rdx
movdqa 0x16c7(%rip),%xmm0
xor    %esi,%esi
movdqa 0x16cc(%rip),%xmm8
movdqa 0x16d3(%rip),%xmm9
movdqa 0x16da(%rip),%xmm10
movdqa 0x16e2(%rip),%xmm4
movdqa 0x16ea(%rip),%xmm5
movdqa 0x16f2(%rip),%xmm6
movdqa 0x16fa(%rip),%xmm7
movdqa 0x1702(%rip),%xmm1
xchg   %ax,%ax
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%r15,%rsi,4)
movdqu %xmm2,0x10(%r15,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r15,%rsi,4)
movdqu %xmm3,0x30(%r15,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r15,%rsi,4)
movdqu %xmm3,0x50(%r15,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r15,%rsi,4)
movdqu %xmm3,0x70(%r15,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    19b0 <somworker+0x850>
test   %rcx,%rcx
je     1a80 <somworker+0x920>
lea    (%r15,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0x15f5(%rip),%xmm1
movdqa 0x15fd(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm3,(%rdx,%rsi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1a60 <somworker+0x900>
cmp    %rdi,%rax
je     1a9d <somworker+0x93d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1a90 <somworker+0x930>
test   %r12d,%r12d
jle    1ade <somworker+0x97e>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %eax,%eax
mov    %rdi,%rbp
call   1030 <uniform@plt>
mov    %rbp,%rdi
imul   %edi,%eax
add    %ebx,%eax
cltq
mov    (%r15,%rax,4),%ecx
mov    (%r15,%rbx,4),%edx
mov    %edx,(%r15,%rax,4)
mov    %ecx,(%r15,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdi
jne    1ab0 <somworker+0x950>
cmpl   $0x0,0x6c(%rsp)
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%rax
jle    28f7 <somworker+0x1797>
movslq 0x38(%rsp),%r13
shlq   $0x3,0x90(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x6c(%rsp),%xmm0
movsd  %xmm0,0xe0(%rsp)
mov    %r14d,%ecx
mov    %rcx,0xa8(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0xd8(%rsp)
mov    %eax,%edi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rcx
mov    %rcx,0x128(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
lea    -0x1(%rax),%rcx
mov    %rcx,0xc8(%rsp)
mov    %eax,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x110(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x108(%rsp)
mov    %rcx,%rbp
shr    %rbp
add    $0x1,%rbp
mov    %rdx,%rcx
mov    %rdx,0x120(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x118(%rsp)
mov    %eax,%r11d
and    $0x3,%r11d
mov    %rbp,%rax
mov    %rbp,0x100(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0xf8(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0x70(%rsp)
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xc0(%rsp)
mov    %r15,0x130(%rsp)
mov    %r13,0x80(%rsp)
mov    %rdi,0x38(%rsp)
mov    %r11,0x60(%rsp)
jmp    1c49 <somworker+0xae9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15,%rdi
call   1040 <free@plt>
mov    0x18(%rsp),%rsi
movsd  0xc0(%rsp),%xmm0
addsd  0x13f2(%rip),%xmm0
movsd  %xmm0,0xc0(%rsp)
mov    0xf0(%rsp),%rax
add    $0x1,%eax
cmp    0x6c(%rsp),%eax
mov    0x4(%rsp),%r14d
mov    0x8c(%rsp),%r12d
mov    0x130(%rsp),%r15
mov    0x80(%rsp),%r13
je     28f7 <somworker+0x1797>
mov    %rax,0xf0(%rsp)
cltd
idiv   %r12d
movslq (%r15,%rdx,4),%r12
cmpl   $0x0,0x78(%rsp)
mov    0xb0(%rsp),%r9
je     1d80 <somworker+0xc20>
mov    0x90(%rsp),%rdi
call   1070 <malloc@plt>
mov    0x18(%rsp),%rsi
mov    (%rsp),%edi
mov    %rax,%r15
test   %edi,%edi
mov    0x8(%rsp),%r9
mov    0x60(%rsp),%rbp
mov    0x70(%rsp),%r10
movdqa 0x1433(%rip),%xmm4
jle    2270 <somworker+0x1110>
mov    0x30(%rsp),%rax
mov    (%rax),%rax
cmp    $0x4,%edi
jb     1cd1 <somworker+0xb71>
lea    0x8(%rax),%rcx
cmp    %rcx,%r15
jae    219a <somworker+0x103a>
mov    0xd8(%rsp),%rcx
add    %r15,%rcx
cmp    %rax,%rcx
jbe    219a <somworker+0x103a>
xor    %ecx,%ecx
mov    0xc8(%rsp),%r8
sub    %rcx,%r8
test   %rbp,%rbp
je     1d0f <somworker+0xbaf>
lea    0x0(,%rcx,8),%rdx
xor    %ebx,%ebx
nopl   (%rax)
mov    (%rax),%rbp
add    %rdx,%rbp
mov    %rbp,(%r15,%rdx,1)
add    $0xffffffffffffffff,%rbx
add    $0x8,%rdx
cmp    %rbx,%r10
jne    1cf0 <somworker+0xb90>
sub    %rbx,%rcx
mov    0x4(%rsp),%r14d
cmp    $0x3,%r8
jb     2270 <somworker+0x1110>
mov    %r9,%rdx
sub    %rcx,%rdx
lea    0x10(,%rcx,8),%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rax),%rbx
add    %rcx,%rbx
add    $0xfffffffffffffff0,%rbx
mov    %rbx,-0x10(%r15,%rcx,1)
mov    (%rax),%rbx
add    %rcx,%rbx
add    $0xfffffffffffffff8,%rbx
mov    %rbx,-0x8(%r15,%rcx,1)
mov    (%rax),%rbx
add    %rcx,%rbx
mov    %rbx,(%r15,%rcx,1)
mov    (%rax),%rbx
add    %rcx,%rbx
add    $0x8,%rbx
mov    %rbx,0x8(%r15,%rcx,1)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1d30 <somworker+0xbd0>
jmp    2270 <somworker+0x1110>
cs nopw 0x0(%rax,%rax,1)
mov    0x30(%rsp),%rbx
mov    (%rbx),%rdx
sub    $0x8,%rsp
mov    0x8(%rsp),%edi
mov    0x60(%rsp),%rcx
mov    0x58(%rsp),%r8
push   $0x0
push   $0x0
push   %r12
call   *%r13
mov    0x38(%rsp),%rsi
add    $0x20,%rsp
cmpl   $0x0,0x2c(%rsp)
jle    1bfd <somworker+0xa9d>
mov    %rbx,%r9
movapd %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sdl 0xf0(%rsp),%xmm0
divsd  0xe0(%rsp),%xmm0
movsd  0x1225(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xb8(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x40(%rsp)
mulsd  0xe8(%rsp),%xmm1
movsd  %xmm1,0x48(%rsp)
xor    %r13d,%r13d
xor    %r15d,%r15d
xor    %ebx,%ebx
jmp    1e48 <somworker+0xce8>
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm0
add    $0x1,%r13
movapd %xmm0,%xmm2
cmp    0x98(%rsp),%r13
mov    0x8(%rsp),%rbp
mov    0x38(%rsp),%rdi
mov    0x10(%rsp),%r10
mov    0x60(%rsp),%r11
pxor   %xmm4,%xmm4
movsd  0x48(%rsp),%xmm5
je     1ee0 <somworker+0xd80>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1e10 <somworker+0xcb0>
xor    %ebp,%ebp
mov    0x80(%rsp),%r14
mov    0x50(%rsp),%r8
mov    (%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm2,0x20(%rsp)
mov    (%r9,%r13,8),%rdx
sub    $0x8,%rsp
mov    0x60(%rsp),%rcx
mov    0xb8(%rsp),%r9
push   $0x0
push   %rbp
push   %r12
call   *%r14
mov    0x70(%rsp),%r8
mov    0x50(%rsp),%r9
mov    0x38(%rsp),%rsi
mov    0x20(%rsp),%edi
add    $0x20,%rsp
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
cmova  %r13d,%ebx
cmova  %ebp,%r15d
minsd  %xmm1,%xmm0
add    $0x1,%ebp
movapd %xmm0,%xmm2
cmp    %ebp,0x4(%rsp)
jne    1e70 <somworker+0xd10>
jmp    1e14 <somworker+0xcb4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x0,0x2c(%rsp)
jle    1bfd <somworker+0xa9d>
xor    %r14d,%r14d
jmp    1f02 <somworker+0xda2>
add    $0x1,%r14
cmp    0x98(%rsp),%r14
je     1bfd <somworker+0xa9d>
cmpl   $0x0,0x4(%rsp)
jle    1ef0 <somworker+0xd90>
mov    %r14d,%eax
sub    %ebx,%eax
imul   %eax,%eax
mov    %eax,0x20(%rsp)
xor    %r13d,%r13d
jmp    1f2e <somworker+0xdce>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0xa8(%rsp),%r13
je     1ef0 <somworker+0xd90>
mov    %r13d,%eax
sub    %r15d,%eax
imul   %eax,%eax
add    0x20(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm4,%xmm0
jb     1f50 <somworker+0xdf0>
sqrtsd %xmm0,%xmm0
jmp    1f7d <somworker+0xe1d>
xchg   %ax,%ax
call   1080 <sqrt@plt>
movsd  0x48(%rsp),%xmm5
xorpd  %xmm4,%xmm4
mov    0x60(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%r9
mov    0x18(%rsp),%rsi
mov    (%rsp),%eax
test   %eax,%eax
jle    1f20 <somworker+0xdc0>
movsd  0x40(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    1f20 <somworker+0xdc0>
mov    0x58(%rsp),%rax
mov    (%rax,%r12,8),%rax
xor    %ecx,%ecx
jmp    1fa9 <somworker+0xe49>
nopl   (%rax)
add    $0x1,%rcx
cmp    %rcx,%rbp
je     1fe0 <somworker+0xe80>
cmpl   $0x0,(%rax,%rcx,4)
je     1fa0 <somworker+0xe40>
mov    (%rsi,%r12,8),%rdx
movsd  (%rdx,%rcx,8),%xmm0
divsd  (%r10,%r12,8),%xmm0
mov    (%r9,%r14,8),%rdx
mov    (%rdx,%r13,8),%rdx
movsd  (%rdx,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
jmp    1fa0 <somworker+0xe40>
xchg   %ax,%ax
cmpl   $0x0,(%rsp)
jle    1f20 <somworker+0xdc0>
mov    (%r9,%r14,8),%rax
mov    (%rax,%r13,8),%rax
cmpq   $0x3,0xc8(%rsp)
jae    2005 <somworker+0xea5>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    2050 <somworker+0xef0>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x10(%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x18(%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    2010 <somworker+0xeb0>
test   $0x3,%bpl
je     2076 <somworker+0xf16>
lea    (%rax,%rcx,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r11
jne    2060 <somworker+0xf00>
ucomisd %xmm4,%xmm0
jbe    1f20 <somworker+0xdc0>
divsd  0xa0(%rsp),%xmm0
ucomisd %xmm4,%xmm0
jb     2095 <somworker+0xf35>
sqrtsd %xmm0,%xmm0
jmp    20c2 <somworker+0xf62>
call   1080 <sqrt@plt>
movsd  0x48(%rsp),%xmm5
xorpd  %xmm4,%xmm4
mov    0x60(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%r9
mov    0x18(%rsp),%rsi
mov    (%rsp),%eax
test   %eax,%eax
jle    1f20 <somworker+0xdc0>
mov    (%r9,%r14,8),%rax
mov    (%rax,%r13,8),%rax
cmpl   $0x1,(%rsp)
jne    20e2 <somworker+0xf82>
xor    %ecx,%ecx
jmp    2170 <somworker+0x1010>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x108(%rsp)
je     218c <somworker+0x102c>
mov    0xf8(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2110 <somworker+0xfb0>
testb  $0x1,0x100(%rsp)
01
je     2150 <somworker+0xff0>
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
mov    0x110(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbp,%rdx
je     1f20 <somworker+0xdc0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    2170 <somworker+0x1010>
jmp    1f20 <somworker+0xdc0>
xor    %ecx,%ecx
testb  $0x1,0x100(%rsp)
01
jne    2142 <somworker+0xfe2>
jmp    2150 <somworker+0xff0>
cmpq   $0x0,0x128(%rsp)
movdqa 0xf35(%rip),%xmm5
movdqa 0xf3d(%rip),%xmm6
movdqa 0xf45(%rip),%xmm7
je     28da <somworker+0x177a>
movq   (%rax),%xmm0
pshufd $0x44,%xmm0,%xmm1
mov    0x118(%rsp),%rdx
xor    %ecx,%ecx
movdqa 0xee4(%rip),%xmm0
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
psllq  $0x3,%xmm2
paddq  %xmm1,%xmm2
movdqa %xmm2,%xmm3
paddq  %xmm4,%xmm3
movdqu %xmm2,(%r15,%rcx,8)
movdqu %xmm3,0x10(%r15,%rcx,8)
movdqa %xmm2,%xmm3
paddq  %xmm5,%xmm3
paddq  %xmm6,%xmm2
movdqu %xmm3,0x20(%r15,%rcx,8)
movdqu %xmm2,0x30(%r15,%rcx,8)
add    $0x8,%rcx
paddq  %xmm7,%xmm0
add    $0xfffffffffffffffe,%rdx
jne    21e0 <somworker+0x1080>
testb  $0x1,0x120(%rsp)
01
je     2257 <somworker+0x10f7>
movq   (%rax),%xmm1
pshufd $0x44,%xmm1,%xmm1
psllq  $0x3,%xmm0
paddq  %xmm1,%xmm0
movdqu %xmm0,(%r15,%rcx,8)
paddq  %xmm4,%xmm0
movdqu %xmm0,0x10(%r15,%rcx,8)
mov    0x38(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r9,%rdx
jne    1cd3 <somworker+0xb73>
nopl   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    %r15,%rdx
mov    0x60(%rsp),%rcx
mov    0x58(%rsp),%r8
mov    0xb8(%rsp),%r9
push   0x80(%rsp)
push   $0x0
push   %r12
call   *%r13
add    $0x20,%rsp
cmpl   $0x0,0x2c(%rsp)
jle    1bf0 <somworker+0xa90>
movapd %xmm0,%xmm2
movsd  0xc0(%rsp),%xmm0
divsd  0xe0(%rsp),%xmm0
movsd  0xd3c(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xb8(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x140(%rsp)
mulsd  0xe8(%rsp),%xmm1
movsd  %xmm1,0xd0(%rsp)
mov    0xd8(%rsp),%rax
add    %r15,%rax
mov    %rax,0x138(%rsp)
movl   $0x0,0x48(%rsp)
xor    %r13d,%r13d
movl   $0x0,0x20(%rsp)
mov    %r14d,%ebp
jmp    233d <somworker+0x11dd>
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm0
mov    0x48(%rsp),%eax
add    $0x1,%eax
movapd %xmm0,%xmm2
mov    %eax,0x48(%rsp)
cmp    0x2c(%rsp),%eax
je     25b0 <somworker+0x1450>
test   %ebp,%ebp
jle    2320 <somworker+0x11c0>
xor    %r14d,%r14d
mov    (%rsp),%ebx
jmp    23b1 <somworker+0x1251>
nopl   0x0(%rax)
sub    $0x8,%rsp
mov    %r15,%rdx
mov    0x60(%rsp),%rcx
mov    %edi,%ebx
mov    0x58(%rsp),%r8
mov    0xb8(%rsp),%r9
push   0x80(%rsp)
push   $0x0
push   %r12
call   *0xa0(%rsp)
add    $0x20,%rsp
movsd  0x40(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    0x20(%rsp),%eax
cmova  0x48(%rsp),%eax
mov    %eax,0x20(%rsp)
cmova  %r14d,%r13d
minsd  %xmm1,%xmm0
add    $0x1,%r14d
movapd %xmm0,%xmm2
cmp    %ebp,%r14d
je     2324 <somworker+0x11c4>
movsd  %xmm2,0x40(%rsp)
test   %ebx,%ebx
mov    %ebx,%edi
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%r9
mov    0x70(%rsp),%r10
movdqa 0xcfe(%rip),%xmm4
movdqa 0xd06(%rip),%xmm5
movdqa 0xd0e(%rip),%xmm6
movdqa 0xd16(%rip),%xmm7
jle    2350 <somworker+0x11f0>
movslq 0x20(%rsp),%rax
mov    0x30(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movslq %r13d,%rdx
lea    (%rcx,%rdx,8),%rax
cmp    $0x4,%edi
jb     2429 <somworker+0x12c9>
lea    (%rcx,%rdx,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%r15
jae    24d6 <somworker+0x1376>
cmp    %rax,0x138(%rsp)
jbe    24d6 <somworker+0x1376>
xor    %r8d,%r8d
mov    %r8,%rdx
not    %rdx
add    %r9,%rdx
test   $0x3,%r9b
je     246e <somworker+0x130e>
lea    0x0(,%r8,8),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rax),%rbx
add    %rcx,%rbx
mov    %rbx,(%r15,%rcx,1)
add    $0xffffffffffffffff,%rbp
add    $0x8,%rcx
cmp    %rbp,%r10
jne    2450 <somworker+0x12f0>
sub    %rbp,%r8
mov    0x4(%rsp),%ebp
cmp    $0x3,%rdx
jb     2350 <somworker+0x11f0>
mov    %r9,%rdx
sub    %r8,%rdx
lea    0x10(,%r8,8),%rcx
cs nopw 0x0(%rax,%rax,1)
mov    (%rax),%rbx
add    %rcx,%rbx
add    $0xfffffffffffffff0,%rbx
mov    %rbx,-0x10(%r15,%rcx,1)
mov    (%rax),%rbx
add    %rcx,%rbx
add    $0xfffffffffffffff8,%rbx
mov    %rbx,-0x8(%r15,%rcx,1)
mov    (%rax),%rbx
add    %rcx,%rbx
mov    %rbx,(%r15,%rcx,1)
mov    (%rax),%rbx
add    %rcx,%rbx
add    $0x8,%rbx
mov    %rbx,0x8(%r15,%rcx,1)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2490 <somworker+0x1330>
jmp    2350 <somworker+0x11f0>
cmpq   $0x0,0x128(%rsp)
je     258d <somworker+0x142d>
movq   (%rax),%xmm0
pshufd $0x44,%xmm0,%xmm1
mov    0x118(%rsp),%rdx
xor    %ecx,%ecx
movdqa 0xbc0(%rip),%xmm0
movdqa %xmm0,%xmm2
psllq  $0x3,%xmm2
paddq  %xmm1,%xmm2
movdqa %xmm2,%xmm3
paddq  %xmm4,%xmm3
movdqu %xmm2,(%r15,%rcx,8)
movdqu %xmm3,0x10(%r15,%rcx,8)
movdqa %xmm2,%xmm3
paddq  %xmm5,%xmm3
paddq  %xmm6,%xmm2
movdqu %xmm3,0x20(%r15,%rcx,8)
movdqu %xmm2,0x30(%r15,%rcx,8)
add    $0x8,%rcx
paddq  %xmm7,%xmm0
add    $0xfffffffffffffffe,%rdx
jne    2500 <somworker+0x13a0>
testb  $0x1,0x120(%rsp)
01
je     2577 <somworker+0x1417>
movq   (%rax),%xmm1
pshufd $0x44,%xmm1,%xmm1
psllq  $0x3,%xmm0
paddq  %xmm1,%xmm0
movdqu %xmm0,(%r15,%rcx,8)
paddq  %xmm4,%xmm0
movdqu %xmm0,0x10(%r15,%rcx,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%r8
cmp    %r9,%rcx
je     2350 <somworker+0x11f0>
jmp    242c <somworker+0x12cc>
xor    %ecx,%ecx
movdqa 0xb29(%rip),%xmm0
testb  $0x1,0x120(%rsp)
01
jne    2554 <somworker+0x13f4>
jmp    2577 <somworker+0x1417>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15,%rdi
call   1040 <free@plt>
cmpl   $0x0,0x2c(%rsp)
mov    0x18(%rsp),%rsi
mov    0x30(%rsp),%r8
mov    0x8(%rsp),%rbp
mov    0x38(%rsp),%rdi
mov    0x10(%rsp),%r10
mov    0x60(%rsp),%r11
pxor   %xmm4,%xmm4
movsd  0xd0(%rsp),%xmm5
jle    1bfd <somworker+0xa9d>
xor    %r14d,%r14d
jmp    2612 <somworker+0x14b2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
cmp    0x98(%rsp),%r14
je     1bfd <somworker+0xa9d>
cmpl   $0x0,0x4(%rsp)
mov    0x58(%rsp),%rbx
mov    (%rsp),%r9d
jle    2600 <somworker+0x14a0>
mov    %r14d,%eax
sub    0x20(%rsp),%eax
imul   %eax,%eax
mov    %eax,0x40(%rsp)
xor    %r15d,%r15d
jmp    264e <somworker+0x14ee>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
cmp    0xa8(%rsp),%r15
je     2600 <somworker+0x14a0>
mov    %r15d,%eax
sub    %r13d,%eax
imul   %eax,%eax
add    0x40(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm4,%xmm0
jb     2680 <somworker+0x1520>
sqrtsd %xmm0,%xmm0
test   %r9d,%r9d
jg     26b9 <somworker+0x1559>
jmp    2640 <somworker+0x14e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1080 <sqrt@plt>
movsd  0xd0(%rsp),%xmm5
xorpd  %xmm4,%xmm4
mov    0x60(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%r8
mov    0x18(%rsp),%rsi
mov    (%rsp),%r9d
test   %r9d,%r9d
jle    2640 <somworker+0x14e0>
movsd  0x140(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    2640 <somworker+0x14e0>
xor    %eax,%eax
jmp    26d9 <somworker+0x1579>
add    $0x1,%rax
cmp    %rax,%rbp
je     2720 <somworker+0x15c0>
mov    (%rbx,%rax,8),%rcx
cmpl   $0x0,(%rcx,%r12,4)
je     26d0 <somworker+0x1570>
mov    (%rsi,%rax,8),%rcx
movsd  (%rcx,%r12,8),%xmm0
divsd  (%r10,%r12,8),%xmm0
mov    (%r8,%r14,8),%rcx
mov    (%rcx,%r15,8),%rcx
movsd  (%rcx,%rax,8),%xmm1
subsd  %xmm1,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
jmp    26d0 <somworker+0x1570>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r9d,%r9d
jle    2640 <somworker+0x14e0>
mov    (%r8,%r14,8),%rax
mov    (%rax,%r15,8),%rax
cmpq   $0x3,0xc8(%rsp)
jae    2744 <somworker+0x15e4>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    2790 <somworker+0x1630>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x10(%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x18(%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    2750 <somworker+0x15f0>
test   $0x3,%bpl
je     27b6 <somworker+0x1656>
lea    (%rax,%rcx,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r11
jne    27a0 <somworker+0x1640>
ucomisd %xmm4,%xmm0
jbe    2640 <somworker+0x14e0>
divsd  0xa0(%rsp),%xmm0
ucomisd %xmm4,%xmm0
jb     27dd <somworker+0x167d>
sqrtsd %xmm0,%xmm0
test   %r9d,%r9d
jg     281a <somworker+0x16ba>
jmp    2640 <somworker+0x14e0>
call   1080 <sqrt@plt>
movsd  0xd0(%rsp),%xmm5
xorpd  %xmm4,%xmm4
mov    0x60(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%r8
mov    0x18(%rsp),%rsi
mov    (%rsp),%r9d
test   %r9d,%r9d
jle    2640 <somworker+0x14e0>
mov    (%r8,%r14,8),%rax
mov    (%rax,%r15,8),%rax
cmp    $0x1,%r9d
jne    282f <somworker+0x16cf>
xor    %ecx,%ecx
jmp    28b0 <somworker+0x1750>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x108(%rsp)
je     28cc <somworker+0x176c>
mov    0xf8(%rsp),%rdx
xor    %ecx,%ecx
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2850 <somworker+0x16f0>
testb  $0x1,0x100(%rsp)
01
je     2890 <somworker+0x1730>
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
mov    0x110(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbp,%rdx
je     2640 <somworker+0x14e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    28b0 <somworker+0x1750>
jmp    2640 <somworker+0x14e0>
xor    %ecx,%ecx
testb  $0x1,0x100(%rsp)
01
jne    2882 <somworker+0x1722>
jmp    2890 <somworker+0x1730>
xor    %ecx,%ecx
movdqa 0x7dc(%rip),%xmm0
testb  $0x1,0x120(%rsp)
01
jne    2234 <somworker+0x10d4>
jmp    2257 <somworker+0x10f7>
cmpl   $0x0,0x78(%rsp)
je     2926 <somworker+0x17c6>
cmpl   $0x0,(%rsp)
mov    0x50(%rsp),%r14
jle    2952 <somworker+0x17f2>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1040 <free@plt>
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
jne    2910 <somworker+0x17b0>
jmp    2952 <somworker+0x17f2>
mov    %r14d,%eax
test   %r14d,%r14d
mov    0x50(%rsp),%r14
jle    2952 <somworker+0x17f2>
mov    %eax,%ebx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbp,8),%rdi
call   1040 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2940 <somworker+0x17e0>
mov    %r14,%rdi
call   1040 <free@plt>
mov    0x10(%rsp),%rdi
call   1040 <free@plt>
mov    %r15,%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free@plt>

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

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