#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
scalar_t__ RAND_MAX;
scalar_t__ calloc(int, int);
int /*<<< orphan*/ fflush(int /*<<< orphan*/ *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ free(double *);
scalar_t__ ignuin(int /*<<< orphan*/, int);
double pow(double, double);
scalar_t__ rand();
double sqrt(double);
int /*<<< orphan*/ srand(scalar_t__);
int /*<<< orphan*/ *stderr;
scalar_t__ time(int /*<<< orphan*/ *);
int wham_error_analysis(int nbins, double *counts, double *p0, int nsim,
                        double *simcounts, double **cu, double *avp, double *dp,
                        int nsamples, int npasses, int no_zerocb, int verbose,
                        FILE *samples_file) {
  double *p = (double *)calloc(nbins, sizeof(double));
  double *av2p = (double *)calloc(nbins, sizeof(double));
  double *f = (double *)calloc(nsim, sizeof(double));
  double *fnew = (double *)calloc(nsim, sizeof(double));
  int i, j, jj, m;
  long moves = 0;
  long accepted = 0;
  int pass;
  long seed1 = (long)time(NULL);
  long seed2 = (long)sqrt((double)seed1);
  int bin0, bin1;
  double p1_old, p0_old;
  double t;
  float csi;
  int sample;
  for (j = 0; j < nbins; j++) {
    p[j] = p0[j];
    dp[j] = 0.0;
    avp[j] = 0.0;
  }
  for (i = 0; i < nsim; i++) {
    f[i] = 0.0;
    for (j = 0; j < nbins; j++) {
      f[i] += cu[i][j] * p0[j];
    }
  }
  srand(time(NULL));
  if (verbose)
    fprintf(stderr, "Starting sampling ...\n");
  for (sample = 0; sample < nsamples; sample++) {
    if (verbose)
      fprintf(stderr, "Begin sample %d\n", sample + 1);
    for (pass = 0; pass < npasses; pass++) {
      if (verbose)
        fprintf(stderr, "Begin pass %d\n", pass + 1);
      for (bin1 = 0; bin1 < nbins; bin1++) {
        if (no_zerocb && counts[bin1] <= 0)
          continue;
        moves += 1;
        bin0 = bin1;
        while (bin0 == bin1 || (no_zerocb && counts[bin0] <= 0)) {
          bin0 = (int)ignuin(0, nbins - 1);
        }
        p0_old = p[bin0];
        p1_old = p[bin1];
        for (i = 0; i < nsim; i++) {
          fnew[i] = f[i] + cu[i][bin0] * (p[bin0] - p0_old) +
                    cu[i][bin1] * (p[bin1] - p1_old);
        }
        t = 1.0;
        for (i = 0; i < nsim; i++) {
          t *= pow(f[i] / fnew[i], simcounts[i]);
        }
        csi = ((double)rand() / (double)RAND_MAX);
        if (t > (double)csi) {
          accepted += 1;
          for (i = 0; i < nsim; i++) {
            f[i] = fnew[i];
          }
        } else {
          p[bin0] = p0_old;
          p[bin1] = p1_old;
        }
      }
      if (verbose)
        fprintf(stderr, "End of pass %d\n", pass + 1);
    }
    for (j = 0; j < nbins; j++) {
      t = p[j];
      avp[j] += t;
      av2p[j] += t * t;
      if (samples_file) {
        fprintf(samples_file, "%16.8e\n", t);
      }
    }
    if (samples_file)
      fflush(samples_file);
    if (verbose)
      fprintf(stderr, "End of sample %d\n", sample + 1);
  }
  fprintf(stderr, "Error analysis acceptance ratio: %10.3f\n",
          (double)accepted / (double)moves);
  for (j = 0; j < nbins; j++) {
    avp[j] /= (double)nsamples;
    av2p[j] /= (double)nsamples;
    dp[j] = sqrt((av2p[j] - avp[j] * avp[j]));
  }
  free(p);
  free(av2p);
  free(f);
  free(fnew);
  return 1;
}


x86 assembly (clang, -O0):
<wham_error_analysis>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1080 <time@plt>
mov    %rax,-0x80(%rbp)
cvtsi2sdq -0x80(%rbp),%xmm0
call   10b0 <sqrt@plt>
cvttsd2si %xmm0,%rax
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12ac <wham_error_analysis+0x10c>
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1258 <wham_error_analysis+0xb8>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    133f <wham_error_analysis+0x19f>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    132c <wham_error_analysis+0x18c>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12d6 <wham_error_analysis+0x136>
jmp    1331 <wham_error_analysis+0x191>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12b3 <wham_error_analysis+0x113>
xor    %eax,%eax
mov    %eax,%edi
call   1080 <time@plt>
mov    %rax,%rdi
call   1050 <srand@plt>
cmpl   $0x0,0x38(%rbp)
je     1372 <wham_error_analysis+0x1d2>
mov    0x2c77(%rip),%rax
mov    (%rax),%rdi
lea    0xc9d(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1823 <wham_error_analysis+0x683>
cmpl   $0x0,0x38(%rbp)
je     13b6 <wham_error_analysis+0x216>
mov    0x2c3c(%rip),%rax
mov    (%rax),%rdi
mov    -0xb0(%rbp),%edx
add    $0x1,%edx
lea    0xc70(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1727 <wham_error_analysis+0x587>
cmpl   $0x0,0x38(%rbp)
je     13f1 <wham_error_analysis+0x251>
mov    0x2bfe(%rip),%rax
mov    (%rax),%rdi
mov    -0x74(%rbp),%edx
add    $0x1,%edx
lea    0xc46(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ec <wham_error_analysis+0x54c>
cmpl   $0x0,0x30(%rbp)
je     1432 <wham_error_analysis+0x292>
mov    -0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     1432 <wham_error_analysis+0x292>
jmp    16d8 <wham_error_analysis+0x538>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x90(%rbp),%ecx
mov    %al,-0xb1(%rbp)
je     149e <wham_error_analysis+0x2fe>
xor    %eax,%eax
cmpl   $0x0,0x30(%rbp)
mov    %al,-0xb2(%rbp)
je     1492 <wham_error_analysis+0x2f2>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
setae  %al
mov    %al,-0xb2(%rbp)
mov    -0xb2(%rbp),%al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    14b1 <wham_error_analysis+0x311>
jmp    14c9 <wham_error_analysis+0x329>
mov    -0x4(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1040 <ignuin@plt>
mov    %eax,-0x8c(%rbp)
jmp    144a <wham_error_analysis+0x2aa>
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15a4 <wham_error_analysis+0x404>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x98(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1500 <wham_error_analysis+0x360>
movsd  0xa54(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1611 <wham_error_analysis+0x471>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
call   10a0 <pow@plt>
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    15bb <wham_error_analysis+0x41b>
mov    $0x0,%al
call   10c0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x29c4(%rip),%rax
cvtsi2sdq (%rax),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16a3 <wham_error_analysis+0x503>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    169e <wham_error_analysis+0x4fe>
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    166a <wham_error_analysis+0x4ca>
jmp    16d3 <wham_error_analysis+0x533>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16d8 <wham_error_analysis+0x538>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    13fb <wham_error_analysis+0x25b>
cmpl   $0x0,0x38(%rbp)
je     1714 <wham_error_analysis+0x574>
mov    0x28db(%rip),%rax
mov    (%rax),%rdi
mov    -0x74(%rbp),%edx
add    $0x1,%edx
lea    0x932(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
jmp    1719 <wham_error_analysis+0x579>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13bd <wham_error_analysis+0x21d>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17cb <wham_error_analysis+0x62b>
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpq   $0x0,0x40(%rbp)
je     17b8 <wham_error_analysis+0x618>
mov    0x40(%rbp),%rdi
movsd  -0xa8(%rbp),%xmm0
ff
lea    0x89e(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
jmp    17bd <wham_error_analysis+0x61d>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    172e <wham_error_analysis+0x58e>
cmpq   $0x0,0x40(%rbp)
je     17df <wham_error_analysis+0x63f>
mov    0x40(%rbp),%rdi
call   1090 <fflush@plt>
cmpl   $0x0,0x38(%rbp)
je     180a <wham_error_analysis+0x66a>
mov    0x27e8(%rip),%rax
mov    (%rax),%rdi
mov    -0xb0(%rbp),%edx
add    $0x1,%edx
lea    0x854(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
jmp    180f <wham_error_analysis+0x66f>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    137c <wham_error_analysis+0x1dc>
mov    0x27ae(%rip),%rax
mov    (%rax),%rdi
cvtsi2sdq -0x70(%rbp),%xmm0
cvtsi2sdq -0x68(%rbp),%xmm1
divsd  %xmm1,%xmm0
lea    0x825(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18fa <wham_error_analysis+0x75a>
cvtsi2sdl 0x20(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl 0x20(%rbp),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10b0 <sqrt@plt>
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1852 <wham_error_analysis+0x6b2>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<wham_error_analysis>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0x88(%rsp)
mov    %r8,0x80(%rsp)
mov    %ecx,%ebx
mov    %rdx,%r12
mov    %rsi,0x90(%rsp)
mov    %edi,%r14d
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,0x58(%rsp)
mov    %ebx,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%rbp
mov    %ebx,0x34(%rsp)
mov    %ebx,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
xor    %edi,%edi
call   1080 <time@plt>
test   %rax,%rax
js     1dc1 <wham_error_analysis+0xc11>
mov    0x128(%rsp),%rdi
mov    %r14d,%r13d
test   %r14d,%r14d
mov    %r15,0x20(%rsp)
mov    %r14,0x28(%rsp)
mov    %r13,0x10(%rsp)
jle    14b5 <wham_error_analysis+0x305>
cmp    $0x4,%r14d
jae    12fa <wham_error_analysis+0x14a>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r13b
je     1295 <wham_error_analysis+0xe5>
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movq   $0x0,(%rdi,%rax,8)
mov    0x120(%rsp),%rdx
movq   $0x0,(%rdx,%rax,8)
or     $0x1,%rax
add    %r13,%rcx
mov    0x120(%rsp),%rcx
je     14b5 <wham_error_analysis+0x305>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movq   $0x0,(%rdi,%rax,8)
movq   $0x0,(%rcx,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movq   $0x0,0x8(%rdi,%rax,8)
movq   $0x0,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    12b0 <wham_error_analysis+0x100>
jmp    14b5 <wham_error_analysis+0x305>
lea    (%r15,%r13,8),%rax
lea    (%rdi,%r13,8),%rcx
mov    0x120(%rsp),%r8
lea    (%r8,%r13,8),%rsi
lea    (%r12,%r13,8),%rdx
cmp    %rcx,%r15
setb   0x38(%rsp)
cmp    %rdi,%rax
seta   %r11b
cmp    %rsi,%r15
setb   %r10b
cmp    %r8,%rax
seta   %r9b
cmp    %rdx,%r15
setb   %r14b
cmp    %r12,%rax
seta   0x18(%rsp)
cmp    %rdi,%rsi
seta   %r15b
cmp    %r8,%rcx
seta   0x78(%rsp)
cmp    %rdi,%rdx
seta   %r13b
cmp    %r12,%rcx
seta   %dil
cmp    %r8,%rdx
seta   %r8b
cmp    %r12,%rsi
seta   %sil
xor    %eax,%eax
test   %r11b,0x38(%rsp)
jne    1d9e <wham_error_analysis+0xbee>
and    %r9b,%r10b
jne    1d9e <wham_error_analysis+0xbee>
and    0x18(%rsp),%r14b
jne    1d9e <wham_error_analysis+0xbee>
and    0x78(%rsp),%r15b
mov    0x28(%rsp),%r14
jne    1daa <wham_error_analysis+0xbfa>
and    %dil,%r13b
mov    0x20(%rsp),%r15
jne    1daf <wham_error_analysis+0xbff>
and    %sil,%r8b
mov    0x128(%rsp),%rdi
mov    0x10(%rsp),%r13
jne    1261 <wham_error_analysis+0xb1>
mov    %r13d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1d8d <wham_error_analysis+0xbdd>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
or     $0x2,%rsi
and    %r8,%rsi
xor    %edx,%edx
xorpd  %xmm0,%xmm0
mov    0x120(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movups (%r12,%rdx,8),%xmm1
movups 0x10(%r12,%rdx,8),%xmm2
movups %xmm1,(%r15,%rdx,8)
movups %xmm2,0x10(%r15,%rdx,8)
movupd %xmm0,(%rdi,%rdx,8)
movupd %xmm0,0x10(%rdi,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
movupd 0x20(%r12,%rdx,8),%xmm1
movupd 0x30(%r12,%rdx,8),%xmm2
movupd %xmm1,0x20(%r15,%rdx,8)
movupd %xmm2,0x30(%r15,%rdx,8)
movupd %xmm0,0x20(%rdi,%rdx,8)
movupd %xmm0,0x30(%rdi,%rdx,8)
movupd %xmm0,0x20(%rcx,%rdx,8)
movupd %xmm0,0x30(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1400 <wham_error_analysis+0x250>
test   $0x1,%r8b
je     14ac <wham_error_analysis+0x2fc>
movupd (%r12,%rdx,8),%xmm0
movupd 0x10(%r12,%rdx,8),%xmm1
movupd %xmm0,(%r15,%rdx,8)
movupd %xmm1,0x10(%r15,%rdx,8)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rdi,%rdx,8)
movupd %xmm0,0x10(%rdi,%rdx,8)
mov    0x120(%rsp),%rcx
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
cmp    %r13,%rax
jne    1261 <wham_error_analysis+0xb1>
mov    0x34(%rsp),%eax
mov    %eax,%edi
test   %eax,%eax
mov    0x88(%rsp),%r8
jle    1565 <wham_error_analysis+0x3b5>
mov    %r13d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
jmp    14e9 <wham_error_analysis+0x339>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
cmp    %rdi,%rcx
je     1565 <wham_error_analysis+0x3b5>
movq   $0x0,0x0(%rbp,%rcx,8)
test   %r14d,%r14d
jle    14e0 <wham_error_analysis+0x330>
mov    (%r8,%rcx,8),%rdx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
cmp    $0x1,%r14d
je     1545 <wham_error_analysis+0x395>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm1
mulsd  (%r12,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  0x8(%rdx,%rsi,8),%xmm0
mulsd  0x8(%r12,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1510 <wham_error_analysis+0x360>
test   $0x1,%r13b
je     14e0 <wham_error_analysis+0x330>
movsd  (%rdx,%rsi,8),%xmm1
mulsd  (%r12,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
jmp    14e0 <wham_error_analysis+0x330>
mov    %rdi,0x48(%rsp)
xor    %edi,%edi
call   1080 <time@plt>
mov    %rax,%rdi
call   1050 <srand@plt>
cmpl   $0x0,0x148(%rsp)
je     15a3 <wham_error_analysis+0x3f3>
mov    0x2a4e(%rip),%rax
mov    (%rax),%rcx
lea    0xa7c(%rip),%rdi
mov    $0x16,%esi
mov    $0x1,%edx
call   10c0 <fwrite@plt>
cmpl   $0x0,0x130(%rsp)
mov    0x34(%rsp),%r15d
mov    0x48(%rsp),%rdx
mov    %rbx,0x68(%rsp)
jle    1c6d <wham_error_analysis+0xabd>
lea    -0x1(%r14),%eax
mov    %eax,0x38(%rsp)
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
lea    (%rbx,%rdx,8),%rcx
mov    %edx,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xc0(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xb8(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %edx,%edi
and    $0xfffffffe,%edi
mov    %rdi,0x78(%rsp)
cmp    %rcx,%rbp
setb   %cl
cmp    %rax,%rbx
setb   %al
and    %cl,%al
mov    %al,0xf(%rsp)
mov    %esi,%eax
and    $0x3,%eax
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x98(%rsp)
mov    %edx,%r12d
and    $0x3,%r12d
mov    %rbp,%rcx
add    $0x10,%rcx
mov    %rcx,0xa8(%rsp)
mov    %rbx,%rcx
add    $0x10,%rcx
mov    %rcx,0xa0(%rsp)
mov    %rax,0xb0(%rsp)
shl    $0x5,%rax
mov    %rax,0xd0(%rsp)
xor    %ecx,%ecx
xor    %eax,%eax
mov    %rax,0x70(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    %r12,0xc8(%rsp)
jmp    16b9 <wham_error_analysis+0x509>
nopl   0x0(%rax,%rax,1)
mov    0x2951(%rip),%rax
mov    (%rax),%rdi
mov    0x50(%rsp),%r14
add    $0x1,%r14d
lea    0x9c5(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    %r14,%rcx
mov    0x28(%rsp),%r14
cmp    0x130(%rsp),%ecx
je     1c7b <wham_error_analysis+0xacb>
mov    %rcx,0x50(%rsp)
cmpl   $0x0,0x148(%rsp)
je     16e8 <wham_error_analysis+0x538>
mov    0x2909(%rip),%rax
mov    (%rax),%rdi
mov    0x50(%rsp),%rax
lea    0x1(%rax),%edx
lea    0x946(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
cmpl   $0x0,0x138(%rsp)
jle    1bc0 <wham_error_analysis+0xa10>
xor    %eax,%eax
jmp    1747 <wham_error_analysis+0x597>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x148(%rsp)
je     1bb0 <wham_error_analysis+0xa00>
mov    0x28c3(%rip),%rax
mov    (%rax),%rdi
mov    0x60(%rsp),%r14
add    $0x1,%r14d
lea    0x91f(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    %r14,%rax
mov    0x28(%rsp),%r14
cmp    0x138(%rsp),%eax
je     1bc0 <wham_error_analysis+0xa10>
mov    %rax,0x60(%rsp)
cmpl   $0x0,0x148(%rsp)
je     1776 <wham_error_analysis+0x5c6>
mov    0x287b(%rip),%rax
mov    (%rax),%rdi
mov    0x60(%rsp),%rax
lea    0x1(%rax),%edx
lea    0x8c9(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
test   %r14d,%r14d
jle    1700 <wham_error_analysis+0x550>
xor    %r14d,%r14d
jmp    17b5 <wham_error_analysis+0x605>
mov    0x20(%rsp),%rax
movsd  0xe0(%rsp),%xmm0
movsd  %xmm0,(%rax,%r13,8)
movsd  0xd8(%rsp),%xmm0
movsd  %xmm0,(%rax,%r14,8)
mov    0x10(%rsp),%r13
add    $0x1,%r14
cmp    %r13,%r14
je     1700 <wham_error_analysis+0x550>
cmpl   $0x0,0x140(%rsp)
je     17d3 <wham_error_analysis+0x623>
mov    0x90(%rsp),%rax
xorpd  %xmm0,%xmm0
ucomisd (%rax,%r14,8),%xmm0
jae    17a8 <wham_error_analysis+0x5f8>
addq   $0x1,0x70(%rsp)
mov    %r14,%rax
jmp    17eb <wham_error_analysis+0x63b>
xchg   %ax,%ax
xor    %edi,%edi
mov    0x38(%rsp),%esi
call   1040 <ignuin@plt>
mov    %eax,%ecx
cmp    %r14,%rcx
je     17e0 <wham_error_analysis+0x630>
movslq %eax,%r13
cmpl   $0x0,0x140(%rsp)
je     1813 <wham_error_analysis+0x663>
mov    0x90(%rsp),%rax
xorpd  %xmm0,%xmm0
ucomisd (%rax,%r13,8),%xmm0
jae    17e0 <wham_error_analysis+0x630>
mov    0x20(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
movsd  (%rax,%r14,8),%xmm3
movsd  0x7d4(%rip),%xmm0
mov    %r15d,%ecx
test   %r15d,%r15d
movsd  %xmm2,0xe0(%rsp)
movsd  %xmm3,0xd8(%rsp)
jle    19d0 <wham_error_analysis+0x820>
mov    0x88(%rsp),%rsi
mov    (%rsi),%rax
movapd %xmm2,%xmm0
subsd  %xmm2,%xmm0
mulsd  (%rax,%r13,8),%xmm0
addsd  0x0(%rbp),%xmm0
movapd %xmm3,%xmm1
subsd  %xmm3,%xmm1
mulsd  (%rax,%r14,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
cmp    $0x1,%ecx
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rdi
je     18dc <wham_error_analysis+0x72c>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%r13,8),%xmm0
mov    (%rsi,%rax,8),%rcx
subsd  %xmm2,%xmm0
mulsd  (%rcx,%r13,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%rdx,%r14,8),%xmm1
subsd  %xmm3,%xmm1
mulsd  (%rcx,%r14,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    18a0 <wham_error_analysis+0x6f0>
movsd  0x71c(%rip),%xmm0
mov    %r15d,%ecx
test   %r15d,%r15d
jle    19d0 <wham_error_analysis+0x820>
mov    %rbp,%rbx
xor    %r15d,%r15d
movsd  0x702(%rip),%xmm0
cmp    $0x1,%ecx
jne    190a <wham_error_analysis+0x75a>
mov    0x68(%rsp),%r12
jmp    1975 <wham_error_analysis+0x7c5>
mov    0x80(%rsp),%rbp
mov    0x68(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,0x18(%rsp)
movsd  (%rbx,%r15,8),%xmm0
divsd  (%r12,%r15,8),%xmm0
movsd  0x0(%rbp,%r15,8),%xmm1
call   10a0 <pow@plt>
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x8(%rbx,%r15,8),%xmm0
divsd  0x8(%r12,%r15,8),%xmm0
movsd  0x8(%rbp,%r15,8),%xmm1
call   10a0 <pow@plt>
mulsd  0x18(%rsp),%xmm0
add    $0x2,%r15
cmp    %r15,0x78(%rsp)
jne    1920 <wham_error_analysis+0x770>
testb  $0x1,0x48(%rsp)
mov    0x34(%rsp),%ecx
mov    %rbx,%rbp
mov    %r12,%rbx
mov    0xc8(%rsp),%r12
je     19d0 <wham_error_analysis+0x820>
movsd  %xmm0,0x18(%rsp)
movsd  0x0(%rbp,%r15,8),%xmm0
divsd  (%rbx,%r15,8),%xmm0
mov    0x80(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
mov    %ecx,%r15d
call   10a0 <pow@plt>
mov    %r15d,%ecx
movsd  0x18(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %ecx,%r15d
xor    %eax,%eax
call   10d0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mov    0x25f9(%rip),%rax
xorps  %xmm1,%xmm1
cvtsi2sdq (%rax),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x18(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    1780 <wham_error_analysis+0x5d0>
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
test   %r15d,%r15d
mov    0xd0(%rsp),%rdi
mov    %rcx,0x40(%rsp)
jle    17a3 <wham_error_analysis+0x5f3>
mov    %r15d,%eax
cmp    $0x4,%r15d
setb   %al
or     0xf(%rsp),%al
mov    0x48(%rsp),%rsi
je     1a53 <wham_error_analysis+0x8a3>
xor    %eax,%eax
mov    0x10(%rsp),%r13
jmp    1b31 <wham_error_analysis+0x981>
cmpq   $0xc,0xb8(%rsp)
jae    1a67 <wham_error_analysis+0x8b7>
xor    %eax,%eax
mov    0x10(%rsp),%r13
jmp    1adb <wham_error_analysis+0x92b>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,0x0(%rbp,%rax,8)
movups %xmm1,0x10(%rbp,%rax,8)
movups 0x20(%rbx,%rax,8),%xmm0
movups 0x30(%rbx,%rax,8),%xmm1
movups %xmm0,0x20(%rbp,%rax,8)
movups %xmm1,0x30(%rbp,%rax,8)
movups 0x40(%rbx,%rax,8),%xmm0
movups 0x50(%rbx,%rax,8),%xmm1
movups %xmm0,0x40(%rbp,%rax,8)
movups %xmm1,0x50(%rbp,%rax,8)
movups 0x60(%rbx,%rax,8),%xmm0
movupd 0x70(%rbx,%rax,8),%xmm1
movups %xmm0,0x60(%rbp,%rax,8)
movupd %xmm1,0x70(%rbp,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1a80 <wham_error_analysis+0x8d0>
cmpq   $0x0,0xb0(%rsp)
je     1b1d <wham_error_analysis+0x96d>
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
movups -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1b00 <wham_error_analysis+0x950>
mov    0xc0(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     17a8 <wham_error_analysis+0x5f8>
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
test   %r12,%r12
je     1b65 <wham_error_analysis+0x9b5>
mov    %r12,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1b50 <wham_error_analysis+0x9a0>
cmp    $0x3,%rcx
jb     17a8 <wham_error_analysis+0x5f8>
nop
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1b70 <wham_error_analysis+0x9c0>
jmp    17a8 <wham_error_analysis+0x5f8>
nopl   (%rax)
mov    0x60(%rsp),%rax
add    $0x1,%eax
jmp    1735 <wham_error_analysis+0x585>
nopl   (%rax)
test   %r14d,%r14d
jle    1c40 <wham_error_analysis+0xa90>
xor    %r14d,%r14d
jmp    1bd9 <wham_error_analysis+0xa29>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %r14,%r13
je     1c40 <wham_error_analysis+0xa90>
mov    0x20(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
mov    0x120(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%r14,8)
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mov    0x58(%rsp),%rax
addsd  (%rax,%r14,8),%xmm1
movsd  %xmm1,(%rax,%r14,8)
mov    0x150(%rsp),%rdi
test   %rdi,%rdi
je     1bd0 <wham_error_analysis+0xa20>
lea    0x42e(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
jmp    1bd0 <wham_error_analysis+0xa20>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x150(%rsp),%rdi
test   %rdi,%rdi
je     1c52 <wham_error_analysis+0xaa2>
call   1090 <fflush@plt>
cmpl   $0x0,0x148(%rsp)
jne    1680 <wham_error_analysis+0x4d0>
mov    0x50(%rsp),%rcx
add    $0x1,%ecx
jmp    16a7 <wham_error_analysis+0x4f7>
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x70(%rsp)
mov    0x2356(%rip),%rax
xorps  %xmm0,%xmm0
cvtsi2sdq 0x40(%rsp),%xmm0
mov    (%rax),%rdi
xorps  %xmm1,%xmm1
cvtsi2sdq 0x70(%rsp),%xmm1
divsd  %xmm1,%xmm0
lea    0x3cd(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
test   %r14d,%r14d
mov    0x128(%rsp),%rcx
mov    0x120(%rsp),%r14
mov    0x20(%rsp),%r15
jle    1d52 <wham_error_analysis+0xba2>
xorps  %xmm2,%xmm2
cvtsi2sdl 0x130(%rsp),%xmm2
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
movsd  %xmm2,0x38(%rsp)
jmp    1d15 <wham_error_analysis+0xb65>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   10b0 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x38(%rsp),%xmm2
mov    0x128(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
je     1d52 <wham_error_analysis+0xba2>
movsd  (%r14,%rbx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
mov    0x58(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  (%r14,%rbx,8),%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1cf0 <wham_error_analysis+0xb40>
sqrtsd %xmm0,%xmm0
jmp    1d07 <wham_error_analysis+0xb57>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    1470 <wham_error_analysis+0x2c0>
jmp    14ac <wham_error_analysis+0x2fc>
mov    0x20(%rsp),%r15
mov    0x28(%rsp),%r14
jmp    1daf <wham_error_analysis+0xbff>
mov    0x20(%rsp),%r15
mov    0x128(%rsp),%rdi
mov    0x10(%rsp),%r13
jmp    1261 <wham_error_analysis+0xb1>
cvtsi2sd %rax,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jae    1232 <wham_error_analysis+0x82>
call   10b0 <sqrt@plt>
jmp    1232 <wham_error_analysis+0x82>

LLVM IR (-O0):
@stderr = global i32* null
@.str = [23 x i8] c"Starting sampling ...\0A\00"
@.str.1 = [17 x i8] c"Begin sample %d\0A\00"
@.str.2 = [15 x i8] c"Begin pass %d\0A\00"
@RAND_MAX = global i64 0
@.str.3 = [16 x i8] c"End of pass %d\0A\00"
@.str.4 = [8 x i8] c"%16.8e\0A\00"
@.str.5 = [18 x i8] c"End of sample %d\0A\00"
@.str.6 = [41 x i8] c"Error analysis acceptance ratio: %10.3f\0A\00"
define i32 @wham_error_analysis(i32 %0, double* %1, double* %2, i32 %3, double* %4, double** %5, double* %6, double* %7, i32 %8, i32 %9, i32 %10, i32 %11, i32* %12) {
%14 = alloca i32
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca double*
%19 = alloca double**
%20 = alloca double*
%21 = alloca double*
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i64
%36 = alloca i64
%37 = alloca i32
%38 = alloca i64
%39 = alloca i64
%40 = alloca i32
%41 = alloca i32
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca float
%46 = alloca i32
store i32 %0, i32* %14
store double* %1, double** %15
store double* %2, double** %16
store i32 %3, i32* %17
store double* %4, double** %18
store double** %5, double*** %19
store double* %6, double** %20
store double* %7, double** %21
store i32 %8, i32* %22
store i32 %9, i32* %23
store i32 %10, i32* %24
store i32 %11, i32* %25
store i32* %12, i32** %26
%47 = load i32, i32* %14
%48 = call i64 @calloc(i32 %47, i32 8)
%49 = inttoptr i64 %48 to double*
store double* %49, double** %27
%50 = load i32, i32* %14
%51 = call i64 @calloc(i32 %50, i32 8)
%52 = inttoptr i64 %51 to double*
store double* %52, double** %28
%53 = load i32, i32* %17
%54 = call i64 @calloc(i32 %53, i32 8)
%55 = inttoptr i64 %54 to double*
store double* %55, double** %29
%56 = load i32, i32* %17
%57 = call i64 @calloc(i32 %56, i32 8)
%58 = inttoptr i64 %57 to double*
store double* %58, double** %30
store i64 0, i64* %35
store i64 0, i64* %36
%59 = call i64 @time(i32* null)
store i64 %59, i64* %38
%60 = load i64, i64* %38
%61 = sitofp i64 %60 to double
%62 = call double @sqrt(double %61)
%63 = fptosi double %62 to i64
store i64 %63, i64* %39
store i32 0, i32* %32
br label %64
64: ; preds = %86, %13
%65 = load i32, i32* %32
%66 = load i32, i32* %14
%67 = icmp slt i32 %65, %66
br i1 %67, label %68, label %89
68: ; preds = %64
%69 = load double*, double** %16
%70 = load i32, i32* %32
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %69, i64 %71
%73 = load double, double* %72
%74 = load double*, double** %27
%75 = load i32, i32* %32
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
store double %73, double* %77
%78 = load double*, double** %21
%79 = load i32, i32* %32
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %78, i64 %80
store double 0.000000e+00, double* %81
%82 = load double*, double** %20
%83 = load i32, i32* %32
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds double, double* %82, i64 %84
store double 0.000000e+00, double* %85
br label %86
86: ; preds = %68
%87 = load i32, i32* %32
%88 = add nsw i32 %87, 1
store i32 %88, i32* %32
br label %64
89: ; preds = %64
store i32 0, i32* %31
br label %90
90: ; preds = %128, %89
%91 = load i32, i32* %31
%92 = load i32, i32* %17
%93 = icmp slt i32 %91, %92
br i1 %93, label %94, label %131
94: ; preds = %90
%95 = load double*, double** %29
%96 = load i32, i32* %31
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
store double 0.000000e+00, double* %98
store i32 0, i32* %32
br label %99
99: ; preds = %124, %94
%100 = load i32, i32* %32
%101 = load i32, i32* %14
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %127
103: ; preds = %99
%104 = load double**, double*** %19
%105 = load i32, i32* %31
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double*, double** %104, i64 %106
%108 = load double*, double** %107
%109 = load i32, i32* %32
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %108, i64 %110
%112 = load double, double* %111
%113 = load double*, double** %16
%114 = load i32, i32* %32
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %113, i64 %115
%117 = load double, double* %116
%118 = load double*, double** %29
%119 = load i32, i32* %31
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
%122 = load double, double* %121
%123 = call double @llvm.fmuladd.f64(double %112, double %117, double %122)
store double %123, double* %121
br label %124
124: ; preds = %103
%125 = load i32, i32* %32
%126 = add nsw i32 %125, 1
store i32 %126, i32* %32
br label %99
127: ; preds = %99
br label %128
128: ; preds = %127
%129 = load i32, i32* %31
%130 = add nsw i32 %129, 1
store i32 %130, i32* %31
br label %90
131: ; preds = %90
%132 = call i64 @time(i32* null)
%133 = call i32 @srand(i64 %132)
%134 = load i32, i32* %25
%135 = icmp ne i32 %134, 0
br i1 %135, label %136, label %139
136: ; preds = %131
%137 = load i32*, i32** @stderr
%138 = call i32 (i32*, i8*, ...) @fprintf(i32* %137, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0))
br label %139
139: ; preds = %136, %131
store i32 0, i32* %46
br label %140
140: ; preds = %408, %139
%141 = load i32, i32* %46
%142 = load i32, i32* %22
%143 = icmp slt i32 %141, %142
br i1 %143, label %144, label %411
144: ; preds = %140
%145 = load i32, i32* %25
%146 = icmp ne i32 %145, 0
br i1 %146, label %147, label %152
147: ; preds = %144
%148 = load i32*, i32** @stderr
%149 = load i32, i32* %46
%150 = add nsw i32 %149, 1
%151 = call i32 (i32*, i8*, ...) @fprintf(i32* %148, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0), i32 %150)
br label %152
152: ; preds = %147, %144
store i32 0, i32* %37
br label %153
153: ; preds = %354, %152
%154 = load i32, i32* %37
%155 = load i32, i32* %23
%156 = icmp slt i32 %154, %155
br i1 %156, label %157, label %357
157: ; preds = %153
%158 = load i32, i32* %25
%159 = icmp ne i32 %158, 0
br i1 %159, label %160, label %165
160: ; preds = %157
%161 = load i32*, i32** @stderr
%162 = load i32, i32* %37
%163 = add nsw i32 %162, 1
%164 = call i32 (i32*, i8*, ...) @fprintf(i32* %161, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 %163)
br label %165
165: ; preds = %160, %157
store i32 0, i32* %41
br label %166
166: ; preds = %342, %165
%167 = load i32, i32* %41
%168 = load i32, i32* %14
%169 = icmp slt i32 %167, %168
br i1 %169, label %170, label %345
170: ; preds = %166
%171 = load i32, i32* %24
%172 = icmp ne i32 %171, 0
br i1 %172, label %173, label %181
173: ; preds = %170
%174 = load double*, double** %15
%175 = load i32, i32* %41
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %174, i64 %176
%178 = load double, double* %177
%179 = fcmp ole double %178, 0.000000e+00
br i1 %179, label %180, label %181
180: ; preds = %173
br label %342
181: ; preds = %173, %170
%182 = load i64, i64* %35
%183 = add nsw i64 %182, 1
store i64 %183, i64* %35
%184 = load i32, i32* %41
store i32 %184, i32* %40
br label %185
185: ; preds = %203, %181
%186 = load i32, i32* %40
%187 = load i32, i32* %41
%188 = icmp eq i32 %186, %187
br i1 %188, label %201, label %189
189: ; preds = %185
%190 = load i32, i32* %24
%191 = icmp ne i32 %190, 0
br i1 %191, label %192, label %199
192: ; preds = %189
%193 = load double*, double** %15
%194 = load i32, i32* %40
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double, double* %193, i64 %195
%197 = load double, double* %196
%198 = fcmp ole double %197, 0.000000e+00
br label %199
199: ; preds = %192, %189
%200 = phi i1 [ false, %189 ], [ %198, %192 ]
br label %201
201: ; preds = %199, %185
%202 = phi i1 [ true, %185 ], [ %200, %199 ]
br i1 %202, label %203, label %208
203: ; preds = %201
%204 = load i32, i32* %14
%205 = sub nsw i32 %204, 1
%206 = call i64 @ignuin(i32 0, i32 %205)
%207 = trunc i64 %206 to i32
store i32 %207, i32* %40
br label %185
208: ; preds = %201
%209 = load double*, double** %27
%210 = load i32, i32* %40
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
%213 = load double, double* %212
store double %213, double* %43
%214 = load double*, double** %27
%215 = load i32, i32* %41
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %214, i64 %216
%218 = load double, double* %217
store double %218, double* %42
store i32 0, i32* %31
br label %219
219: ; preds = %267, %208
%220 = load i32, i32* %31
%221 = load i32, i32* %17
%222 = icmp slt i32 %220, %221
br i1 %222, label %223, label %270
223: ; preds = %219
%224 = load double*, double** %29
%225 = load i32, i32* %31
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = load double**, double*** %19
%230 = load i32, i32* %31
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double*, double** %229, i64 %231
%233 = load double*, double** %232
%234 = load i32, i32* %40
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = load double*, double** %27
%239 = load i32, i32* %40
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
%243 = load double, double* %43
%244 = fsub double %242, %243
%245 = call double @llvm.fmuladd.f64(double %237, double %244, double %228)
%246 = load double**, double*** %19
%247 = load i32, i32* %31
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double*, double** %246, i64 %248
%250 = load double*, double** %249
%251 = load i32, i32* %41
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = load double*, double** %27
%256 = load i32, i32* %41
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %255, i64 %257
%259 = load double, double* %258
%260 = load double, double* %42
%261 = fsub double %259, %260
%262 = call double @llvm.fmuladd.f64(double %254, double %261, double %245)
%263 = load double*, double** %30
%264 = load i32, i32* %31
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %263, i64 %265
store double %262, double* %266
br label %267
267: ; preds = %223
%268 = load i32, i32* %31
%269 = add nsw i32 %268, 1
store i32 %269, i32* %31
br label %219
270: ; preds = %219
store double 1.000000e+00, double* %44
store i32 0, i32* %31
br label %271
271: ; preds = %295, %270
%272 = load i32, i32* %31
%273 = load i32, i32* %17
%274 = icmp slt i32 %272, %273
br i1 %274, label %275, label %298
275: ; preds = %271
%276 = load double*, double** %29
%277 = load i32, i32* %31
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %276, i64 %278
%280 = load double, double* %279
%281 = load double*, double** %30
%282 = load i32, i32* %31
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = fdiv double %280, %285
%287 = load double*, double** %18
%288 = load i32, i32* %31
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
%291 = load double, double* %290
%292 = call double @pow(double %286, double %291)
%293 = load double, double* %44
%294 = fmul double %293, %292
store double %294, double* %44
br label %295
295: ; preds = %275
%296 = load i32, i32* %31
%297 = add nsw i32 %296, 1
store i32 %297, i32* %31
br label %271
298: ; preds = %271
%299 = call i64 (...) @rand()
%300 = sitofp i64 %299 to double
%301 = load i64, i64* @RAND_MAX
%302 = sitofp i64 %301 to double
%303 = fdiv double %300, %302
%304 = fptrunc double %303 to float
store float %304, float* %45
%305 = load double, double* %44
%306 = load float, float* %45
%307 = fpext float %306 to double
%308 = fcmp ogt double %305, %307
br i1 %308, label %309, label %330
309: ; preds = %298
%310 = load i64, i64* %36
%311 = add nsw i64 %310, 1
store i64 %311, i64* %36
store i32 0, i32* %31
br label %312
312: ; preds = %326, %309
%313 = load i32, i32* %31
%314 = load i32, i32* %17
%315 = icmp slt i32 %313, %314
br i1 %315, label %316, label %329
316: ; preds = %312
%317 = load double*, double** %30
%318 = load i32, i32* %31
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %317, i64 %319
%321 = load double, double* %320
%322 = load double*, double** %29
%323 = load i32, i32* %31
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %322, i64 %324
store double %321, double* %325
br label %326
326: ; preds = %316
%327 = load i32, i32* %31
%328 = add nsw i32 %327, 1
store i32 %328, i32* %31
br label %312
329: ; preds = %312
br label %341
330: ; preds = %298
%331 = load double, double* %43
%332 = load double*, double** %27
%333 = load i32, i32* %40
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %332, i64 %334
store double %331, double* %335
%336 = load double, double* %42
%337 = load double*, double** %27
%338 = load i32, i32* %41
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %337, i64 %339
store double %336, double* %340
br label %341
341: ; preds = %330, %329
br label %342
342: ; preds = %341, %180
%343 = load i32, i32* %41
%344 = add nsw i32 %343, 1
store i32 %344, i32* %41
br label %166
345: ; preds = %166
%346 = load i32, i32* %25
%347 = icmp ne i32 %346, 0
br i1 %347, label %348, label %353
348: ; preds = %345
%349 = load i32*, i32** @stderr
%350 = load i32, i32* %37
%351 = add nsw i32 %350, 1
%352 = call i32 (i32*, i8*, ...) @fprintf(i32* %349, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), i32 %351)
br label %353
353: ; preds = %348, %345
br label %354
354: ; preds = %353
%355 = load i32, i32* %37
%356 = add nsw i32 %355, 1
store i32 %356, i32* %37
br label %153
357: ; preds = %153
store i32 0, i32* %32
br label %358
358: ; preds = %390, %357
%359 = load i32, i32* %32
%360 = load i32, i32* %14
%361 = icmp slt i32 %359, %360
br i1 %361, label %362, label %393
362: ; preds = %358
%363 = load double*, double** %27
%364 = load i32, i32* %32
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %363, i64 %365
%367 = load double, double* %366
store double %367, double* %44
%368 = load double, double* %44
%369 = load double*, double** %20
%370 = load i32, i32* %32
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %369, i64 %371
%373 = load double, double* %372
%374 = fadd double %373, %368
store double %374, double* %372
%375 = load double, double* %44
%376 = load double, double* %44
%377 = load double*, double** %28
%378 = load i32, i32* %32
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %377, i64 %379
%381 = load double, double* %380
%382 = call double @llvm.fmuladd.f64(double %375, double %376, double %381)
store double %382, double* %380
%383 = load i32*, i32** %26
%384 = icmp ne i32* %383, null
br i1 %384, label %385, label %389
385: ; preds = %362
%386 = load i32*, i32** %26
%387 = load double, double* %44
%388 = call i32 (i32*, i8*, ...) @fprintf(i32* %386, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0), double %387)
br label %389
389: ; preds = %385, %362
br label %390
390: ; preds = %389
%391 = load i32, i32* %32
%392 = add nsw i32 %391, 1
store i32 %392, i32* %32
br label %358
393: ; preds = %358
%394 = load i32*, i32** %26
%395 = icmp ne i32* %394, null
br i1 %395, label %396, label %399
396: ; preds = %393
%397 = load i32*, i32** %26
%398 = call i32 @fflush(i32* %397)
br label %399
399: ; preds = %396, %393
%400 = load i32, i32* %25
%401 = icmp ne i32 %400, 0
br i1 %401, label %402, label %407
402: ; preds = %399
%403 = load i32*, i32** @stderr
%404 = load i32, i32* %46
%405 = add nsw i32 %404, 1
%406 = call i32 (i32*, i8*, ...) @fprintf(i32* %403, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i32 %405)
br label %407
407: ; preds = %402, %399
br label %408
408: ; preds = %407
%409 = load i32, i32* %46
%410 = add nsw i32 %409, 1
store i32 %410, i32* %46
br label %140
411: ; preds = %140
%412 = load i32*, i32** @stderr
%413 = load i64, i64* %36
%414 = sitofp i64 %413 to double
%415 = load i64, i64* %35
%416 = sitofp i64 %415 to double
%417 = fdiv double %414, %416
%418 = call i32 (i32*, i8*, ...) @fprintf(i32* %412, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.6, i64 0, i64 0), double %417)
store i32 0, i32* %32
br label %419
419: ; preds = %462, %411
%420 = load i32, i32* %32
%421 = load i32, i32* %14
%422 = icmp slt i32 %420, %421
br i1 %422, label %423, label %465
423: ; preds = %419
%424 = load i32, i32* %22
%425 = sitofp i32 %424 to double
%426 = load double*, double** %20
%427 = load i32, i32* %32
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %426, i64 %428
%430 = load double, double* %429
%431 = fdiv double %430, %425
store double %431, double* %429
%432 = load i32, i32* %22
%433 = sitofp i32 %432 to double
%434 = load double*, double** %28
%435 = load i32, i32* %32
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %434, i64 %436
%438 = load double, double* %437
%439 = fdiv double %438, %433
store double %439, double* %437
%440 = load double*, double** %28
%441 = load i32, i32* %32
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %440, i64 %442
%444 = load double, double* %443
%445 = load double*, double** %20
%446 = load i32, i32* %32
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %445, i64 %447
%449 = load double, double* %448
%450 = load double*, double** %20
%451 = load i32, i32* %32
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double, double* %450, i64 %452
%454 = load double, double* %453
%455 = fneg double %449
%456 = call double @llvm.fmuladd.f64(double %455, double %454, double %444)
%457 = call double @sqrt(double %456)
%458 = load double*, double** %21
%459 = load i32, i32* %32
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %458, i64 %460
store double %457, double* %461
br label %462
462: ; preds = %423
%463 = load i32, i32* %32
%464 = add nsw i32 %463, 1
store i32 %464, i32* %32
br label %419
465: ; preds = %419
%466 = load double*, double** %27
%467 = call i32 @free(double* %466)
%468 = load double*, double** %28
%469 = call i32 @free(double* %468)
%470 = load double*, double** %29
%471 = call i32 @free(double* %470)
%472 = load double*, double** %30
%473 = call i32 @free(double* %472)
ret i32 1
}

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