#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 */

/* Variables and functions */
int /*<<< orphan*/ abort();
double atof(int /*<<< orphan*/);
int atoi(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ printf(char *, ...);
double rand_beta(double, double);
double rand_cauchy();
double rand_exp();
double rand_gamma(double);
double rand_gaussian();
double rand_int(int);
double rand_poisson(double);
int /*<<< orphan*/ rand_seed(int);
double rand_uniform();
double rand_uniopen();
int /*<<< orphan*/ stderr;
scalar_t__ strcmp(char *, char *);
int /*<<< orphan*/ usage();
main(int argc, char **argv) {
  int seed, sample_size, bins, np;
  double low, high;
  char *generator;
  double p1, p2;
  double mean, variance;
  double tmean, tvariance;
  int undef_mean, undef_variance;
  int count[1000];
  int under, over;
  char **ap;
  double x;
  int i, n;
  bins = 0;
  if (argc < 5)
    usage();
  if ((seed = atoi(argv[1])) == 0 && strcmp(argv[1], "0") != 0)
    usage();
  generator = argv[2];
  if (strcmp(generator, "uniform") == 0)
    np = 0;
  else if (strcmp(generator, "uniopen") == 0)
    np = 0;
  else if (strcmp(generator, "int") == 0)
    np = 1;
  else if (strcmp(generator, "poisson") == 0)
    np = 1;
  else if (strcmp(generator, "gaussian") == 0)
    np = 0;
  else if (strcmp(generator, "exp") == 0)
    np = 0;
  else if (strcmp(generator, "cauchy") == 0)
    np = 0;
  else if (strcmp(generator, "gamma") == 0)
    np = 1;
  else if (strcmp(generator, "beta") == 0)
    np = 2;
  else {
    fprintf(stderr, "Unknown generator: %s\n", generator);
    exit(1);
  }
  ap = argv + 3;
  if (np > 0) {
    if (*ap == 0 || (p1 = atof(*ap++)) <= 0)
      usage();
  }
  if (np > 1) {
    if (*ap == 0 || (p2 = atof(*ap++)) <= 0)
      usage();
  }
  if (*ap == 0 || strcmp(*ap++, "/") != 0)
    usage();
  if (*ap == 0 || (sample_size = atoi(*ap++)) <= 0)
    usage();
  if (*ap != 0) {
    low = atof(*ap++);
    if (*ap == 0)
      usage();
    high = atof(*ap++);
    if (high <= low)
      usage();
    if (*ap == 0 || (bins = atoi(*ap++)) <= 0)
      usage();
    if (bins > 1000) {
      fprintf(stderr, "Too many histogram bins\n");
      exit(1);
    }
  }
  if (*ap != 0)
    usage();
  printf("\nTest of %s(", generator);
  if (np > 0)
    printf("%.4f", p1);
  if (np > 1)
    printf(",%.4f", p2);
  printf(") generator using sample of size %d with seed %d\n\n", sample_size,
         seed);
  undef_mean = undef_variance = 0;
  if (strcmp(generator, "uniform") == 0) {
    tmean = 0.5;
    tvariance = 1.0 / 12.0;
  } else if (strcmp(generator, "uniopen") == 0) {
    tmean = 0.5;
    tvariance = 1.0 / 12.0;
  } else if (strcmp(generator, "int") == 0) {
    tmean = (p1 - 1) / 2;
    tvariance = p1 * p1 / 3.0 - p1 / 2.0 + 1 / 6.0 - tmean * tmean;
  } else if (strcmp(generator, "poisson") == 0) {
    tmean = p1;
    tvariance = p1;
  } else if (strcmp(generator, "gaussian") == 0) {
    tmean = 0;
    tvariance = 1;
  } else if (strcmp(generator, "exp") == 0) {
    tmean = 1;
    tvariance = 1;
  } else if (strcmp(generator, "cauchy") == 0) {
    undef_mean = 1;
    undef_variance = 1;
  } else if (strcmp(generator, "gamma") == 0) {
    tmean = p1;
    tvariance = p1;
  } else if (strcmp(generator, "beta") == 0) {
    tmean = p1 / (p1 + p2);
    tvariance = (p1 * p2) / ((p1 + p2) * (p1 + p2) * (p1 + p2 + 1));
  } else {
    abort();
  }
  mean = 0;
  variance = 0;
  if (bins > 0) {
    for (i = 0; i < bins; i++)
      count[i] = 0;
    under = over = 0;
  }
  rand_seed(seed);
  for (n = 0; n < sample_size; n++) {
    if (strcmp(generator, "uniform") == 0)
      x = rand_uniform();
    else if (strcmp(generator, "uniopen") == 0)
      x = rand_uniopen();
    else if (strcmp(generator, "int") == 0)
      x = rand_int((int)p1);
    else if (strcmp(generator, "poisson") == 0)
      x = rand_poisson(p1);
    else if (strcmp(generator, "gaussian") == 0)
      x = rand_gaussian();
    else if (strcmp(generator, "exp") == 0)
      x = rand_exp();
    else if (strcmp(generator, "cauchy") == 0)
      x = rand_cauchy();
    else if (strcmp(generator, "gamma") == 0)
      x = rand_gamma(p1);
    else if (strcmp(generator, "beta") == 0)
      x = rand_beta(p1, p2);
    else
      abort();
    mean += x;
    variance += x * x;
    if (bins > 0) {
      if (x < low) {
        under += 1;
      } else {
        i = (int)((x - low) / ((high - low) / bins));
        if (i >= bins) {
          over += 1;
        } else {
          count[i] += 1;
        }
      }
    }
  }
  mean /= sample_size;
  variance /= sample_size;
  variance -= mean * mean;
  printf("Sample mean:     %.4f", mean);
  if (undef_mean) {
    printf(" (true value: undefined)\n");
  } else {
    printf(" (true value: %.4f)\n", tmean);
  }
  printf("Sample variance: %.4f", variance);
  if (undef_variance) {
    printf(" (true value: undefined)\n");
  } else {
    printf(" (true value: %.4f)\n", tvariance);
  }
  printf("\n");
  if (bins != 0) {
    printf("Histogram:\n");
    printf("                    under : %8d  %.5f\n\n", under,
           (double)under / sample_size);
    for (i = 0; i < bins; i++) {
      printf("  %10.4f - %10.4f : %8d  %.5f\n", i * (high - low) / bins + low,
             (i + 1) * (high - low) / bins + low, count[i],
             (double)count[i] / sample_size);
    }
    printf("\n                     over : %8d  %.5f\n", over,
           (double)over / sample_size);
    printf("\n");
  }
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1030,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x5,-0x8(%rbp)
jge    1251 <main+0x31>
mov    $0x0,%al
call   10d0 <usage@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1120 <atoi@plt>
mov    %eax,-0x14(%rbp)
cmp    $0x0,%eax
jne    128f <main+0x6f>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xdb7(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
je     128f <main+0x6f>
mov    $0x0,%al
call   10d0 <usage@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
lea    0xd8c(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    12c1 <main+0xa1>
movl   $0x0,-0x20(%rbp)
jmp    143e <main+0x21e>
mov    -0x38(%rbp),%rdi
lea    0xd6e(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    12e7 <main+0xc7>
movl   $0x0,-0x20(%rbp)
jmp    1439 <main+0x219>
mov    -0x38(%rbp),%rdi
lea    0xd50(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    130d <main+0xed>
movl   $0x1,-0x20(%rbp)
jmp    1434 <main+0x214>
mov    -0x38(%rbp),%rdi
lea    0xd2e(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1333 <main+0x113>
movl   $0x1,-0x20(%rbp)
jmp    142f <main+0x20f>
mov    -0x38(%rbp),%rdi
lea    0xd10(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1359 <main+0x139>
movl   $0x0,-0x20(%rbp)
jmp    142a <main+0x20a>
mov    -0x38(%rbp),%rdi
lea    0xcf3(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    137f <main+0x15f>
movl   $0x0,-0x20(%rbp)
jmp    1425 <main+0x205>
mov    -0x38(%rbp),%rdi
lea    0xcd1(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    13a5 <main+0x185>
movl   $0x0,-0x20(%rbp)
jmp    1420 <main+0x200>
mov    -0x38(%rbp),%rdi
lea    0xcb2(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    13cb <main+0x1ab>
movl   $0x1,-0x20(%rbp)
jmp    141b <main+0x1fb>
mov    -0x38(%rbp),%rdi
lea    0xc92(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    13f1 <main+0x1d1>
movl   $0x2,-0x20(%rbp)
jmp    1416 <main+0x1f6>
mov    0x2be8(%rip),%rax
mov    (%rax),%edi
mov    -0x38(%rbp),%rdx
lea    0xc68(%rip),%rsi
mov    $0x0,%al
call   10a0 <fprintf@plt>
mov    $0x1,%edi
call   1130 <exit@plt>
jmp    141b <main+0x1fb>
jmp    1420 <main+0x200>
jmp    1425 <main+0x205>
jmp    142a <main+0x20a>
jmp    142f <main+0x20f>
jmp    1434 <main+0x214>
jmp    1439 <main+0x219>
jmp    143e <main+0x21e>
mov    -0x10(%rbp),%rax
add    $0x18,%rax
mov    %rax,-0x1020(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    14a8 <main+0x288>
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
je     149c <main+0x27c>
mov    -0x1020(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1020(%rbp)
mov    (%rax),%rax
mov    %eax,%edi
call   1050 <atof@plt>
movaps %xmm0,%xmm1
movsd  %xmm1,-0x40(%rbp)
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     14a3 <main+0x283>
mov    $0x0,%al
call   10d0 <usage@plt>
jmp    14a8 <main+0x288>
cmpl   $0x1,-0x20(%rbp)
jle    1503 <main+0x2e3>
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
je     14f7 <main+0x2d7>
mov    -0x1020(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1020(%rbp)
mov    (%rax),%rax
mov    %eax,%edi
call   1050 <atof@plt>
movaps %xmm0,%xmm1
movsd  %xmm1,-0x48(%rbp)
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     14fe <main+0x2de>
mov    $0x0,%al
call   10d0 <usage@plt>
jmp    1503 <main+0x2e3>
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
je     1542 <main+0x322>
mov    -0x1020(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1020(%rbp)
mov    (%rax),%rdi
lea    0xb51(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
je     1549 <main+0x329>
mov    $0x0,%al
call   10d0 <usage@plt>
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
je     1583 <main+0x363>
mov    -0x1020(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1020(%rbp)
mov    (%rax),%rdi
call   1120 <atoi@plt>
mov    %eax,-0x18(%rbp)
cmp    $0x0,%eax
jg     158a <main+0x36a>
mov    $0x0,%al
call   10d0 <usage@plt>
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
je     168a <main+0x46a>
mov    -0x1020(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1020(%rbp)
mov    (%rax),%rax
mov    %eax,%edi
call   1050 <atof@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
jne    15d7 <main+0x3b7>
mov    $0x0,%al
call   10d0 <usage@plt>
mov    -0x1020(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1020(%rbp)
mov    (%rax),%rax
mov    %eax,%edi
call   1050 <atof@plt>
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1616 <main+0x3f6>
mov    $0x0,%al
call   10d0 <usage@plt>
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
je     1650 <main+0x430>
mov    -0x1020(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1020(%rbp)
mov    (%rax),%rdi
call   1120 <atoi@plt>
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jg     1657 <main+0x437>
mov    $0x0,%al
call   10d0 <usage@plt>
cmpl   $0x3e8,-0x1c(%rbp)
jle    1685 <main+0x465>
mov    0x2975(%rip),%rax
mov    (%rax),%edi
lea    0xa12(%rip),%rsi
mov    $0x0,%al
call   10a0 <fprintf@plt>
mov    $0x1,%edi
call   1130 <exit@plt>
jmp    168a <main+0x46a>
mov    -0x1020(%rbp),%rax
cmpq   $0x0,(%rax)
je     16a2 <main+0x482>
mov    $0x0,%al
call   10d0 <usage@plt>
mov    -0x38(%rbp),%rsi
lea    0x9f2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cmpl   $0x0,-0x20(%rbp)
jle    16d1 <main+0x4b1>
movsd  -0x40(%rbp),%xmm0
lea    0xa2c(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
cmpl   $0x1,-0x20(%rbp)
jle    16ee <main+0x4ce>
movsd  -0x48(%rbp),%xmm0
lea    0x9c5(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edx
lea    0x9b7(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x38(%rbp),%rdi
lea    0x917(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1749 <main+0x529>
movsd  0x8f6(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x8e1(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19d3 <main+0x7b3>
mov    -0x38(%rbp),%rdi
lea    0x8e6(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1782 <main+0x562>
movsd  0x8bd(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x8a8(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19ce <main+0x7ae>
mov    -0x38(%rbp),%rdi
lea    0x8b5(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1828 <main+0x608>
movsd  -0x40(%rbp),%xmm0
movsd  0x857(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x85b(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  0x848(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  0x82f(%rip),%xmm2
divsd  %xmm2,%xmm0
subsd  %xmm0,%xmm1
movsd  0x817(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19c9 <main+0x7a9>
mov    -0x38(%rbp),%rdi
lea    0x813(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    185b <main+0x63b>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19c4 <main+0x7a4>
mov    -0x38(%rbp),%rdi
lea    0x7e8(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    188f <main+0x66f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x77b(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19bf <main+0x79f>
mov    -0x38(%rbp),%rdi
lea    0x7bd(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    18c8 <main+0x6a8>
movsd  0x74f(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x742(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19ba <main+0x79a>
mov    -0x38(%rbp),%rdi
lea    0x788(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    18f5 <main+0x6d5>
movl   $0x1,-0x6c(%rbp)
movl   $0x1,-0x70(%rbp)
jmp    19b5 <main+0x795>
mov    -0x38(%rbp),%rdi
lea    0x762(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1928 <main+0x708>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19b0 <main+0x790>
mov    -0x38(%rbp),%rdi
lea    0x735(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    19a4 <main+0x784>
movsd  -0x40(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
addsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  -0x40(%rbp),%xmm2
addsd  -0x48(%rbp),%xmm2
movsd  0x672(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19ab <main+0x78b>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    19b0 <main+0x790>
jmp    19b5 <main+0x795>
jmp    19ba <main+0x79a>
jmp    19bf <main+0x79f>
jmp    19c4 <main+0x7a4>
jmp    19c9 <main+0x7a9>
jmp    19ce <main+0x7ae>
jmp    19d3 <main+0x7b3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1a40 <main+0x820>
movl   $0x0,-0x102c(%rbp)
mov    -0x102c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a2c <main+0x80c>
movslq -0x102c(%rbp),%rax
movl   $0x0,-0x1010(%rbp,%rax,4)
mov    -0x102c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x102c(%rbp)
jmp    19f7 <main+0x7d7>
movl   $0x0,-0x1018(%rbp)
movl   $0x0,-0x1014(%rbp)
mov    -0x14(%rbp),%edi
call   10b0 <rand_seed@plt>
movl   $0x0,-0x1030(%rbp)
mov    -0x1030(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d34 <main+0xb14>
mov    -0x38(%rbp),%rdi
lea    0x5c6(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1a8f <main+0x86f>
mov    $0x0,%al
call   1110 <rand_uniform@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c3f <main+0xa1f>
mov    -0x38(%rbp),%rdi
lea    0x5a0(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1abd <main+0x89d>
mov    $0x0,%al
call   1070 <rand_uniopen@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c3a <main+0xa1a>
mov    -0x38(%rbp),%rdi
lea    0x57a(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1aee <main+0x8ce>
cvttsd2si -0x40(%rbp),%edi
call   10e0 <rand_int@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c35 <main+0xa15>
mov    -0x38(%rbp),%rdi
lea    0x54d(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1b1f <main+0x8ff>
movsd  -0x40(%rbp),%xmm0
call   10c0 <rand_poisson@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c30 <main+0xa10>
mov    -0x38(%rbp),%rdi
lea    0x524(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1b4d <main+0x92d>
mov    $0x0,%al
call   10f0 <rand_gaussian@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c2b <main+0xa0b>
mov    -0x38(%rbp),%rdi
lea    0x4ff(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1b7b <main+0x95b>
mov    $0x0,%al
call   1040 <rand_exp@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c26 <main+0xa06>
mov    -0x38(%rbp),%rdi
lea    0x4d5(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1ba9 <main+0x989>
mov    $0x0,%al
call   1090 <rand_cauchy@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c21 <main+0xa01>
mov    -0x38(%rbp),%rdi
lea    0x4ae(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1bda <main+0x9ba>
movsd  -0x40(%rbp),%xmm0
call   1100 <rand_gamma@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c1c <main+0x9fc>
mov    -0x38(%rbp),%rdi
lea    0x483(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    1c10 <main+0x9f0>
movsd  -0x40(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
call   1140 <rand_beta@plt>
movsd  %xmm0,-0x1028(%rbp)
ff
jmp    1c17 <main+0x9f7>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    1c1c <main+0x9fc>
jmp    1c21 <main+0xa01>
jmp    1c26 <main+0xa06>
jmp    1c2b <main+0xa0b>
jmp    1c30 <main+0xa10>
jmp    1c35 <main+0xa15>
jmp    1c3a <main+0xa1a>
jmp    1c3f <main+0xa1f>
movsd  -0x1028(%rbp),%xmm0
ff
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x1028(%rbp),%xmm0
ff
movsd  -0x1028(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1d1b <main+0xafb>
movsd  -0x1028(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ca8 <main+0xa88>
mov    -0x1014(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1014(%rbp)
jmp    1d16 <main+0xaf6>
movsd  -0x1028(%rbp),%xmm0
ff
subsd  -0x28(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm2
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x102c(%rbp)
mov    -0x102c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     1cf9 <main+0xad9>
mov    -0x1018(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1018(%rbp)
jmp    1d11 <main+0xaf1>
movslq -0x102c(%rbp),%rax
mov    -0x1010(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1010(%rbp,%rax,4)
jmp    1d16 <main+0xaf6>
jmp    1d1b <main+0xafb>
jmp    1d20 <main+0xb00>
mov    -0x1030(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1030(%rbp)
jmp    1a52 <main+0x832>
cvtsi2sdl -0x18(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
lea    0x34c(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
cmpl   $0x0,-0x6c(%rbp)
je     1dbd <main+0xb9d>
lea    0x34a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1dd0 <main+0xbb0>
movsd  -0x60(%rbp),%xmm0
lea    0x34c(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  -0x58(%rbp),%xmm0
lea    0x34e(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
cmpl   $0x0,-0x70(%rbp)
je     1e00 <main+0xbe0>
lea    0x307(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1e13 <main+0xbf3>
movsd  -0x68(%rbp),%xmm0
lea    0x309(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x2c9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cmpl   $0x0,-0x1c(%rbp)
je     1f40 <main+0xd20>
lea    0x30e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x1014(%rbp),%esi
cvtsi2sdl -0x1014(%rbp),%xmm0
ff
cvtsi2sdl -0x18(%rbp),%xmm1
divsd  %xmm1,%xmm0
lea    0x2f5(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movl   $0x0,-0x102c(%rbp)
mov    -0x102c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1f0d <main+0xced>
cvtsi2sdl -0x102c(%rbp),%xmm0
ff
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x28(%rbp),%xmm0
mov    -0x102c(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
movsd  -0x30(%rbp),%xmm2
subsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm2
divsd  %xmm2,%xmm1
addsd  -0x28(%rbp),%xmm1
movslq -0x102c(%rbp),%rax
mov    -0x1010(%rbp,%rax,4),%esi
movslq -0x102c(%rbp),%rax
cvtsi2sdl -0x1010(%rbp,%rax,4),%xmm2
ff ff
cvtsi2sdl -0x18(%rbp),%xmm3
divsd  %xmm3,%xmm2
lea    0x282(%rip),%rdi
mov    $0x3,%al
call   1060 <printf@plt>
mov    -0x102c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x102c(%rbp)
jmp    1e68 <main+0xc48>
mov    -0x1018(%rbp),%esi
cvtsi2sdl -0x1018(%rbp),%xmm0
ff
cvtsi2sdl -0x18(%rbp),%xmm1
divsd  %xmm1,%xmm0
lea    0x268(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x1aa(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
xor    %edi,%edi
call   1130 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1018,%rsp
mov    %rsi,%r12
cmp    $0x4,%edi
jg     1270 <main+0x20>
xor    %eax,%eax
call   1100 <usage@plt>
mov    0x8(%r12),%rbx
mov    %rbx,%rdi
call   1150 <atoi@plt>
mov    %eax,%r14d
test   %eax,%eax
jne    129f <main+0x4f>
lea    0xdbd(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     129f <main+0x4f>
xor    %eax,%eax
call   1100 <usage@plt>
mov    0x10(%r12),%rbx
lea    0xd9f(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     12d0 <main+0x80>
lea    0xd93(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    14db <main+0x28b>
add    $0x18,%r12
xor    %r13d,%r13d
xor    %r15d,%r15d
mov    (%r12),%rdi
test   %rdi,%rdi
je     12f8 <main+0xa8>
add    $0x8,%r12
lea    0xdae(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     12ff <main+0xaf>
xor    %eax,%eax
call   1100 <usage@plt>
mov    (%r12),%rdi
test   %rdi,%rdi
jne    130a <main+0xba>
jmp    131b <main+0xcb>
add    $0x8,%r12
call   1150 <atoi@plt>
mov    %eax,0x20(%rsp)
test   %eax,%eax
jg     1322 <main+0xd2>
xor    %eax,%eax
call   1100 <usage@plt>
mov    (%r12),%rdi
test   %rdi,%rdi
jne    1337 <main+0xe7>
xor    %ebp,%ebp
mov    0x20(%rsp),%r12d
jmp    13d2 <main+0x182>
mov    %r15d,0x8(%rsp)
mov    %r13d,%r15d
mov    %r14d,%r13d
call   1070 <atof@plt>
movsd  %xmm0,0x10(%rsp)
mov    0x8(%r12),%rdi
test   %rdi,%rdi
jne    1363 <main+0x113>
xor    %eax,%eax
call   1100 <usage@plt>
mov    0x8(%r12),%rdi
lea    0x10(%r12),%r14
call   1070 <atof@plt>
movapd %xmm0,%xmm1
movsd  0x10(%rsp),%xmm0
movsd  %xmm1,0x28(%rsp)
ucomisd %xmm1,%xmm0
jb     138a <main+0x13a>
xor    %eax,%eax
call   1100 <usage@plt>
mov    (%r14),%rdi
xor    %ebp,%ebp
test   %rdi,%rdi
je     13aa <main+0x15a>
add    $0x18,%r12
call   1150 <atoi@plt>
mov    %eax,%ebp
test   %eax,%eax
jg     1520 <main+0x2d0>
mov    %r12,%r14
xor    %eax,%eax
call   1100 <usage@plt>
mov    %r14,%r12
cmpq   $0x0,(%r12)
je     13c2 <main+0x172>
xor    %eax,%eax
call   1100 <usage@plt>
mov    %r13d,%r14d
mov    0x20(%rsp),%r12d
mov    %r15d,%r13d
mov    0x8(%rsp),%r15d
lea    0xcde(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
test   %r13b,%r13b
je     13fc <main+0x1ac>
lea    0xd1f(%rip),%rdi
movapd 0x30(%rsp),%xmm0
mov    $0x1,%al
call   1080 <printf@plt>
test   %r15b,%r15b
je     1415 <main+0x1c5>
lea    0xcbc(%rip),%rdi
movsd  0x58(%rsp),%xmm0
mov    $0x1,%al
call   1080 <printf@plt>
lea    0xcae(%rip),%rdi
mov    %r12d,%esi
mov    %r14d,%edx
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xc1a(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
movapd 0xbc0(%rip),%xmm0
movapd %xmm0,0x40(%rsp)
mov    $0x1,%r15b
test   %rax,%rax
je     1772 <main+0x522>
lea    0xbf9(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1772 <main+0x522>
lea    0xbe9(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    154d <main+0x2fd>
movsd  0xb9e(%rip),%xmm3
movapd 0x30(%rsp),%xmm2
addsd  %xmm2,%xmm3
movsd  0xb94(%rip),%xmm0
mulsd  %xmm0,%xmm3
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
divsd  0xb88(%rip),%xmm1
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm1
addsd  0xb80(%rip),%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
subsd  %xmm0,%xmm1
unpcklpd %xmm1,%xmm3
movapd %xmm3,0x40(%rsp)
jmp    1772 <main+0x522>
lea    0xb78(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1507 <main+0x2b7>
lea    0xb68(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    15f3 <main+0x3a3>
xor    %ebp,%ebp
mov    0x18(%r12),%rdi
test   %rdi,%rdi
jne    15a4 <main+0x354>
add    $0x18,%r12
jmp    15ca <main+0x37a>
cmp    $0x3e9,%ebp
jb     13b4 <main+0x164>
mov    0x2aad(%rip),%rax
mov    (%rax),%edi
lea    0xb62(%rip),%rsi
xor    %eax,%eax
call   10d0 <fprintf@plt>
mov    $0x1,%edi
call   1160 <exit@plt>
lea    0xb0a(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
movapd 0x30(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
test   %rax,%rax
je     1772 <main+0x522>
lea    0xaea(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    16c0 <main+0x470>
xorpd  %xmm0,%xmm0
movhpd 0xa87(%rip),%xmm0
movapd %xmm0,0x40(%rsp)
jmp    1772 <main+0x522>
add    $0x20,%r12
call   1070 <atof@plt>
xorpd  %xmm1,%xmm1
movapd %xmm0,0x30(%rsp)
ucomisd %xmm0,%xmm1
jae    15ca <main+0x37a>
test   %bpl,%bpl
jne    15d9 <main+0x389>
mov    $0x1,%r13b
jmp    12d7 <main+0x87>
xor    %r15d,%r15d
xor    %eax,%eax
call   1100 <usage@plt>
test   %bpl,%bpl
je     15eb <main+0x39b>
mov    (%r12),%rdi
test   %rdi,%rdi
jne    1692 <main+0x442>
jmp    16ae <main+0x45e>
mov    $0x1,%r13b
jmp    12da <main+0x8a>
lea    0xa6c(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     12d0 <main+0x80>
lea    0xa5d(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     12d0 <main+0x80>
lea    0xa49(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     12d0 <main+0x80>
lea    0xa38(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1507 <main+0x2b7>
lea    0xa26(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
mov    $0x1,%bpl
test   %rax,%rax
je     1509 <main+0x2b9>
mov    0x296b(%rip),%rax
mov    (%rax),%edi
lea    0xa07(%rip),%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   10d0 <fprintf@plt>
mov    $0x1,%edi
call   1160 <exit@plt>
add    $0x8,%r12
call   1070 <atof@plt>
mov    $0x1,%r13b
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x58(%rsp)
ucomisd %xmm0,%xmm1
jb     16b8 <main+0x468>
xor    %eax,%eax
call   1100 <usage@plt>
mov    $0x1,%r13b
mov    $0x1,%r15b
jmp    12da <main+0x8a>
lea    0x9a8(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    16e7 <main+0x497>
movapd 0x934(%rip),%xmm0
movapd %xmm0,0x40(%rsp)
jmp    1772 <main+0x522>
lea    0x985(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    1700 <main+0x4b0>
xor    %r15d,%r15d
jmp    1772 <main+0x522>
lea    0x973(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1772 <main+0x522>
lea    0x965(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    1b6f <main+0x91f>
movapd 0x30(%rsp),%xmm4
movapd %xmm4,%xmm0
movsd  0x58(%rsp),%xmm2
addsd  %xmm2,%xmm0
movapd %xmm4,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movsd  0x8c8(%rip),%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm2,%xmm3
unpcklpd %xmm1,%xmm4
unpcklpd %xmm3,%xmm0
divpd  %xmm0,%xmm4
movapd %xmm4,0x40(%rsp)
test   %ebp,%ebp
jle    1788 <main+0x538>
mov    %ebp,%edx
shl    $0x2,%rdx
lea    0x70(%rsp),%rdi
xor    %esi,%esi
call   1090 <memset@plt>
mov    %r14d,%edi
call   10e0 <rand_seed@plt>
test   %r12d,%r12d
mov    %r15d,0x60(%rsp)
jle    19b0 <main+0x760>
cvttsd2si 0x30(%rsp),%eax
mov    %eax,0x64(%rsp)
movsd  0x28(%rsp),%xmm1
subsd  0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x68(%rsp)
xorpd  %xmm3,%xmm3
lea    0x87a(%rip),%r15
lea    0x87b(%rip),%r13
mov    %r12d,%r14d
movl   $0x0,0x24(%rsp)
xor    %r12d,%r12d
xorpd  %xmm4,%xmm4
jmp    180a <main+0x5ba>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12d
addsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0xffffffff,%r14d
je     19c3 <main+0x773>
movsd  %xmm4,0x18(%rsp)
movsd  %xmm3,0x8(%rsp)
mov    %rbx,%rdi
mov    %r15,%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1900 <main+0x6b0>
mov    %rbx,%rdi
mov    %r13,%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1910 <main+0x6c0>
mov    %rbx,%rdi
lea    0x812(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1919 <main+0x6c9>
mov    %rbx,%rdi
lea    0x7fe(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1924 <main+0x6d4>
mov    %rbx,%rdi
lea    0x7ee(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1931 <main+0x6e1>
mov    %rbx,%rdi
lea    0x7df(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     193a <main+0x6ea>
mov    %rbx,%rdi
lea    0x7cb(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1943 <main+0x6f3>
mov    %rbx,%rdi
lea    0x7ba(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     194c <main+0x6fc>
mov    %rbx,%rdi
lea    0x7a8(%rip),%rsi
call   10b0 <strcmp@plt>
test   %rax,%rax
jne    1b6f <main+0x91f>
movapd 0x30(%rsp),%xmm0
movsd  0x58(%rsp),%xmm1
call   1170 <rand_beta@plt>
jmp    1960 <main+0x710>
nopl   0x0(%rax)
xor    %eax,%eax
call   1140 <rand_uniform@plt>
jmp    1960 <main+0x710>
nopl   0x0(%rax)
xor    %eax,%eax
call   10a0 <rand_uniopen@plt>
jmp    1960 <main+0x710>
mov    0x64(%rsp),%edi
call   1110 <rand_int@plt>
jmp    1960 <main+0x710>
movapd 0x30(%rsp),%xmm0
call   10f0 <rand_poisson@plt>
jmp    1960 <main+0x710>
xor    %eax,%eax
call   1120 <rand_gaussian@plt>
jmp    1960 <main+0x710>
xor    %eax,%eax
call   1060 <rand_exp@plt>
jmp    1960 <main+0x710>
xor    %eax,%eax
call   10c0 <rand_cauchy@plt>
jmp    1960 <main+0x710>
movapd 0x30(%rsp),%xmm0
call   1130 <rand_gamma@plt>
nopw   0x0(%rax,%rax,1)
movsd  0x10(%rsp),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x18(%rsp),%xmm4
test   %ebp,%ebp
jle    17f4 <main+0x5a4>
ucomisd %xmm0,%xmm2
ja     17f0 <main+0x5a0>
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
divsd  0x68(%rsp),%xmm1
cvttsd2si %xmm1,%eax
cmp    %eax,%ebp
jle    19a6 <main+0x756>
cltq
addl   $0x1,0x70(%rsp,%rax,4)
jmp    17f4 <main+0x5a4>
addl   $0x1,0x24(%rsp)
jmp    17f4 <main+0x5a4>
xor    %r12d,%r12d
xorpd  %xmm4,%xmm4
xorpd  %xmm3,%xmm3
movl   $0x0,0x24(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x20(%rsp),%xmm0
divsd  %xmm0,%xmm4
movsd  %xmm0,0x18(%rsp)
divsd  %xmm0,%xmm3
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
subsd  %xmm0,%xmm3
movsd  %xmm3,0x8(%rsp)
lea    0x70a(%rip),%rdi
movapd %xmm4,%xmm0
mov    $0x1,%al
call   1080 <printf@plt>
cmpb   $0x0,0x60(%rsp)
je     1a45 <main+0x7f5>
lea    0x707(%rip),%rbx
mov    %rbx,%rdi
movaps 0x40(%rsp),%xmm0
mov    $0x1,%al
call   1080 <printf@plt>
lea    0x706(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1080 <printf@plt>
movapd 0x40(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
jmp    1a70 <main+0x820>
lea    0x76c(%rip),%rbx
mov    %rbx,%rdi
call   1050 <puts@plt>
lea    0x6cd(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1080 <printf@plt>
mov    %rbx,%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %ebp,%ebp
je     1b68 <main+0x918>
lea    0x724(%rip),%rdi
call   1050 <puts@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
divsd  0x18(%rsp),%xmm0
lea    0x69b(%rip),%rdi
mov    %r12d,%esi
mov    $0x1,%al
call   1080 <printf@plt>
test   %ebp,%ebp
jle    1b3f <main+0x8ef>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x28(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %ebp,%ebp
xor    %eax,%eax
lea    0x687(%rip),%r14
nop
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x28(%rsp),%xmm3
mulsd  %xmm3,%xmm0
movsd  0x8(%rsp),%xmm4
divsd  %xmm4,%xmm0
lea    0x1(%rax),%rbx
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movsd  0x10(%rsp),%xmm2
addsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm1
divsd  %xmm4,%xmm1
addsd  %xmm2,%xmm1
mov    0x70(%rsp,%rax,4),%esi
xorps  %xmm2,%xmm2
cvtsi2sd %esi,%xmm2
divsd  0x18(%rsp),%xmm2
mov    %r14,%rdi
mov    $0x3,%al
call   1080 <printf@plt>
mov    %rbx,%rax
cmp    %rbx,%rbp
jne    1ae0 <main+0x890>
mov    0x24(%rsp),%esi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
divsd  0x18(%rsp),%xmm0
lea    0x62e(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %edi,%edi
call   1160 <exit@plt>
xor    %eax,%eax
call   1040 <abort@plt>

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

LLVM IR (-O2):
@.str = [2 x i8] c"0\00"
@.str.1 = [8 x i8] c"uniform\00"
@.str.2 = [8 x i8] c"uniopen\00"
@.str.3 = [4 x i8] c"int\00"
@.str.4 = [8 x i8] c"poisson\00"
@.str.5 = [9 x i8] c"gaussian\00"
@.str.6 = [4 x i8] c"exp\00"
@.str.7 = [7 x i8] c"cauchy\00"
@.str.8 = [6 x i8] c"gamma\00"
@.str.9 = [5 x i8] c"beta\00"
@stderr = global i32 0
@.str.10 = [23 x i8] c"Unknown generator: %s\0A\00"
@.str.11 = [2 x i8] c"/\00"
@.str.12 = [25 x i8] c"Too many histogram bins\0A\00"
@.str.13 = [13 x i8] c"\0ATest of %s(\00"
@.str.14 = [5 x i8] c"%.4f\00"
@.str.15 = [6 x i8] c",%.4f\00"
@.str.16 = [51 x i8] c") generator using sample of size %d with seed %d\0A\0A\00"
@.str.17 = [22 x i8] c"Sample mean: %.4f\00"
@.str.19 = [21 x i8] c" (true value: %.4f)\0A\00"
@.str.20 = [22 x i8] c"Sample variance: %.4f\00"
@.str.23 = [40 x i8] c" under : %8d %.5f\0A\0A\00"
@.str.24 = [31 x i8] c" %10.4f - %10.4f : %8d %.5f\0A\00"
@.str.25 = [40 x i8] c"\0A over : %8d %.5f\0A\00"
@str = [11 x i8] c"Histogram:\00"
@str.27 = [25 x i8] c" (true value: undefined)\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [1000 x i32]
%4 = bitcast [1000 x i32]* %3 to i8*
%5 = icmp slt i32 %0, 5
br i1 %5, label %6, label %8
6: ; preds = %2
%7 = tail call i32 (...) @usage()
br label %8
8: ; preds = %6, %2
%9 = getelementptr inbounds i8*, i8** %1, i64 1
%10 = load i8*, i8** %9
%11 = tail call i32 @atoi(i8* %10)
%12 = icmp eq i32 %11, 0
br i1 %12, label %13, label %18
13: ; preds = %8
%14 = tail call i64 @strcmp(i8* %10, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%15 = icmp eq i64 %14, 0
br i1 %15, label %18, label %16
16: ; preds = %13
%17 = tail call i32 (...) @usage()
br label %18
18: ; preds = %16, %13, %8
%19 = getelementptr inbounds i8*, i8** %1, i64 2
%20 = load i8*, i8** %19
%21 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%22 = icmp eq i64 %21, 0
br i1 %22, label %51, label %23
23: ; preds = %18
%24 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%25 = icmp eq i64 %24, 0
br i1 %25, label %51, label %26
26: ; preds = %23
%27 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%28 = icmp eq i64 %27, 0
br i1 %28, label %53, label %29
29: ; preds = %26
%30 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%31 = icmp eq i64 %30, 0
br i1 %31, label %53, label %32
32: ; preds = %29
%33 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%34 = icmp eq i64 %33, 0
br i1 %34, label %51, label %35
35: ; preds = %32
%36 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0))
%37 = icmp eq i64 %36, 0
br i1 %37, label %51, label %38
38: ; preds = %35
%39 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
%40 = icmp eq i64 %39, 0
br i1 %40, label %51, label %41
41: ; preds = %38
%42 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0))
%43 = icmp eq i64 %42, 0
br i1 %43, label %53, label %44
44: ; preds = %41
%45 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%46 = icmp eq i64 %45, 0
br i1 %46, label %53, label %47
47: ; preds = %44
%48 = load i32, i32* @stderr
%49 = tail call i32 (i32, i8*, ...) @fprintf(i32 %48, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.10, i64 0, i64 0), i8* %20)
%50 = tail call i32 @exit(i32 1)
unreachable
51: ; preds = %38, %35, %32, %23, %18
%52 = getelementptr inbounds i8*, i8** %1, i64 3
br label %84
53: ; preds = %26, %29, %41, %44
%54 = phi i1 [ false, %26 ], [ false, %29 ], [ false, %41 ], [ true, %44 ]
%55 = getelementptr inbounds i8*, i8** %1, i64 3
%56 = load i8*, i8** %55
%57 = icmp eq i8* %56, null
br i1 %57, label %64, label %58
58: ; preds = %53
%59 = getelementptr inbounds i8*, i8** %1, i64 4
%60 = ptrtoint i8* %56 to i64
%61 = trunc i64 %60 to i32
%62 = tail call double @atof(i32 %61)
%63 = fcmp ugt double %62, 0.000000e+00
br i1 %63, label %68, label %64
64: ; preds = %58, %53
%65 = phi double [ undef, %53 ], [ %62, %58 ]
%66 = phi i8** [ %55, %53 ], [ %59, %58 ]
%67 = tail call i32 (...) @usage()
br i1 %54, label %69, label %84
68: ; preds = %58
br i1 %54, label %69, label %84
69: ; preds = %64, %68
%70 = phi i8** [ %66, %64 ], [ %59, %68 ]
%71 = phi double [ %65, %64 ], [ %62, %68 ]
%72 = load i8*, i8** %70
%73 = icmp eq i8* %72, null
br i1 %73, label %80, label %74
74: ; preds = %69
%75 = getelementptr inbounds i8*, i8** %70, i64 1
%76 = ptrtoint i8* %72 to i64
%77 = trunc i64 %76 to i32
%78 = tail call double @atof(i32 %77)
%79 = fcmp ugt double %78, 0.000000e+00
br i1 %79, label %84, label %80
80: ; preds = %74, %69
%81 = phi double [ undef, %69 ], [ %78, %74 ]
%82 = phi i8** [ %70, %69 ], [ %75, %74 ]
%83 = tail call i32 (...) @usage()
br label %84
84: ; preds = %64, %51, %74, %80, %68
%85 = phi double [ %71, %80 ], [ %71, %74 ], [ %62, %68 ], [ undef, %51 ], [ %65, %64 ]
%86 = phi i1 [ true, %80 ], [ true, %74 ], [ true, %68 ], [ false, %51 ], [ true, %64 ]
%87 = phi i1 [ true, %80 ], [ true, %74 ], [ false, %68 ], [ false, %51 ], [ false, %64 ]
%88 = phi double [ %81, %80 ], [ %78, %74 ], [ undef, %68 ], [ undef, %51 ], [ undef, %64 ]
%89 = phi i8** [ %82, %80 ], [ %75, %74 ], [ %59, %68 ], [ %52, %51 ], [ %66, %64 ]
%90 = load i8*, i8** %89
%91 = icmp eq i8* %90, null
br i1 %91, label %96, label %92
92: ; preds = %84
%93 = getelementptr inbounds i8*, i8** %89, i64 1
%94 = tail call i64 @strcmp(i8* %90, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
%95 = icmp eq i64 %94, 0
br i1 %95, label %99, label %96
96: ; preds = %92, %84
%97 = phi i8** [ %89, %84 ], [ %93, %92 ]
%98 = tail call i32 (...) @usage()
br label %99
99: ; preds = %96, %92
%100 = phi i8** [ %97, %96 ], [ %93, %92 ]
%101 = load i8*, i8** %100
%102 = icmp eq i8* %101, null
br i1 %102, label %107, label %103
103: ; preds = %99
%104 = getelementptr inbounds i8*, i8** %100, i64 1
%105 = tail call i32 @atoi(i8* %101)
%106 = icmp slt i32 %105, 1
br i1 %106, label %107, label %111
107: ; preds = %103, %99
%108 = phi i32 [ undef, %99 ], [ %105, %103 ]
%109 = phi i8** [ %100, %99 ], [ %104, %103 ]
%110 = tail call i32 (...) @usage()
br label %111
111: ; preds = %107, %103
%112 = phi i32 [ %108, %107 ], [ %105, %103 ]
%113 = phi i8** [ %109, %107 ], [ %104, %103 ]
%114 = load i8*, i8** %113
%115 = icmp eq i8* %114, null
br i1 %115, label %159, label %116
116: ; preds = %111
%117 = getelementptr inbounds i8*, i8** %113, i64 1
%118 = ptrtoint i8* %114 to i64
%119 = trunc i64 %118 to i32
%120 = tail call double @atof(i32 %119)
%121 = load i8*, i8** %117
%122 = icmp eq i8* %121, null
br i1 %122, label %123, label %126
123: ; preds = %116
%124 = tail call i32 (...) @usage()
%125 = load i8*, i8** %117
br label %126
126: ; preds = %123, %116
%127 = phi i8* [ %125, %123 ], [ %121, %116 ]
%128 = getelementptr inbounds i8*, i8** %113, i64 2
%129 = ptrtoint i8* %127 to i64
%130 = trunc i64 %129 to i32
%131 = tail call double @atof(i32 %130)
%132 = fcmp ugt double %131, %120
br i1 %132, label %135, label %133
133: ; preds = %126
%134 = tail call i32 (...) @usage()
br label %135
135: ; preds = %133, %126
%136 = load i8*, i8** %128
%137 = icmp eq i8* %136, null
br i1 %137, label %142, label %138
138: ; preds = %135
%139 = getelementptr inbounds i8*, i8** %113, i64 3
%140 = tail call i32 @atoi(i8* %136)
%141 = icmp slt i32 %140, 1
br i1 %141, label %142, label %146
142: ; preds = %135, %138
%143 = phi i32 [ 0, %135 ], [ %140, %138 ]
%144 = phi i8** [ %128, %135 ], [ %139, %138 ]
%145 = tail call i32 (...) @usage()
br label %152
146: ; preds = %138
%147 = icmp ugt i32 %140, 1000
br i1 %147, label %148, label %152
148: ; preds = %146
%149 = load i32, i32* @stderr
%150 = tail call i32 (i32, i8*, ...) @fprintf(i32 %149, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.12, i64 0, i64 0))
%151 = tail call i32 @exit(i32 1)
unreachable
152: ; preds = %142, %146
%153 = phi i32 [ %143, %142 ], [ %140, %146 ]
%154 = phi i8** [ %144, %142 ], [ %139, %146 ]
%155 = load i8*, i8** %154
%156 = icmp eq i8* %155, null
br i1 %156, label %159, label %157
157: ; preds = %152
%158 = tail call i32 (...) @usage()
br label %159
159: ; preds = %111, %157, %152
%160 = phi double [ %131, %157 ], [ %131, %152 ], [ undef, %111 ]
%161 = phi double [ %120, %157 ], [ %120, %152 ], [ undef, %111 ]
%162 = phi i32 [ %153, %157 ], [ %153, %152 ], [ 0, %111 ]
%163 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.13, i64 0, i64 0), i8* %20)
br i1 %86, label %164, label %166
164: ; preds = %159
%165 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), double %85)
br label %166
166: ; preds = %164, %159
br i1 %87, label %167, label %169
167: ; preds = %166
%168 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.15, i64 0, i64 0), double %88)
br label %169
169: ; preds = %167, %166
%170 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.16, i64 0, i64 0), i32 %112, i32 %11)
%171 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%172 = icmp eq i64 %171, 0
br i1 %172, label %223, label %173
173: ; preds = %169
%174 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%175 = icmp eq i64 %174, 0
br i1 %175, label %223, label %176
176: ; preds = %173
%177 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%178 = icmp eq i64 %177, 0
br i1 %178, label %179, label %191
179: ; preds = %176
%180 = fadd double %85, -1.000000e+00
%181 = fmul double %180, 5.000000e-01
%182 = fmul double %85, %85
%183 = fdiv double %182, 3.000000e+00
%184 = fmul double %85, 5.000000e-01
%185 = fsub double %183, %184
%186 = fadd double %185, 0x3FC5555555555555
%187 = fneg double %181
%188 = tail call double @llvm.fmuladd.f64(double %187, double %181, double %186)
%189 = insertelement <2 x double> poison, double %181, i64 0
%190 = insertelement <2 x double> %189, double %188, i64 1
br label %223
191: ; preds = %176
%192 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%193 = icmp eq i64 %192, 0
%194 = insertelement <2 x double> poison, double %85, i64 0
%195 = shufflevector <2 x double> %194, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %193, label %223, label %196
196: ; preds = %191
%197 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%198 = icmp eq i64 %197, 0
br i1 %198, label %223, label %199
199: ; preds = %196
%200 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0))
%201 = icmp eq i64 %200, 0
br i1 %201, label %223, label %202
202: ; preds = %199
%203 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
%204 = icmp eq i64 %203, 0
br i1 %204, label %223, label %205
205: ; preds = %202
%206 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0))
%207 = icmp eq i64 %206, 0
br i1 %207, label %223, label %208
208: ; preds = %205
%209 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%210 = icmp eq i64 %209, 0
br i1 %210, label %211, label %221
211: ; preds = %208
%212 = fadd double %85, %88
%213 = fmul double %85, %88
%214 = fmul double %212, %212
%215 = fadd double %212, 1.000000e+00
%216 = fmul double %214, %215
%217 = insertelement <2 x double> %194, double %213, i64 1
%218 = insertelement <2 x double> poison, double %212, i64 0
%219 = insertelement <2 x double> %218, double %216, i64 1
%220 = fdiv <2 x double> %217, %219
br label %223
221: ; preds = %208
%222 = tail call i32 (...) @abort()
unreachable
223: ; preds = %205, %202, %199, %196, %191, %173, %169, %211, %179
%224 = phi i1 [ true, %179 ], [ true, %211 ], [ true, %169 ], [ true, %173 ], [ true, %191 ], [ true, %196 ], [ true, %199 ], [ false, %202 ], [ true, %205 ]
%225 = phi <2 x double> [ %190, %179 ], [ %220, %211 ], [ <double 5.000000e-01, double 0x3FB5555555555555>, %169 ], [ <double 5.000000e-01, double 0x3FB5555555555555>, %173 ], [ %195, %191 ], [ <double 0.000000e+00, double 1.000000e+00>, %196 ], [ <double 1.000000e+00, double 1.000000e+00>, %199 ], [ undef, %202 ], [ %195, %205 ]
%226 = icmp sgt i32 %162, 0
br i1 %226, label %227, label %230
227: ; preds = %223
%228 = zext i32 %162 to i64
%229 = shl nuw nsw i64 %228, 2
br label %230
230: ; preds = %227, %223
%231 = tail call i32 @rand_seed(i32 %11)
%232 = icmp sgt i32 %112, 0
br i1 %232, label %233, label %315
233: ; preds = %230
%234 = fptosi double %85 to i32
%235 = fsub double %160, %161
%236 = sitofp i32 %162 to double
%237 = fdiv double %235, %236
br label %238
238: ; preds = %233, %310
%239 = phi i32 [ 0, %233 ], [ %313, %310 ]
%240 = phi i32 [ 0, %233 ], [ %312, %310 ]
%241 = phi i32 [ 0, %233 ], [ %311, %310 ]
%242 = phi double [ 0.000000e+00, %233 ], [ %293, %310 ]
%243 = phi double [ 0.000000e+00, %233 ], [ %292, %310 ]
%244 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%245 = icmp eq i64 %244, 0
br i1 %245, label %246, label %248
246: ; preds = %238
%247 = tail call double (...) @rand_uniform()
br label %290
248: ; preds = %238
%249 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%250 = icmp eq i64 %249, 0
br i1 %250, label %251, label %253
251: ; preds = %248
%252 = tail call double (...) @rand_uniopen()
br label %290
253: ; preds = %248
%254 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%255 = icmp eq i64 %254, 0
br i1 %255, label %256, label %258
256: ; preds = %253
%257 = tail call double @rand_int(i32 %234)
br label %290
258: ; preds = %253
%259 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%260 = icmp eq i64 %259, 0
br i1 %260, label %261, label %263
261: ; preds = %258
%262 = tail call double @rand_poisson(double %85)
br label %290
263: ; preds = %258
%264 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%265 = icmp eq i64 %264, 0
br i1 %265, label %266, label %268
266: ; preds = %263
%267 = tail call double (...) @rand_gaussian()
br label %290
268: ; preds = %263
%269 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0))
%270 = icmp eq i64 %269, 0
br i1 %270, label %271, label %273
271: ; preds = %268
%272 = tail call double (...) @rand_exp()
br label %290
273: ; preds = %268
%274 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
%275 = icmp eq i64 %274, 0
br i1 %275, label %276, label %278
276: ; preds = %273
%277 = tail call double (...) @rand_cauchy()
br label %290
278: ; preds = %273
%279 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0))
%280 = icmp eq i64 %279, 0
br i1 %280, label %281, label %283
281: ; preds = %278
%282 = tail call double @rand_gamma(double %85)
br label %290
283: ; preds = %278
%284 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%285 = icmp eq i64 %284, 0
br i1 %285, label %286, label %288
286: ; preds = %283
%287 = tail call double @rand_beta(double %85, double %88)
br label %290
288: ; preds = %283
%289 = tail call i32 (...) @abort()
unreachable
290: ; preds = %251, %261, %271, %281, %286, %276, %266, %256, %246
%291 = phi double [ %247, %246 ], [ %252, %251 ], [ %257, %256 ], [ %262, %261 ], [ %267, %266 ], [ %272, %271 ], [ %277, %276 ], [ %282, %281 ], [ %287, %286 ]
%292 = fadd double %243, %291
%293 = tail call double @llvm.fmuladd.f64(double %291, double %291, double %242)
br i1 %226, label %294, label %310
294: ; preds = %290
%295 = fcmp olt double %291, %161
br i1 %295, label %296, label %298
296: ; preds = %294
%297 = add nsw i32 %241, 1
br label %310
298: ; preds = %294
%299 = fsub double %291, %161
%300 = fdiv double %299, %237
%301 = fptosi double %300 to i32
%302 = icmp sgt i32 %162, %301
br i1 %302, label %305, label %303
303: ; preds = %298
%304 = add nsw i32 %240, 1
br label %310
305: ; preds = %298
%306 = sext i32 %301 to i64
%307 = getelementptr inbounds [1000 x i32], [1000 x i32]* %3, i64 0, i64 %306
%308 = load i32, i32* %307
%309 = add nsw i32 %308, 1
store i32 %309, i32* %307
br label %310
310: ; preds = %290, %303, %305, %296
%311 = phi i32 [ %297, %296 ], [ %241, %303 ], [ %241, %305 ], [ %241, %290 ]
%312 = phi i32 [ %240, %296 ], [ %304, %303 ], [ %240, %305 ], [ %240, %290 ]
%313 = add nuw nsw i32 %239, 1
%314 = icmp eq i32 %313, %112
br i1 %314, label %315, label %238
315: ; preds = %310, %230
%316 = phi double [ 0.000000e+00, %230 ], [ %292, %310 ]
%317 = phi double [ 0.000000e+00, %230 ], [ %293, %310 ]
%318 = phi i32 [ 0, %230 ], [ %311, %310 ]
%319 = phi i32 [ 0, %230 ], [ %312, %310 ]
%320 = sitofp i32 %112 to double
%321 = fdiv double %316, %320
%322 = fdiv double %317, %320
%323 = fneg double %321
%324 = tail call double @llvm.fmuladd.f64(double %323, double %321, double %322)
%325 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.17, i64 0, i64 0), double %321)
br i1 %224, label %330, label %326
326: ; preds = %315
%327 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.27, i64 0, i64 0))
%328 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.20, i64 0, i64 0), double %324)
%329 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.27, i64 0, i64 0))
br label %336
330: ; preds = %315
%331 = extractelement <2 x double> %225, i64 0
%332 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.19, i64 0, i64 0), double %331)
%333 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.20, i64 0, i64 0), double %324)
%334 = extractelement <2 x double> %225, i64 1
%335 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.19, i64 0, i64 0), double %334)
br label %336
336: ; preds = %330, %326
%337 = tail call i32 @putchar(i32 10)
%338 = icmp eq i32 %162, 0
br i1 %338, label %372, label %339
339: ; preds = %336
%340 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str, i64 0, i64 0))
%341 = sitofp i32 %318 to double
%342 = fdiv double %341, %320
%343 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.23, i64 0, i64 0), i32 %318, double %342)
br i1 %226, label %344, label %367
344: ; preds = %339
%345 = fsub double %160, %161
%346 = sitofp i32 %162 to double
%347 = zext i32 %162 to i64
br label %348
348: ; preds = %344, %348
%349 = phi i64 [ 0, %344 ], [ %355, %348 ]
%350 = trunc i64 %349 to i32
%351 = sitofp i32 %350 to double
%352 = fmul double %345, %351
%353 = fdiv double %352, %346
%354 = fadd double %161, %353
%355 = add nuw nsw i64 %349, 1
%356 = trunc i64 %355 to i32
%357 = sitofp i32 %356 to double
%358 = fmul double %345, %357
%359 = fdiv double %358, %346
%360 = fadd double %161, %359
%361 = getelementptr inbounds [1000 x i32], [1000 x i32]* %3, i64 0, i64 %349
%362 = load i32, i32* %361
%363 = sitofp i32 %362 to double
%364 = fdiv double %363, %320
%365 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.24, i64 0, i64 0), double %354, double %360, i32 %362, double %364)
%366 = icmp eq i64 %355, %347
br i1 %366, label %367, label %348
367: ; preds = %348, %339
%368 = sitofp i32 %319 to double
%369 = fdiv double %368, %320
%370 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.25, i64 0, i64 0), i32 %319, double %369)
%371 = tail call i32 @putchar(i32 10)
br label %372
372: ; preds = %367, %336
%373 = tail call i32 @exit(i32 0)
unreachable
}