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;
  double (*metric)(int, double **, double **, int **, int **, const double[],
                   int, int, int);
  int i, j;
  double *stddata = calloc(nelements, sizeof(double));
  int **dummymask;
  int ix, iy;
  long *index;
  int iter;
  double maxradius = sqrt(nxgrid * nxgrid + nygrid * nygrid);
  initran();
  setmetric(dist, &metric);
  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 = genunf(-1., 1.);
        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(long));
  for (i = 0; i < nelements; i++)
    index[i] = i;
  genprm(index, nelements);
  for (iter = 0; iter < niter; iter++) {
    int ixbest = 0;
    int iybest = 0;
    long 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);
  return;
}


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    11cf <somworker+0x4f>
mov    -0xc(%rbp),%eax
mov    %eax,-0x12c(%rbp)
jmp    11d8 <somworker+0x58>
mov    -0x10(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    11f9 <somworker+0x79>
mov    -0x10(%rbp),%eax
mov    %eax,-0x130(%rbp)
jmp    1202 <somworker+0x82>
mov    -0xc(%rbp),%eax
mov    %eax,-0x130(%rbp)
mov    -0x130(%rbp),%eax
mov    %eax,-0x40(%rbp)
movslq -0x3c(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
mov    0x18(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
mov    $0x0,%al
call   1080 <initran@plt>
movsbl 0x30(%rbp),%edi
lea    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1060 <setmetric@plt>
cmpl   $0x0,-0x2c(%rbp)
jne    138d <somworker+0x20d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1388 <somworker+0x208>
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1316 <somworker+0x196>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1303 <somworker+0x183>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%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    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1308 <somworker+0x188>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    127f <somworker+0xff>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1360 <somworker+0x1e0>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x84(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1375 <somworker+0x1f5>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  0x1c90(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    137a <somworker+0x1fa>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1262 <somworker+0xe2>
jmp    14bf <somworker+0x33f>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    14ba <somworker+0x33a>
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1448 <somworker+0x2c8>
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1435 <somworker+0x2b5>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%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    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    143a <somworker+0x2ba>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13b1 <somworker+0x231>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1492 <somworker+0x312>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x94(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    14a7 <somworker+0x327>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  0x1b5e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    14ac <somworker+0x32c>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1394 <somworker+0x214>
jmp    14bf <somworker+0x33f>
cmpl   $0x0,-0x2c(%rbp)
jne    1559 <somworker+0x3d9>
movslq 0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1554 <somworker+0x3d4>
movslq -0x40(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1541 <somworker+0x3c1>
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1510 <somworker+0x390>
jmp    1546 <somworker+0x3c6>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14e1 <somworker+0x361>
jmp    15bb <somworker+0x43b>
movslq -0x40(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    15b6 <somworker+0x436>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x1,(%rax)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1571 <somworker+0x3f1>
jmp    15bb <somworker+0x43b>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1710 <somworker+0x590>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16fd <somworker+0x57d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    167d <somworker+0x4fd>
movsd  0x1a01(%rip),%xmm0
movsd  0x19f1(%rip),%xmm1
mov    $0x2,%al
call   1090 <genunf@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%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    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15f3 <somworker+0x473>
movsd  -0xa8(%rbp),%xmm0
ff
cvtsi2sdl -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    16ea <somworker+0x56a>
movsd  -0xa8(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16a2 <somworker+0x522>
jmp    16ef <somworker+0x56f>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    15d5 <somworker+0x455>
jmp    1702 <somworker+0x582>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    15c2 <somworker+0x442>
movslq -0x3c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1752 <somworker+0x5d2>
movslq -0x4c(%rbp),%rdx
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1728 <somworker+0x5a8>
mov    -0x70(%rbp),%rdi
mov    -0x3c(%rbp),%esi
mov    $0x0,%al
call   1050 <genprm@plt>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    2045 <somworker+0xec5>
movl   $0x0,-0xb4(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0x74(%rbp),%eax
cltd
idivl  -0x3c(%rbp)
movslq %edx,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x70(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    1b96 <somworker+0xa16>
mov    -0x48(%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    -0x60(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xc0(%rbp),%r10
mov    %r10d,%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  -0x80(%rbp),%xmm0
cvtsi2sdl -0x74(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x17db(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x74(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x17b0(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1934 <somworker+0x7b4>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1921 <somworker+0x7a1>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    0x20(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xc0(%rbp),%r10
mov    %r10d,%ebx
mov    -0x68(%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    190e <somworker+0x78e>
mov    -0x64(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1913 <somworker+0x793>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    187a <somworker+0x6fa>
jmp    1926 <somworker+0x7a6>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1867 <somworker+0x6e7>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1b91 <somworker+0xa11>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b7e <somworker+0x9fe>
mov    -0x64(%rbp),%eax
sub    -0xb4(%rbp),%eax
mov    -0x64(%rbp),%ecx
sub    -0xb4(%rbp),%ecx
imul   %ecx,%eax
mov    -0x68(%rbp),%ecx
sub    -0xb8(%rbp),%ecx
mov    -0x68(%rbp),%edx
sub    -0xb8(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1b6b <somworker+0x9eb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1a69 <somworker+0x8e9>
mov    -0x20(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    19e4 <somworker+0x864>
jmp    1a5b <somworker+0x8db>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
mov    -0xc0(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    19b6 <somworker+0x836>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1adf <somworker+0x95f>
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%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    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a70 <somworker+0x8f0>
movsd  -0xe8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b66 <somworker+0x9e6>
movsd  -0xe8(%rbp),%xmm0
ff
cvtsi2sdl -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1b61 <somworker+0x9e1>
movsd  -0xe8(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1b19 <somworker+0x999>
jmp    1b66 <somworker+0x9e6>
jmp    1b6b <somworker+0x9eb>
jmp    1b70 <somworker+0x9f0>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    194e <somworker+0x7ce>
jmp    1b83 <somworker+0xa03>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    193b <somworker+0x7bb>
jmp    2032 <somworker+0xeb2>
movslq -0x40(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x100(%rbp)
movsd  -0x80(%rbp),%xmm0
cvtsi2sdl -0x74(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x143b(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x74(%rbp),%xmm2
cvtsi2sdl 0x28(%rbp),%xmm1
divsd  %xmm1,%xmm2
movsd  0x1410(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1c55 <somworker+0xad5>
mov    0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1c07 <somworker+0xa87>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x100(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xc0(%rbp),%r10
mov    %r10d,%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,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1dc4 <somworker+0xc44>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1db1 <somworker+0xc31>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1d19 <somworker+0xb99>
mov    0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1ccb <somworker+0xb4b>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x100(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    -0xc0(%rbp),%r10
mov    %r10d,%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    1d9e <somworker+0xc1e>
mov    -0x64(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1da3 <somworker+0xc23>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1cb8 <somworker+0xb38>
jmp    1db6 <somworker+0xc36>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1ca5 <somworker+0xb25>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    202d <somworker+0xead>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    201a <somworker+0xe9a>
mov    -0x64(%rbp),%eax
sub    -0xb4(%rbp),%eax
mov    -0x64(%rbp),%ecx
sub    -0xb4(%rbp),%ecx
imul   %ecx,%eax
mov    -0x68(%rbp),%ecx
sub    -0xb8(%rbp),%ecx
mov    -0x68(%rbp),%edx
sub    -0xb8(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2007 <somworker+0xe87>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1f05 <somworker+0xd85>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc0(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1e80 <somworker+0xd00>
jmp    1ef7 <somworker+0xd77>
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
mov    -0xc0(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1e52 <somworker+0xcd2>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1f7b <somworker+0xdfb>
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%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    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1f0c <somworker+0xd8c>
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2002 <somworker+0xe82>
movsd  -0x120(%rbp),%xmm0
ff
cvtsi2sdl -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1ffd <somworker+0xe7d>
movsd  -0x120(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1fb5 <somworker+0xe35>
jmp    2002 <somworker+0xe82>
jmp    2007 <somworker+0xe87>
jmp    200c <somworker+0xe8c>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1dea <somworker+0xc6a>
jmp    201f <somworker+0xe9f>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1dd7 <somworker+0xc57>
jmp    2032 <somworker+0xeb2>
jmp    2037 <somworker+0xeb7>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1767 <somworker+0x5e7>
cmpl   $0x0,-0x2c(%rbp)
jne    2086 <somworker+0xf06>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    2081 <somworker+0xf01>
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2056 <somworker+0xed6>
jmp    20bd <somworker+0xf3d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    20b8 <somworker+0xf38>
mov    -0x60(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    208d <somworker+0xf0d>
jmp    20bd <somworker+0xf3d>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <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    $0x138,%rsp
movsd  %xmm0,0xd8(%rsp)
mov    %r8,%rbp
mov    %rcx,%r12
mov    %rdx,0x28(%rsp)
mov    0x190(%rsp),%r15b
mov    0x178(%rsp),%r14d
mov    %r9,0x60(%rsp)
test   %r9d,%r9d
mov    %esi,%eax
cmove  %edi,%eax
mov    0x170(%rsp),%ebx
cmove  %esi,%edi
mov    %edi,0xc(%rsp)
mov    %eax,0x1c(%rsp)
movslq %eax,%rdi
mov    $0x8,%esi
mov    %rdi,0x90(%rsp)
call   1040 <calloc@plt>
mov    %ebx,%ecx
imul   %ebx,%ecx
mov    %r14d,%edx
imul   %r14d,%edx
add    %ecx,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
mov    %rax,0x20(%rsp)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1213 <somworker+0x93>
sqrtsd %xmm0,%xmm0
jmp    1218 <somworker+0x98>
call   10a0 <sqrt@plt>
movsd  %xmm0,0xa0(%rsp)
xor    %eax,%eax
call   1080 <initran@plt>
movsbl %r15b,%edi
lea    0x98(%rsp),%rsi
xor    %eax,%eax
call   1060 <setmetric@plt>
mov    0xc(%rsp),%r8d
movslq %r8d,%rax
mov    %rax,0x70(%rsp)
mov    %r8d,%edi
cmpl   $0x0,0x60(%rsp)
mov    %rbp,0x88(%rsp)
mov    %r12,0x68(%rsp)
mov    %rdi,0x10(%rsp)
je     1355 <somworker+0x1d5>
cmpl   $0x0,0x1c(%rsp)
jle    14a8 <somworker+0x328>
mov    0x1c(%rsp),%ebx
xor    %ebp,%ebp
movsd  0x1d7f(%rip),%xmm2
xorpd  %xmm3,%xmm3
jmp    12c6 <somworker+0x146>
nopw   0x0(%rax,%rax,1)
call   10a0 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x1d5f(%rip),%xmm2
mov    0x10(%rsp),%rdi
mov    0xc(%rsp),%r8d
movapd %xmm0,%xmm1
mov    0x20(%rsp),%rcx
movsd  %xmm1,(%rcx,%rbp,8)
add    $0x1,%rbp
cmp    %rbx,%rbp
je     14a1 <somworker+0x321>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1320 <somworker+0x1a0>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    12e9 <somworker+0x169>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%rdi
je     1320 <somworker+0x1a0>
mov    (%r12,%rcx,8),%rdx
cmpl   $0x0,(%rdx,%rbp,4)
je     12e0 <somworker+0x160>
mov    0x28(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x20(%rsp),%rdx
addsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
add    $0x1,%eax
jmp    12e0 <somworker+0x160>
nopl   0x0(%rax)
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm0
ucomisd %xmm3,%xmm0
movapd %xmm2,%xmm1
jbe    12b4 <somworker+0x134>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1290 <somworker+0x110>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    12af <somworker+0x12f>
cmpl   $0x0,0x1c(%rsp)
jle    1509 <somworker+0x389>
mov    0x1c(%rsp),%r15d
mov    %edi,%ebp
and    $0xfffffffe,%ebp
xor    %ebx,%ebx
movsd  0x1c8c(%rip),%xmm2
xorpd  %xmm3,%xmm3
jmp    13b6 <somworker+0x236>
nopw   0x0(%rax,%rax,1)
call   10a0 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x1c6f(%rip),%xmm2
mov    0x10(%rsp),%rdi
mov    0xc(%rsp),%r8d
movapd %xmm0,%xmm1
mov    0x20(%rsp),%rcx
movsd  %xmm1,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %r15,%rbx
je     14a1 <somworker+0x321>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1400 <somworker+0x280>
mov    (%r12,%rbx,8),%rcx
xor    %edx,%edx
xor    %eax,%eax
cmp    $0x1,%r8d
jne    1449 <somworker+0x2c9>
test   $0x1,%dil
je     1400 <somworker+0x280>
cmpl   $0x0,(%rcx,%rdx,4)
je     1400 <somworker+0x280>
mov    0x28(%rsp),%rcx
mov    (%rcx,%rbx,8),%rcx
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x20(%rsp),%rcx
addsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x1,%eax
xchg   %ax,%ax
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm0
ucomisd %xmm3,%xmm0
movapd %xmm2,%xmm1
jbe    13a4 <somworker+0x224>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1380 <somworker+0x200>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    139f <somworker+0x21f>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rdx
cmp    %rdx,%rbp
je     13ce <somworker+0x24e>
cmpl   $0x0,(%rcx,%rdx,4)
je     1473 <somworker+0x2f3>
mov    0x28(%rsp),%rsi
mov    (%rsi,%rbx,8),%rsi
movsd  (%rsi,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x20(%rsp),%rsi
addsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
add    $0x1,%eax
cmpl   $0x0,0x4(%rcx,%rdx,4)
je     1440 <somworker+0x2c0>
mov    0x28(%rsp),%rsi
mov    (%rsi,%rbx,8),%rsi
movsd  0x8(%rsi,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0x20(%rsp),%rsi
addsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
add    $0x1,%eax
jmp    1440 <somworker+0x2c0>
cmpl   $0x0,0x60(%rsp)
je     1509 <somworker+0x389>
mov    0x70(%rsp),%rax
lea    0x0(,%rax,8),%rdi
call   1070 <malloc@plt>
mov    0xc(%rsp),%esi
test   %esi,%esi
mov    %rax,0x50(%rsp)
jle    16a9 <somworker+0x529>
mov    %rax,%r15
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
movl   $0x1,(%rax)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    14e0 <somworker+0x360>
mov    0xc(%rsp),%esi
mov    %rbp,%rdi
jmp    16ae <somworker+0x52e>
movslq %r14d,%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,0x50(%rsp)
test   %r14d,%r14d
jle    16a5 <somworker+0x525>
mov    0x70(%rsp),%rax
lea    0x0(,%rax,4),%r15
mov    %r14d,%ebx
mov    0x10(%rsp),%rbp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%r14
mov    %r14,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r13d
and    $0x7,%r13d
and    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rsp)
mov    %r13,0x30(%rsp)
shl    $0x5,%r13
xor    %r12d,%r12d
jmp    157d <somworker+0x3fd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %rbx,%r12
je     16ae <somworker+0x52e>
mov    %r15,%rdi
call   1070 <malloc@plt>
movapd 0x1a93(%rip),%xmm0
mov    0x10(%rsp),%rdi
mov    0xc(%rsp),%esi
mov    0x50(%rsp),%rcx
mov    %rax,(%rcx,%r12,8)
test   %esi,%esi
jle    1570 <somworker+0x3f0>
cmp    $0x8,%esi
jae    15b0 <somworker+0x430>
xor    %ecx,%ecx
jmp    1690 <somworker+0x510>
nop
cmp    $0x38,%r14
jae    15bd <somworker+0x43d>
xor    %ecx,%ecx
jmp    1655 <somworker+0x4d5>
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    15d0 <somworker+0x450>
cmpq   $0x0,0x30(%rsp)
je     1684 <somworker+0x504>
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    1670 <somworker+0x4f0>
mov    %rbp,%rcx
cmp    %rdi,%rbp
je     1570 <somworker+0x3f0>
movl   $0x1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1690 <somworker+0x510>
jmp    1570 <somworker+0x3f0>
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
movsd  %xmm0,0x80(%rsp)
mov    0x170(%rsp),%eax
mov    %eax,%ecx
mov    %rcx,0x78(%rsp)
test   %eax,%eax
jle    1906 <somworker+0x786>
mov    0x178(%rsp),%ebx
xorpd  %xmm0,%xmm0
divsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    %edi,%ebp
and    $0xfffffffe,%ebp
lea    -0x2(%rbp),%rax
mov    %rax,0x38(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,%r14
and    $0xfffffffffffffffe,%rax
mov    %rax,0x48(%rsp)
xor    %r13d,%r13d
movq   0x18ee(%rip),%xmm4
movsd  0x18de(%rip),%xmm1
jmp    173f <somworker+0x5bf>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
cmp    0x78(%rsp),%r13
je     1906 <somworker+0x786>
cmpl   $0x0,0x178(%rsp)
jle    1730 <somworker+0x5b0>
xor    %r15d,%r15d
jmp    1759 <somworker+0x5d9>
xchg   %ax,%ax
add    $0x1,%r15
cmp    %rbx,%r15
je     1730 <somworker+0x5b0>
test   %esi,%esi
jle    17f0 <somworker+0x670>
xorpd  %xmm0,%xmm0
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x30(%rsp)
movdqa %xmm4,%xmm0
mov    $0x2,%al
call   1090 <genunf@plt>
movsd  0x1877(%rip),%xmm1
movq   0x1877(%rip),%xmm4
mov    0x180(%rsp),%rcx
mov    0x10(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    (%rcx,%r13,8),%rax
mov    (%rax,%r15,8),%rax
movsd  %xmm0,(%rax,%r12,8)
mulsd  %xmm0,%xmm0
movsd  0x30(%rsp),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x30(%rsp)
movsd  0x30(%rsp),%xmm0
add    $0x1,%r12
cmp    %r12,%rdi
jne    1770 <somworker+0x5f0>
divsd  0x80(%rsp),%xmm0
ucomisd 0x1829(%rip),%xmm0
jb     1830 <somworker+0x6b0>
sqrtsd %xmm0,%xmm0
jmp    1852 <somworker+0x6d2>
nop
movsd  0x40(%rsp),%xmm0
ucomisd 0x1812(%rip),%xmm0
jae    1750 <somworker+0x5d0>
movsd  0x40(%rsp),%xmm0
call   10a0 <sqrt@plt>
movsd  0x17e9(%rip),%xmm1
movq   0x17e9(%rip),%xmm4
mov    0xc(%rsp),%esi
jmp    1750 <somworker+0x5d0>
nopl   0x0(%rax,%rax,1)
call   10a0 <sqrt@plt>
movsd  0x17c3(%rip),%xmm1
movq   0x17c3(%rip),%xmm4
mov    0x180(%rsp),%rcx
mov    0x10(%rsp),%rdi
mov    0xc(%rsp),%esi
test   %esi,%esi
jle    1750 <somworker+0x5d0>
mov    (%rcx,%r13,8),%rax
mov    (%rax,%r15,8),%rax
cmp    $0x1,%esi
jne    186f <somworker+0x6ef>
xor    %ecx,%ecx
jmp    18e0 <somworker+0x760>
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
cmpq   $0x0,0x38(%rsp)
je     18fc <somworker+0x77c>
mov    0x48(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
divpd  %xmm5,%xmm2
movupd %xmm2,(%rax,%rcx,8)
divpd  %xmm5,%xmm3
movupd %xmm3,0x10(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1890 <somworker+0x710>
test   $0x1,%r14b
je     18cc <somworker+0x74c>
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm5,%xmm2
movupd %xmm2,(%rax,%rcx,8)
mov    %rbp,%rcx
cmp    %rdi,%rbp
je     1750 <somworker+0x5d0>
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    18e0 <somworker+0x760>
jmp    1750 <somworker+0x5d0>
xor    %ecx,%ecx
test   $0x1,%r14b
jne    18be <somworker+0x73e>
jmp    18cc <somworker+0x74c>
mov    0x90(%rsp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,%r12
cmpl   $0x0,0x1c(%rsp)
mov    0x178(%rsp),%r14d
jle    1aad <somworker+0x92d>
mov    0x1c(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    193f <somworker+0x7bf>
xor    %ecx,%ecx
jmp    1aa0 <somworker+0x920>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    196d <somworker+0x7ed>
movdqa 0x16ca(%rip),%xmm0
xor    %edi,%edi
jmp    1a40 <somworker+0x8c0>
and    $0xfffffffffffffffc,%rsi
movdqa 0x16b7(%rip),%xmm0
xor    %edi,%edi
movdqa 0x16bc(%rip),%xmm8
movdqa 0x16c3(%rip),%xmm9
movdqa 0x16ca(%rip),%xmm10
movdqa 0x16d2(%rip),%xmm4
movdqa 0x16da(%rip),%xmm5
movdqa 0x16e2(%rip),%xmm6
movdqa 0x16ea(%rip),%xmm7
movdqa 0x16f2(%rip),%xmm1
xchg   %ax,%ax
movdqa %xmm0,%xmm2
paddq  %xmm8,%xmm2
movdqu %xmm0,(%r12,%rdi,8)
movdqu %xmm2,0x10(%r12,%rdi,8)
movdqa %xmm0,%xmm2
paddq  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm10,%xmm3
movdqu %xmm2,0x20(%r12,%rdi,8)
movdqu %xmm3,0x30(%r12,%rdi,8)
movdqa %xmm0,%xmm2
paddq  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm5,%xmm3
movdqu %xmm2,0x40(%r12,%rdi,8)
movdqu %xmm3,0x50(%r12,%rdi,8)
movdqa %xmm0,%xmm2
paddq  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm7,%xmm3
movdqu %xmm2,0x60(%r12,%rdi,8)
movdqu %xmm3,0x70(%r12,%rdi,8)
add    $0x10,%rdi
paddq  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    19c0 <somworker+0x840>
test   %rdx,%rdx
je     1a90 <somworker+0x910>
lea    (%r12,%rdi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0x15e5(%rip),%xmm1
movdqa 0x15ed(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm3
paddq  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddq  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1a70 <somworker+0x8f0>
cmp    %rax,%rcx
je     1aad <somworker+0x92d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1aa0 <somworker+0x920>
xor    %ebx,%ebx
mov    %r12,%rdi
mov    0x1c(%rsp),%esi
xor    %eax,%eax
call   1050 <genprm@plt>
cmpl   $0x0,0x188(%rsp)
mov    0xc(%rsp),%edi
mov    0x10(%rsp),%rax
jle    2927 <somworker+0x17a7>
shlq   $0x3,0x70(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x188(%rsp),%xmm0
movsd  %xmm0,0xd0(%rsp)
mov    %r14d,%ecx
mov    %rcx,0x120(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0xc8(%rsp)
mov    %eax,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%rcx
mov    %rcx,0x118(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
lea    -0x1(%rax),%rdx
mov    %rdx,0xb0(%rsp)
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x100(%rsp)
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0xf8(%rsp)
mov    %rdx,%rsi
shr    %rsi
add    $0x1,%rsi
movabs $0x7ffffffffffffffc,%rbp
ff ff 7f
or     $0x2,%rbp
mov    %rcx,%rdx
mov    %rcx,0x110(%rsp)
and    %rcx,%rbp
mov    %rbp,0x108(%rsp)
mov    %eax,%r10d
and    $0x3,%r10d
mov    %rsi,%rax
mov    %rsi,0xf0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xe8(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0x90(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    %r12,0x128(%rsp)
mov    %r9,0x38(%rsp)
mov    %r10,0x58(%rsp)
jmp    1c1e <somworker+0xa9e>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rdi
call   1030 <free@plt>
mov    0xc(%rsp),%edi
movsd  0xa8(%rsp),%xmm0
addsd  0x1413(%rip),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    0xe0(%rsp),%rbx
add    $0x1,%ebx
cmp    0x188(%rsp),%ebx
mov    0x178(%rsp),%r14d
mov    0x128(%rsp),%r12
je     2927 <somworker+0x17a7>
mov    %rbx,0xe0(%rsp)
mov    %ebx,%eax
cltd
idivl  0x1c(%rsp)
mov    (%r12,%rdx,8),%r13
cmpl   $0x0,0x60(%rsp)
mov    0x88(%rsp),%rbp
je     1d70 <somworker+0xbf0>
mov    0x70(%rsp),%rdi
call   1070 <malloc@plt>
mov    0xc(%rsp),%edi
mov    %rax,%r15
test   %edi,%edi
mov    0x10(%rsp),%r8
mov    0x68(%rsp),%r12
mov    0x38(%rsp),%r10
mov    0x58(%rsp),%rbx
mov    0x90(%rsp),%r9
movdqa 0x1435(%rip),%xmm4
mov    0x28(%rsp),%rsi
jle    2280 <somworker+0x1100>
mov    0x180(%rsp),%rax
mov    (%rax),%rax
cmp    $0x4,%edi
jb     1cb7 <somworker+0xb37>
lea    0x8(%rax),%rcx
cmp    %rcx,%r15
jae    21aa <somworker+0x102a>
mov    0xc8(%rsp),%rcx
add    %r15,%rcx
cmp    %rax,%rcx
jbe    21aa <somworker+0x102a>
xor    %ecx,%ecx
mov    0xb0(%rsp),%rdx
sub    %rcx,%rdx
test   %rbx,%rbx
je     1d07 <somworker+0xb87>
lea    0x0(,%rcx,8),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax),%rbp
add    %rsi,%rbp
mov    %rbp,(%r15,%rsi,1)
add    $0xffffffffffffffff,%rbx
add    $0x8,%rsi
cmp    %rbx,%r9
jne    1ce0 <somworker+0xb60>
sub    %rbx,%rcx
mov    0x88(%rsp),%rbp
mov    0x28(%rsp),%rsi
cmp    $0x3,%rdx
jb     2280 <somworker+0x1100>
mov    %r8,%rdx
sub    %rcx,%rdx
lea    0x10(,%rcx,8),%rcx
nop
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    1d20 <somworker+0xba0>
jmp    2280 <somworker+0x1100>
cs nopw 0x0(%rax,%rax,1)
mov    0x180(%rsp),%r14
mov    (%r14),%rdx
sub    $0x8,%rsp
mov    0x30(%rsp),%rsi
mov    0x70(%rsp),%rcx
mov    0x58(%rsp),%r8
mov    %rbp,%r9
push   $0x0
push   $0x0
push   %r13
call   *0xb8(%rsp)
mov    0x2c(%rsp),%edi
add    $0x20,%rsp
cmpl   $0x0,0x170(%rsp)
jle    1bdc <somworker+0xa5c>
mov    %r14,%rbp
movapd %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sdl 0xe0(%rsp),%xmm0
divsd  0xd0(%rsp),%xmm0
movsd  0x1228(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xa0(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x40(%rsp)
mulsd  0xd8(%rsp),%xmm1
movsd  %xmm1,0x48(%rsp)
xor    %r12d,%r12d
xor    %r15d,%r15d
xor    %eax,%eax
mov    0x178(%rsp),%r14d
jmp    1e46 <somworker+0xcc6>
movapd %xmm2,%xmm0
add    $0x1,%r12
movapd %xmm0,%xmm2
cmp    0x78(%rsp),%r12
mov    0x20(%rsp),%r8
mov    0x28(%rsp),%r11
mov    0x10(%rsp),%rsi
mov    0x38(%rsp),%r9
mov    0x58(%rsp),%r10
pxor   %xmm4,%xmm4
movsd  0x48(%rsp),%xmm5
je     1ec0 <somworker+0xd40>
test   %r14d,%r14d
jle    1e10 <somworker+0xc90>
xor    %ebx,%ebx
nopl   (%rax)
movsd  %xmm2,0x30(%rsp)
mov    0x0(%rbp,%r12,8),%rdx
sub    $0x8,%rsp
mov    0x30(%rsp),%rsi
mov    0x70(%rsp),%rcx
mov    0x58(%rsp),%r8
mov    0x90(%rsp),%r9
push   $0x0
push   %rbx
push   %r13
mov    %eax,%ebp
call   *0xb8(%rsp)
mov    %ebp,%eax
mov    0x1a0(%rsp),%rbp
mov    0x2c(%rsp),%edi
add    $0x20,%rsp
movsd  0x30(%rsp),%xmm1
ucomisd %xmm0,%xmm1
cmova  %r12d,%eax
cmova  %ebx,%r15d
minsd  %xmm1,%xmm0
add    $0x1,%ebx
movapd %xmm0,%xmm2
cmp    %ebx,%r14d
jne    1e50 <somworker+0xcd0>
jmp    1e14 <somworker+0xc94>
nopl   (%rax)
mov    %eax,0xc0(%rsp)
cmpl   $0x0,0x170(%rsp)
jle    1bdc <somworker+0xa5c>
xor    %ebx,%ebx
jmp    1eef <somworker+0xd6f>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    0x78(%rsp),%rbx
je     1bdc <somworker+0xa5c>
cmpl   $0x0,0x178(%rsp)
jle    1ee0 <somworker+0xd60>
mov    %ebx,%eax
sub    0xc0(%rsp),%eax
imul   %eax,%eax
mov    %eax,0x30(%rsp)
xor    %r12d,%r12d
jmp    1f1e <somworker+0xd9e>
xchg   %ax,%ax
add    $0x1,%r12
cmp    0x120(%rsp),%r12
je     1ee0 <somworker+0xd60>
mov    %r12d,%eax
sub    %r15d,%eax
imul   %eax,%eax
add    0x30(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm4,%xmm0
jb     1f50 <somworker+0xdd0>
sqrtsd %xmm0,%xmm0
test   %edi,%edi
jg     1f8a <somworker+0xe0a>
jmp    1f10 <somworker+0xd90>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rbp
mov    %r11,%r14
call   10a0 <sqrt@plt>
movsd  0x48(%rsp),%xmm5
mov    %r14,%r11
xorpd  %xmm4,%xmm4
mov    0x58(%rsp),%r10
mov    0x38(%rsp),%r9
mov    %rbp,%r8
mov    0x180(%rsp),%rbp
mov    0x10(%rsp),%rsi
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    1f10 <somworker+0xd90>
movsd  0x40(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    1f10 <somworker+0xd90>
mov    0x68(%rsp),%rax
mov    (%rax,%r13,8),%rax
xor    %ecx,%ecx
jmp    1fb9 <somworker+0xe39>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%rsi
je     1ff0 <somworker+0xe70>
cmpl   $0x0,(%rax,%rcx,4)
je     1fb0 <somworker+0xe30>
mov    (%r11,%r13,8),%rdx
movsd  (%rdx,%rcx,8),%xmm0
divsd  (%r8,%r13,8),%xmm0
mov    0x0(%rbp,%rbx,8),%rdx
mov    (%rdx,%r12,8),%rdx
movsd  (%rdx,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
jmp    1fb0 <somworker+0xe30>
nop
test   %edi,%edi
jle    1f10 <somworker+0xd90>
mov    0x0(%rbp,%rbx,8),%rax
mov    (%rax,%r12,8),%rax
cmpq   $0x3,0xb0(%rsp)
jae    2014 <somworker+0xe94>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    2060 <somworker+0xee0>
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,%r9
jne    2020 <somworker+0xea0>
test   $0x3,%sil
je     2086 <somworker+0xf06>
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,%r10
jne    2070 <somworker+0xef0>
ucomisd %xmm4,%xmm0
jbe    1f10 <somworker+0xd90>
divsd  0x80(%rsp),%xmm0
ucomisd %xmm4,%xmm0
jb     20ac <somworker+0xf2c>
sqrtsd %xmm0,%xmm0
test   %edi,%edi
jg     20ea <somworker+0xf6a>
jmp    1f10 <somworker+0xd90>
mov    %r8,%rbp
mov    %r11,%r14
call   10a0 <sqrt@plt>
movsd  0x48(%rsp),%xmm5
mov    %r14,%r11
xorpd  %xmm4,%xmm4
mov    0x58(%rsp),%r10
mov    0x38(%rsp),%r9
mov    %rbp,%r8
mov    0x180(%rsp),%rbp
mov    0x10(%rsp),%rsi
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    1f10 <somworker+0xd90>
mov    0x0(%rbp,%rbx,8),%rax
mov    (%rax,%r12,8),%rax
cmp    $0x1,%edi
jne    20ff <somworker+0xf7f>
xor    %ecx,%ecx
jmp    2180 <somworker+0x1000>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xf8(%rsp)
je     219c <somworker+0x101c>
mov    0xe8(%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    2120 <somworker+0xfa0>
testb  $0x1,0xf0(%rsp)
01
je     2160 <somworker+0xfe0>
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
mov    0x100(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rsi,%rdx
je     1f10 <somworker+0xd90>
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,%rsi
jne    2180 <somworker+0x1000>
jmp    1f10 <somworker+0xd90>
xor    %ecx,%ecx
testb  $0x1,0xf0(%rsp)
01
jne    2152 <somworker+0xfd2>
jmp    2160 <somworker+0xfe0>
cmpq   $0x0,0x118(%rsp)
movdqa 0xf05(%rip),%xmm5
movdqa 0xf0d(%rip),%xmm6
movdqa 0xea5(%rip),%xmm7
je     290a <somworker+0x178a>
movq   (%rax),%xmm0
pshufd $0x44,%xmm0,%xmm1
mov    0x108(%rsp),%rdx
xor    %ecx,%ecx
movdqa 0xe44(%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    21f0 <somworker+0x1070>
testb  $0x1,0x110(%rsp)
01
je     2267 <somworker+0x10e7>
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    %r10,%rcx
cmp    %r8,%r10
jne    1cb9 <somworker+0xb39>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    $0x8,%rsp
mov    %r15,%rdx
mov    %r12,%rcx
mov    0x58(%rsp),%r8
mov    %rbp,%r9
push   0x68(%rsp)
push   $0x0
push   %r13
call   *0xb8(%rsp)
add    $0x20,%rsp
cmpl   $0x0,0x170(%rsp)
jle    1bd0 <somworker+0xa50>
movapd %xmm0,%xmm2
movsd  0xa8(%rsp),%xmm0
divsd  0xd0(%rsp),%xmm0
movsd  0xd2f(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xa0(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0xc0(%rsp)
mulsd  0xd8(%rsp),%xmm1
movsd  %xmm1,0xb8(%rsp)
mov    0xc8(%rsp),%rax
add    %r15,%rax
mov    %rax,0x130(%rsp)
movl   $0x0,0x48(%rsp)
xor    %r14d,%r14d
xor    %r10d,%r10d
jmp    2345 <somworker+0x11c5>
movapd %xmm2,%xmm0
mov    0x48(%rsp),%eax
add    $0x1,%eax
movapd %xmm0,%xmm2
mov    %eax,0x48(%rsp)
cmp    0x170(%rsp),%eax
mov    0x68(%rsp),%r12
je     25d0 <somworker+0x1450>
cmpl   $0x0,0x178(%rsp)
jle    2320 <somworker+0x11a0>
xor    %eax,%eax
mov    0xc(%rsp),%ebx
jmp    23d1 <somworker+0x1251>
nopw   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    %r15,%rdx
mov    0x70(%rsp),%rcx
mov    %edi,%ebx
mov    0x58(%rsp),%r8
mov    %rbp,%r9
push   0x68(%rsp)
push   $0x0
push   %r13
mov    %r13,%r12
mov    %r14d,%r13d
mov    %rbp,%r14
mov    %r10d,%ebp
call   *0xb8(%rsp)
mov    %ebp,%r10d
mov    %r14,%rbp
mov    %r13d,%r14d
mov    %r12,%r13
add    $0x20,%rsp
movsd  0x30(%rsp),%xmm1
ucomisd %xmm0,%xmm1
cmova  0x48(%rsp),%r10d
mov    0x40(%rsp),%eax
cmova  %eax,%r14d
minsd  %xmm1,%xmm0
add    $0x1,%eax
movapd %xmm0,%xmm2
cmp    0x178(%rsp),%eax
je     2324 <somworker+0x11a4>
mov    %eax,0x40(%rsp)
movsd  %xmm2,0x30(%rsp)
test   %ebx,%ebx
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%rbx
mov    0x90(%rsp),%r9
movdqa 0xcb2(%rip),%xmm4
movdqa 0xcba(%rip),%xmm5
movdqa 0xcc2(%rip),%xmm6
movdqa 0xc5a(%rip),%xmm7
jle    2360 <somworker+0x11e0>
movslq %r10d,%rax
mov    0x180(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movslq %r14d,%rdx
lea    (%rcx,%rdx,8),%rax
cmp    $0x4,%edi
jb     2456 <somworker+0x12d6>
lea    (%rcx,%rdx,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%r15
jae    2506 <somworker+0x1386>
cmp    %rax,0x130(%rsp)
jbe    2506 <somworker+0x1386>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
test   $0x3,%r8b
je     24a7 <somworker+0x1327>
lea    0x0(,%rcx,8),%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rax),%rbx
add    %rsi,%rbx
mov    %rbx,(%r15,%rsi,1)
add    $0xffffffffffffffff,%rbp
add    $0x8,%rsi
cmp    %rbp,%r9
jne    2480 <somworker+0x1300>
sub    %rbp,%rcx
mov    0x88(%rsp),%rbp
mov    0x28(%rsp),%rsi
cmp    $0x3,%rdx
jb     2360 <somworker+0x11e0>
mov    %r8,%rdx
sub    %rcx,%rdx
lea    0x10(,%rcx,8),%rcx
nop
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    24c0 <somworker+0x1340>
jmp    2360 <somworker+0x11e0>
cmpq   $0x0,0x118(%rsp)
je     25b8 <somworker+0x1438>
movq   (%rax),%xmm0
pshufd $0x44,%xmm0,%xmm1
mov    0x108(%rsp),%rdx
xor    %ecx,%ecx
movdqa 0xb00(%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    2530 <somworker+0x13b0>
testb  $0x1,0x110(%rsp)
01
je     25a7 <somworker+0x1427>
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    %rbx,%rcx
cmp    %r8,%rbx
je     2360 <somworker+0x11e0>
jmp    2458 <somworker+0x12d8>
xor    %ecx,%ecx
movdqa 0xa6e(%rip),%xmm0
testb  $0x1,0x110(%rsp)
01
jne    2584 <somworker+0x1404>
jmp    25a7 <somworker+0x1427>
xchg   %ax,%ax
mov    %r10d,0x40(%rsp)
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%r11
cmpl   $0x0,0x170(%rsp)
mov    0xc(%rsp),%edi
mov    0x10(%rsp),%rsi
mov    0x180(%rsp),%rbx
mov    0x20(%rsp),%r8
mov    0x38(%rsp),%r9
mov    0x58(%rsp),%r10
pxor   %xmm4,%xmm4
movsd  0xb8(%rsp),%xmm5
jle    1bdc <somworker+0xa5c>
xor    %ebp,%ebp
jmp    263f <somworker+0x14bf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    0x78(%rsp),%rbp
je     1bdc <somworker+0xa5c>
cmpl   $0x0,0x178(%rsp)
jle    2630 <somworker+0x14b0>
mov    %ebp,%eax
sub    0x40(%rsp),%eax
imul   %eax,%eax
mov    %eax,0x30(%rsp)
xor    %r15d,%r15d
jmp    266e <somworker+0x14ee>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x120(%rsp),%r15
je     2630 <somworker+0x14b0>
mov    %r15d,%eax
sub    %r14d,%eax
imul   %eax,%eax
add    0x30(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm4,%xmm0
jb     26a0 <somworker+0x1520>
sqrtsd %xmm0,%xmm0
test   %edi,%edi
jg     26db <somworker+0x155b>
jmp    2660 <somworker+0x14e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   10a0 <sqrt@plt>
movsd  0xb8(%rsp),%xmm5
mov    0x28(%rsp),%r11
xorpd  %xmm4,%xmm4
mov    0x58(%rsp),%r10
mov    0x38(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0x180(%rsp),%rbx
mov    0x10(%rsp),%rsi
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    2660 <somworker+0x14e0>
movsd  0xc0(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    2660 <somworker+0x14e0>
xor    %eax,%eax
jmp    2709 <somworker+0x1589>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%rsi
je     2750 <somworker+0x15d0>
mov    (%r12,%rax,8),%rcx
cmpl   $0x0,(%rcx,%r13,4)
je     2700 <somworker+0x1580>
mov    (%r11,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm0
divsd  (%r8,%r13,8),%xmm0
mov    (%rbx,%rbp,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    2700 <somworker+0x1580>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %edi,%edi
jle    2660 <somworker+0x14e0>
mov    (%rbx,%rbp,8),%rax
mov    (%rax,%r15,8),%rax
cmpq   $0x3,0xb0(%rsp)
jae    2773 <somworker+0x15f3>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    27c0 <somworker+0x1640>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
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,%r9
jne    2780 <somworker+0x1600>
test   $0x3,%sil
je     27e6 <somworker+0x1666>
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,%r10
jne    27d0 <somworker+0x1650>
ucomisd %xmm4,%xmm0
jbe    2660 <somworker+0x14e0>
divsd  0x80(%rsp),%xmm0
ucomisd %xmm4,%xmm0
jb     280c <somworker+0x168c>
sqrtsd %xmm0,%xmm0
test   %edi,%edi
jg     284b <somworker+0x16cb>
jmp    2660 <somworker+0x14e0>
call   10a0 <sqrt@plt>
movsd  0xb8(%rsp),%xmm5
mov    0x28(%rsp),%r11
xorpd  %xmm4,%xmm4
mov    0x58(%rsp),%r10
mov    0x38(%rsp),%r9
mov    0x20(%rsp),%r8
mov    0x180(%rsp),%rbx
mov    0x10(%rsp),%rsi
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    2660 <somworker+0x14e0>
mov    (%rbx,%rbp,8),%rax
mov    (%rax,%r15,8),%rax
cmp    $0x1,%edi
jne    285f <somworker+0x16df>
xor    %ecx,%ecx
jmp    28e0 <somworker+0x1760>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xf8(%rsp)
je     28fc <somworker+0x177c>
mov    0xe8(%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    2880 <somworker+0x1700>
testb  $0x1,0xf0(%rsp)
01
je     28c0 <somworker+0x1740>
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rcx,8)
mov    0x100(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rsi,%rdx
je     2660 <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,%rsi
jne    28e0 <somworker+0x1760>
jmp    2660 <somworker+0x14e0>
xor    %ecx,%ecx
testb  $0x1,0xf0(%rsp)
01
jne    28b2 <somworker+0x1732>
jmp    28c0 <somworker+0x1740>
xor    %ecx,%ecx
movdqa 0x71c(%rip),%xmm0
testb  $0x1,0x110(%rsp)
01
jne    2244 <somworker+0x10c4>
jmp    2267 <somworker+0x10e7>
cmpl   $0x0,0x60(%rsp)
je     2956 <somworker+0x17d6>
test   %edi,%edi
mov    0x50(%rsp),%r15
jle    2982 <somworker+0x1802>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,0x10(%rsp)
jne    2940 <somworker+0x17c0>
jmp    2982 <somworker+0x1802>
test   %r14d,%r14d
mov    0x50(%rsp),%r15
jle    2982 <somworker+0x1802>
mov    %r14d,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2970 <somworker+0x17f0>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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