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);
#pragma omp parallel for shared(weights, Nparticles) private(x)
  for (x = 0; x < Nparticles; x++) {
    weights[x] = 1 / ((double)(Nparticles));
  }
  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);
#pragma omp parallel for shared(arrayX, arrayY, xe, ye) private(x)
  for (x = 0; x < Nparticles; x++) {
    arrayX[x] = xe;
    arrayY[x] = ye;
  }
  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();
#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);
    }
    long long error = get_time();
    printf("TIME TO SET ERROR TOOK: %f\n", elapsed_time(set_arrays, error));
#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);
    }
    long long likelihood_time = get_time();
    printf("TIME TO GET LIKELIHOODS TOOK: %f\n",
           elapsed_time(error, likelihood_time));
#pragma omp parallel for shared(Nparticles, weights, likelihood) private(x)
    for (x = 0; x < Nparticles; x++) {
      weights[x] = weights[x] * exp(likelihood[x]);
    }
    long long exponential = get_time();
    printf("TIME TO GET EXP TOOK: %f\n",
           elapsed_time(likelihood_time, exponential));
    double sumWeights = 0;
#pragma omp parallel for private(x) reduction(+ : sumWeights)
    for (x = 0; x < Nparticles; x++) {
      sumWeights += weights[x];
    }
    long long sum_time = get_time();
    printf("TIME TO SUM WEIGHTS TOOK: %f\n",
           elapsed_time(exponential, sum_time));
#pragma omp parallel for shared(sumWeights, weights) private(x)
    for (x = 0; x < Nparticles; x++) {
      weights[x] = weights[x] / sumWeights;
    }
    long long normalize = get_time();
    printf("TIME TO NORMALIZE WEIGHTS TOOK: %f\n",
           elapsed_time(sum_time, normalize));
    xe = 0;
    ye = 0;
#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];
    }
    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);
#pragma omp parallel for shared(u, u1, Nparticles) private(x)
    for (x = 0; x < Nparticles; x++) {
      u[x] = u1 + x / ((double)(Nparticles));
    }
    long long u_time = get_time();
    printf("TIME TO CALC U TOOK: %f\n", elapsed_time(cum_sum, u_time));
    int j, i;
#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];
    }
    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    $0x180,%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  0xdd8(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0xdb7(%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    130c <particleFilter+0x12c>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    12f9 <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    12e6 <particleFilter+0x106>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12eb <particleFilter+0x10b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12b6 <particleFilter+0xd6>
jmp    12fe <particleFilter+0x11e>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12a3 <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    0xcd4(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13b3 <particleFilter+0x1d3>
cvtsi2sdl -0x24(%rbp),%xmm1
movsd  0xc74(%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    137b <particleFilter+0x19b>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x80(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0xc78(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x90(%rbp)
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 -0x54(%rbp),%rdi
shl    $0x2,%rdi
movslq -0x24(%rbp),%rax
imul   %rax,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14d2 <particleFilter+0x2f2>
movsd  -0x38(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%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    148e <particleFilter+0x2ae>
mov    -0x80(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    $0x0,%al
call   1080 <get_time@plt>
mov    -0x150(%rbp),%rdi
mov    %eax,%esi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0xb70(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e9a <particleFilter+0xcba>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    15aa <particleFilter+0x3ca>
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    -0x90(%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    -0x98(%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    1534 <particleFilter+0x354>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0xd8(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0xab2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1819 <particleFilter+0x639>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    170e <particleFilter+0x52e>
mov    -0x90(%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,-0xc8(%rbp)
mov    -0x98(%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,-0xcc(%rbp)
mov    -0xc8(%rbp),%eax
imul   -0x10(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0xcc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xc4(%rbp),%eax
cvtsi2sd %eax,%xmm0
movaps 0x97f(%rip),%xmm1
pand   %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0xc0(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc0(%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     16fb <particleFilter+0x51b>
mov    -0xc0(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1700 <particleFilter+0x520>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    15f9 <particleFilter+0x419>
mov    -0x88(%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    17e2 <particleFilter+0x602>
mov    -0x8(%rbp),%rax
mov    -0xc0(%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  0x89e(%rip),%xmm1
call   10f0 <pow@plt>
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0xc0(%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  0x861(%rip),%xmm1
call   10f0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x158(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  0x855(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x88(%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    1728 <particleFilter+0x548>
mov    -0x88(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15e6 <particleFilter+0x406>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0xe8(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0xe8(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x85f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    18b5 <particleFilter+0x6d5>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x88(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10b0 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x160(%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    1855 <particleFilter+0x675>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0xf0(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x7e5(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1933 <particleFilter+0x753>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    18fc <particleFilter+0x71c>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    -0xf0(%rbp),%rdi
mov    -0x100(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x781(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    19ab <particleFilter+0x7cb>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xf8(%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    196f <particleFilter+0x78f>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    -0x100(%rbp),%rdi
mov    -0x108(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x727(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1a6f <particleFilter+0x88f>
mov    -0x90(%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    -0x98(%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    19f7 <particleFilter+0x817>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    -0x108(%rbp),%rdi
mov    -0x110(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x687(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movsd  -0x38(%rbp),%xmm0
lea    0x692(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x40(%rbp),%xmm0
lea    0x688(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
cvtsi2sdl -0x10(%rbp),%xmm0
movsd  0x51c(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
movsd  -0x178(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  0x4f9(%rip),%xmm1
call   10f0 <pow@plt>
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0x4d2(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    $0x1,%al
call   1090 <roundDouble@plt>
movsd  -0x170(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  0x4af(%rip),%xmm1
call   10f0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x168(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
call   1100 <sqrt@plt>
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
lea    0x5c5(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x78(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xb0(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1bee <particleFilter+0xa0e>
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1ba2 <particleFilter+0x9c2>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x120(%rbp)
mov    -0x110(%rbp),%rdi
mov    -0x120(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x538(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cvtsi2sdl -0x24(%rbp),%xmm1
movsd  0x3d8(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0x0,%al
call   10c0 <randu@plt>
movsd  -0x180(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1cac <particleFilter+0xacc>
movsd  -0x128(%rbp),%xmm0
ff
cvtsi2sdl -0x58(%rbp),%xmm1
cvtsi2sdl -0x24(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1c68 <particleFilter+0xa88>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x130(%rbp)
mov    -0x120(%rbp),%rdi
mov    -0x130(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x499(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1d9d <particleFilter+0xbbd>
mov    -0xb0(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0xb8(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x1,%al
call   1070 <findIndex@plt>
mov    %eax,-0x138(%rbp)
cmpl   $0xffffffff,-0x138(%rbp)
jne    1d3d <particleFilter+0xb5d>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x138(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x138(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
movslq -0x138(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1ceb <particleFilter+0xb0b>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x140(%rbp)
mov    -0x130(%rbp),%rdi
mov    -0x140(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x3c1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1e51 <particleFilter+0xc71>
mov    -0xa0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x24(%rbp),%xmm1
movsd  0x1d6(%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    1dd9 <particleFilter+0xbf9>
mov    $0x0,%al
call   1080 <get_time@plt>
cltq
mov    %rax,-0x148(%rbp)
mov    -0x140(%rbp),%rdi
mov    -0x148(%rbp),%rsi
mov    $0x0,%al
call   1040 <elapsed_time@plt>
mov    %eax,%esi
lea    0x336(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    150e <particleFilter+0x32e>
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    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%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    -0xc0(%rbp),%rdi
call   1030 <free@plt>
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<particleFilter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %r9d,%r15d
mov    %r8,0x58(%rsp)
mov    %ecx,%r12d
mov    %edx,%ebx
mov    %esi,%ebp
mov    %rdi,0x178(%rsp)
xor    %eax,%eax
call   1080 <get_time@plt>
mov    %eax,0x18(%rsp)
mov    %ebx,0x4c(%rsp)
cvtsi2sd %ebx,%xmm0
mulsd  0x1ddd(%rip),%xmm0
movsd  %xmm0,0x168(%rsp)
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    %eax,0x50(%rsp)
mov    %ebp,0x34(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0x1db6(%rip),%xmm0
movsd  %xmm0,0x160(%rsp)
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    %eax,0x68(%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 0x1d92(%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,%r14d
add    %ecx,%r14d
add    %eax,%r14d
movslq 0x18(%rsp),%rbx
lea    (%r14,%r14,1),%edi
shl    $0x3,%rdi
call   10b0 <malloc@plt>
mov    %r13,0x108(%rsp)
mov    %r13,%rdi
mov    %r14d,%esi
mov    %rax,0xe0(%rsp)
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    %rbx,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x1aa3(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
movslq %r15d,%rbp
lea    0x0(,%rbp,8),%rbx
mov    %rbx,%rdi
call   10b0 <malloc@plt>
xorps  %xmm2,%xmm2
cvtsi2sd %r15d,%xmm2
mov    %r15d,%ecx
test   %ebp,%ebp
jle    172e <particleFilter+0x54e>
movsd  0x19f4(%rip),%xmm0
divsd  %xmm2,%xmm0
cmp    $0x4,%r15d
jae    1625 <particleFilter+0x445>
xor    %edi,%edi
jmp    1720 <particleFilter+0x540>
mov    %ecx,%edi
and    $0xfffffffc,%edi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rdi),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x7,%r8d
cmp    $0x1c,%rsi
jae    1655 <particleFilter+0x475>
xor    %esi,%esi
jmp    16e5 <particleFilter+0x505>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd %xmm1,(%rax,%rsi,8)
movupd %xmm1,0x10(%rax,%rsi,8)
movupd %xmm1,0x20(%rax,%rsi,8)
movupd %xmm1,0x30(%rax,%rsi,8)
movupd %xmm1,0x40(%rax,%rsi,8)
movupd %xmm1,0x50(%rax,%rsi,8)
movupd %xmm1,0x60(%rax,%rsi,8)
movupd %xmm1,0x70(%rax,%rsi,8)
movupd %xmm1,0x80(%rax,%rsi,8)
movupd %xmm1,0x90(%rax,%rsi,8)
movupd %xmm1,0xa0(%rax,%rsi,8)
movupd %xmm1,0xb0(%rax,%rsi,8)
movupd %xmm1,0xc0(%rax,%rsi,8)
movupd %xmm1,0xd0(%rax,%rsi,8)
movupd %xmm1,0xe0(%rax,%rsi,8)
movupd %xmm1,0xf0(%rax,%rsi,8)
add    $0x20,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1660 <particleFilter+0x480>
test   %r8,%r8
je     1714 <particleFilter+0x534>
lea    (%rax,%rsi,8),%rdx
add    $0x10,%rdx
shl    $0x5,%r8
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    1700 <particleFilter+0x520>
cmp    %rcx,%rdi
je     172e <particleFilter+0x54e>
nopl   0x0(%rax)
movsd  %xmm0,(%rax,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1720 <particleFilter+0x540>
movapd %xmm2,0x1a0(%rsp)
mov    %rax,(%rsp)
xor    %eax,%eax
mov    %rcx,0x8(%rsp)
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r13,%rdi
mov    %rsi,0x20(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x1940(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x78(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %rbx,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %r14d,%ecx
mov    %rcx,0xd0(%rsp)
imul   %rcx,%rbp
shl    $0x2,%rbp
mov    %rbp,%rdi
call   10b0 <malloc@plt>
mov    0x18(%rsp),%rbp
mov    0x8(%rsp),%rcx
mov    %rax,0xb8(%rsp)
test   %r15d,%r15d
mov    0x58(%rsp),%rbx
jle    1956 <particleFilter+0x776>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x50(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x68(%rsp),%xmm1
cmp    $0x4,%r15d
jae    181f <particleFilter+0x63f>
xor    %eax,%eax
jmp    1940 <particleFilter+0x760>
mov    %ecx,%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,%r8d
and    $0x3,%r8d
cmp    $0xc,%rsi
jae    1857 <particleFilter+0x677>
xor    %esi,%esi
jmp    18e2 <particleFilter+0x702>
movabs $0x7ffffffffffffff8,%rsi
ff ff 7f
or     $0x4,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd %xmm2,0x0(%r13,%rsi,8)
movupd %xmm2,0x10(%r13,%rsi,8)
movupd %xmm3,0x0(%rbp,%rsi,8)
movupd %xmm3,0x10(%rbp,%rsi,8)
movupd %xmm2,0x20(%r13,%rsi,8)
movupd %xmm2,0x30(%r13,%rsi,8)
movupd %xmm3,0x20(%rbp,%rsi,8)
movupd %xmm3,0x30(%rbp,%rsi,8)
movupd %xmm2,0x40(%r13,%rsi,8)
movupd %xmm2,0x50(%r13,%rsi,8)
movupd %xmm3,0x40(%rbp,%rsi,8)
movupd %xmm3,0x50(%rbp,%rsi,8)
movupd %xmm2,0x60(%r13,%rsi,8)
movupd %xmm2,0x70(%r13,%rsi,8)
movupd %xmm3,0x60(%rbp,%rsi,8)
movupd %xmm3,0x70(%rbp,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1870 <particleFilter+0x690>
test   %r8,%r8
je     192f <particleFilter+0x74f>
lea    0x10(,%rsi,8),%rdx
add    %rbp,%rdx
lea    0x10(,%rsi,8),%rsi
add    %r13,%rsi
shl    $0x5,%r8
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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,%r8
jne    1910 <particleFilter+0x730>
cmp    %rcx,%rax
je     1956 <particleFilter+0x776>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1940 <particleFilter+0x760>
xor    %eax,%eax
call   1080 <get_time@plt>
mov    0x20(%rsp),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x174b(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    $0x2,%r12d
mov    0x34(%rsp),%ebp
jl     2668 <particleFilter+0x1488>
imul   0x4c(%rsp),%ebp
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  %xmm0,0x68(%rsp)
imul   %r12d,%ebp
movsd  0x1660(%rip),%xmm1
movapd 0x1a0(%rsp),%xmm0
divsd  %xmm0,%xmm1
lea    -0x1(%r15),%eax
mov    %eax,0x8c(%rsp)
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x38(%rsp)
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0xb0(%rsp)
mov    %rdx,%rsi
shr    %rsi
add    $0x1,%rsi
mov    %eax,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x140(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x138(%rsp)
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %eax,%edx
and    $0x7,%edx
mov    %rdx,0xa0(%rsp)
mov    %eax,%edx
and    $0xfffffff8,%edx
mov    %rdx,0x130(%rsp)
mov    %rsi,%rdx
mov    %rsi,0xa8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x98(%rsp)
mov    %ecx,%edx
and    $0x3,%edx
mov    %rdx,0x158(%rsp)
mov    %rcx,0xc0(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x120(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x190(%rsp)
movapd %xmm1,0xf0(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x180(%rsp)
mov    %edi,%ecx
and    $0x7,%ecx
and    $0xfffffffffffffff8,%rdi
mov    %rdi,0x110(%rsp)
mov    %rcx,0x128(%rsp)
shl    $0x5,%rcx
mov    %rcx,0x90(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x150(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x148(%rsp)
mov    0xd0(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x50(%rsp)
mov    (%rsp),%rax
add    $0x10,%rax
mov    %rax,0x118(%rsp)
mov    $0x1,%eax
mov    %r14,0xe8(%rsp)
mov    %r15,0xc8(%rsp)
mov    %r12d,0x14(%rsp)
mov    %r13,0xd8(%rsp)
mov    %ebp,0x34(%rsp)
jmp    1b46 <particleFilter+0x966>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    0x20(%rsp),%rdi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x16d8(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x48(%rsp),%eax
add    $0x1,%eax
cmp    %r12d,%eax
je     2668 <particleFilter+0x1488>
mov    %eax,0x48(%rsp)
xor    %eax,%eax
call   1080 <get_time@plt>
mov    %eax,0x20(%rsp)
test   %r15d,%r15d
mov    0x8(%rsp),%r15
mov    0x18(%rsp),%rbp
jle    1bc8 <particleFilter+0x9e8>
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
mov    %rbx,%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  0x0(%r13,%r12,8),%xmm0
movsd  %xmm0,0x0(%r13,%r12,8)
mov    %rbx,%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(%rbp,%r12,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r12,8)
add    $0x1,%r12
cmp    %r12,%r15
jne    1b70 <particleFilter+0x990>
movslq 0x20(%rsp),%r12
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r12,%rdi
mov    %rsi,0x170(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x14ea(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmpl   $0x0,0xc8(%rsp)
mov    0x60(%rsp),%r12
mov    0x50(%rsp),%rdi
jle    1da0 <particleFilter+0xbc0>
mov    0xb8(%rsp),%rsi
xor    %eax,%eax
jmp    1c4b <particleFilter+0xa6b>
nopl   (%rax)
lea    (%r12,%rax,8),%r8
movq   $0x0,(%r12,%rax,8)
xorpd  %xmm0,%xmm0
divsd  0x68(%rsp),%xmm0
movsd  %xmm0,(%r8)
add    $0x1,%rax
add    %rdi,%rsi
cmp    %r15,%rax
je     1da0 <particleFilter+0xbc0>
test   %r14d,%r14d
je     1c20 <particleFilter+0xa40>
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp)
xor    %ebx,%ebx
mov    0xe0(%rsp),%rbp
mov    0x48(%rsp),%r13d
mov    %rax,%r15
nop
movsd  0x20(%rsp),%xmm0
mov    $0x1,%al
mov    %rsi,%r12
call   10a0 <roundDouble@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rbp,%rbx,4),%xmm0
cvttsd2si %xmm0,%r14d
mov    0x18(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    %r12,%rsi
mov    0x50(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x0(%rbp,%rbx,4),%xmm0
cvttsd2si %xmm0,%eax
imul   0x4c(%rsp),%r14d
add    %eax,%r14d
imul   0x14(%rsp),%r14d
add    %r13d,%r14d
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
andpd  0x1351(%rip),%xmm0
cvttsd2si %xmm0,%eax
cmp    %eax,0x34(%rsp)
mov    $0x0,%ecx
cmovle %ecx,%eax
mov    %eax,(%r12,%rbx,1)
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    1c70 <particleFilter+0xa90>
mov    0x60(%rsp),%r12
lea    (%r12,%r15,8),%r8
movq   $0x0,(%r12,%r15,8)
mov    0xe8(%rsp),%r14
test   %r14d,%r14d
mov    %r15,%rax
xorpd  %xmm0,%xmm0
je     1d8c <particleFilter+0xbac>
xor    %ecx,%ecx
mov    0x178(%rsp),%rbx
mov    0xd0(%rsp),%rbp
movdqa 0x1301(%rip),%xmm3
movsd  0x12c9(%rip),%xmm4
nopw   0x0(%rax,%rax,1)
movslq (%rsi,%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,%rbp
jne    1d50 <particleFilter+0xb70>
movsd  %xmm0,(%r8)
mov    0x8(%rsp),%r15
mov    0xd8(%rsp),%r13
jmp    1c30 <particleFilter+0xa50>
xchg   %ax,%ax
xor    %eax,%eax
mov    %r15,%rbp
call   1080 <get_time@plt>
movslq %eax,%r14
mov    0x170(%rsp),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x1330(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0xc8(%rsp),%r15
test   %r15d,%r15d
mov    (%rsp),%rax
jle    1e1e <particleFilter+0xc3e>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  (%r12,%rbx,8),%xmm0
call   10c0 <exp@plt>
mov    (%rsp),%rax
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1df0 <particleFilter+0xc10>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%r12
mov    %r14,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x12dc(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
test   %r15d,%r15d
jle    1e70 <particleFilter+0xc90>
cmpq   $0x7,0xc0(%rsp)
jae    1e80 <particleFilter+0xca0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    (%rsp),%rcx
mov    0x40(%rsp),%rbx
mov    0xa0(%rsp),%rdx
jmp    1ed8 <particleFilter+0xcf8>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
mov    0x40(%rsp),%rbx
jmp    1efe <particleFilter+0xd1e>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    (%rsp),%rcx
mov    0x40(%rsp),%rbx
mov    0xa0(%rsp),%rdx
mov    0x130(%rsp),%rsi
nop
addsd  (%rcx,%rax,8),%xmm0
addsd  0x8(%rcx,%rax,8),%xmm0
addsd  0x10(%rcx,%rax,8),%xmm0
addsd  0x18(%rcx,%rax,8),%xmm0
addsd  0x20(%rcx,%rax,8),%xmm0
addsd  0x28(%rcx,%rax,8),%xmm0
addsd  0x30(%rcx,%rax,8),%xmm0
addsd  0x38(%rcx,%rax,8),%xmm0
add    $0x8,%rax
cmp    %rax,%rsi
jne    1ea0 <particleFilter+0xcc0>
test   %rdx,%rdx
je     1efe <particleFilter+0xd1e>
lea    (%rcx,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rax,%rcx,8),%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1ef0 <particleFilter+0xd10>
movapd %xmm0,0x20(%rsp)
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rbp
mov    %r12,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x1210(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
movapd 0x20(%rsp),%xmm3
mov    (%rsp),%rdx
test   %r15d,%r15d
mov    0x8(%rsp),%rsi
jle    1fe7 <particleFilter+0xe07>
cmp    $0x1,%r15d
jne    1f50 <particleFilter+0xd70>
xor    %eax,%eax
jmp    1fd0 <particleFilter+0xdf0>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x0,0xb0(%rsp)
je     2623 <particleFilter+0x1443>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
mov    0x38(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movupd (%rdx,%rax,8),%xmm1
movupd 0x10(%rdx,%rax,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rax,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rdx,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f80 <particleFilter+0xda0>
testb  $0x1,0xa8(%rsp)
01
je     1fc0 <particleFilter+0xde0>
movupd (%rdx,%rax,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rax,8)
mov    %rdi,%rax
cmp    %rsi,%rdi
je     1fe7 <particleFilter+0xe07>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1fd0 <particleFilter+0xdf0>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%r12
mov    %rbp,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x114b(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
test   %r15d,%r15d
jle    2090 <particleFilter+0xeb0>
cmpq   $0x0,0xc0(%rsp)
je     20a0 <particleFilter+0xec0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    (%rsp),%rcx
mov    0x18(%rsp),%rdx
mov    0x38(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm2
movsd  0x8(%rdx,%rax,8),%xmm3
movhpd 0x0(%r13,%rax,8),%xmm2
movsd  (%rcx,%rax,8),%xmm1
movsd  0x8(%rcx,%rax,8),%xmm4
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movhpd 0x8(%r13,%rax,8),%xmm3
unpcklpd %xmm4,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm1,%xmm0
add    $0x2,%rax
cmp    %rax,%rsi
jne    2040 <particleFilter+0xe60>
addpd  %xmm1,%xmm4
jmp    20a6 <particleFilter+0xec6>
nop
xorpd  %xmm4,%xmm4
jmp    20d6 <particleFilter+0xef6>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x8(%rsp),%rcx
test   $0x1,%cl
je     20d6 <particleFilter+0xef6>
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
movhpd 0x0(%r13,%rax,8),%xmm1
mov    (%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm4
unpcklpd %xmm4,%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm0,%xmm4
movapd %xmm4,0x20(%rsp)
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r12,%rdi
mov    %rsi,%rbp
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0x107a(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
movaps 0x20(%rsp),%xmm0
movhlps %xmm0,%xmm0
lea    0x1080(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x107b(%rip),%rdi
movaps 0x20(%rsp),%xmm0
mov    $0x1,%al
call   1060 <printf@plt>
movsd  0x168(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <roundDouble@plt>
mov    %eax,%r12d
movsd  0x160(%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 0xe96(%rip),%xmm0
jb     2190 <particleFilter+0xfb0>
sqrtsd %xmm0,%xmm0
jmp    2195 <particleFilter+0xfb5>
nopw   0x0(%rax,%rax,1)
call   1100 <sqrt@plt>
mov    0x14(%rsp),%r12d
lea    0xff5(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    (%rsp),%rdx
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rbx)
cmp    $0x2,%r15d
mov    0x158(%rsp),%rsi
jl     2243 <particleFilter+0x1063>
mov    $0x1,%eax
cmpq   $0x3,0x148(%rsp)
jb     221d <particleFilter+0x103d>
xor    %eax,%eax
mov    0x120(%rsp),%rcx
addsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
addsd  0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
addsd  0x18(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
addsd  0x20(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x20(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    21e0 <particleFilter+0x1000>
add    $0x1,%rax
test   %rsi,%rsi
je     2243 <particleFilter+0x1063>
lea    (%rbx,%rax,8),%rcx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax)
addsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    2230 <particleFilter+0x1050>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0xf43(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x58(%rsp),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   10d0 <randu@plt>
test   %r15d,%r15d
movapd 0x1a0(%rsp),%xmm4
mov    0x8(%rsp),%rdx
mov    0x80(%rsp),%rsi
jle    238d <particleFilter+0x11ad>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xf0(%rsp),%xmm0
cmp    $0x1,%r15d
jne    22c0 <particleFilter+0x10e0>
xor    %eax,%eax
jmp    2370 <particleFilter+0x1190>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xb0(%rsp)
je     263d <particleFilter+0x145d>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
movdqa 0xd67(%rip),%xmm2
mov    0x38(%rsp),%rdi
movapd 0x190(%rsp),%xmm5
movdqa 0xd61(%rip),%xmm6
movdqa 0xd69(%rip),%xmm7
nopw   0x0(%rax,%rax,1)
cvtdq2pd %xmm2,%xmm3
divpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,(%rsi,%rax,8)
movdqa %xmm2,%xmm3
paddd  %xmm6,%xmm3
cvtdq2pd %xmm3,%xmm3
divpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rsi,%rax,8)
add    $0x4,%rax
paddd  %xmm7,%xmm2
add    $0xfffffffffffffffe,%rcx
jne    2310 <particleFilter+0x1130>
testb  $0x1,0xa8(%rsp)
01
je     2364 <particleFilter+0x1184>
cvtdq2pd %xmm2,%xmm2
divpd  %xmm5,%xmm2
addpd  %xmm2,%xmm1
movupd %xmm1,(%rsi,%rax,8)
mov    %rdi,%rax
cmp    %rdx,%rdi
je     238d <particleFilter+0x11ad>
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    2370 <particleFilter+0x1190>
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%r14
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0xe18(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
test   %r15d,%r15d
jle    2420 <particleFilter+0x1240>
xor    %ebx,%ebx
jmp    23f3 <particleFilter+0x1213>
nopl   (%rax)
movslq %ecx,%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x78(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x70(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
je     2420 <particleFilter+0x1240>
mov    0x80(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    0x40(%rsp),%rdi
mov    %r15d,%esi
mov    $0x1,%al
call   1070 <findIndex@plt>
mov    0x8c(%rsp),%ecx
cmp    $0xffffffff,%eax
je     23c0 <particleFilter+0x11e0>
mov    %eax,%ecx
jmp    23c0 <particleFilter+0x11e0>
nop
xor    %eax,%eax
call   1080 <get_time@plt>
movslq %eax,%rsi
mov    %r14,%rdi
mov    %rsi,0x20(%rsp)
xor    %eax,%eax
call   1040 <elapsed_time@plt>
lea    0xd9c(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1060 <printf@plt>
test   %r15d,%r15d
mov    0xe8(%rsp),%r14
mov    0x58(%rsp),%rbx
jle    1b10 <particleFilter+0x930>
mov    %r13,%rdi
mov    0x78(%rsp),%rsi
mov    0x150(%rsp),%r12
mov    %r12,%rdx
call   1090 <memcpy@plt>
mov    0x18(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %r12,%rdx
call   1090 <memcpy@plt>
mov    %r15,%r8
cmp    $0x4,%r15d
jae    24c0 <particleFilter+0x12e0>
xor    %eax,%eax
mov    (%rsp),%rdx
mov    0x8(%rsp),%rsi
movapd 0xf0(%rsp),%xmm0
mov    0x14(%rsp),%r12d
mov    %r8,%r15
jmp    2610 <particleFilter+0x1430>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x1c,0x138(%rsp)
jae    24fd <particleFilter+0x131d>
xor    %eax,%eax
mov    (%rsp),%rdx
mov    0x8(%rsp),%rsi
movapd 0xf0(%rsp),%xmm0
movapd 0x180(%rsp),%xmm1
mov    0x90(%rsp),%rdi
mov    0x14(%rsp),%r12d
mov    %r8,%r15
jmp    25c5 <particleFilter+0x13e5>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
mov    (%rsp),%rdx
mov    0x8(%rsp),%rsi
movapd 0xf0(%rsp),%xmm0
movapd 0x180(%rsp),%xmm1
mov    0x90(%rsp),%rdi
mov    0x14(%rsp),%r12d
mov    %r8,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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    2540 <particleFilter+0x1360>
cmpq   $0x0,0x128(%rsp)
je     25f4 <particleFilter+0x1414>
mov    0x118(%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    25e0 <particleFilter+0x1400>
mov    0x140(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     1b10 <particleFilter+0x930>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2610 <particleFilter+0x1430>
jmp    1b10 <particleFilter+0x930>
xor    %eax,%eax
mov    0x38(%rsp),%rdi
testb  $0x1,0xa8(%rsp)
01
jne    1fb2 <particleFilter+0xdd2>
jmp    1fc0 <particleFilter+0xde0>
xor    %eax,%eax
movdqa 0xa09(%rip),%xmm2
mov    0x38(%rsp),%rdi
movapd 0x190(%rsp),%xmm5
testb  $0x1,0xa8(%rsp)
01
jne    2353 <particleFilter+0x1173>
jmp    2364 <particleFilter+0x1184>
mov    0x108(%rsp),%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
add    $0x1b8,%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 = [29 x i8] c"TIME TO GET WEIGHTSTOOK: %f\0A\00"
@.str.2 = [29 x i8] c"TIME TO SET ARRAYS TOOK: %f\0A\00"
@.str.3 = [28 x i8] c"TIME TO SET ERROR TOOK: %f\0A\00"
@.str.4 = [34 x i8] c"TIME TO GET LIKELIHOODS TOOK: %f\0A\00"
@.str.5 = [26 x i8] c"TIME TO GET EXP TOOK: %f\0A\00"
@.str.6 = [30 x i8] c"TIME TO SUM WEIGHTS TOOK: %f\0A\00"
@.str.7 = [36 x i8] c"TIME TO NORMALIZE WEIGHTS TOOK: %f\0A\00"
@.str.8 = [30 x i8] c"TIME TO MOVE OBJECT TOOK: %f\0A\00"
@.str.9 = [9 x i8] c"XE: %lf\0A\00"
@.str.10 = [9 x i8] c"YE: %lf\0A\00"
@.str.11 = [5 x i8] c"%lf\0A\00"
@.str.12 = [31 x i8] c"TIME TO CALC CUM SUM TOOK: %f\0A\00"
@.str.13 = [25 x i8] c"TIME TO CALC U TOOK: %f\0A\00"
@.str.14 = [41 x i8] c"TIME TO CALC NEW ARRAY X AND Y TOOK: %f\0A\00"
@.str.15 = [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 double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca i32*
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i64
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca double
%43 = alloca i64
%44 = alloca i64
%45 = alloca i64
%46 = alloca double
%47 = alloca i64
%48 = alloca double
%49 = alloca i64
%50 = alloca i32
%51 = alloca i32
%52 = alloca i64
%53 = 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
%54 = load i32, i32* %8
%55 = load i32, i32* %9
%56 = mul nsw i32 %54, %55
%57 = load i32, i32* %10
%58 = mul nsw i32 %56, %57
store i32 %58, i32* %13
%59 = call i32 (...) @get_time()
%60 = sext i32 %59 to i64
store i64 %60, i64* %14
%61 = load i32, i32* %9
%62 = sitofp i32 %61 to double
%63 = fdiv double %62, 2.000000e+00
%64 = call i32 (double, ...) bitcast (i32 (...)* @roundDouble to i32 (double, ...)*)(double %63)
%65 = sitofp i32 %64 to double
store double %65, double* %15
%66 = load i32, i32* %8
%67 = sitofp i32 %66 to double
%68 = fdiv double %67, 2.000000e+00
%69 = call i32 (double, ...) bitcast (i32 (...)* @roundDouble to i32 (double, ...)*)(double %68)
%70 = sitofp i32 %69 to double
store double %70, double* %16
store i32 5, i32* %17
%71 = load i32, i32* %17
%72 = mul nsw i32 %71, 2
%73 = sub nsw i32 %72, 1
store i32 %73, i32* %18
%74 = load i32, i32* %18
%75 = load i32, i32* %18
%76 = mul nsw i32 %74, %75
%77 = sext i32 %76 to i64
%78 = mul i64 %77, 4
%79 = call i8* @malloc(i64 %78)
%80 = bitcast i8* %79 to i32*
store i32* %80, i32** %19
%81 = load i32*, i32** %19
%82 = load i32, i32* %17
%83 = call i32 (i32*, i32, ...) bitcast (i32 (...)* @strelDisk to i32 (i32*, i32, ...)*)(i32* %81, i32 %82)
store i32 0, i32* %20
store i32 0, i32* %21
br label %84
84: ; preds = %112, %6
%85 = load i32, i32* %21
%86 = load i32, i32* %18
%87 = icmp slt i32 %85, %86
br i1 %87, label %88, label %115
88: ; preds = %84
store i32 0, i32* %22
br label %89
89: ; preds = %108, %88
%90 = load i32, i32* %22
%91 = load i32, i32* %18
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %111
93: ; preds = %89
%94 = load i32*, i32** %19
%95 = load i32, i32* %21
%96 = load i32, i32* %18
%97 = mul nsw i32 %95, %96
%98 = load i32, i32* %22
%99 = add nsw i32 %97, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %94, i64 %100
%102 = load i32, i32* %101
%103 = icmp eq i32 %102, 1
br i1 %103, label %104, label %107
104: ; preds = %93
%105 = load i32, i32* %20
%106 = add nsw i32 %105, 1
store i32 %106, i32* %20
br label %107
107: ; preds = %104, %93
br label %108
108: ; preds = %107
%109 = load i32, i32* %22
%110 = add nsw i32 %109, 1
store i32 %110, i32* %22
br label %89
111: ; preds = %89
br label %112
112: ; preds = %111
%113 = load i32, i32* %21
%114 = add nsw i32 %113, 1
store i32 %114, i32* %21
br label %84
115: ; preds = %84
%116 = load i32, i32* %20
%117 = mul nsw i32 %116, 2
%118 = sext i32 %117 to i64
%119 = mul i64 %118, 8
%120 = call i8* @malloc(i64 %119)
%121 = bitcast i8* %120 to double*
store double* %121, double** %23
%122 = load i32*, i32** %19
%123 = load i32, i32* %20
%124 = load double*, double** %23
%125 = load i32, i32* %17
%126 = call i32 (i32*, i32, double*, i32, ...) bitcast (i32 (...)* @getneighbors to i32 (i32*, i32, double*, i32, ...)*)(i32* %122, i32 %123, double* %124, i32 %125)
%127 = call i32 (...) @get_time()
%128 = sext i32 %127 to i64
store i64 %128, i64* %24
%129 = load i64, i64* %14
%130 = load i64, i64* %24
%131 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %129, i64 %130)
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i32 %131)
%133 = load i32, i32* %12
%134 = sext i32 %133 to i64
%135 = mul i64 8, %134
%136 = call i8* @malloc(i64 %135)
%137 = bitcast i8* %136 to double*
store double* %137, double** %25
store i32 0, i32* %21
br label %138
138: ; preds = %150, %115
%139 = load i32, i32* %21
%140 = load i32, i32* %12
%141 = icmp slt i32 %139, %140
br i1 %141, label %142, label %153
142: ; preds = %138
%143 = load i32, i32* %12
%144 = sitofp i32 %143 to double
%145 = fdiv double 1.000000e+00, %144
%146 = load double*, double** %25
%147 = load i32, i32* %21
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
store double %145, double* %149
br label %150
150: ; preds = %142
%151 = load i32, i32* %21
%152 = add nsw i32 %151, 1
store i32 %152, i32* %21
br label %138
153: ; preds = %138
%154 = call i32 (...) @get_time()
%155 = sext i32 %154 to i64
store i64 %155, i64* %26
%156 = load i64, i64* %24
%157 = load i64, i64* %26
%158 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %156, i64 %157)
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), i32 %158)
%160 = load i32, i32* %12
%161 = sext i32 %160 to i64
%162 = mul i64 8, %161
%163 = call i8* @malloc(i64 %162)
%164 = bitcast i8* %163 to double*
store double* %164, double** %27
%165 = load i32, i32* %12
%166 = sext i32 %165 to i64
%167 = mul i64 8, %166
%168 = call i8* @malloc(i64 %167)
%169 = bitcast i8* %168 to double*
store double* %169, double** %28
%170 = load i32, i32* %12
%171 = sext i32 %170 to i64
%172 = mul i64 8, %171
%173 = call i8* @malloc(i64 %172)
%174 = bitcast i8* %173 to double*
store double* %174, double** %29
%175 = load i32, i32* %12
%176 = sext i32 %175 to i64
%177 = mul i64 8, %176
%178 = call i8* @malloc(i64 %177)
%179 = bitcast i8* %178 to double*
store double* %179, double** %30
%180 = load i32, i32* %12
%181 = sext i32 %180 to i64
%182 = mul i64 8, %181
%183 = call i8* @malloc(i64 %182)
%184 = bitcast i8* %183 to double*
store double* %184, double** %31
%185 = load i32, i32* %12
%186 = sext i32 %185 to i64
%187 = mul i64 8, %186
%188 = call i8* @malloc(i64 %187)
%189 = bitcast i8* %188 to double*
store double* %189, double** %32
%190 = load i32, i32* %12
%191 = sext i32 %190 to i64
%192 = mul i64 8, %191
%193 = call i8* @malloc(i64 %192)
%194 = bitcast i8* %193 to double*
store double* %194, double** %33
%195 = load i32, i32* %20
%196 = sext i32 %195 to i64
%197 = mul i64 4, %196
%198 = load i32, i32* %12
%199 = sext i32 %198 to i64
%200 = mul i64 %197, %199
%201 = call i8* @malloc(i64 %200)
%202 = bitcast i8* %201 to i32*
store i32* %202, i32** %34
store i32 0, i32* %21
br label %203
203: ; preds = %218, %153
%204 = load i32, i32* %21
%205 = load i32, i32* %12
%206 = icmp slt i32 %204, %205
br i1 %206, label %207, label %221
207: ; preds = %203
%208 = load double, double* %15
%209 = load double*, double** %28
%210 = load i32, i32* %21
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
store double %208, double* %212
%213 = load double, double* %16
%214 = load double*, double** %29
%215 = load i32, i32* %21
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %214, i64 %216
store double %213, double* %217
br label %218
218: ; preds = %207
%219 = load i32, i32* %21
%220 = add nsw i32 %219, 1
store i32 %220, i32* %21
br label %203
221: ; preds = %203
%222 = load i64, i64* %26
%223 = call i32 (...) @get_time()
%224 = call i32 (i64, i32, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i32, ...)*)(i64 %222, i32 %223)
%225 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i32 %224)
store i32 1, i32* %35
br label %226
226: ; preds = %733, %221
%227 = load i32, i32* %35
%228 = load i32, i32* %10
%229 = icmp slt i32 %227, %228
br i1 %229, label %230, label %736
230: ; preds = %226
%231 = call i32 (...) @get_time()
%232 = sext i32 %231 to i64
store i64 %232, i64* %38
store i32 0, i32* %21
br label %233
233: ; preds = %262, %230
%234 = load i32, i32* %21
%235 = load i32, i32* %12
%236 = icmp slt i32 %234, %235
br i1 %236, label %237, label %265
237: ; preds = %233
%238 = load i32*, i32** %11
%239 = load i32, i32* %21
%240 = call i32 (i32*, i32, ...) bitcast (i32 (...)* @randn to i32 (i32*, i32, ...)*)(i32* %238, i32 %239)
%241 = mul nsw i32 5, %240
%242 = add nsw i32 1, %241
%243 = sitofp i32 %242 to double
%244 = load double*, double** %28
%245 = load i32, i32* %21
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %244, i64 %246
%248 = load double, double* %247
%249 = fadd double %248, %243
store double %249, double* %247
%250 = load i32*, i32** %11
%251 = load i32, i32* %21
%252 = call i32 (i32*, i32, ...) bitcast (i32 (...)* @randn to i32 (i32*, i32, ...)*)(i32* %250, i32 %251)
%253 = mul nsw i32 2, %252
%254 = add nsw i32 -2, %253
%255 = sitofp i32 %254 to double
%256 = load double*, double** %29
%257 = load i32, i32* %21
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %256, i64 %258
%260 = load double, double* %259
%261 = fadd double %260, %255
store double %261, double* %259
br label %262
262: ; preds = %237
%263 = load i32, i32* %21
%264 = add nsw i32 %263, 1
store i32 %264, i32* %21
br label %233
265: ; preds = %233
%266 = call i32 (...) @get_time()
%267 = sext i32 %266 to i64
store i64 %267, i64* %39
%268 = load i64, i64* %38
%269 = load i64, i64* %39
%270 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %268, i64 %269)
%271 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0), i32 %270)
store i32 0, i32* %21
br label %272
272: ; preds = %425, %265
%273 = load i32, i32* %21
%274 = load i32, i32* %12
%275 = icmp slt i32 %273, %274
br i1 %275, label %276, label %428
276: ; preds = %272
store i32 0, i32* %22
br label %277
277: ; preds = %356, %276
%278 = load i32, i32* %22
%279 = load i32, i32* %20
%280 = icmp slt i32 %278, %279
br i1 %280, label %281, label %359
281: ; preds = %277
%282 = load double*, double** %28
%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 = call i32 (double, ...) bitcast (i32 (...)* @roundDouble to i32 (double, ...)*)(double %286)
%288 = sitofp i32 %287 to double
%289 = load double*, double** %23
%290 = load i32, i32* %22
%291 = mul nsw i32 %290, 2
%292 = add nsw i32 %291, 1
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %289, i64 %293
%295 = load double, double* %294
%296 = fadd double %288, %295
%297 = fptosi double %296 to i32
store i32 %297, i32* %36
%298 = load double*, double** %29
%299 = load i32, i32* %21
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %298, i64 %300
%302 = load double, double* %301
%303 = call i32 (double, ...) bitcast (i32 (...)* @roundDouble to i32 (double, ...)*)(double %302)
%304 = sitofp i32 %303 to double
%305 = load double*, double** %23
%306 = load i32, i32* %22
%307 = mul nsw i32 %306, 2
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %305, i64 %308
%310 = load double, double* %309
%311 = fadd double %304, %310
%312 = fptosi double %311 to i32
store i32 %312, i32* %37
%313 = load i32, i32* %36
%314 = load i32, i32* %9
%315 = mul nsw i32 %313, %314
%316 = load i32, i32* %10
%317 = mul nsw i32 %315, %316
%318 = load i32, i32* %37
%319 = load i32, i32* %10
%320 = mul nsw i32 %318, %319
%321 = add nsw i32 %317, %320
%322 = load i32, i32* %35
%323 = add nsw i32 %321, %322
%324 = sitofp i32 %323 to double
%325 = call double @llvm.fabs.f64(double %324)
%326 = fptosi double %325 to i32
%327 = load i32*, i32** %34
%328 = load i32, i32* %21
%329 = load i32, i32* %20
%330 = mul nsw i32 %328, %329
%331 = load i32, i32* %22
%332 = add nsw i32 %330, %331
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i32, i32* %327, i64 %333
store i32 %326, i32* %334
%335 = load i32*, i32** %34
%336 = load i32, i32* %21
%337 = load i32, i32* %20
%338 = mul nsw i32 %336, %337
%339 = load i32, i32* %22
%340 = add nsw i32 %338, %339
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %335, i64 %341
%343 = load i32, i32* %342
%344 = load i32, i32* %13
%345 = icmp sge i32 %343, %344
br i1 %345, label %346, label %355
346: ; preds = %281
%347 = load i32*, i32** %34
%348 = load i32, i32* %21
%349 = load i32, i32* %20
%350 = mul nsw i32 %348, %349
%351 = load i32, i32* %22
%352 = add nsw i32 %350, %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds i32, i32* %347, i64 %353
store i32 0, i32* %354
br label %355
355: ; preds = %346, %281
br label %356
356: ; preds = %355
%357 = load i32, i32* %22
%358 = add nsw i32 %357, 1
store i32 %358, i32* %22
br label %277
359: ; preds = %277
%360 = load double*, double** %27
%361 = load i32, i32* %21
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %360, i64 %362
store double 0.000000e+00, double* %363
store i32 0, i32* %22
br label %364
364: ; preds = %409, %359
%365 = load i32, i32* %22
%366 = load i32, i32* %20
%367 = icmp slt i32 %365, %366
br i1 %367, label %368, label %412
368: ; preds = %364
%369 = load i32*, i32** %7
%370 = load i32*, i32** %34
%371 = load i32, i32* %21
%372 = load i32, i32* %20
%373 = mul nsw i32 %371, %372
%374 = load i32, i32* %22
%375 = add nsw i32 %373, %374
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i32, i32* %370, i64 %376
%378 = load i32, i32* %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %369, i64 %379
%381 = load i32, i32* %380
%382 = sub nsw i32 %381, 100
%383 = sitofp i32 %382 to double
%384 = call double @pow(double %383, double 2.000000e+00)
%385 = load i32*, i32** %7
%386 = load i32*, i32** %34
%387 = load i32, i32* %21
%388 = load i32, i32* %20
%389 = mul nsw i32 %387, %388
%390 = load i32, i32* %22
%391 = add nsw i32 %389, %390
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds i32, i32* %386, i64 %392
%394 = load i32, i32* %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %385, i64 %395
%397 = load i32, i32* %396
%398 = sub nsw i32 %397, 228
%399 = sitofp i32 %398 to double
%400 = call double @pow(double %399, double 2.000000e+00)
%401 = fsub double %384, %400
%402 = fdiv double %401, 5.000000e+01
%403 = load double*, double** %27
%404 = load i32, i32* %21
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double, double* %403, i64 %405
%407 = load double, double* %406
%408 = fadd double %407, %402
store double %408, double* %406
br label %409
409: ; preds = %368
%410 = load i32, i32* %22
%411 = add nsw i32 %410, 1
store i32 %411, i32* %22
br label %364
412: ; preds = %364
%413 = load double*, double** %27
%414 = load i32, i32* %21
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %413, i64 %415
%417 = load double, double* %416
%418 = load i32, i32* %20
%419 = sitofp i32 %418 to double
%420 = fdiv double %417, %419
%421 = load double*, double** %27
%422 = load i32, i32* %21
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %421, i64 %423
store double %420, double* %424
br label %425
425: ; preds = %412
%426 = load i32, i32* %21
%427 = add nsw i32 %426, 1
store i32 %427, i32* %21
br label %272
428: ; preds = %272
%429 = call i32 (...) @get_time()
%430 = sext i32 %429 to i64
store i64 %430, i64* %40
%431 = load i64, i64* %39
%432 = load i64, i64* %40
%433 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %431, i64 %432)
%434 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %433)
store i32 0, i32* %21
br label %435
435: ; preds = %456, %428
%436 = load i32, i32* %21
%437 = load i32, i32* %12
%438 = icmp slt i32 %436, %437
br i1 %438, label %439, label %459
439: ; preds = %435
%440 = load double*, double** %25
%441 = load i32, i32* %21
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %440, i64 %442
%444 = load double, double* %443
%445 = load double*, double** %27
%446 = load i32, i32* %21
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %445, i64 %447
%449 = load double, double* %448
%450 = call double @exp(double %449)
%451 = fmul double %444, %450
%452 = load double*, double** %25
%453 = load i32, i32* %21
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds double, double* %452, i64 %454
store double %451, double* %455
br label %456
456: ; preds = %439
%457 = load i32, i32* %21
%458 = add nsw i32 %457, 1
store i32 %458, i32* %21
br label %435
459: ; preds = %435
%460 = call i32 (...) @get_time()
%461 = sext i32 %460 to i64
store i64 %461, i64* %41
%462 = load i64, i64* %40
%463 = load i64, i64* %41
%464 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %462, i64 %463)
%465 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0), i32 %464)
store double 0.000000e+00, double* %42
store i32 0, i32* %21
br label %466
466: ; preds = %478, %459
%467 = load i32, i32* %21
%468 = load i32, i32* %12
%469 = icmp slt i32 %467, %468
br i1 %469, label %470, label %481
470: ; preds = %466
%471 = load double*, double** %25
%472 = load i32, i32* %21
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %471, i64 %473
%475 = load double, double* %474
%476 = load double, double* %42
%477 = fadd double %476, %475
store double %477, double* %42
br label %478
478: ; preds = %470
%479 = load i32, i32* %21
%480 = add nsw i32 %479, 1
store i32 %480, i32* %21
br label %466
481: ; preds = %466
%482 = call i32 (...) @get_time()
%483 = sext i32 %482 to i64
store i64 %483, i64* %43
%484 = load i64, i64* %41
%485 = load i64, i64* %43
%486 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %484, i64 %485)
%487 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.6, i64 0, i64 0), i32 %486)
store i32 0, i32* %21
br label %488
488: ; preds = %504, %481
%489 = load i32, i32* %21
%490 = load i32, i32* %12
%491 = icmp slt i32 %489, %490
br i1 %491, label %492, label %507
492: ; preds = %488
%493 = load double*, double** %25
%494 = load i32, i32* %21
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds double, double* %493, i64 %495
%497 = load double, double* %496
%498 = load double, double* %42
%499 = fdiv double %497, %498
%500 = load double*, double** %25
%501 = load i32, i32* %21
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds double, double* %500, i64 %502
store double %499, double* %503
br label %504
504: ; preds = %492
%505 = load i32, i32* %21
%506 = add nsw i32 %505, 1
store i32 %506, i32* %21
br label %488
507: ; preds = %488
%508 = call i32 (...) @get_time()
%509 = sext i32 %508 to i64
store i64 %509, i64* %44
%510 = load i64, i64* %43
%511 = load i64, i64* %44
%512 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %510, i64 %511)
%513 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.7, i64 0, i64 0), i32 %512)
store double 0.000000e+00, double* %15
store double 0.000000e+00, double* %16
store i32 0, i32* %21
br label %514
514: ; preds = %543, %507
%515 = load i32, i32* %21
%516 = load i32, i32* %12
%517 = icmp slt i32 %515, %516
br i1 %517, label %518, label %546
518: ; preds = %514
%519 = load double*, double** %28
%520 = load i32, i32* %21
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
%523 = load double, double* %522
%524 = load double*, double** %25
%525 = load i32, i32* %21
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds double, double* %524, i64 %526
%528 = load double, double* %527
%529 = load double, double* %15
%530 = call double @llvm.fmuladd.f64(double %523, double %528, double %529)
store double %530, double* %15
%531 = load double*, double** %29
%532 = load i32, i32* %21
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds double, double* %531, i64 %533
%535 = load double, double* %534
%536 = load double*, double** %25
%537 = load i32, i32* %21
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds double, double* %536, i64 %538
%540 = load double, double* %539
%541 = load double, double* %16
%542 = call double @llvm.fmuladd.f64(double %535, double %540, double %541)
store double %542, double* %16
br label %543
543: ; preds = %518
%544 = load i32, i32* %21
%545 = add nsw i32 %544, 1
store i32 %545, i32* %21
br label %514
546: ; preds = %514
%547 = call i32 (...) @get_time()
%548 = sext i32 %547 to i64
store i64 %548, i64* %45
%549 = load i64, i64* %44
%550 = load i64, i64* %45
%551 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %549, i64 %550)
%552 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), i32 %551)
%553 = load double, double* %15
%554 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0), double %553)
%555 = load double, double* %16
%556 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i64 0, i64 0), double %555)
%557 = load double, double* %15
%558 = load i32, i32* %9
%559 = sitofp i32 %558 to double
%560 = fdiv double %559, 2.000000e+00
%561 = call i32 (double, ...) bitcast (i32 (...)* @roundDouble to i32 (double, ...)*)(double %560)
%562 = sitofp i32 %561 to double
%563 = fsub double %557, %562
%564 = call double @pow(double %563, double 2.000000e+00)
%565 = load double, double* %16
%566 = load i32, i32* %8
%567 = sitofp i32 %566 to double
%568 = fdiv double %567, 2.000000e+00
%569 = call i32 (double, ...) bitcast (i32 (...)* @roundDouble to i32 (double, ...)*)(double %568)
%570 = sitofp i32 %569 to double
%571 = fsub double %565, %570
%572 = call double @pow(double %571, double 2.000000e+00)
%573 = fadd double %564, %572
%574 = call double @sqrt(double %573)
store double %574, double* %46
%575 = load double, double* %46
%576 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0), double %575)
%577 = load double*, double** %25
%578 = getelementptr inbounds double, double* %577, i64 0
%579 = load double, double* %578
%580 = load double*, double** %32
%581 = getelementptr inbounds double, double* %580, i64 0
store double %579, double* %581
store i32 1, i32* %21
br label %582
582: ; preds = %603, %546
%583 = load i32, i32* %21
%584 = load i32, i32* %12
%585 = icmp slt i32 %583, %584
br i1 %585, label %586, label %606
586: ; preds = %582
%587 = load double*, double** %25
%588 = load i32, i32* %21
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds double, double* %587, i64 %589
%591 = load double, double* %590
%592 = load double*, double** %32
%593 = load i32, i32* %21
%594 = sub nsw i32 %593, 1
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds double, double* %592, i64 %595
%597 = load double, double* %596
%598 = fadd double %591, %597
%599 = load double*, double** %32
%600 = load i32, i32* %21
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %599, i64 %601
store double %598, double* %602
br label %603
603: ; preds = %586
%604 = load i32, i32* %21
%605 = add nsw i32 %604, 1
store i32 %605, i32* %21
br label %582
606: ; preds = %582
%607 = call i32 (...) @get_time()
%608 = sext i32 %607 to i64
store i64 %608, i64* %47
%609 = load i64, i64* %45
%610 = load i64, i64* %47
%611 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %609, i64 %610)
%612 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0), i32 %611)
%613 = load i32, i32* %12
%614 = sitofp i32 %613 to double
%615 = fdiv double 1.000000e+00, %614
%616 = load i32*, i32** %11
%617 = call i32 (i32*, i32, ...) bitcast (i32 (...)* @randu to i32 (i32*, i32, ...)*)(i32* %616, i32 0)
%618 = sitofp i32 %617 to double
%619 = fmul double %615, %618
store double %619, double* %48
store i32 0, i32* %21
br label %620
620: ; preds = %636, %606
%621 = load i32, i32* %21
%622 = load i32, i32* %12
%623 = icmp slt i32 %621, %622
br i1 %623, label %624, label %639
624: ; preds = %620
%625 = load double, double* %48
%626 = load i32, i32* %21
%627 = sitofp i32 %626 to double
%628 = load i32, i32* %12
%629 = sitofp i32 %628 to double
%630 = fdiv double %627, %629
%631 = fadd double %625, %630
%632 = load double*, double** %33
%633 = load i32, i32* %21
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds double, double* %632, i64 %634
store double %631, double* %635
br label %636
636: ; preds = %624
%637 = load i32, i32* %21
%638 = add nsw i32 %637, 1
store i32 %638, i32* %21
br label %620
639: ; preds = %620
%640 = call i32 (...) @get_time()
%641 = sext i32 %640 to i64
store i64 %641, i64* %49
%642 = load i64, i64* %47
%643 = load i64, i64* %49
%644 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %642, i64 %643)
%645 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.13, i64 0, i64 0), i32 %644)
store i32 0, i32* %50
br label %646
646: ; preds = %683, %639
%647 = load i32, i32* %50
%648 = load i32, i32* %12
%649 = icmp slt i32 %647, %648
br i1 %649, label %650, label %686
650: ; preds = %646
%651 = load double*, double** %32
%652 = load i32, i32* %12
%653 = load double*, double** %33
%654 = load i32, i32* %50
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds double, double* %653, i64 %655
%657 = load double, double* %656
%658 = call i32 (double*, i32, double, ...) bitcast (i32 (...)* @findIndex to i32 (double*, i32, double, ...)*)(double* %651, i32 %652, double %657)
store i32 %658, i32* %51
%659 = load i32, i32* %51
%660 = icmp eq i32 %659, -1
br i1 %660, label %661, label %664
661: ; preds = %650
%662 = load i32, i32* %12
%663 = sub nsw i32 %662, 1
store i32 %663, i32* %51
br label %664
664: ; preds = %661, %650
%665 = load double*, double** %28
%666 = load i32, i32* %51
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds double, double* %665, i64 %667
%669 = load double, double* %668
%670 = load double*, double** %30
%671 = load i32, i32* %50
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds double, double* %670, i64 %672
store double %669, double* %673
%674 = load double*, double** %29
%675 = load i32, i32* %51
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds double, double* %674, i64 %676
%678 = load double, double* %677
%679 = load double*, double** %31
%680 = load i32, i32* %50
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double, double* %679, i64 %681
store double %678, double* %682
br label %683
683: ; preds = %664
%684 = load i32, i32* %50
%685 = add nsw i32 %684, 1
store i32 %685, i32* %50
br label %646
686: ; preds = %646
%687 = call i32 (...) @get_time()
%688 = sext i32 %687 to i64
store i64 %688, i64* %52
%689 = load i64, i64* %49
%690 = load i64, i64* %52
%691 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %689, i64 %690)
%692 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.14, i64 0, i64 0), i32 %691)
store i32 0, i32* %21
br label %693
693: ; preds = %723, %686
%694 = load i32, i32* %21
%695 = load i32, i32* %12
%696 = icmp slt i32 %694, %695
br i1 %696, label %697, label %726
697: ; preds = %693
%698 = load double*, double** %30
%699 = load i32, i32* %21
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds double, double* %698, i64 %700
%702 = load double, double* %701
%703 = load double*, double** %28
%704 = load i32, i32* %21
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds double, double* %703, i64 %705
store double %702, double* %706
%707 = load double*, double** %31
%708 = load i32, i32* %21
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds double, double* %707, i64 %709
%711 = load double, double* %710
%712 = load double*, double** %29
%713 = load i32, i32* %21
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds double, double* %712, i64 %714
store double %711, double* %715
%716 = load i32, i32* %12
%717 = sitofp i32 %716 to double
%718 = fdiv double 1.000000e+00, %717
%719 = load double*, double** %25
%720 = load i32, i32* %21
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds double, double* %719, i64 %721
store double %718, double* %722
br label %723
723: ; preds = %697
%724 = load i32, i32* %21
%725 = add nsw i32 %724, 1
store i32 %725, i32* %21
br label %693
726: ; preds = %693
%727 = call i32 (...) @get_time()
%728 = sext i32 %727 to i64
store i64 %728, i64* %53
%729 = load i64, i64* %52
%730 = load i64, i64* %53
%731 = call i32 (i64, i64, ...) bitcast (i32 (...)* @elapsed_time to i32 (i64, i64, ...)*)(i64 %729, i64 %730)
%732 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i32 %731)
br label %733
733: ; preds = %726
%734 = load i32, i32* %35
%735 = add nsw i32 %734, 1
store i32 %735, i32* %35
br label %226
736: ; preds = %226
%737 = load i32*, i32** %19
%738 = bitcast i32* %737 to i8*
%739 = load double*, double** %23
%740 = bitcast double* %739 to i8*
%741 = load double*, double** %25
%742 = bitcast double* %741 to i8*
%743 = load double*, double** %27
%744 = bitcast double* %743 to i8*
%745 = load double*, double** %30
%746 = bitcast double* %745 to i8*
%747 = load double*, double** %31
%748 = bitcast double* %747 to i8*
%749 = load double*, double** %28
%750 = bitcast double* %749 to i8*
%751 = load double*, double** %29
%752 = bitcast double* %751 to i8*
%753 = load double*, double** %32
%754 = bitcast double* %753 to i8*
%755 = load double*, double** %33
%756 = bitcast double* %755 to i8*
%757 = load i32*, i32** %34
%758 = bitcast i32* %757 to i8*
ret void
}

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