#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 */
double RAND_MAX;
int abs(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, double, double, double,
                           double, double);
int /*<<< orphan*/ printf(char *, double);
scalar_t__ rand();
int /*<<< orphan*/ sprintf(char *, char *, int, int, int, double, double,
                           double, double);
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main() {
  int op[10000], op_temp[10000];
  int state[10000], state_temp[10000];
  int A_cont, B_cont;
  double A_cum, B_cum;
  double A_ave, B_ave;
  double A[500], B[500];
  int S_cont, I_cont, V_cont;
  double S_cum, I_cum, V_cum;
  double S_ave, I_ave, V_ave;
  double S[500], I[500], V[500];
  double lambda;
  int soma_op;
  int n1, cont, cont2, count;
  int node1, node2, node3;
  int i, j, l, t, sample;
  double aux3, aux2, aux;
  double auxA, auxB;
  double r, num;
  srand(time(NULL));
  FILE *fp, *fq;
  char out_name[100], out_name2[100];
  sprintf(out_name2,
          "op_ep_phtr_simu%d_tmax%d_N%d_pao%3.2lf_alpha%3.2lf_gamma%3.2lf_phi%"
          "3.2lf.dat",
          1, 500, 10000, 0.60, 0.1, 0.2, 0.1);
  fq = fopen(out_name2, "w");
  for (lambda = 0; lambda <= 1.0; lambda += 0.05) {
    printf("lambda %3.2lf\n", lambda);
    for (t = 0; t < 500; t++) {
      S[t] = 0.0;
      I[t] = 0.0;
      V[t] = 0.0;
      A[t] = 0.0;
      B[t] = 0.0;
    }
    S_ave = 0.0;
    I_ave = 0.0;
    V_ave = 0.0;
    A_ave = 0.0;
    B_ave = 0.0;
    for (sample = 0; sample < 10; sample++) {
      S_cont = 0;
      I_cont = 0;
      V_cont = 0;
      A_cont = 0;
      B_cont = 0;
      S_cum = 0.0;
      I_cum = 0.0;
      V_cum = 0.0;
      A_cum = 0.0;
      B_cum = 0.0;
      count = 0;
      aux = 0.0;
      aux2 = 0.0;
      aux3 = 0.0;
      auxA = 0.0;
      auxB = 0.0;
      for (i = 0; i < 10000; i++) {
        r = ((double)rand() / RAND_MAX);
        if (r < 0.99) {
          state[i] = 0;
          state_temp[i] = 0;
          S_cont++;
        } else {
          state[i] = -1;
          state_temp[i] = -1;
          I_cont++;
        }
      }
      for (i = 0; i < 10000; i++) {
        r = ((double)rand() / RAND_MAX);
        if (r < 0.60) {
          op[i] = 1;
          op_temp[i] = 1;
          A_cont++;
        } else {
          op[i] = -1;
          op_temp[i] = -1;
          B_cont++;
        }
      }
      S[0] += ((double)S_cont);
      I[0] += ((double)I_cont);
      V[0] += ((double)V_cont);
      A[0] += ((double)A_cont);
      B[0] += ((double)B_cont);
      for (t = 1; t < 500; t++) {
        for (node1 = 0; node1 < 10000; node1++) {
          do {
            r = ((double)rand() / RAND_MAX);
            node2 = ((int)10000 * r);
          } while (node2 == node1);
          do {
            r = ((double)rand() / RAND_MAX);
            node3 = ((int)10000 * r);
          } while (node3 == node1 || node3 == node2);
          soma_op = op[node1] + op[node2] + op[node3];
          if (abs(soma_op) < 3) {
            if (soma_op > 0) {
              op_temp[node1] = +1;
              op_temp[node2] = +1;
              op_temp[node3] = +1;
            } else {
              op_temp[node1] = -1;
              op_temp[node2] = -1;
              op_temp[node3] = -1;
            }
          }
        }
        for (j = 0; j < 10000; j++)
          op[j] = op_temp[j];
        for (node1 = 0; node1 < 10000; node1++) {
          if (op[node1] == +1) {
            if (state[node1] == 0) {
              num = ((double)rand() / RAND_MAX);
              if (num <= 0.2) {
                state_temp[node1] = +1;
              } else {
                do {
                  r = ((double)rand() / RAND_MAX);
                  node2 = ((int)10000 * r);
                } while (node2 == node1);
                if (state[node2] == -1) {
                  num = ((double)rand() / RAND_MAX);
                  if (num <= lambda) {
                    state_temp[node1] = -1;
                  }
                }
              }
            }
            if (state[node1] == -1) {
              num = ((double)rand() / RAND_MAX);
              if (num <= 0.1) {
                state_temp[node1] = 0;
              }
            }
            if (state[node1] == 1) {
              num = ((double)rand() / RAND_MAX);
              if (num <= 0.1) {
                state_temp[node1] = 0;
              }
            }
          }
          if (op[node1] == -1) {
            if (state[node1] == 0) {
              do {
                r = ((double)rand() / RAND_MAX);
                node2 = ((int)10000 * r);
              } while (node2 == node1);
              if (state[node2] == -1) {
                num = ((double)rand() / RAND_MAX);
                if (num <= lambda) {
                  state_temp[node1] = -1;
                }
              }
            }
            if (state[node1] == -1) {
              num = ((double)rand() / RAND_MAX);
              if (num <= 0.1) {
                state_temp[node1] = 0;
              }
            }
            if (state[node1] == +1) {
              num = ((double)rand() / RAND_MAX);
              if (num <= 0.1) {
                state_temp[node1] = 0;
              }
            }
          }
        }
        for (j = 0; j < 10000; j++)
          state[j] = state_temp[j];
        S_cont = 0;
        I_cont = 0;
        V_cont = 0;
        A_cont = 0;
        B_cont = 0;
        for (i = 0; i < 10000; i++) {
          if (state[i] == 1)
            V_cont++;
          if (state[i] == 0)
            S_cont++;
          if (state[i] == -1)
            I_cont++;
          if (op[i] == +1)
            A_cont++;
          if (op[i] == -1)
            B_cont++;
        }
        S[t] += ((double)S_cont);
        I[t] += ((double)I_cont);
        V[t] += ((double)V_cont);
        A[t] += ((double)A_cont);
        B[t] += ((double)B_cont);
        if (t > 400) {
          S_cum += S_cont;
          I_cum += I_cont;
          V_cum += V_cont;
          A_cum += A_cont;
          B_cum += B_cont;
          count++;
        }
      }
      aux = ((double)S_cum / (10000 * count));
      aux2 = ((double)I_cum / (10000 * count));
      aux3 = ((double)V_cum / (10000 * count));
      auxA = ((double)A_cum / (10000 * count));
      auxB = ((double)B_cum / (10000 * count));
      S_ave += aux;
      I_ave += aux2;
      V_ave += aux3;
      A_ave += auxA;
      B_ave += auxB;
    }
    fprintf(fq, "%8.6lf\t%8.6lf\t%8.6lf\t%8.6lf\t%8.6lf\n", lambda,
            (S_ave / 10), (I_ave / 10), (V_ave / 10), (A_ave / 10));
  }
  fclose(fq);
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2c110,%rsp
movl   $0x0,-0x4(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1080 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
lea    -0x2c100(%rbp),%rdi
lea    0x1e80(%rip),%rsi
mov    $0x1,%edx
mov    $0x1f4,%ecx
mov    $0x2710,%r8d
movsd  0x1e28(%rip),%xmm0
movsd  0x1e28(%rip),%xmm3
movsd  0x1e28(%rip),%xmm2
movaps %xmm3,%xmm1
call   10a0 <sprintf@plt>
lea    -0x2c100(%rbp),%rdi
lea    0x1e8f(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x2c028(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2bfa8(%rbp)
ff
movsd  0x1dfb(%rip),%xmm0
ucomisd -0x2bfa8(%rbp),%xmm0
ff
jb     205b <main+0xecb>
movsd  -0x2bfa8(%rbp),%xmm0
ff
lea    0x1e55(%rip),%rdi
call   1050 <printf@plt>
movl   $0x0,-0x2bfd8(%rbp)
cmpl   $0x1f4,-0x2bfd8(%rbp)
jge    12cc <main+0x13c>
movslq -0x2bfd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a060(%rbp,%rax,8)
fd ff
movslq -0x2bfd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b000(%rbp,%rax,8)
fd ff
movslq -0x2bfd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2bfa0(%rbp,%rax,8)
fd ff
movslq -0x2bfd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x280e0(%rbp,%rax,8)
fd ff
movslq -0x2bfd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29080(%rbp,%rax,8)
fd ff
mov    -0x2bfd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfd8(%rbp)
jmp    1249 <main+0xb9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290b0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290b8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x27130(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x27138(%rbp)
ff
movl   $0x0,-0x2bfdc(%rbp)
cmpl   $0xa,-0x2bfdc(%rbp)
jge    1fd3 <main+0xe43>
movl   $0x0,-0x29084(%rbp)
movl   $0x0,-0x29088(%rbp)
movl   $0x0,-0x2908c(%rbp)
movl   $0x0,-0x27114(%rbp)
movl   $0x0,-0x27118(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29098(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290a8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x27120(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x27128(%rbp)
ff
movl   $0x0,-0x2bfbc(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2bff8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2bff0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2bfe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c000(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2c008(%rbp)
ff
movl   $0x0,-0x2bfcc(%rbp)
cmpl   $0x2710,-0x2bfcc(%rbp)
jge    1497 <main+0x307>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3bf7(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c010(%rbp)
ff
movsd  0x1c33(%rip),%xmm0
ucomisd -0x2c010(%rbp),%xmm0
ff
jbe    144b <main+0x2bb>
movslq -0x2bfcc(%rbp),%rax
movl   $0x0,-0x1d4d0(%rbp,%rax,4)
movslq -0x2bfcc(%rbp),%rax
movl   $0x0,-0x27110(%rbp,%rax,4)
mov    -0x29084(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29084(%rbp)
jmp    147e <main+0x2ee>
movslq -0x2bfcc(%rbp),%rax
movl   $0xffffffff,-0x1d4d0(%rbp,%rax,4)
ff ff ff ff
movslq -0x2bfcc(%rbp),%rax
movl   $0xffffffff,-0x27110(%rbp,%rax,4)
ff ff ff ff
mov    -0x29088(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29088(%rbp)
jmp    1483 <main+0x2f3>
mov    -0x2bfcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfcc(%rbp)
jmp    13ce <main+0x23e>
movl   $0x0,-0x2bfcc(%rbp)
cmpl   $0x2710,-0x2bfcc(%rbp)
jge    156a <main+0x3da>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3b24(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c010(%rbp)
ff
movsd  0x1b28(%rip),%xmm0
ucomisd -0x2c010(%rbp),%xmm0
ff
jbe    151e <main+0x38e>
movslq -0x2bfcc(%rbp),%rax
movl   $0x1,-0x9c50(%rbp,%rax,4)
movslq -0x2bfcc(%rbp),%rax
movl   $0x1,-0x13890(%rbp,%rax,4)
mov    -0x27114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27114(%rbp)
jmp    1551 <main+0x3c1>
movslq -0x2bfcc(%rbp),%rax
movl   $0xffffffff,-0x9c50(%rbp,%rax,4)
ff ff ff ff
movslq -0x2bfcc(%rbp),%rax
movl   $0xffffffff,-0x13890(%rbp,%rax,4)
ff ff ff ff
mov    -0x27118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27118(%rbp)
jmp    1556 <main+0x3c6>
mov    -0x2bfcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfcc(%rbp)
jmp    14a1 <main+0x311>
cvtsi2sdl -0x29084(%rbp),%xmm0
ff
addsd  -0x2a060(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a060(%rbp)
ff
cvtsi2sdl -0x29088(%rbp),%xmm0
ff
addsd  -0x2b000(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b000(%rbp)
ff
cvtsi2sdl -0x2908c(%rbp),%xmm0
ff
addsd  -0x2bfa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2bfa0(%rbp)
ff
cvtsi2sdl -0x27114(%rbp),%xmm0
ff
addsd  -0x280e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x280e0(%rbp)
ff
cvtsi2sdl -0x27118(%rbp),%xmm0
ff
addsd  -0x29080(%rbp),%xmm0
ff
movsd  %xmm0,-0x29080(%rbp)
ff
movl   $0x1,-0x2bfd8(%rbp)
cmpl   $0x1f4,-0x2bfd8(%rbp)
jge    1e9d <main+0xd0d>
movl   $0x0,-0x2bfc0(%rbp)
cmpl   $0x2710,-0x2bfc0(%rbp)
jge    17c1 <main+0x631>
jmp    161b <main+0x48b>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x39ba(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c010(%rbp)
ff
movsd  0x19ee(%rip),%xmm0
mulsd  -0x2c010(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x2bfc4(%rbp)
mov    -0x2bfc4(%rbp),%eax
cmp    -0x2bfc0(%rbp),%eax
je     161b <main+0x48b>
jmp    166b <main+0x4db>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x396a(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c010(%rbp)
ff
movsd  0x199e(%rip),%xmm0
mulsd  -0x2c010(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x2bfc8(%rbp)
mov    -0x2bfc8(%rbp),%ecx
mov    $0x1,%al
cmp    -0x2bfc0(%rbp),%ecx
mov    %al,-0x2c101(%rbp)
je     16d3 <main+0x543>
mov    -0x2bfc8(%rbp),%eax
cmp    -0x2bfc4(%rbp),%eax
sete   %al
mov    %al,-0x2c101(%rbp)
mov    -0x2c101(%rbp),%al
test   $0x1,%al
jne    166b <main+0x4db>
movslq -0x2bfc0(%rbp),%rax
mov    -0x9c50(%rbp,%rax,4),%eax
movslq -0x2bfc4(%rbp),%rcx
add    -0x9c50(%rbp,%rcx,4),%eax
movslq -0x2bfc8(%rbp),%rcx
add    -0x9c50(%rbp,%rcx,4),%eax
mov    %eax,-0x2bfac(%rbp)
mov    -0x2bfac(%rbp),%edi
call   1030 <abs@plt>
cmp    $0x3,%eax
jge    17a8 <main+0x618>
cmpl   $0x0,-0x2bfac(%rbp)
jle    176d <main+0x5dd>
movslq -0x2bfc0(%rbp),%rax
movl   $0x1,-0x13890(%rbp,%rax,4)
movslq -0x2bfc4(%rbp),%rax
movl   $0x1,-0x13890(%rbp,%rax,4)
movslq -0x2bfc8(%rbp),%rax
movl   $0x1,-0x13890(%rbp,%rax,4)
jmp    17a3 <main+0x613>
movslq -0x2bfc0(%rbp),%rax
movl   $0xffffffff,-0x13890(%rbp,%rax,4)
ff ff ff ff
movslq -0x2bfc4(%rbp),%rax
movl   $0xffffffff,-0x13890(%rbp,%rax,4)
ff ff ff ff
movslq -0x2bfc8(%rbp),%rax
movl   $0xffffffff,-0x13890(%rbp,%rax,4)
ff ff ff ff
jmp    17a8 <main+0x618>
jmp    17ad <main+0x61d>
mov    -0x2bfc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfc0(%rbp)
jmp    1606 <main+0x476>
movl   $0x0,-0x2bfd0(%rbp)
cmpl   $0x2710,-0x2bfd0(%rbp)
jge    180b <main+0x67b>
movslq -0x2bfd0(%rbp),%rax
mov    -0x13890(%rbp,%rax,4),%ecx
movslq -0x2bfd0(%rbp),%rax
mov    %ecx,-0x9c50(%rbp,%rax,4)
mov    -0x2bfd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfd0(%rbp)
jmp    17cb <main+0x63b>
movl   $0x0,-0x2bfc0(%rbp)
cmpl   $0x2710,-0x2bfc0(%rbp)
jge    1be5 <main+0xa55>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0x1,-0x9c50(%rbp,%rax,4)
01
jne    1a21 <main+0x891>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0x0,-0x1d4d0(%rbp,%rax,4)
jne    195a <main+0x7ca>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3786(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c018(%rbp)
ff
movsd  0x179a(%rip),%xmm0
ucomisd -0x2c018(%rbp),%xmm0
ff
jb     189b <main+0x70b>
movslq -0x2bfc0(%rbp),%rax
movl   $0x1,-0x27110(%rbp,%rax,4)
jmp    1955 <main+0x7c5>
jmp    18a0 <main+0x710>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3735(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c010(%rbp)
ff
movsd  0x1769(%rip),%xmm0
mulsd  -0x2c010(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x2bfc4(%rbp)
mov    -0x2bfc4(%rbp),%eax
cmp    -0x2bfc0(%rbp),%eax
je     18a0 <main+0x710>
movslq -0x2bfc4(%rbp),%rax
cmpl   $0xffffffff,-0x1d4d0(%rbp,%rax,4)
ff
jne    1950 <main+0x7c0>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x36d5(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c018(%rbp)
ff
movsd  -0x2c018(%rbp),%xmm1
ff
movsd  -0x2bfa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     194b <main+0x7bb>
movslq -0x2bfc0(%rbp),%rax
movl   $0xffffffff,-0x27110(%rbp,%rax,4)
ff ff ff ff
jmp    1950 <main+0x7c0>
jmp    1955 <main+0x7c5>
jmp    195a <main+0x7ca>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0xffffffff,-0x1d4d0(%rbp,%rax,4)
ff
jne    19bb <main+0x82b>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3666(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c018(%rbp)
ff
movsd  0x1672(%rip),%xmm0
ucomisd -0x2c018(%rbp),%xmm0
ff
jb     19b6 <main+0x826>
movslq -0x2bfc0(%rbp),%rax
movl   $0x0,-0x27110(%rbp,%rax,4)
jmp    19bb <main+0x82b>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0x1,-0x1d4d0(%rbp,%rax,4)
01
jne    1a1c <main+0x88c>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3605(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c018(%rbp)
ff
movsd  0x1611(%rip),%xmm0
ucomisd -0x2c018(%rbp),%xmm0
ff
jb     1a17 <main+0x887>
movslq -0x2bfc0(%rbp),%rax
movl   $0x0,-0x27110(%rbp,%rax,4)
jmp    1a1c <main+0x88c>
jmp    1a21 <main+0x891>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0xffffffff,-0x9c50(%rbp,%rax,4)
ff
jne    1bcc <main+0xa3c>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0x0,-0x1d4d0(%rbp,%rax,4)
jne    1b05 <main+0x975>
jmp    1a50 <main+0x8c0>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3585(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c010(%rbp)
ff
movsd  0x15b9(%rip),%xmm0
mulsd  -0x2c010(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x2bfc4(%rbp)
mov    -0x2bfc4(%rbp),%eax
cmp    -0x2bfc0(%rbp),%eax
je     1a50 <main+0x8c0>
movslq -0x2bfc4(%rbp),%rax
cmpl   $0xffffffff,-0x1d4d0(%rbp,%rax,4)
ff
jne    1b00 <main+0x970>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x3525(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c018(%rbp)
ff
movsd  -0x2c018(%rbp),%xmm1
ff
movsd  -0x2bfa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1afb <main+0x96b>
movslq -0x2bfc0(%rbp),%rax
movl   $0xffffffff,-0x27110(%rbp,%rax,4)
ff ff ff ff
jmp    1b00 <main+0x970>
jmp    1b05 <main+0x975>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0xffffffff,-0x1d4d0(%rbp,%rax,4)
ff
jne    1b66 <main+0x9d6>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x34bb(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c018(%rbp)
ff
movsd  0x14c7(%rip),%xmm0
ucomisd -0x2c018(%rbp),%xmm0
ff
jb     1b61 <main+0x9d1>
movslq -0x2bfc0(%rbp),%rax
movl   $0x0,-0x27110(%rbp,%rax,4)
jmp    1b66 <main+0x9d6>
movslq -0x2bfc0(%rbp),%rax
cmpl   $0x1,-0x1d4d0(%rbp,%rax,4)
01
jne    1bc7 <main+0xa37>
mov    $0x0,%al
call   10b0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x345a(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x2c018(%rbp)
ff
movsd  0x1466(%rip),%xmm0
ucomisd -0x2c018(%rbp),%xmm0
ff
jb     1bc2 <main+0xa32>
movslq -0x2bfc0(%rbp),%rax
movl   $0x0,-0x27110(%rbp,%rax,4)
jmp    1bc7 <main+0xa37>
jmp    1bcc <main+0xa3c>
jmp    1bd1 <main+0xa41>
mov    -0x2bfc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfc0(%rbp)
jmp    1815 <main+0x685>
movl   $0x0,-0x2bfd0(%rbp)
cmpl   $0x2710,-0x2bfd0(%rbp)
jge    1c2f <main+0xa9f>
movslq -0x2bfd0(%rbp),%rax
mov    -0x27110(%rbp,%rax,4),%ecx
movslq -0x2bfd0(%rbp),%rax
mov    %ecx,-0x1d4d0(%rbp,%rax,4)
mov    -0x2bfd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfd0(%rbp)
jmp    1bef <main+0xa5f>
movl   $0x0,-0x29084(%rbp)
movl   $0x0,-0x29088(%rbp)
movl   $0x0,-0x2908c(%rbp)
movl   $0x0,-0x27114(%rbp)
movl   $0x0,-0x27118(%rbp)
movl   $0x0,-0x2bfcc(%rbp)
cmpl   $0x2710,-0x2bfcc(%rbp)
jge    1d48 <main+0xbb8>
movslq -0x2bfcc(%rbp),%rax
cmpl   $0x1,-0x1d4d0(%rbp,%rax,4)
01
jne    1c9f <main+0xb0f>
mov    -0x2908c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2908c(%rbp)
movslq -0x2bfcc(%rbp),%rax
cmpl   $0x0,-0x1d4d0(%rbp,%rax,4)
jne    1cc3 <main+0xb33>
mov    -0x29084(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29084(%rbp)
movslq -0x2bfcc(%rbp),%rax
cmpl   $0xffffffff,-0x1d4d0(%rbp,%rax,4)
ff
jne    1ce7 <main+0xb57>
mov    -0x29088(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29088(%rbp)
movslq -0x2bfcc(%rbp),%rax
cmpl   $0x1,-0x9c50(%rbp,%rax,4)
01
jne    1d0b <main+0xb7b>
mov    -0x27114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27114(%rbp)
movslq -0x2bfcc(%rbp),%rax
cmpl   $0xffffffff,-0x9c50(%rbp,%rax,4)
ff
jne    1d2f <main+0xb9f>
mov    -0x27118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27118(%rbp)
jmp    1d34 <main+0xba4>
mov    -0x2bfcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfcc(%rbp)
jmp    1c6b <main+0xadb>
cvtsi2sdl -0x29084(%rbp),%xmm0
ff
movslq -0x2bfd8(%rbp),%rax
addsd  -0x2a060(%rbp,%rax,8),%xmm0
fd ff
movsd  %xmm0,-0x2a060(%rbp,%rax,8)
fd ff
cvtsi2sdl -0x29088(%rbp),%xmm0
ff
movslq -0x2bfd8(%rbp),%rax
addsd  -0x2b000(%rbp,%rax,8),%xmm0
fd ff
movsd  %xmm0,-0x2b000(%rbp,%rax,8)
fd ff
cvtsi2sdl -0x2908c(%rbp),%xmm0
ff
movslq -0x2bfd8(%rbp),%rax
addsd  -0x2bfa0(%rbp,%rax,8),%xmm0
fd ff
movsd  %xmm0,-0x2bfa0(%rbp,%rax,8)
fd ff
cvtsi2sdl -0x27114(%rbp),%xmm0
ff
movslq -0x2bfd8(%rbp),%rax
addsd  -0x280e0(%rbp,%rax,8),%xmm0
fd ff
movsd  %xmm0,-0x280e0(%rbp,%rax,8)
fd ff
cvtsi2sdl -0x27118(%rbp),%xmm0
ff
movslq -0x2bfd8(%rbp),%rax
addsd  -0x29080(%rbp,%rax,8),%xmm0
fd ff
movsd  %xmm0,-0x29080(%rbp,%rax,8)
fd ff
cmpl   $0x190,-0x2bfd8(%rbp)
jle    1e84 <main+0xcf4>
cvtsi2sdl -0x29084(%rbp),%xmm0
ff
addsd  -0x29098(%rbp),%xmm0
ff
movsd  %xmm0,-0x29098(%rbp)
ff
cvtsi2sdl -0x29088(%rbp),%xmm0
ff
addsd  -0x290a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x290a0(%rbp)
ff
cvtsi2sdl -0x2908c(%rbp),%xmm0
ff
addsd  -0x290a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x290a8(%rbp)
ff
cvtsi2sdl -0x27114(%rbp),%xmm0
ff
addsd  -0x27120(%rbp),%xmm0
ff
movsd  %xmm0,-0x27120(%rbp)
ff
cvtsi2sdl -0x27118(%rbp),%xmm0
ff
addsd  -0x27128(%rbp),%xmm0
ff
movsd  %xmm0,-0x27128(%rbp)
ff
mov    -0x2bfbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfbc(%rbp)
jmp    1e89 <main+0xcf9>
mov    -0x2bfd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfd8(%rbp)
jmp    15ec <main+0x45c>
movsd  -0x29098(%rbp),%xmm0
ff
imul   $0x2710,-0x2bfbc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2bff8(%rbp)
ff
movsd  -0x290a0(%rbp),%xmm0
ff
imul   $0x2710,-0x2bfbc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2bff0(%rbp)
ff
movsd  -0x290a8(%rbp),%xmm0
ff
imul   $0x2710,-0x2bfbc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2bfe8(%rbp)
ff
movsd  -0x27120(%rbp),%xmm0
ff
imul   $0x2710,-0x2bfbc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c000(%rbp)
ff
movsd  -0x27128(%rbp),%xmm0
ff
imul   $0x2710,-0x2bfbc(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c008(%rbp)
ff
movsd  -0x2bff8(%rbp),%xmm0
ff
addsd  -0x290b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x290b0(%rbp)
ff
movsd  -0x2bff0(%rbp),%xmm0
ff
addsd  -0x290b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x290b8(%rbp)
ff
movsd  -0x2bfe8(%rbp),%xmm0
ff
addsd  -0x290c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x290c0(%rbp)
ff
movsd  -0x2c000(%rbp),%xmm0
ff
addsd  -0x27130(%rbp),%xmm0
ff
movsd  %xmm0,-0x27130(%rbp)
ff
movsd  -0x2c008(%rbp),%xmm0
ff
addsd  -0x27138(%rbp),%xmm0
ff
movsd  %xmm0,-0x27138(%rbp)
ff
mov    -0x2bfdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2bfdc(%rbp)
jmp    130d <main+0x17d>
mov    -0x2c028(%rbp),%rdi
movsd  -0x2bfa8(%rbp),%xmm0
ff
movsd  -0x290b0(%rbp),%xmm1
ff
movsd  0x102e(%rip),%xmm2
divsd  %xmm2,%xmm1
movsd  -0x290b8(%rbp),%xmm2
ff
movsd  0x101a(%rip),%xmm3
divsd  %xmm3,%xmm2
movsd  -0x290c0(%rbp),%xmm3
ff
movsd  0x1006(%rip),%xmm4
divsd  %xmm4,%xmm3
movsd  -0x27130(%rbp),%xmm4
ff
movsd  0xff2(%rip),%xmm5
divsd  %xmm5,%xmm4
lea    0x1065(%rip),%rsi
call   1070 <fprintf@plt>
movsd  0xfe2(%rip),%xmm0
addsd  -0x2bfa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2bfa8(%rbp)
ff
jmp    1215 <main+0x85>
mov    -0x2c028(%rbp),%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
add    $0x2c110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2c038,%rsp
xor    %edi,%edi
call   1090 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
lea    0xe8a(%rip),%rsi
lea    0xa0(%rsp),%rbx
movsd  0xe2a(%rip),%xmm0
movq   0xe2a(%rip),%xmm2
movq   0xe2a(%rip),%xmm1
mov    %rbx,%rdi
mov    $0x1,%edx
mov    $0x1f4,%ecx
mov    $0x2710,%r8d
movdqa %xmm1,%xmm3
call   10b0 <sprintf@plt>
lea    0xe94(%rip),%rsi
mov    %rbx,%rdi
call   10a0 <fopen@plt>
mov    %rax,0x38(%rsp)
xorpd  %xmm0,%xmm0
mov    0x2dc7(%rip),%r14
jmp    12dd <main+0x13d>
cs nopw 0x0(%rax,%rax,1)
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x2050(%rsp)
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10b0(%rsp)
movq   $0x0,0x110(%rsp)
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x3f90(%rsp)
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x2ff0(%rsp)
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movsd  0xda0(%rip),%xmm0
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm2
movapd 0x40(%rsp),%xmm4
movapd %xmm4,%xmm3
unpckhpd %xmm4,%xmm3
divsd  %xmm0,%xmm3
divsd  %xmm0,%xmm4
mov    0x38(%rsp),%rdi
lea    0xdfc(%rip),%rsi
movsd  0x8(%rsp),%xmm0
call   1070 <fprintf@plt>
movsd  0x8(%rsp),%xmm0
addsd  0xd65(%rip),%xmm0
movsd  0xd65(%rip),%xmm1
ucomisd %xmm0,%xmm1
jb     1992 <main+0x7f2>
lea    0xdbb(%rip),%rdi
movsd  %xmm0,0x8(%rsp)
call   1040 <printf@plt>
mov    $0xfa0,%edx
lea    0x2050(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0xfa0,%edx
lea    0x10b0(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0xfa0,%edx
lea    0x110(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0xfa0,%edx
lea    0x3f90(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0xfa0,%edx
lea    0x2ff0(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
pxor   %xmm2,%xmm2
jmp    141e <main+0x27e>
movsd  0x10(%rsp),%xmm0
addsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x20(%rsp),%xmm0
addsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
imul   $0x2710,%eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x28(%rsp),%xmm1
addsd  0x88(%rsp),%xmm1
movsd  %xmm1,0x28(%rsp)
unpcklpd %xmm0,%xmm0
movapd 0x60(%rsp),%xmm2
divpd  %xmm0,%xmm2
movapd 0x40(%rsp),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x40(%rsp)
movapd 0x50(%rsp),%xmm1
divpd  %xmm0,%xmm1
movapd 0x90(%rsp),%xmm2
addpd  %xmm1,%xmm2
mov    0x34(%rsp),%eax
add    $0x1,%eax
cmp    $0xa,%eax
je     1230 <main+0x90>
mov    %eax,0x34(%rsp)
movdqa %xmm2,0x90(%rsp)
xor    %ebx,%ebx
xor    %r15d,%r15d
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
xor    %eax,%eax
xor    %ecx,%ecx
movsd  0xbb8(%rip),%xmm1
ucomisd %xmm0,%xmm1
seta   %al
setbe  %cl
add    %ecx,%r12d
neg    %ecx
add    %eax,%r15d
mov    %ecx,0x4f30(%rsp,%rbx,4)
mov    %ecx,0x223f0(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0x2710,%rbx
jne    1440 <main+0x2a0>
xor    %r13d,%r13d
xor    %ebx,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
xor    %eax,%eax
xor    %ecx,%ecx
movsd  0xb40(%rip),%xmm1
ucomisd %xmm0,%xmm1
setbe  %al
seta   %cl
lea    (%rcx,%rcx,1),%edx
add    $0xffffffff,%edx
add    %eax,%ebp
add    %ecx,%ebx
mov    %edx,0xeb70(%rsp,%r13,4)
mov    %edx,0x187b0(%rsp,%r13,4)
add    $0x1,%r13
cmp    $0x2710,%r13
jne    14a0 <main+0x300>
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
movsd  %xmm0,0x80(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,0x78(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movsd  %xmm0,0x88(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x60(%rsp)
xor    %eax,%eax
mov    $0x1,%r13d
xorpd  %xmm0,%xmm0
movapd %xmm0,0x50(%rsp)
jmp    1571 <main+0x3d1>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
cmp    $0x1f4,%r13
je     1390 <main+0x1f0>
mov    %eax,%r15d
xor    %ebp,%ebp
jmp    1590 <main+0x3f0>
add    $0x1,%rbp
cmp    $0x2710,%rbp
je     1640 <main+0x4a0>
nopl   0x0(%rax)
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
mulsd  0xa74(%rip),%xmm0
cvttsd2si %xmm0,%ebx
cmp    %rbx,%rbp
je     1590 <main+0x3f0>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
mulsd  0xa44(%rip),%xmm0
cvttsd2si %xmm0,%ecx
cmp    %rcx,%rbp
je     15c0 <main+0x420>
cmp    %ebx,%ecx
je     15c0 <main+0x420>
movslq %ebx,%rax
mov    0xeb70(%rsp,%rax,4),%edx
add    0xeb70(%rsp,%rbp,4),%edx
movslq %ecx,%rcx
add    0xeb70(%rsp,%rcx,4),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x2,%esi
ja     1578 <main+0x3d8>
xor    %esi,%esi
test   %edx,%edx
setg   %sil
lea    -0x1(%rsi,%rsi,1),%edx
mov    %edx,0x187b0(%rsp,%rbp,4)
mov    %edx,0x187b0(%rsp,%rax,4)
mov    %edx,0x187b0(%rsp,%rcx,4)
jmp    1578 <main+0x3d8>
nopw   0x0(%rax,%rax,1)
mov    $0x9c40,%edx
lea    0xeb70(%rsp),%rdi
lea    0x187b0(%rsp),%rsi
call   1080 <memcpy@plt>
xor    %r12d,%r12d
jmp    1679 <main+0x4d9>
nop
mov    %ebp,0x223f0(%rsp,%r12,4)
add    $0x1,%r12
cmp    $0x2710,%r12
je     17c0 <main+0x620>
mov    0xeb70(%rsp,%r12,4),%eax
cmp    $0xffffffff,%eax
je     1700 <main+0x560>
cmp    $0x1,%eax
jne    1668 <main+0x4c8>
mov    0x4f30(%rsp,%r12,4),%eax
cmp    $0xffffffff,%eax
je     1790 <main+0x5f0>
cmp    $0x1,%eax
je     1790 <main+0x5f0>
test   %eax,%eax
jne    1668 <main+0x4c8>
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
mov    $0x1,%ebp
movsd  0x93e(%rip),%xmm1
ucomisd %xmm0,%xmm1
jae    1660 <main+0x4c0>
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
mulsd  0x934(%rip),%xmm0
cvttsd2si %xmm0,%eax
cmp    %rax,%r12
je     16d0 <main+0x530>
jmp    1745 <main+0x5a5>
nopw   0x0(%rax,%rax,1)
mov    0x4f30(%rsp,%r12,4),%eax
cmp    $0xffffffff,%eax
je     1790 <main+0x5f0>
cmp    $0x1,%eax
je     1790 <main+0x5f0>
test   %eax,%eax
jne    1668 <main+0x4c8>
xchg   %ax,%ax
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
mulsd  0x8e4(%rip),%xmm0
cvttsd2si %xmm0,%eax
cmp    %rax,%r12
je     1720 <main+0x580>
cltq
cmpl   $0xffffffff,0x4f30(%rsp,%rax,4)
ff
jne    1668 <main+0x4c8>
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
mov    $0xffffffff,%ebp
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    1660 <main+0x4c0>
jmp    1668 <main+0x4c8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebp,%ebp
xor    %eax,%eax
call   10c0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  (%r14),%xmm0
movsd  0x862(%rip),%xmm1
ucomisd %xmm0,%xmm1
jae    1660 <main+0x4c0>
jmp    1668 <main+0x4c8>
nopl   (%rax)
mov    $0x9c40,%edx
lea    0x4f30(%rsp),%rdi
lea    0x223f0(%rsp),%rsi
call   1080 <memcpy@plt>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xorpd  %xmm1,%xmm1
pxor   %xmm2,%xmm2
pxor   %xmm3,%xmm3
pxor   %xmm4,%xmm4
movdqa 0x847(%rip),%xmm9
pxor   %xmm8,%xmm8
pcmpeqd %xmm7,%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa 0x4f30(%rsp,%rax,4),%xmm5
movdqa %xmm5,%xmm6
pcmpeqd %xmm9,%xmm6
psubd  %xmm6,%xmm4
movdqa %xmm5,%xmm6
pcmpeqd %xmm8,%xmm6
psubd  %xmm6,%xmm2
pcmpeqd %xmm7,%xmm5
psubd  %xmm5,%xmm3
movdqa 0xeb70(%rsp,%rax,4),%xmm5
movdqa %xmm5,%xmm6
pcmpeqd %xmm9,%xmm6
psubd  %xmm6,%xmm0
pcmpeqd %xmm7,%xmm5
psubd  %xmm5,%xmm1
add    $0x4,%rax
cmp    $0x2710,%rax
jne    1810 <main+0x670>
pshufd $0xee,%xmm4,%xmm5
paddd  %xmm4,%xmm5
pshufd $0x55,%xmm5,%xmm8
pshufd $0xee,%xmm3,%xmm6
paddd  %xmm3,%xmm6
pshufd $0x55,%xmm6,%xmm3
pshufd $0xee,%xmm2,%xmm7
paddd  %xmm2,%xmm7
pshufd $0x55,%xmm7,%xmm2
punpckldq %xmm2,%xmm3
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm4
paddd  %xmm2,%xmm4
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
punpckldq %xmm8,%xmm0
punpckldq %xmm7,%xmm6
paddd  %xmm3,%xmm6
punpckldq %xmm5,%xmm1
paddd  %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm1
cvtdq2pd %xmm6,%xmm0
movd   %xmm4,%eax
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  0x2050(%rsp,%r13,8),%xmm2
movsd  %xmm2,0x2050(%rsp,%r13,8)
movsd  0x10b0(%rsp,%r13,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10b0(%rsp,%r13,8)
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  0x110(%rsp,%r13,8),%xmm2
movsd  %xmm2,0x110(%rsp,%r13,8)
movsd  0x3f90(%rsp,%r13,8),%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movsd  %xmm2,0x3f90(%rsp,%r13,8)
addsd  0x2ff0(%rsp,%r13,8),%xmm3
movsd  %xmm3,0x2ff0(%rsp,%r13,8)
lea    0x1(%r15),%eax
cmp    $0x191,%r13
cmovb  %r15d,%eax
jb     1560 <main+0x3c0>
movapd 0x60(%rsp),%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,0x60(%rsp)
movapd 0x50(%rsp),%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
jmp    1560 <main+0x3c0>
mov    0x38(%rsp),%rdi
call   1030 <fclose@plt>
xor    %eax,%eax
add    $0x2c038,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [77 x i8] c"op_ep_phtr_simu%d_tmax%d_N%d_pao%3.2lf_alpha%3.2lf_gamma%3.2lf_phi%3.2lf.dat\00"
@.str.1 = [2 x i8] c"w\00"
@.str.2 = [15 x i8] c"lambda %3.2lf\0A\00"
@RAND_MAX = global double 0.000000e+00
@.str.3 = [36 x i8] c"%8.6lf\09%8.6lf\09%8.6lf\09%8.6lf\09%8.6lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [10000 x i32]
%3 = alloca [10000 x i32]
%4 = alloca [10000 x i32]
%5 = alloca [10000 x i32]
%6 = alloca i32
%7 = alloca i32
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca [500 x double]
%13 = alloca [500 x double]
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca [500 x double]
%24 = alloca [500 x double]
%25 = alloca [500 x double]
%26 = alloca double
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca i32*
%48 = alloca i32*
%49 = alloca [100 x i8]
%50 = alloca [100 x i8]
store i32 0, i32* %1
%51 = call i32 @time(i32* null)
%52 = call i32 @srand(i32 %51)
%53 = getelementptr inbounds [100 x i8], [100 x i8]* %50, i64 0, i64 0
%54 = call i32 @sprintf(i8* %53, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str, i64 0, i64 0), i32 1, i32 500, i32 10000, double 6.000000e-01, double 1.000000e-01, double 2.000000e-01, double 1.000000e-01)
%55 = getelementptr inbounds [100 x i8], [100 x i8]* %50, i64 0, i64 0
%56 = call i32* @fopen(i8* %55, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %56, i32** %48
store double 0.000000e+00, double* %26
br label %57
57: ; preds = %654, %0
%58 = load double, double* %26
%59 = fcmp ole double %58, 1.000000e+00
br i1 %59, label %60, label %657
60: ; preds = %57
%61 = load double, double* %26
%62 = call i32 @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), double %61)
store i32 0, i32* %38
br label %63
63: ; preds = %82, %60
%64 = load i32, i32* %38
%65 = icmp slt i32 %64, 500
br i1 %65, label %66, label %85
66: ; preds = %63
%67 = load i32, i32* %38
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [500 x double], [500 x double]* %23, i64 0, i64 %68
store double 0.000000e+00, double* %69
%70 = load i32, i32* %38
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [500 x double], [500 x double]* %24, i64 0, i64 %71
store double 0.000000e+00, double* %72
%73 = load i32, i32* %38
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [500 x double], [500 x double]* %25, i64 0, i64 %74
store double 0.000000e+00, double* %75
%76 = load i32, i32* %38
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [500 x double], [500 x double]* %12, i64 0, i64 %77
store double 0.000000e+00, double* %78
%79 = load i32, i32* %38
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [500 x double], [500 x double]* %13, i64 0, i64 %80
store double 0.000000e+00, double* %81
br label %82
82: ; preds = %66
%83 = load i32, i32* %38
%84 = add nsw i32 %83, 1
store i32 %84, i32* %38
br label %63
85: ; preds = %63
store double 0.000000e+00, double* %20
store double 0.000000e+00, double* %21
store double 0.000000e+00, double* %22
store double 0.000000e+00, double* %10
store double 0.000000e+00, double* %11
store i32 0, i32* %39
br label %86
86: ; preds = %639, %85
%87 = load i32, i32* %39
%88 = icmp slt i32 %87, 10
br i1 %88, label %89, label %642
89: ; preds = %86
store i32 0, i32* %14
store i32 0, i32* %15
store i32 0, i32* %16
store i32 0, i32* %6
store i32 0, i32* %7
store double 0.000000e+00, double* %17
store double 0.000000e+00, double* %18
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %8
store double 0.000000e+00, double* %9
store i32 0, i32* %31
store double 0.000000e+00, double* %42
store double 0.000000e+00, double* %41
store double 0.000000e+00, double* %40
store double 0.000000e+00, double* %43
store double 0.000000e+00, double* %44
store i32 0, i32* %35
br label %90
90: ; preds = %119, %89
%91 = load i32, i32* %35
%92 = icmp slt i32 %91, 10000
br i1 %92, label %93, label %122
93: ; preds = %90
%94 = call i64 (...) @rand()
%95 = sitofp i64 %94 to double
%96 = load double, double* @RAND_MAX
%97 = fdiv double %95, %96
store double %97, double* %45
%98 = load double, double* %45
%99 = fcmp olt double %98, 0x3FEFAE147AE147AE
br i1 %99, label %100, label %109
100: ; preds = %93
%101 = load i32, i32* %35
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %102
store i32 0, i32* %103
%104 = load i32, i32* %35
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %105
store i32 0, i32* %106
%107 = load i32, i32* %14
%108 = add nsw i32 %107, 1
store i32 %108, i32* %14
br label %118
109: ; preds = %93
%110 = load i32, i32* %35
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %111
store i32 -1, i32* %112
%113 = load i32, i32* %35
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %114
store i32 -1, i32* %115
%116 = load i32, i32* %15
%117 = add nsw i32 %116, 1
store i32 %117, i32* %15
br label %118
118: ; preds = %109, %100
br label %119
119: ; preds = %118
%120 = load i32, i32* %35
%121 = add nsw i32 %120, 1
store i32 %121, i32* %35
br label %90
122: ; preds = %90
store i32 0, i32* %35
br label %123
123: ; preds = %152, %122
%124 = load i32, i32* %35
%125 = icmp slt i32 %124, 10000
br i1 %125, label %126, label %155
126: ; preds = %123
%127 = call i64 (...) @rand()
%128 = sitofp i64 %127 to double
%129 = load double, double* @RAND_MAX
%130 = fdiv double %128, %129
store double %130, double* %45
%131 = load double, double* %45
%132 = fcmp olt double %131, 6.000000e-01
br i1 %132, label %133, label %142
133: ; preds = %126
%134 = load i32, i32* %35
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %135
store i32 1, i32* %136
%137 = load i32, i32* %35
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %138
store i32 1, i32* %139
%140 = load i32, i32* %6
%141 = add nsw i32 %140, 1
store i32 %141, i32* %6
br label %151
142: ; preds = %126
%143 = load i32, i32* %35
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %144
store i32 -1, i32* %145
%146 = load i32, i32* %35
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %147
store i32 -1, i32* %148
%149 = load i32, i32* %7
%150 = add nsw i32 %149, 1
store i32 %150, i32* %7
br label %151
151: ; preds = %142, %133
br label %152
152: ; preds = %151
%153 = load i32, i32* %35
%154 = add nsw i32 %153, 1
store i32 %154, i32* %35
br label %123
155: ; preds = %123
%156 = load i32, i32* %14
%157 = sitofp i32 %156 to double
%158 = getelementptr inbounds [500 x double], [500 x double]* %23, i64 0, i64 0
%159 = load double, double* %158
%160 = fadd double %159, %157
store double %160, double* %158
%161 = load i32, i32* %15
%162 = sitofp i32 %161 to double
%163 = getelementptr inbounds [500 x double], [500 x double]* %24, i64 0, i64 0
%164 = load double, double* %163
%165 = fadd double %164, %162
store double %165, double* %163
%166 = load i32, i32* %16
%167 = sitofp i32 %166 to double
%168 = getelementptr inbounds [500 x double], [500 x double]* %25, i64 0, i64 0
%169 = load double, double* %168
%170 = fadd double %169, %167
store double %170, double* %168
%171 = load i32, i32* %6
%172 = sitofp i32 %171 to double
%173 = getelementptr inbounds [500 x double], [500 x double]* %12, i64 0, i64 0
%174 = load double, double* %173
%175 = fadd double %174, %172
store double %175, double* %173
%176 = load i32, i32* %7
%177 = sitofp i32 %176 to double
%178 = getelementptr inbounds [500 x double], [500 x double]* %13, i64 0, i64 0
%179 = load double, double* %178
%180 = fadd double %179, %177
store double %180, double* %178
store i32 1, i32* %38
br label %181
181: ; preds = %595, %155
%182 = load i32, i32* %38
%183 = icmp slt i32 %182, 500
br i1 %183, label %184, label %598
184: ; preds = %181
store i32 0, i32* %32
br label %185
185: ; preds = %263, %184
%186 = load i32, i32* %32
%187 = icmp slt i32 %186, 10000
br i1 %187, label %188, label %266
188: ; preds = %185
br label %189
189: ; preds = %197, %188
%190 = call i64 (...) @rand()
%191 = sitofp i64 %190 to double
%192 = load double, double* @RAND_MAX
%193 = fdiv double %191, %192
store double %193, double* %45
%194 = load double, double* %45
%195 = fmul double 1.000000e+04, %194
%196 = fptosi double %195 to i32
store i32 %196, i32* %33
br label %197
197: ; preds = %189
%198 = load i32, i32* %33
%199 = load i32, i32* %32
%200 = icmp eq i32 %198, %199
br i1 %200, label %189, label %201
201: ; preds = %197
br label %202
202: ; preds = %218, %201
%203 = call i64 (...) @rand()
%204 = sitofp i64 %203 to double
%205 = load double, double* @RAND_MAX
%206 = fdiv double %204, %205
store double %206, double* %45
%207 = load double, double* %45
%208 = fmul double 1.000000e+04, %207
%209 = fptosi double %208 to i32
store i32 %209, i32* %34
br label %210
210: ; preds = %202
%211 = load i32, i32* %34
%212 = load i32, i32* %32
%213 = icmp eq i32 %211, %212
br i1 %213, label %218, label %214
214: ; preds = %210
%215 = load i32, i32* %34
%216 = load i32, i32* %33
%217 = icmp eq i32 %215, %216
br label %218
218: ; preds = %214, %210
%219 = phi i1 [ true, %210 ], [ %217, %214 ]
br i1 %219, label %202, label %220
220: ; preds = %218
%221 = load i32, i32* %32
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %222
%224 = load i32, i32* %223
%225 = load i32, i32* %33
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %226
%228 = load i32, i32* %227
%229 = add nsw i32 %224, %228
%230 = load i32, i32* %34
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %231
%233 = load i32, i32* %232
%234 = add nsw i32 %229, %233
store i32 %234, i32* %27
%235 = load i32, i32* %27
%236 = call i32 @abs(i32 %235)
%237 = icmp slt i32 %236, 3
br i1 %237, label %238, label %262
238: ; preds = %220
%239 = load i32, i32* %27
%240 = icmp sgt i32 %239, 0
br i1 %240, label %241, label %251
241: ; preds = %238
%242 = load i32, i32* %32
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %243
store i32 1, i32* %244
%245 = load i32, i32* %33
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %246
store i32 1, i32* %247
%248 = load i32, i32* %34
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %249
store i32 1, i32* %250
br label %261
251: ; preds = %238
%252 = load i32, i32* %32
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %253
store i32 -1, i32* %254
%255 = load i32, i32* %33
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %256
store i32 -1, i32* %257
%258 = load i32, i32* %34
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %259
store i32 -1, i32* %260
br label %261
261: ; preds = %251, %241
br label %262
262: ; preds = %261, %220
br label %263
263: ; preds = %262
%264 = load i32, i32* %32
%265 = add nsw i32 %264, 1
store i32 %265, i32* %32
br label %185
266: ; preds = %185
store i32 0, i32* %36
br label %267
267: ; preds = %278, %266
%268 = load i32, i32* %36
%269 = icmp slt i32 %268, 10000
br i1 %269, label %270, label %281
270: ; preds = %267
%271 = load i32, i32* %36
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %272
%274 = load i32, i32* %273
%275 = load i32, i32* %36
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %276
store i32 %274, i32* %277
br label %278
278: ; preds = %270
%279 = load i32, i32* %36
%280 = add nsw i32 %279, 1
store i32 %280, i32* %36
br label %267
281: ; preds = %267
store i32 0, i32* %32
br label %282
282: ; preds = %462, %281
%283 = load i32, i32* %32
%284 = icmp slt i32 %283, 10000
br i1 %284, label %285, label %465
285: ; preds = %282
%286 = load i32, i32* %32
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %287
%289 = load i32, i32* %288
%290 = icmp eq i32 %289, 1
br i1 %290, label %291, label %379
291: ; preds = %285
%292 = load i32, i32* %32
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %293
%295 = load i32, i32* %294
%296 = icmp eq i32 %295, 0
br i1 %296, label %297, label %342
297: ; preds = %291
%298 = call i64 (...) @rand()
%299 = sitofp i64 %298 to double
%300 = load double, double* @RAND_MAX
%301 = fdiv double %299, %300
store double %301, double* %46
%302 = load double, double* %46
%303 = fcmp ole double %302, 2.000000e-01
br i1 %303, label %304, label %308
304: ; preds = %297
%305 = load i32, i32* %32
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %306
store i32 1, i32* %307
br label %341
308: ; preds = %297
br label %309
309: ; preds = %317, %308
%310 = call i64 (...) @rand()
%311 = sitofp i64 %310 to double
%312 = load double, double* @RAND_MAX
%313 = fdiv double %311, %312
store double %313, double* %45
%314 = load double, double* %45
%315 = fmul double 1.000000e+04, %314
%316 = fptosi double %315 to i32
store i32 %316, i32* %33
br label %317
317: ; preds = %309
%318 = load i32, i32* %33
%319 = load i32, i32* %32
%320 = icmp eq i32 %318, %319
br i1 %320, label %309, label %321
321: ; preds = %317
%322 = load i32, i32* %33
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %323
%325 = load i32, i32* %324
%326 = icmp eq i32 %325, -1
br i1 %326, label %327, label %340
327: ; preds = %321
%328 = call i64 (...) @rand()
%329 = sitofp i64 %328 to double
%330 = load double, double* @RAND_MAX
%331 = fdiv double %329, %330
store double %331, double* %46
%332 = load double, double* %46
%333 = load double, double* %26
%334 = fcmp ole double %332, %333
br i1 %334, label %335, label %339
335: ; preds = %327
%336 = load i32, i32* %32
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %337
store i32 -1, i32* %338
br label %339
339: ; preds = %335, %327
br label %340
340: ; preds = %339, %321
br label %341
341: ; preds = %340, %304
br label %342
342: ; preds = %341, %291
%343 = load i32, i32* %32
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %344
%346 = load i32, i32* %345
%347 = icmp eq i32 %346, -1
br i1 %347, label %348, label %360
348: ; preds = %342
%349 = call i64 (...) @rand()
%350 = sitofp i64 %349 to double
%351 = load double, double* @RAND_MAX
%352 = fdiv double %350, %351
store double %352, double* %46
%353 = load double, double* %46
%354 = fcmp ole double %353, 1.000000e-01
br i1 %354, label %355, label %359
355: ; preds = %348
%356 = load i32, i32* %32
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %357
store i32 0, i32* %358
br label %359
359: ; preds = %355, %348
br label %360
360: ; preds = %359, %342
%361 = load i32, i32* %32
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %362
%364 = load i32, i32* %363
%365 = icmp eq i32 %364, 1
br i1 %365, label %366, label %378
366: ; preds = %360
%367 = call i64 (...) @rand()
%368 = sitofp i64 %367 to double
%369 = load double, double* @RAND_MAX
%370 = fdiv double %368, %369
store double %370, double* %46
%371 = load double, double* %46
%372 = fcmp ole double %371, 1.000000e-01
br i1 %372, label %373, label %377
373: ; preds = %366
%374 = load i32, i32* %32
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %375
store i32 0, i32* %376
br label %377
377: ; preds = %373, %366
br label %378
378: ; preds = %377, %360
br label %379
379: ; preds = %378, %285
%380 = load i32, i32* %32
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %381
%383 = load i32, i32* %382
%384 = icmp eq i32 %383, -1
br i1 %384, label %385, label %461
385: ; preds = %379
%386 = load i32, i32* %32
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %387
%389 = load i32, i32* %388
%390 = icmp eq i32 %389, 0
br i1 %390, label %391, label %424
391: ; preds = %385
br label %392
392: ; preds = %400, %391
%393 = call i64 (...) @rand()
%394 = sitofp i64 %393 to double
%395 = load double, double* @RAND_MAX
%396 = fdiv double %394, %395
store double %396, double* %45
%397 = load double, double* %45
%398 = fmul double 1.000000e+04, %397
%399 = fptosi double %398 to i32
store i32 %399, i32* %33
br label %400
400: ; preds = %392
%401 = load i32, i32* %33
%402 = load i32, i32* %32
%403 = icmp eq i32 %401, %402
br i1 %403, label %392, label %404
404: ; preds = %400
%405 = load i32, i32* %33
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %406
%408 = load i32, i32* %407
%409 = icmp eq i32 %408, -1
br i1 %409, label %410, label %423
410: ; preds = %404
%411 = call i64 (...) @rand()
%412 = sitofp i64 %411 to double
%413 = load double, double* @RAND_MAX
%414 = fdiv double %412, %413
store double %414, double* %46
%415 = load double, double* %46
%416 = load double, double* %26
%417 = fcmp ole double %415, %416
br i1 %417, label %418, label %422
418: ; preds = %410
%419 = load i32, i32* %32
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %420
store i32 -1, i32* %421
br label %422
422: ; preds = %418, %410
br label %423
423: ; preds = %422, %404
br label %424
424: ; preds = %423, %385
%425 = load i32, i32* %32
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %426
%428 = load i32, i32* %427
%429 = icmp eq i32 %428, -1
br i1 %429, label %430, label %442
430: ; preds = %424
%431 = call i64 (...) @rand()
%432 = sitofp i64 %431 to double
%433 = load double, double* @RAND_MAX
%434 = fdiv double %432, %433
store double %434, double* %46
%435 = load double, double* %46
%436 = fcmp ole double %435, 1.000000e-01
br i1 %436, label %437, label %441
437: ; preds = %430
%438 = load i32, i32* %32
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %439
store i32 0, i32* %440
br label %441
441: ; preds = %437, %430
br label %442
442: ; preds = %441, %424
%443 = load i32, i32* %32
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %444
%446 = load i32, i32* %445
%447 = icmp eq i32 %446, 1
br i1 %447, label %448, label %460
448: ; preds = %442
%449 = call i64 (...) @rand()
%450 = sitofp i64 %449 to double
%451 = load double, double* @RAND_MAX
%452 = fdiv double %450, %451
store double %452, double* %46
%453 = load double, double* %46
%454 = fcmp ole double %453, 1.000000e-01
br i1 %454, label %455, label %459
455: ; preds = %448
%456 = load i32, i32* %32
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %457
store i32 0, i32* %458
br label %459
459: ; preds = %455, %448
br label %460
460: ; preds = %459, %442
br label %461
461: ; preds = %460, %379
br label %462
462: ; preds = %461
%463 = load i32, i32* %32
%464 = add nsw i32 %463, 1
store i32 %464, i32* %32
br label %282
465: ; preds = %282
store i32 0, i32* %36
br label %466
466: ; preds = %477, %465
%467 = load i32, i32* %36
%468 = icmp slt i32 %467, 10000
br i1 %468, label %469, label %480
469: ; preds = %466
%470 = load i32, i32* %36
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %471
%473 = load i32, i32* %472
%474 = load i32, i32* %36
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %475
store i32 %473, i32* %476
br label %477
477: ; preds = %469
%478 = load i32, i32* %36
%479 = add nsw i32 %478, 1
store i32 %479, i32* %36
br label %466
480: ; preds = %466
store i32 0, i32* %14
store i32 0, i32* %15
store i32 0, i32* %16
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %35
br label %481
481: ; preds = %530, %480
%482 = load i32, i32* %35
%483 = icmp slt i32 %482, 10000
br i1 %483, label %484, label %533
484: ; preds = %481
%485 = load i32, i32* %35
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %486
%488 = load i32, i32* %487
%489 = icmp eq i32 %488, 1
br i1 %489, label %490, label %493
490: ; preds = %484
%491 = load i32, i32* %16
%492 = add nsw i32 %491, 1
store i32 %492, i32* %16
br label %493
493: ; preds = %490, %484
%494 = load i32, i32* %35
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %495
%497 = load i32, i32* %496
%498 = icmp eq i32 %497, 0
br i1 %498, label %499, label %502
499: ; preds = %493
%500 = load i32, i32* %14
%501 = add nsw i32 %500, 1
store i32 %501, i32* %14
br label %502
502: ; preds = %499, %493
%503 = load i32, i32* %35
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds [10000 x i32], [10000 x i32]* %4, i64 0, i64 %504
%506 = load i32, i32* %505
%507 = icmp eq i32 %506, -1
br i1 %507, label %508, label %511
508: ; preds = %502
%509 = load i32, i32* %15
%510 = add nsw i32 %509, 1
store i32 %510, i32* %15
br label %511
511: ; preds = %508, %502
%512 = load i32, i32* %35
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %513
%515 = load i32, i32* %514
%516 = icmp eq i32 %515, 1
br i1 %516, label %517, label %520
517: ; preds = %511
%518 = load i32, i32* %6
%519 = add nsw i32 %518, 1
store i32 %519, i32* %6
br label %520
520: ; preds = %517, %511
%521 = load i32, i32* %35
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds [10000 x i32], [10000 x i32]* %2, i64 0, i64 %522
%524 = load i32, i32* %523
%525 = icmp eq i32 %524, -1
br i1 %525, label %526, label %529
526: ; preds = %520
%527 = load i32, i32* %7
%528 = add nsw i32 %527, 1
store i32 %528, i32* %7
br label %529
529: ; preds = %526, %520
br label %530
530: ; preds = %529
%531 = load i32, i32* %35
%532 = add nsw i32 %531, 1
store i32 %532, i32* %35
br label %481
533: ; preds = %481
%534 = load i32, i32* %14
%535 = sitofp i32 %534 to double
%536 = load i32, i32* %38
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds [500 x double], [500 x double]* %23, i64 0, i64 %537
%539 = load double, double* %538
%540 = fadd double %539, %535
store double %540, double* %538
%541 = load i32, i32* %15
%542 = sitofp i32 %541 to double
%543 = load i32, i32* %38
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds [500 x double], [500 x double]* %24, i64 0, i64 %544
%546 = load double, double* %545
%547 = fadd double %546, %542
store double %547, double* %545
%548 = load i32, i32* %16
%549 = sitofp i32 %548 to double
%550 = load i32, i32* %38
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds [500 x double], [500 x double]* %25, i64 0, i64 %551
%553 = load double, double* %552
%554 = fadd double %553, %549
store double %554, double* %552
%555 = load i32, i32* %6
%556 = sitofp i32 %555 to double
%557 = load i32, i32* %38
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds [500 x double], [500 x double]* %12, i64 0, i64 %558
%560 = load double, double* %559
%561 = fadd double %560, %556
store double %561, double* %559
%562 = load i32, i32* %7
%563 = sitofp i32 %562 to double
%564 = load i32, i32* %38
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds [500 x double], [500 x double]* %13, i64 0, i64 %565
%567 = load double, double* %566
%568 = fadd double %567, %563
store double %568, double* %566
%569 = load i32, i32* %38
%570 = icmp sgt i32 %569, 400
br i1 %570, label %571, label %594
571: ; preds = %533
%572 = load i32, i32* %14
%573 = sitofp i32 %572 to double
%574 = load double, double* %17
%575 = fadd double %574, %573
store double %575, double* %17
%576 = load i32, i32* %15
%577 = sitofp i32 %576 to double
%578 = load double, double* %18
%579 = fadd double %578, %577
store double %579, double* %18
%580 = load i32, i32* %16
%581 = sitofp i32 %580 to double
%582 = load double, double* %19
%583 = fadd double %582, %581
store double %583, double* %19
%584 = load i32, i32* %6
%585 = sitofp i32 %584 to double
%586 = load double, double* %8
%587 = fadd double %586, %585
store double %587, double* %8
%588 = load i32, i32* %7
%589 = sitofp i32 %588 to double
%590 = load double, double* %9
%591 = fadd double %590, %589
store double %591, double* %9
%592 = load i32, i32* %31
%593 = add nsw i32 %592, 1
store i32 %593, i32* %31
br label %594
594: ; preds = %571, %533
br label %595
595: ; preds = %594
%596 = load i32, i32* %38
%597 = add nsw i32 %596, 1
store i32 %597, i32* %38
br label %181
598: ; preds = %181
%599 = load double, double* %17
%600 = load i32, i32* %31
%601 = mul nsw i32 10000, %600
%602 = sitofp i32 %601 to double
%603 = fdiv double %599, %602
store double %603, double* %42
%604 = load double, double* %18
%605 = load i32, i32* %31
%606 = mul nsw i32 10000, %605
%607 = sitofp i32 %606 to double
%608 = fdiv double %604, %607
store double %608, double* %41
%609 = load double, double* %19
%610 = load i32, i32* %31
%611 = mul nsw i32 10000, %610
%612 = sitofp i32 %611 to double
%613 = fdiv double %609, %612
store double %613, double* %40
%614 = load double, double* %8
%615 = load i32, i32* %31
%616 = mul nsw i32 10000, %615
%617 = sitofp i32 %616 to double
%618 = fdiv double %614, %617
store double %618, double* %43
%619 = load double, double* %9
%620 = load i32, i32* %31
%621 = mul nsw i32 10000, %620
%622 = sitofp i32 %621 to double
%623 = fdiv double %619, %622
store double %623, double* %44
%624 = load double, double* %42
%625 = load double, double* %20
%626 = fadd double %625, %624
store double %626, double* %20
%627 = load double, double* %41
%628 = load double, double* %21
%629 = fadd double %628, %627
store double %629, double* %21
%630 = load double, double* %40
%631 = load double, double* %22
%632 = fadd double %631, %630
store double %632, double* %22
%633 = load double, double* %43
%634 = load double, double* %10
%635 = fadd double %634, %633
store double %635, double* %10
%636 = load double, double* %44
%637 = load double, double* %11
%638 = fadd double %637, %636
store double %638, double* %11
br label %639
639: ; preds = %598
%640 = load i32, i32* %39
%641 = add nsw i32 %640, 1
store i32 %641, i32* %39
br label %86
642: ; preds = %86
%643 = load i32*, i32** %48
%644 = load double, double* %26
%645 = load double, double* %20
%646 = fdiv double %645, 1.000000e+01
%647 = load double, double* %21
%648 = fdiv double %647, 1.000000e+01
%649 = load double, double* %22
%650 = fdiv double %649, 1.000000e+01
%651 = load double, double* %10
%652 = fdiv double %651, 1.000000e+01
%653 = call i32 @fprintf(i32* %643, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.3, i64 0, i64 0), double %644, double %646, double %648, double %650, double %652)
br label %654
654: ; preds = %642
%655 = load double, double* %26
%656 = fadd double %655, 5.000000e-02
store double %656, double* %26
br label %57
657: ; preds = %57
%658 = load i32*, i32** %48
%659 = call i32 @fclose(i32* %658)
ret i32 0
}

LLVM IR (-O2):
@.str = [77 x i8] c"op_ep_phtr_simu%d_tmax%d_N%d_pao%3.2lf_alpha%3.2lf_gamma%3.2lf_phi%3.2lf.dat\00"
@.str.1 = [2 x i8] c"w\00"
@.str.2 = [15 x i8] c"lambda %3.2lf\0A\00"
@RAND_MAX = global double 0.000000e+00
@.str.3 = [36 x i8] c"%8.6lf\09%8.6lf\09%8.6lf\09%8.6lf\09%8.6lf\0A\00"
define i32 @main() {
%1 = alloca [10000 x i32]
%2 = bitcast [10000 x i32]* %1 to i8*
%3 = alloca [10000 x i32]
%4 = bitcast [10000 x i32]* %3 to i8*
%5 = alloca [10000 x i32]
%6 = bitcast [10000 x i32]* %5 to i8*
%7 = alloca [10000 x i32]
%8 = bitcast [10000 x i32]* %7 to i8*
%9 = alloca [500 x double]
%10 = bitcast [500 x double]* %9 to i8*
%11 = alloca [500 x double]
%12 = bitcast [500 x double]* %11 to i8*
%13 = alloca [500 x double]
%14 = bitcast [500 x double]* %13 to i8*
%15 = alloca [500 x double]
%16 = bitcast [500 x double]* %15 to i8*
%17 = alloca [500 x double]
%18 = bitcast [500 x double]* %17 to i8*
%19 = alloca [100 x i8]
%20 = tail call i32 @time(i32* null)
%21 = tail call i32 @srand(i32 %20)
%22 = getelementptr inbounds [100 x i8], [100 x i8]* %19, i64 0, i64 0
%23 = call i32 @sprintf(i8* %22, i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @.str, i64 0, i64 0), i32 1, i32 500, i32 10000, double 6.000000e-01, double 1.000000e-01, double 2.000000e-01, double 1.000000e-01)
%24 = call i32* @fopen(i8* %22, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%25 = getelementptr inbounds [500 x double], [500 x double]* %13, i64 0, i64 0
%26 = getelementptr inbounds [500 x double], [500 x double]* %15, i64 0, i64 0
%27 = getelementptr inbounds [500 x double], [500 x double]* %17, i64 0, i64 0
%28 = getelementptr inbounds [500 x double], [500 x double]* %9, i64 0, i64 0
%29 = getelementptr inbounds [500 x double], [500 x double]* %11, i64 0, i64 0
br label %30
30: ; preds = %0, %301
%31 = phi double [ 0.000000e+00, %0 ], [ %311, %301 ]
%32 = tail call i32 @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), double %31)
br label %33
33: ; preds = %30, %289
%34 = phi double [ 0.000000e+00, %30 ], [ %292, %289 ]
%35 = phi double [ 0.000000e+00, %30 ], [ %291, %289 ]
%36 = phi double [ 0.000000e+00, %30 ], [ %82, %289 ]
%37 = phi double [ 0.000000e+00, %30 ], [ %290, %289 ]
%38 = phi i32 [ 0, %30 ], [ %299, %289 ]
%39 = phi <4 x double> [ zeroinitializer, %30 ], [ %298, %289 ]
br label %40
40: ; preds = %33, %40
%41 = phi i64 [ 0, %33 ], [ %58, %40 ]
%42 = phi i32 [ 0, %33 ], [ %55, %40 ]
%43 = phi i32 [ 0, %33 ], [ %53, %40 ]
%44 = tail call i64 (...) @rand()
%45 = sitofp i64 %44 to double
%46 = load double, double* @RAND_MAX
%47 = fdiv double %45, %46
%48 = fcmp olt double %47, 0x3FEFAE147AE147AE
%49 = xor i1 %48, true
%50 = sext i1 %49 to i32
%51 = xor i1 %48, true
%52 = zext i1 %51 to i32
%53 = add nuw nsw i32 %43, %52
%54 = zext i1 %48 to i32
%55 = add nuw nsw i32 %42, %54
%56 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %41
store i32 %50, i32* %56
%57 = getelementptr inbounds [10000 x i32], [10000 x i32]* %7, i64 0, i64 %41
store i32 %50, i32* %57
%58 = add nuw nsw i64 %41, 1
%59 = icmp eq i64 %58, 10000
br i1 %59, label %60, label %40
60: ; preds = %40, %60
%61 = phi i64 [ %77, %60 ], [ 0, %40 ]
%62 = phi i32 [ %74, %60 ], [ 0, %40 ]
%63 = phi i32 [ %72, %60 ], [ 0, %40 ]
%64 = tail call i64 (...) @rand()
%65 = sitofp i64 %64 to double
%66 = load double, double* @RAND_MAX
%67 = fdiv double %65, %66
%68 = fcmp olt double %67, 6.000000e-01
%69 = select i1 %68, i32 1, i32 -1
%70 = xor i1 %68, true
%71 = zext i1 %70 to i32
%72 = add nuw nsw i32 %63, %71
%73 = zext i1 %68 to i32
%74 = add nuw nsw i32 %62, %73
%75 = getelementptr inbounds [10000 x i32], [10000 x i32]* %1, i64 0, i64 %61
store i32 %69, i32* %75
%76 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %61
store i32 %69, i32* %76
%77 = add nuw nsw i64 %61, 1
%78 = icmp eq i64 %77, 10000
br i1 %78, label %79, label %60
79: ; preds = %60
%80 = sitofp i32 %55 to double
%81 = sitofp i32 %53 to double
%82 = fadd double %36, %81
%83 = sitofp i32 %74 to double
%84 = sitofp i32 %72 to double
br label %85
85: ; preds = %79, %251
%86 = phi i64 [ 1, %79 ], [ %287, %251 ]
%87 = phi i32 [ 0, %79 ], [ %285, %251 ]
%88 = phi <4 x double> [ zeroinitializer, %79 ], [ %286, %251 ]
br label %89
89: ; preds = %85, %130
%90 = phi i64 [ 0, %85 ], [ %131, %130 ]
br label %91
91: ; preds = %89, %91
%92 = tail call i64 (...) @rand()
%93 = sitofp i64 %92 to double
%94 = load double, double* @RAND_MAX
%95 = fdiv double %93, %94
%96 = fmul double %95, 1.000000e+04
%97 = fptosi double %96 to i32
%98 = zext i32 %97 to i64
%99 = icmp eq i64 %90, %98
br i1 %99, label %91, label %100
100: ; preds = %91, %100
%101 = tail call i64 (...) @rand()
%102 = sitofp i64 %101 to double
%103 = load double, double* @RAND_MAX
%104 = fdiv double %102, %103
%105 = fmul double %104, 1.000000e+04
%106 = fptosi double %105 to i32
%107 = zext i32 %106 to i64
%108 = icmp eq i64 %90, %107
%109 = icmp eq i32 %106, %97
%110 = select i1 %108, i1 true, i1 %109
br i1 %110, label %100, label %111
111: ; preds = %100
%112 = getelementptr inbounds [10000 x i32], [10000 x i32]* %1, i64 0, i64 %90
%113 = load i32, i32* %112
%114 = sext i32 %97 to i64
%115 = getelementptr inbounds [10000 x i32], [10000 x i32]* %1, i64 0, i64 %114
%116 = load i32, i32* %115
%117 = add nsw i32 %116, %113
%118 = sext i32 %106 to i64
%119 = getelementptr inbounds [10000 x i32], [10000 x i32]* %1, i64 0, i64 %118
%120 = load i32, i32* %119
%121 = add nsw i32 %117, %120
%122 = tail call i32 @llvm.abs.i32(i32 %121, i1 true)
%123 = icmp ult i32 %122, 3
br i1 %123, label %124, label %130
124: ; preds = %111
%125 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %90
%126 = icmp slt i32 %121, 1
%127 = select i1 %126, i32 -1, i32 1
store i32 %127, i32* %125
%128 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %114
store i32 %127, i32* %128
%129 = getelementptr inbounds [10000 x i32], [10000 x i32]* %3, i64 0, i64 %118
store i32 %127, i32* %129
br label %130
130: ; preds = %124, %111
%131 = add nuw nsw i64 %90, 1
%132 = icmp eq i64 %131, 10000
br i1 %132, label %133, label %89
133: ; preds = %130
br label %134
134: ; preds = %133, %217
%135 = phi i64 [ 0, %133 ], [ %218, %217 ]
%136 = getelementptr inbounds [10000 x i32], [10000 x i32]* %1, i64 0, i64 %135
%137 = load i32, i32* %136
switch i32 %137, label %217 [
i32 1, label %138
i32 -1, label %179
]
138: ; preds = %134
%139 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %135
%140 = load i32, i32* %139
switch i32 %140, label %217 [
i32 0, label %141
i32 -1, label %167
i32 1, label %173
]
141: ; preds = %138
%142 = tail call i64 (...) @rand()
%143 = sitofp i64 %142 to double
%144 = load double, double* @RAND_MAX
%145 = fdiv double %143, %144
%146 = fcmp ugt double %145, 2.000000e-01
br i1 %146, label %147, label %214
147: ; preds = %141, %147
%148 = tail call i64 (...) @rand()
%149 = sitofp i64 %148 to double
%150 = load double, double* @RAND_MAX
%151 = fdiv double %149, %150
%152 = fmul double %151, 1.000000e+04
%153 = fptosi double %152 to i32
%154 = zext i32 %153 to i64
%155 = icmp eq i64 %135, %154
br i1 %155, label %147, label %156
156: ; preds = %147
%157 = sext i32 %153 to i64
%158 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %157
%159 = load i32, i32* %158
%160 = icmp eq i32 %159, -1
br i1 %160, label %161, label %217
161: ; preds = %156
%162 = tail call i64 (...) @rand()
%163 = sitofp i64 %162 to double
%164 = load double, double* @RAND_MAX
%165 = fdiv double %163, %164
%166 = fcmp ugt double %165, %31
br i1 %166, label %217, label %214
167: ; preds = %138
%168 = tail call i64 (...) @rand()
%169 = sitofp i64 %168 to double
%170 = load double, double* @RAND_MAX
%171 = fdiv double %169, %170
%172 = fcmp ugt double %171, 1.000000e-01
br i1 %172, label %217, label %214
173: ; preds = %138
%174 = tail call i64 (...) @rand()
%175 = sitofp i64 %174 to double
%176 = load double, double* @RAND_MAX
%177 = fdiv double %175, %176
%178 = fcmp ugt double %177, 1.000000e-01
br i1 %178, label %217, label %214
179: ; preds = %134
%180 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %135
%181 = load i32, i32* %180
switch i32 %181, label %217 [
i32 0, label %182
i32 -1, label %202
i32 1, label %208
]
182: ; preds = %179, %182
%183 = tail call i64 (...) @rand()
%184 = sitofp i64 %183 to double
%185 = load double, double* @RAND_MAX
%186 = fdiv double %184, %185
%187 = fmul double %186, 1.000000e+04
%188 = fptosi double %187 to i32
%189 = zext i32 %188 to i64
%190 = icmp eq i64 %135, %189
br i1 %190, label %182, label %191
191: ; preds = %182
%192 = sext i32 %188 to i64
%193 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %192
%194 = load i32, i32* %193
%195 = icmp eq i32 %194, -1
br i1 %195, label %196, label %217
196: ; preds = %191
%197 = tail call i64 (...) @rand()
%198 = sitofp i64 %197 to double
%199 = load double, double* @RAND_MAX
%200 = fdiv double %198, %199
%201 = fcmp ugt double %200, %31
br i1 %201, label %217, label %214
202: ; preds = %179
%203 = tail call i64 (...) @rand()
%204 = sitofp i64 %203 to double
%205 = load double, double* @RAND_MAX
%206 = fdiv double %204, %205
%207 = fcmp ugt double %206, 1.000000e-01
br i1 %207, label %217, label %214
208: ; preds = %179
%209 = tail call i64 (...) @rand()
%210 = sitofp i64 %209 to double
%211 = load double, double* @RAND_MAX
%212 = fdiv double %210, %211
%213 = fcmp ugt double %212, 1.000000e-01
br i1 %213, label %217, label %214
214: ; preds = %208, %202, %196, %173, %167, %161, %141
%215 = phi i32 [ 1, %141 ], [ -1, %161 ], [ 0, %167 ], [ 0, %173 ], [ -1, %196 ], [ 0, %202 ], [ 0, %208 ]
%216 = getelementptr inbounds [10000 x i32], [10000 x i32]* %7, i64 0, i64 %135
store i32 %215, i32* %216
br label %217
217: ; preds = %214, %196, %191, %173, %167, %138, %161, %156, %179, %134, %202, %208
%218 = add nuw nsw i64 %135, 1
%219 = icmp eq i64 %218, 10000
br i1 %219, label %220, label %134
220: ; preds = %217
br label %221
221: ; preds = %221, %220
%222 = phi i64 [ 0, %220 ], [ %249, %221 ]
%223 = phi <4 x i32> [ zeroinitializer, %220 ], [ %245, %221 ]
%224 = phi <4 x i32> [ zeroinitializer, %220 ], [ %248, %221 ]
%225 = phi <4 x i32> [ zeroinitializer, %220 ], [ %236, %221 ]
%226 = phi <4 x i32> [ zeroinitializer, %220 ], [ %239, %221 ]
%227 = phi <4 x i32> [ zeroinitializer, %220 ], [ %233, %221 ]
%228 = getelementptr inbounds [10000 x i32], [10000 x i32]* %5, i64 0, i64 %222
%229 = bitcast i32* %228 to <4 x i32>*
%230 = load <4 x i32>, <4 x i32>* %229
%231 = icmp eq <4 x i32> %230, <i32 1, i32 1, i32 1, i32 1>
%232 = zext <4 x i1> %231 to <4 x i32>
%233 = add <4 x i32> %227, %232
%234 = icmp eq <4 x i32> %230, zeroinitializer
%235 = zext <4 x i1> %234 to <4 x i32>
%236 = add <4 x i32> %225, %235
%237 = icmp eq <4 x i32> %230, <i32 -1, i32 -1, i32 -1, i32 -1>
%238 = zext <4 x i1> %237 to <4 x i32>
%239 = add <4 x i32> %226, %238
%240 = getelementptr inbounds [10000 x i32], [10000 x i32]* %1, i64 0, i64 %222
%241 = bitcast i32* %240 to <4 x i32>*
%242 = load <4 x i32>, <4 x i32>* %241
%243 = icmp eq <4 x i32> %242, <i32 1, i32 1, i32 1, i32 1>
%244 = zext <4 x i1> %243 to <4 x i32>
%245 = add <4 x i32> %223, %244
%246 = icmp eq <4 x i32> %242, <i32 -1, i32 -1, i32 -1, i32 -1>
%247 = zext <4 x i1> %246 to <4 x i32>
%248 = add <4 x i32> %224, %247
%249 = add nuw i64 %222, 4
%250 = icmp eq i64 %249, 10000
br i1 %250, label %251, label %221
251: ; preds = %221
%252 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %233)
%253 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %239)
%254 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %236)
%255 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %248)
%256 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %245)
%257 = getelementptr inbounds [500 x double], [500 x double]* %13, i64 0, i64 %86
%258 = load double, double* %257
%259 = insertelement <4 x i32> poison, i32 %256, i64 0
%260 = insertelement <4 x i32> %259, i32 %252, i64 1
%261 = insertelement <4 x i32> %260, i32 %253, i64 2
%262 = insertelement <4 x i32> %261, i32 %254, i64 3
%263 = sitofp <4 x i32> %262 to <4 x double>
%264 = extractelement <4 x double> %263, i64 3
%265 = fadd double %258, %264
store double %265, double* %257
%266 = getelementptr inbounds [500 x double], [500 x double]* %15, i64 0, i64 %86
%267 = load double, double* %266
%268 = extractelement <4 x double> %263, i64 2
%269 = fadd double %267, %268
store double %269, double* %266
%270 = getelementptr inbounds [500 x double], [500 x double]* %17, i64 0, i64 %86
%271 = load double, double* %270
%272 = extractelement <4 x double> %263, i64 1
%273 = fadd double %271, %272
store double %273, double* %270
%274 = getelementptr inbounds [500 x double], [500 x double]* %9, i64 0, i64 %86
%275 = load double, double* %274
%276 = extractelement <4 x double> %263, i64 0
%277 = fadd double %275, %276
store double %277, double* %274
%278 = sitofp i32 %255 to double
%279 = getelementptr inbounds [500 x double], [500 x double]* %11, i64 0, i64 %86
%280 = load double, double* %279
%281 = fadd double %280, %278
store double %281, double* %279
%282 = icmp ugt i64 %86, 400
%283 = fadd <4 x double> %88, %263
%284 = add nsw i32 %87, 1
%285 = select i1 %282, i32 %284, i32 %87
%286 = select i1 %282, <4 x double> %283, <4 x double> %88
%287 = add nuw nsw i64 %86, 1
%288 = icmp eq i64 %287, 500
br i1 %288, label %289, label %85
289: ; preds = %251
%290 = fadd double %37, %80
%291 = fadd double %35, %83
%292 = fadd double %34, %84
%293 = mul nsw i32 %285, 10000
%294 = sitofp i32 %293 to double
%295 = insertelement <4 x double> poison, double %294, i64 0
%296 = shufflevector <4 x double> %295, <4 x double> poison, <4 x i32> zeroinitializer
%297 = fdiv <4 x double> %286, %296
%298 = fadd <4 x double> %39, %297
%299 = add nuw nsw i32 %38, 1
%300 = icmp eq i32 %299, 10
br i1 %300, label %301, label %33
301: ; preds = %289
store double %290, double* %25
store double %82, double* %26
store double 0.000000e+00, double* %27
store double %291, double* %28
store double %292, double* %29
%302 = extractelement <4 x double> %298, i64 3
%303 = fdiv double %302, 1.000000e+01
%304 = extractelement <4 x double> %298, i64 2
%305 = fdiv double %304, 1.000000e+01
%306 = extractelement <4 x double> %298, i64 1
%307 = fdiv double %306, 1.000000e+01
%308 = extractelement <4 x double> %298, i64 0
%309 = fdiv double %308, 1.000000e+01
%310 = tail call i32 @fprintf(i32* %24, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.3, i64 0, i64 0), double %31, double %303, double %305, double %307, double %309)
%311 = fadd double %31, 5.000000e-02
%312 = fcmp ugt double %311, 1.000000e+00
br i1 %312, label %313, label %30
313: ; preds = %301
%314 = tail call i32 @fclose(i32* %24)
ret i32 0
}