void particleFilter(int *I, int IszX, int IszY, int Nfr, int *seed,
                    int Nparticles) {
  int max_size = IszX * IszY * Nfr;
  long long start = get_time();
  double xe = roundDouble(IszY / 2.0);
  double ye = roundDouble(IszX / 2.0);
  int radius = 5;
  int diameter = radius * 2 - 1;
  int *disk = (int *)malloc(diameter * diameter * sizeof(int));
  strelDisk(disk, radius);
  int countOnes = 0;
  int x, y;
  for (x = 0; x < diameter; x++) {
    for (y = 0; y < diameter; y++) {
      if (disk[x * diameter + y] == 1)
        countOnes++;
    }
  }
  double *objxy = (double *)malloc(countOnes * 2 * sizeof(double));
  getneighbors(disk, countOnes, objxy, radius);
  long long get_neighbors = get_time();
  printf("TIME TO GET NEIGHBORS TOOK: %f\n",
         elapsed_time(start, get_neighbors));
  double *weights = (double *)malloc(sizeof(double) * Nparticles);
  {
    const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(weights, Nparticles) private(x)
    for (x = 0; x < Nparticles; x++) {
      weights[x] = 1 / ((double)(Nparticles));
    };
    const unsigned long long parallel_for_end = current_time_ns();
    printf("pragma373_omp_parallel %llu ns\n",
           parallel_for_end - parallel_for_start);
  }
  long long get_weights = get_time();
  printf("TIME TO GET WEIGHTSTOOK: %f\n",
         elapsed_time(get_neighbors, get_weights));
  double *likelihood = (double *)malloc(sizeof(double) * Nparticles);
  double *arrayX = (double *)malloc(sizeof(double) * Nparticles);
  double *arrayY = (double *)malloc(sizeof(double) * Nparticles);
  double *xj = (double *)malloc(sizeof(double) * Nparticles);
  double *yj = (double *)malloc(sizeof(double) * Nparticles);
  double *CDF = (double *)malloc(sizeof(double) * Nparticles);
  double *u = (double *)malloc(sizeof(double) * Nparticles);
  int *ind = (int *)malloc(sizeof(int) * countOnes * Nparticles);
  {
    const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(arrayX, arrayY, xe, ye) private(x)
    for (x = 0; x < Nparticles; x++) {
      arrayX[x] = xe;
      arrayY[x] = ye;
    };
    const unsigned long long parallel_for_end = current_time_ns();
    printf("pragma388_omp_parallel %llu ns\n",
           parallel_for_end - parallel_for_start);
  }
  int k;
  printf("TIME TO SET ARRAYS TOOK: %f\n",
         elapsed_time(get_weights, get_time()));
  int indX, indY;
  for (k = 1; k < Nfr; k++) {
    long long set_arrays = get_time();
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(arrayX, arrayY, Nparticles, seed) private(x)
      for (x = 0; x < Nparticles; x++) {
        arrayX[x] += 1 + 5 * randn(seed, x);
        arrayY[x] += -2 + 2 * randn(seed, x);
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma402_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long error = get_time();
    printf("TIME TO SET ERROR TOOK: %f\n", elapsed_time(set_arrays, error));
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(likelihood, I, arrayX, arrayY, objxy,          \
                                ind) private(x, y, indX, indY)
      for (x = 0; x < Nparticles; x++) {
        for (y = 0; y < countOnes; y++) {
          indX = roundDouble(arrayX[x]) + objxy[y * 2 + 1];
          indY = roundDouble(arrayY[x]) + objxy[y * 2];
          ind[x * countOnes + y] =
              fabs((double)(indX * IszY * Nfr + indY * Nfr + k));
          if (ind[x * countOnes + y] >= max_size)
            ind[x * countOnes + y] = 0;
        }
        likelihood[x] = 0;
        for (y = 0; y < countOnes; y++)
          likelihood[x] += (pow((I[ind[x * countOnes + y]] - 100), 2) -
                            pow((I[ind[x * countOnes + y]] - 228), 2)) /
                           50.0;
        likelihood[x] = likelihood[x] / ((double)countOnes);
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma410_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long likelihood_time = get_time();
    printf("TIME TO GET LIKELIHOODS TOOK: %f\n",
           elapsed_time(error, likelihood_time));
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(Nparticles, weights, likelihood) private(x)
      for (x = 0; x < Nparticles; x++) {
        weights[x] = weights[x] * exp(likelihood[x]);
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma433_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long exponential = get_time();
    printf("TIME TO GET EXP TOOK: %f\n",
           elapsed_time(likelihood_time, exponential));
    double sumWeights = 0;
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for private(x) reduction(+ : sumWeights)
      for (x = 0; x < Nparticles; x++) {
        sumWeights += weights[x];
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma440_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long sum_time = get_time();
    printf("TIME TO SUM WEIGHTS TOOK: %f\n",
           elapsed_time(exponential, sum_time));
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(sumWeights, weights) private(x)
      for (x = 0; x < Nparticles; x++) {
        weights[x] = weights[x] / sumWeights;
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma446_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long normalize = get_time();
    printf("TIME TO NORMALIZE WEIGHTS TOOK: %f\n",
           elapsed_time(sum_time, normalize));
    xe = 0;
    ye = 0;
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for private(x) reduction(+ : xe, ye)
      for (x = 0; x < Nparticles; x++) {
        xe += arrayX[x] * weights[x];
        ye += arrayY[x] * weights[x];
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma455_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long move_time = get_time();
    printf("TIME TO MOVE OBJECT TOOK: %f\n",
           elapsed_time(normalize, move_time));
    printf("XE: %lf\n", xe);
    printf("YE: %lf\n", ye);
    double distance = sqrt(pow((double)(xe - (int)roundDouble(IszY / 2.0)), 2) +
                           pow((double)(ye - (int)roundDouble(IszX / 2.0)), 2));
    printf("%lf\n", distance);
    CDF[0] = weights[0];
    for (x = 1; x < Nparticles; x++) {
      CDF[x] = weights[x] + CDF[x - 1];
    }
    long long cum_sum = get_time();
    printf("TIME TO CALC CUM SUM TOOK: %f\n", elapsed_time(move_time, cum_sum));
    double u1 = (1 / ((double)(Nparticles))) * randu(seed, 0);
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(u, u1, Nparticles) private(x)
      for (x = 0; x < Nparticles; x++) {
        u[x] = u1 + x / ((double)(Nparticles));
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma480_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long u_time = get_time();
    printf("TIME TO CALC U TOOK: %f\n", elapsed_time(cum_sum, u_time));
    int j, i;
    {
      const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for shared(CDF, Nparticles, xj, yj, u, arrayX,            \
                                arrayY) private(i, j)
      for (j = 0; j < Nparticles; j++) {
        i = findIndex(CDF, Nparticles, u[j]);
        if (i == -1)
          i = Nparticles - 1;
        xj[j] = arrayX[i];
        yj[j] = arrayY[i];
      };
      const unsigned long long parallel_for_end = current_time_ns();
      printf("pragma488_omp_parallel %llu ns\n",
             parallel_for_end - parallel_for_start);
    }
    long long xyj_time = get_time();
    printf("TIME TO CALC NEW ARRAY X AND Y TOOK: %f\n",
           elapsed_time(u_time, xyj_time));
    for (x = 0; x < Nparticles; x++) {
      arrayX[x] = xj[x];
      arrayY[x] = yj[x];
      weights[x] = 1 / ((double)(Nparticles));
    }
    long long reset = get_time();
    printf("TIME TO RESET WEIGHTS TOOK: %f\n", elapsed_time(xyj_time, reset));
  }
  free(disk);
  free(objxy);
  free(weights);
  free(likelihood);
  free(xj);
  free(yj);
  free(arrayX);
  free(arrayY);
  free(CDF);
  free(u);
  free(ind);
}


x86 assembly (clang, -O0):
<particleFilter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x30(%rbp)
cvtsi2sdl -0x10(%rbp),%xmm0
movsd  0x1dc8(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0x1da7(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x5,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
imul   -0x48(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x44(%rbp),%esi
mov    $0x0,%al
call   10d0 <strelDisk@plt>
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    131c <particleFilter+0x12c>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1309 <particleFilter+0x119>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x48(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    12f6 <particleFilter+0x106>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12fb <particleFilter+0x10b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12c6 <particleFilter+0xd6>
jmp    130e <particleFilter+0x11e>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12b3 <particleFilter+0xc3>
mov    -0x54(%rbp),%eax
shl    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x44(%rbp),%ecx
mov    $0x0,%al
call   1050 <getneighbors@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1cc4(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13d0 <particleFilter+0x1e0>
cvtsi2sdl -0x24(%rbp),%xmm1
movsd  0x1c57(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1398 <particleFilter+0x1a8>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rsi
sub    -0x80(%rbp),%rsi
lea    0x1c5e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1c4c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movslq -0x54(%rbp),%rdi
shl    $0x2,%rdi
movslq -0x24(%rbp),%rax
imul   %rax,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xd0(%rbp)
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    152e <particleFilter+0x33e>
movsd  -0x38(%rbp),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14ea <particleFilter+0x2fa>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rsi
sub    -0xd8(%rbp),%rsi
lea    0x1b3a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x90(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    $0x0,%al
call   1080 <get_time@plt>
mov    -0x1f0(%rbp),%rdi
mov    %eax,%esi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1b25(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2105 <particleFilter+0xf15>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0xf8(%rbp)
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x100(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1645 <particleFilter+0x455>
mov    -0x20(%rbp),%rdi
mov    -0x58(%rbp),%esi
mov    $0x0,%al
call   10e0 <randn@plt>
imul   $0x5,%eax,%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdi
mov    -0x58(%rbp),%esi
mov    $0x0,%al
call   10e0 <randn@plt>
shl    $0x1,%eax
add    $0xfffffffe,%eax
cvtsi2sd %eax,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15cf <particleFilter+0x3df>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rsi
sub    -0x100(%rbp),%rsi
lea    0x1a60(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    -0xf8(%rbp),%rdi
mov    -0x110(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1a4b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x118(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    18f0 <particleFilter+0x700>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    17e5 <particleFilter+0x5f5>
mov    -0xa0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
cvtsi2sd %eax,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xe8(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
cvtsi2sd %eax,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xec(%rbp)
mov    -0xe8(%rbp),%eax
imul   -0x10(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0xec(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xe4(%rbp),%eax
cvtsi2sd %eax,%xmm0
movaps 0x18a8(%rip),%xmm1
pand   %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0xd0(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xd0(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x28(%rbp),%eax
jl     17d2 <particleFilter+0x5e2>
mov    -0xd0(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    17d7 <particleFilter+0x5e7>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    16d0 <particleFilter+0x4e0>
mov    -0x98(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    18b9 <particleFilter+0x6c9>
mov    -0x8(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    -0x58(%rbp),%edx
imul   -0x54(%rbp),%edx
add    -0x5c(%rbp),%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x64,%eax
cvtsi2sd %eax,%xmm0
movsd  0x17c7(%rip),%xmm1
call   10f0 <pow@plt>
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    -0x58(%rbp),%edx
imul   -0x54(%rbp),%edx
add    -0x5c(%rbp),%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0xe4,%eax
cvtsi2sd %eax,%xmm0
movsd  0x178a(%rip),%xmm1
call   10f0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1f8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  0x177e(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    17ff <particleFilter+0x60f>
mov    -0x98(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    16bd <particleFilter+0x4cd>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rsi
sub    -0x118(%rbp),%rsi
lea    0x17f1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x128(%rbp)
mov    -0x110(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x17dc(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x130(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    19c8 <particleFilter+0x7d8>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10b0 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x200(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1968 <particleFilter+0x778>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rsi
sub    -0x130(%rbp),%rsi
lea    0x175b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x140(%rbp)
mov    -0x128(%rbp),%rdi
mov    -0x140(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1746(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x150(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1a82 <particleFilter+0x892>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1a4b <particleFilter+0x85b>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x158(%rbp)
mov    -0x158(%rbp),%rsi
sub    -0x150(%rbp),%rsi
lea    0x16db(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x160(%rbp)
mov    -0x140(%rbp),%rdi
mov    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x16c6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x168(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1b36 <particleFilter+0x946>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x148(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1afa <particleFilter+0x90a>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x170(%rbp)
mov    -0x170(%rbp),%rsi
sub    -0x168(%rbp),%rsi
lea    0x1665(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x178(%rbp)
mov    -0x160(%rbp),%rdi
mov    -0x178(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1650(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x180(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1c36 <particleFilter+0xa46>
mov    -0xa0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1bbe <particleFilter+0x9ce>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x188(%rbp)
mov    -0x188(%rbp),%rsi
sub    -0x180(%rbp),%rsi
lea    0x15a9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x190(%rbp)
mov    -0x178(%rbp),%rdi
mov    -0x190(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1594(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movsd  -0x38(%rbp),%xmm0
lea    0x159f(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x40(%rbp),%xmm0
lea    0x1595(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
cvtsi2sdl -0x10(%rbp),%xmm0
movsd  0x1329(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
movsd  -0x218(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  0x1306(%rip),%xmm1
call   10f0 <pow@plt>
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0x12df(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
movsd  -0x210(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  0x12bc(%rip),%xmm1
call   10f0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x208(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
call   1100 <sqrt@plt>
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
lea    0x14d2(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x78(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xc0(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1de1 <particleFilter+0xbf1>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1d95 <particleFilter+0xba5>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x1a0(%rbp)
mov    -0x190(%rbp),%rdi
mov    -0x1a0(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1445(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cvtsi2sdl -0x24(%rbp),%xmm1
movsd  0x11e5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0x0,%al
call   10c0 <randu@plt>
movsd  -0x220(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x1b0(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1eaf <particleFilter+0xcbf>
movsd  -0x1a8(%rbp),%xmm0
ff
cvtsi2sdl -0x58(%rbp),%xmm1
cvtsi2sdl -0x24(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1e6b <particleFilter+0xc7b>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x1b8(%rbp)
mov    -0x1b8(%rbp),%rsi
sub    -0x1b0(%rbp),%rsi
lea    0x139f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x1c0(%rbp)
mov    -0x1a0(%rbp),%rdi
mov    -0x1c0(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x138a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x1d0(%rbp)
movl   $0x0,-0x1c4(%rbp)
mov    -0x1c4(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1fdc <particleFilter+0xdec>
mov    -0xc0(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0xc8(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x1,%al
call   1070 <findIndex@plt>
mov    %eax,-0x1c8(%rbp)
cmpl   $0xffffffff,-0x1c8(%rbp)
jne    1f7c <particleFilter+0xd8c>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
mov    -0xa0(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    1f2a <particleFilter+0xd3a>
mov    $0x0,%al
call   1110 <current_time_ns@plt>
cltq
mov    %rax,-0x1d8(%rbp)
mov    -0x1d8(%rbp),%rsi
sub    -0x1d0(%rbp),%rsi
lea    0x12ab(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x1e0(%rbp)
mov    -0x1c0(%rbp),%rdi
mov    -0x1e0(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x1296(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    20bc <particleFilter+0xecc>
mov    -0xb0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x24(%rbp),%xmm1
movsd  0xf6b(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    2044 <particleFilter+0xe54>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x1e8(%rbp)
mov    -0x1e0(%rbp),%rdi
mov    -0x1e8(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x120b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1599 <particleFilter+0x3a9>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<particleFilter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %r9d,%ebp
mov    %r8,0x90(%rsp)
mov    %ecx,%r12d
mov    %edx,%ebx
mov    %esi,%r15d
mov    %rdi,0x188(%rsp)
xor    %eax,%eax
call   1080 <get_time@plt>
mov    %eax,%r14d
mov    %ebx,0x68(%rsp)
cvtsi2sd %ebx,%xmm0
mulsd  0x1dca(%rip),%xmm0
movsd  %xmm0,0x180(%rsp)
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    %eax,0x48(%rsp)
mov    %r15d,0x4c(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
mulsd  0x1da1(%rip),%xmm0
movsd  %xmm0,0x178(%rsp)
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    %eax,0x3c(%rsp)
mov    $0x144,%edi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    %rax,%rdi
mov    $0x5,%esi
xor    %eax,%eax
call   10e0 <strelDisk@plt>
movdqu 0x0(%r13),%xmm1
movdqu 0x10(%r13),%xmm2
movdqa 0x1d7d(%rip),%xmm0
xor    %eax,%eax
cmpl   $0x1,0x20(%r13)
sete   %al
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ecx
mov    %ecx,%edx
shr    %dl
and    $0x55,%dl
sub    %dl,%cl
mov    %ecx,%edx
and    $0x33,%dl
shr    $0x2,%cl
and    $0x33,%cl
add    %dl,%cl
mov    %ecx,%edx
shr    $0x4,%dl
add    %cl,%dl
and    $0xf,%dl
movzbl %dl,%ecx
add    %eax,%ecx
movdqu 0x24(%r13),%xmm1
movdqu 0x34(%r13),%xmm2
xor    %edx,%edx
cmpl   $0x1,0x44(%r13)
sete   %dl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%eax
mov    %eax,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%al
mov    %eax,%ebx
and    $0x33,%bl
shr    $0x2,%al
and    $0x33,%al
add    %bl,%al
mov    %eax,%ebx
shr    $0x4,%bl
add    %al,%bl
and    $0xf,%bl
movzbl %bl,%eax
add    %edx,%eax
add    %ecx,%eax
movdqu 0x48(%r13),%xmm1
movdqu 0x58(%r13),%xmm2
xor    %edx,%edx
cmpl   $0x1,0x68(%r13)
sete   %dl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ecx
mov    %ecx,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%cl
mov    %ecx,%ebx
and    $0x33,%bl
shr    $0x2,%cl
and    $0x33,%cl
add    %bl,%cl
mov    %ecx,%ebx
shr    $0x4,%bl
add    %cl,%bl
and    $0xf,%bl
movzbl %bl,%ecx
add    %edx,%ecx
add    %eax,%ecx
movdqu 0x6c(%r13),%xmm1
movdqu 0x7c(%r13),%xmm2
xor    %edx,%edx
cmpl   $0x1,0x8c(%r13)
01
sete   %dl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%eax
mov    %eax,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%al
mov    %eax,%ebx
and    $0x33,%bl
shr    $0x2,%al
and    $0x33,%al
add    %bl,%al
mov    %eax,%ebx
shr    $0x4,%bl
add    %al,%bl
and    $0xf,%bl
movzbl %bl,%eax
add    %edx,%eax
add    %ecx,%eax
movdqu 0x90(%r13),%xmm1
movdqu 0xa0(%r13),%xmm2
xor    %edx,%edx
cmpl   $0x1,0xb0(%r13)
01
sete   %dl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ecx
mov    %ecx,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%cl
mov    %ecx,%ebx
and    $0x33,%bl
shr    $0x2,%cl
and    $0x33,%cl
add    %bl,%cl
mov    %ecx,%ebx
shr    $0x4,%bl
add    %cl,%bl
and    $0xf,%bl
movzbl %bl,%ecx
add    %edx,%ecx
add    %eax,%ecx
movdqu 0xb4(%r13),%xmm1
movdqu 0xc4(%r13),%xmm2
xor    %edx,%edx
cmpl   $0x1,0xd4(%r13)
01
sete   %dl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%eax
mov    %eax,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%al
mov    %eax,%ebx
and    $0x33,%bl
shr    $0x2,%al
and    $0x33,%al
add    %bl,%al
mov    %eax,%ebx
shr    $0x4,%bl
add    %al,%bl
and    $0xf,%bl
movzbl %bl,%eax
add    %edx,%eax
add    %ecx,%eax
movdqu 0xd8(%r13),%xmm1
movdqu 0xe8(%r13),%xmm2
xor    %edx,%edx
cmpl   $0x1,0xf8(%r13)
01
sete   %dl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ecx
mov    %ecx,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%cl
mov    %ecx,%ebx
and    $0x33,%bl
shr    $0x2,%cl
and    $0x33,%cl
add    %bl,%cl
mov    %ecx,%ebx
shr    $0x4,%bl
add    %cl,%bl
and    $0xf,%bl
movzbl %bl,%ecx
add    %edx,%ecx
add    %eax,%ecx
movdqu 0xfc(%r13),%xmm1
movdqu 0x10c(%r13),%xmm2
xor    %edx,%edx
cmpl   $0x1,0x11c(%r13)
01
sete   %dl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%eax
mov    %eax,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%al
mov    %eax,%ebx
and    $0x33,%bl
shr    $0x2,%al
and    $0x33,%al
add    %bl,%al
mov    %eax,%ebx
shr    $0x4,%bl
add    %al,%bl
and    $0xf,%bl
movzbl %bl,%eax
add    %edx,%eax
add    %ecx,%eax
movdqu 0x120(%r13),%xmm1
movdqu 0x130(%r13),%xmm2
xor    %ecx,%ecx
cmpl   $0x1,0x140(%r13)
01
sete   %cl
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%edx
mov    %edx,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%dl
mov    %edx,%ebx
and    $0x33,%bl
shr    $0x2,%dl
and    $0x33,%dl
add    %bl,%dl
mov    %edx,%ebx
shr    $0x4,%bl
add    %dl,%bl
and    $0xf,%bl
movzbl %bl,%ebx
add    %ecx,%ebx
add    %eax,%ebx
movslq %r14d,%r15
lea    (%rbx,%rbx,1),%edi
shl    $0x3,%rdi
call   10b0 <malloc@plt>
mov    %rax,%r14
mov    %r13,0x128(%rsp)
mov    %r13,%rdi
mov    %rbx,0x80(%rsp)
mov    %ebx,%esi
mov    %rax,%rdx
mov    $0x5,%ecx
xor    %eax,%eax
call   1050 <getneighbors@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%r13
mov    %r15,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x1a92(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbp,%r15
movslq %r15d,%rbp
lea    0x0(,%rbp,8),%rdi
mov    %rdi,0x98(%rsp)
call   10b0 <malloc@plt>
mov    %rax,%rbx
xor    %eax,%eax
call   1110 <current_time_ns@plt>
mov    %rbx,%rdi
cltq
mov    %rax,0x20(%rsp)
xorps  %xmm2,%xmm2
cvtsi2sd %r15d,%xmm2
mov    %r15,0x8(%rsp)
mov    %r15d,%ebx
mov    %rbp,0x50(%rsp)
test   %ebp,%ebp
jle    176e <particleFilter+0x57e>
movsd  0x19bd(%rip),%xmm0
divsd  %xmm2,%xmm0
cmpl   $0x4,0x8(%rsp)
jae    165d <particleFilter+0x46d>
xor    %eax,%eax
jmp    1760 <particleFilter+0x570>
mov    %ebx,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x1c,%rsi
jae    168b <particleFilter+0x49b>
xor    %esi,%esi
jmp    1725 <particleFilter+0x535>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd %xmm1,(%rdi,%rsi,8)
movupd %xmm1,0x10(%rdi,%rsi,8)
movupd %xmm1,0x20(%rdi,%rsi,8)
movupd %xmm1,0x30(%rdi,%rsi,8)
movupd %xmm1,0x40(%rdi,%rsi,8)
movupd %xmm1,0x50(%rdi,%rsi,8)
movupd %xmm1,0x60(%rdi,%rsi,8)
movupd %xmm1,0x70(%rdi,%rsi,8)
movupd %xmm1,0x80(%rdi,%rsi,8)
movupd %xmm1,0x90(%rdi,%rsi,8)
movupd %xmm1,0xa0(%rdi,%rsi,8)
movupd %xmm1,0xb0(%rdi,%rsi,8)
movupd %xmm1,0xc0(%rdi,%rsi,8)
movupd %xmm1,0xd0(%rdi,%rsi,8)
movupd %xmm1,0xe0(%rdi,%rsi,8)
movupd %xmm1,0xf0(%rdi,%rsi,8)
add    $0x20,%rsi
add    $0xfffffffffffffff8,%rdx
jne    16a0 <particleFilter+0x4b0>
test   %rcx,%rcx
je     1754 <particleFilter+0x564>
lea    (%rdi,%rsi,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1740 <particleFilter+0x550>
cmp    %rbx,%rax
je     176e <particleFilter+0x57e>
nopl   0x0(%rax)
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1760 <particleFilter+0x570>
movapd %xmm2,0x1b0(%rsp)
mov    %rdi,0x10(%rsp)
mov    %r14,0x100(%rsp)
xor    %eax,%eax
mov    %rbx,0x18(%rsp)
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    0x20(%rsp),%rsi
lea    0x1901(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r13,%rdi
mov    %rsi,0x20(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x18fa(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x98(%rsp),%rbx
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,%r14
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0xa0(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,%rbp
mov    0x80(%rsp),%ecx
mov    %rcx,0xf8(%rsp)
mov    0x50(%rsp),%rdi
imul   %rcx,%rdi
shl    $0x2,%rdi
call   10b0 <malloc@plt>
mov    %rax,0xe0(%rsp)
xor    %eax,%eax
call   1110 <current_time_ns@plt>
mov    0x18(%rsp),%rbx
cltq
mov    %rax,0x50(%rsp)
cmpl   $0x0,0x8(%rsp)
jle    19c6 <particleFilter+0x7d6>
cvtsi2sdl 0x48(%rsp),%xmm0
cvtsi2sdl 0x3c(%rsp),%xmm1
cmpl   $0x4,0x8(%rsp)
jae    1894 <particleFilter+0x6a4>
xor    %eax,%eax
jmp    19b0 <particleFilter+0x7c0>
mov    %ebx,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0xc,%rsi
jae    18ca <particleFilter+0x6da>
xor    %esi,%esi
jmp    1959 <particleFilter+0x769>
movabs $0x7ffffffffffffff8,%rsi
ff ff 7f
or     $0x4,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nopl   (%rax)
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm2,0x10(%r14,%rsi,8)
movupd %xmm3,0x0(%r13,%rsi,8)
movupd %xmm3,0x10(%r13,%rsi,8)
movupd %xmm2,0x20(%r14,%rsi,8)
movupd %xmm2,0x30(%r14,%rsi,8)
movupd %xmm3,0x20(%r13,%rsi,8)
movupd %xmm3,0x30(%r13,%rsi,8)
movupd %xmm2,0x40(%r14,%rsi,8)
movupd %xmm2,0x50(%r14,%rsi,8)
movupd %xmm3,0x40(%r13,%rsi,8)
movupd %xmm3,0x50(%r13,%rsi,8)
movupd %xmm2,0x60(%r14,%rsi,8)
movupd %xmm2,0x70(%r14,%rsi,8)
movupd %xmm3,0x60(%r13,%rsi,8)
movupd %xmm3,0x70(%r13,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    18e0 <particleFilter+0x6f0>
test   %rcx,%rcx
je     199f <particleFilter+0x7af>
lea    0x10(,%rsi,8),%rdx
add    %r13,%rdx
lea    (%r14,%rsi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd %xmm2,-0x10(%rsi,%rdi,1)
movupd %xmm2,(%rsi,%rdi,1)
movupd %xmm3,-0x10(%rdx,%rdi,1)
movupd %xmm3,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1980 <particleFilter+0x790>
cmp    %rbx,%rax
je     19c6 <particleFilter+0x7d6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm0,(%r14,%rax,8)
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    19b0 <particleFilter+0x7c0>
mov    %rbp,0x70(%rsp)
mov    %r15,0x78(%rsp)
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    0x50(%rsp),%rsi
lea    0x16f7(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
mov    0x20(%rsp),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x16f4(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    $0x2,%r12d
mov    0x90(%rsp),%r15
jl     28c8 <particleFilter+0x16d8>
mov    0x4c(%rsp),%eax
imul   0x68(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x80(%rsp),%xmm0
movsd  %xmm0,0x98(%rsp)
imul   %r12d,%eax
mov    %eax,0x4c(%rsp)
movsd  0x15b6(%rip),%xmm1
movapd 0x1b0(%rsp),%xmm0
divsd  %xmm0,%xmm1
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x48(%rsp)
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x58(%rsp)
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0xd8(%rsp)
mov    %rdx,%rsi
shr    %rsi
add    $0x1,%rsi
mov    %eax,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x160(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x158(%rsp)
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %eax,%edx
and    $0x7,%edx
mov    %rdx,0xc8(%rsp)
mov    %eax,%edx
and    $0xfffffff8,%edx
mov    %rdx,0x150(%rsp)
mov    %rsi,%rdx
mov    %rsi,0xd0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xc0(%rsp)
mov    %ecx,%edx
and    $0x3,%edx
mov    %rdx,0xe8(%rsp)
mov    %rcx,0xf0(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x140(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x1a0(%rsp)
movapd %xmm1,0x110(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x190(%rsp)
mov    %edi,%ecx
and    $0x7,%ecx
and    $0xfffffffffffffff8,%rdi
mov    %rdi,0x130(%rsp)
mov    %rcx,0x148(%rsp)
shl    $0x5,%rcx
mov    %rcx,0xb8(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x170(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x168(%rsp)
mov    0xf8(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x50(%rsp)
mov    0x10(%rsp),%rax
add    $0x10,%rax
mov    %rax,0x138(%rsp)
mov    $0x1,%eax
mov    %r14,0x60(%rsp)
mov    %r12d,0x6c(%rsp)
mov    %r13,0x108(%rsp)
jmp    1be4 <particleFilter+0x9f4>
nopl   (%rax)
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x177a(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x3c(%rsp),%eax
add    $0x1,%eax
cmp    %r12d,%eax
je     28c8 <particleFilter+0x16d8>
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
call   1080 <get_time@plt>
mov    %eax,0x20(%rsp)
xor    %eax,%eax
call   1110 <current_time_ns@plt>
mov    %eax,0x40(%rsp)
mov    %r14,%rbx
mov    0x8(%rsp),%rax
mov    %rax,%r14
test   %eax,%eax
mov    0x18(%rsp),%rbp
jle    1c76 <particleFilter+0xa86>
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   10f0 <randn@plt>
lea    (%rax,%rax,4),%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rbx,%r12,8),%xmm0
movsd  %xmm0,(%rbx,%r12,8)
mov    %r15,%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   10f0 <randn@plt>
add    %eax,%eax
add    $0xfffffffe,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x0(%r13,%r12,8),%xmm0
movsd  %xmm0,0x0(%r13,%r12,8)
add    $0x1,%r12
cmp    %r12,%rbp
jne    1c20 <particleFilter+0xa30>
movslq 0x20(%rsp),%r12
movslq 0x40(%rsp),%r15
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %r15,%rsi
lea    0x1486(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r12,%rdi
mov    %rsi,0x40(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x147f(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1110 <current_time_ns@plt>
mov    %eax,0xb4(%rsp)
test   %r14d,%r14d
mov    %rbp,%rdx
mov    0x80(%rsp),%r8
mov    0x50(%rsp),%rsi
jle    1e90 <particleFilter+0xca0>
mov    0xe0(%rsp),%rbp
xor    %eax,%eax
jmp    1d36 <particleFilter+0xb46>
nopw   0x0(%rax,%rax,1)
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,8),%r9
movq   $0x0,(%rcx,%rax,8)
xorpd  %xmm0,%xmm0
divsd  0x98(%rsp),%xmm0
movsd  %xmm0,(%r9)
add    $0x1,%rax
add    %rsi,%rbp
cmp    %rdx,%rax
je     1e90 <particleFilter+0xca0>
test   %r8d,%r8d
je     1d00 <particleFilter+0xb10>
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp)
xor    %ebx,%ebx
mov    0x100(%rsp),%r13
mov    0x3c(%rsp),%r12d
mov    %rax,%r14
nopl   0x0(%rax,%rax,1)
movsd  0x20(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <roundDouble@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%r13,%rbx,4),%xmm0
cvttsd2si %xmm0,%r15d
mov    0x108(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    0x50(%rsp),%rsi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x0(%r13,%rbx,4),%xmm0
cvttsd2si %xmm0,%eax
imul   0x68(%rsp),%r15d
add    %eax,%r15d
imul   0x6c(%rsp),%r15d
add    %r12d,%r15d
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
andpd  0x1262(%rip),%xmm0
cvttsd2si %xmm0,%eax
cmp    %eax,0x4c(%rsp)
mov    $0x0,%ecx
cmovle %ecx,%eax
mov    %eax,0x0(%rbp,%rbx,1)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    1d60 <particleFilter+0xb70>
mov    0x88(%rsp),%rcx
lea    (%rcx,%r14,8),%r9
movq   $0x0,(%rcx,%r14,8)
mov    0x80(%rsp),%r8
test   %r8d,%r8d
mov    %r14,%rax
xorpd  %xmm0,%xmm0
je     1e7d <particleFilter+0xc8d>
xor    %ecx,%ecx
mov    0x188(%rsp),%rbx
mov    0xf8(%rsp),%rdi
movdqa 0x120f(%rip),%xmm3
movsd  0x11d7(%rip),%xmm4
nopl   0x0(%rax)
movslq 0x0(%rbp,%rcx,4),%rdx
movd   (%rbx,%rdx,4),%xmm1
pshufd $0x50,%xmm1,%xmm1
paddd  %xmm3,%xmm1
cvtdq2pd %xmm1,%xmm1
mulpd  %xmm1,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm4,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1e40 <particleFilter+0xc50>
movsd  %xmm0,(%r9)
mov    0x18(%rsp),%rdx
mov    0x60(%rsp),%rbx
jmp    1d18 <particleFilter+0xb28>
nopl   0x0(%rax)
movslq 0xb4(%rsp),%rbx
xor    %eax,%eax
mov    %rdx,%rbp
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %rbx,%rsi
lea    0x12a7(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%r13
mov    0x40(%rsp),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x12a0(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1110 <current_time_ns@plt>
mov    %eax,%r12d
mov    0x8(%rsp),%rax
mov    %rax,%r15
test   %eax,%eax
mov    0x10(%rsp),%rax
mov    0x88(%rsp),%r14
jle    1f3f <particleFilter+0xd4f>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  (%r14,%rbx,8),%xmm0
call   10c0 <exp@plt>
mov    0x10(%rsp),%rax
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1f10 <particleFilter+0xd20>
movslq %r12d,%rbx
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %rbx,%rsi
lea    0x1242(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%r12
mov    %r13,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x123d(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1110 <current_time_ns@plt>
test   %r15d,%r15d
mov    0x108(%rsp),%r13
jle    1fd0 <particleFilter+0xde0>
cmpq   $0x7,0xf0(%rsp)
jae    1ff0 <particleFilter+0xe00>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x10(%rsp),%rdx
mov    0x60(%rsp),%r14
mov    0x78(%rsp),%rbp
mov    0x70(%rsp),%r15
mov    0xc8(%rsp),%rsi
jmp    2058 <particleFilter+0xe68>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    0x60(%rsp),%r14
mov    0x78(%rsp),%rbp
mov    0x70(%rsp),%r15
jmp    207e <particleFilter+0xe8e>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x10(%rsp),%rdx
mov    0x60(%rsp),%r14
mov    0x78(%rsp),%rbp
mov    0x70(%rsp),%r15
mov    0xc8(%rsp),%rsi
mov    0x150(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
addsd  (%rdx,%rcx,8),%xmm0
addsd  0x8(%rdx,%rcx,8),%xmm0
addsd  0x10(%rdx,%rcx,8),%xmm0
addsd  0x18(%rdx,%rcx,8),%xmm0
addsd  0x20(%rdx,%rcx,8),%xmm0
addsd  0x28(%rdx,%rcx,8),%xmm0
addsd  0x30(%rdx,%rcx,8),%xmm0
addsd  0x38(%rdx,%rcx,8),%xmm0
add    $0x8,%rcx
cmp    %rcx,%rdi
jne    2020 <particleFilter+0xe30>
test   %rsi,%rsi
je     207e <particleFilter+0xe8e>
lea    (%rdx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rcx,%rdx,8),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    2070 <particleFilter+0xe80>
movapd %xmm0,0x20(%rsp)
movslq %eax,%rbx
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %rbx,%rsi
lea    0x1137(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r12,%rdi
mov    %rsi,0x40(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x1130(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movapd 0x20(%rsp),%xmm3
mov    0x10(%rsp),%rsi
cmpl   $0x0,0x8(%rsp)
mov    0x18(%rsp),%rdi
jle    2197 <particleFilter+0xfa7>
cmpl   $0x1,0x8(%rsp)
jne    2100 <particleFilter+0xf10>
xor    %ecx,%ecx
jmp    2180 <particleFilter+0xf90>
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x0,0xd8(%rsp)
je     2883 <particleFilter+0x1693>
mov    0xc0(%rsp),%rdx
xor    %ecx,%ecx
mov    0x58(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movupd (%rsi,%rcx,8),%xmm1
movupd 0x10(%rsi,%rcx,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rcx,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rsi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2130 <particleFilter+0xf40>
testb  $0x1,0xd0(%rsp)
01
je     2170 <particleFilter+0xf80>
movupd (%rsi,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rcx,8)
mov    %rbx,%rcx
cmp    %rdi,%rbx
je     2197 <particleFilter+0xfa7>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    2180 <particleFilter+0xf90>
movslq %eax,%rbx
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %rbx,%rsi
lea    0x1062(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%r12
mov    0x40(%rsp),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x105b(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1110 <current_time_ns@plt>
cmpl   $0x0,0x8(%rsp)
jle    2270 <particleFilter+0x1080>
cmpq   $0x0,0xf0(%rsp)
je     2280 <particleFilter+0x1090>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x10(%rsp),%rdx
mov    0x58(%rsp),%rsi
nop
movsd  0x0(%r13,%rcx,8),%xmm2
movsd  0x8(%r13,%rcx,8),%xmm3
movhpd (%r14,%rcx,8),%xmm2
movsd  (%rdx,%rcx,8),%xmm1
movsd  0x8(%rdx,%rcx,8),%xmm4
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movhpd 0x8(%r14,%rcx,8),%xmm3
unpcklpd %xmm4,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm1,%xmm0
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    2210 <particleFilter+0x1020>
addpd  %xmm1,%xmm4
jmp    2286 <particleFilter+0x1096>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm4,%xmm4
jmp    22b3 <particleFilter+0x10c3>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x18(%rsp),%rdx
test   $0x1,%dl
je     22b3 <particleFilter+0x10c3>
movsd  0x0(%r13,%rcx,8),%xmm1
movhpd (%r14,%rcx,8),%xmm1
mov    0x10(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm4
unpcklpd %xmm4,%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm0,%xmm4
movapd %xmm4,0x20(%rsp)
movslq %eax,%rbx
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %rbx,%rsi
lea    0xf84(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rbx
mov    %r12,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0xf7f(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
movaps 0x20(%rsp),%xmm0
movhlps %xmm0,%xmm0
lea    0xf85(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0xf80(%rip),%rdi
movaps 0x20(%rsp),%xmm0
mov    $0x1,%al
call   1060 <printf@plt>
movsd  0x180(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    %eax,%r12d
movsd  0x178(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <roundDouble@plt>
movd   %r12d,%xmm0
movd   %eax,%xmm1
punpckldq %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm0
movapd 0x20(%rsp),%xmm1
subpd  %xmm0,%xmm1
mulpd  %xmm1,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xc9b(%rip),%xmm0
jb     2390 <particleFilter+0x11a0>
mov    %rbx,%r12
sqrtsd %xmm0,%xmm0
jmp    2398 <particleFilter+0x11a8>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%r12
call   1100 <sqrt@plt>
mov    0xe8(%rsp),%rbx
lea    0xeef(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rsp),%rdx
movsd  (%rdx),%xmm0
movsd  %xmm0,0x0(%rbp)
cmpl   $0x2,0x8(%rsp)
jl     2463 <particleFilter+0x1273>
mov    $0x1,%eax
cmpq   $0x3,0x168(%rsp)
jb     242d <particleFilter+0x123d>
xor    %eax,%eax
mov    0x140(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
addsd  0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
addsd  0x18(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
addsd  0x20(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x20(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    23f0 <particleFilter+0x1200>
add    $0x1,%rax
test   %rbx,%rbx
je     2463 <particleFilter+0x1273>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    2450 <particleFilter+0x1260>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r12,%rdi
mov    %rsi,0x20(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0xe21(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x90(%rsp),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   10d0 <randu@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   1110 <current_time_ns@plt>
cmpl   $0x0,0x8(%rsp)
movapd 0x1b0(%rsp),%xmm4
mov    0x18(%rsp),%rsi
jle    25ae <particleFilter+0x13be>
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
mulsd  0x110(%rsp),%xmm0
cmpl   $0x1,0x8(%rsp)
jne    24e0 <particleFilter+0x12f0>
xor    %ecx,%ecx
jmp    2590 <particleFilter+0x13a0>
nop
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xd8(%rsp)
je     289d <particleFilter+0x16ad>
mov    0xc0(%rsp),%rdx
xor    %ecx,%ecx
movdqa 0xb47(%rip),%xmm2
mov    0x58(%rsp),%rdi
movapd 0x1a0(%rsp),%xmm5
movdqa 0xb41(%rip),%xmm6
movdqa 0xb49(%rip),%xmm7
nopw   0x0(%rax,%rax,1)
cvtdq2pd %xmm2,%xmm3
divpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,(%r15,%rcx,8)
movdqa %xmm2,%xmm3
paddd  %xmm6,%xmm3
cvtdq2pd %xmm3,%xmm3
divpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,0x10(%r15,%rcx,8)
add    $0x4,%rcx
paddd  %xmm7,%xmm2
add    $0xfffffffffffffffe,%rdx
jne    2530 <particleFilter+0x1340>
testb  $0x1,0xd0(%rsp)
01
je     2587 <particleFilter+0x1397>
cvtdq2pd %xmm2,%xmm2
divpd  %xmm5,%xmm2
addpd  %xmm2,%xmm1
movupd %xmm1,(%r15,%rcx,8)
mov    %rdi,%rcx
cmp    %rsi,%rdi
je     25ae <particleFilter+0x13be>
nop
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    2590 <particleFilter+0x13a0>
movslq %eax,%rbx
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %rbx,%rsi
lea    0xcfe(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    0x20(%rsp),%rdi
mov    %rsi,0x20(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0xcf5(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1110 <current_time_ns@plt>
mov    %eax,0x40(%rsp)
cmpl   $0x0,0x8(%rsp)
mov    0x6c(%rsp),%r12d
jle    2680 <particleFilter+0x1490>
xor    %ebx,%ebx
jmp    2655 <particleFilter+0x1465>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ecx,%rax
movsd  (%r14,%rax,8),%xmm0
mov    0xa8(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
movsd  0x0(%r13,%rax,8),%xmm0
mov    0xa0(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,0x18(%rsp)
je     2680 <particleFilter+0x1490>
movsd  (%r15,%rbx,8),%xmm0
mov    %rbp,%rdi
mov    0x8(%rsp),%rsi
mov    $0x1,%al
call   1070 <findIndex@plt>
mov    0x48(%rsp),%ecx
cmp    $0xffffffff,%eax
je     2620 <particleFilter+0x1430>
mov    %eax,%ecx
jmp    2620 <particleFilter+0x1430>
nopw   0x0(%rax,%rax,1)
movslq 0x40(%rsp),%rbx
xor    %eax,%eax
call   1110 <current_time_ns@plt>
movslq %eax,%rsi
sub    %rbx,%rsi
lea    0xc63(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rbp
mov    0x20(%rsp),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0xc5c(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmpl   $0x0,0x8(%rsp)
mov    0x90(%rsp),%r15
jle    1bb0 <particleFilter+0x9c0>
mov    %r14,%rdi
mov    0xa8(%rsp),%rsi
mov    0x170(%rsp),%rbx
mov    %rbx,%rdx
call   1090 <memcpy@plt>
mov    %r13,%rdi
mov    0xa0(%rsp),%rsi
mov    %rbx,%rdx
call   1090 <memcpy@plt>
cmpl   $0x4,0x8(%rsp)
jae    2730 <particleFilter+0x1540>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rsi
movapd 0x110(%rsp),%xmm0
jmp    2870 <particleFilter+0x1680>
nopl   0x0(%rax,%rax,1)
cmpq   $0x1c,0x158(%rsp)
jae    2766 <particleFilter+0x1576>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rsi
movapd 0x110(%rsp),%xmm0
movapd 0x190(%rsp),%xmm1
mov    0xb8(%rsp),%rdi
jmp    2825 <particleFilter+0x1635>
mov    0x130(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rsi
movapd 0x110(%rsp),%xmm0
movapd 0x190(%rsp),%xmm1
mov    0xb8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd %xmm1,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
movupd %xmm1,0x20(%rdx,%rax,8)
movupd %xmm1,0x30(%rdx,%rax,8)
movupd %xmm1,0x40(%rdx,%rax,8)
movupd %xmm1,0x50(%rdx,%rax,8)
movupd %xmm1,0x60(%rdx,%rax,8)
movupd %xmm1,0x70(%rdx,%rax,8)
movupd %xmm1,0x80(%rdx,%rax,8)
movupd %xmm1,0x90(%rdx,%rax,8)
movupd %xmm1,0xa0(%rdx,%rax,8)
movupd %xmm1,0xb0(%rdx,%rax,8)
movupd %xmm1,0xc0(%rdx,%rax,8)
movupd %xmm1,0xd0(%rdx,%rax,8)
movupd %xmm1,0xe0(%rdx,%rax,8)
movupd %xmm1,0xf0(%rdx,%rax,8)
add    $0x20,%rax
add    $0xfffffffffffffff8,%rcx
jne    27a0 <particleFilter+0x15b0>
cmpq   $0x0,0x148(%rsp)
je     2854 <particleFilter+0x1664>
mov    0x138(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
xor    %ecx,%ecx
xchg   %ax,%ax
movupd %xmm1,-0x10(%rax,%rcx,1)
movupd %xmm1,(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdi
jne    2840 <particleFilter+0x1650>
mov    0x160(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     1bb0 <particleFilter+0x9c0>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2870 <particleFilter+0x1680>
jmp    1bb0 <particleFilter+0x9c0>
xor    %ecx,%ecx
mov    0x58(%rsp),%rbx
testb  $0x1,0xd0(%rsp)
01
jne    2162 <particleFilter+0xf72>
jmp    2170 <particleFilter+0xf80>
xor    %ecx,%ecx
movdqa 0x7a9(%rip),%xmm2
mov    0x58(%rsp),%rdi
movapd 0x1a0(%rsp),%xmm5
testb  $0x1,0xd0(%rsp)
01
jne    2575 <particleFilter+0x1385>
jmp    2587 <particleFilter+0x1397>
mov    0x128(%rsp),%rdi
call   1030 <free@plt>
mov    0x100(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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