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

/* Variables and functions */
int /*<<< orphan*/ TRUE;
int /*<<< orphan*/ cbreak();
int /*<<< orphan*/ curs_set(int /*<<< orphan*/);
int /*<<< orphan*/ delwin(int /*<<< orphan*/ *);
int /*<<< orphan*/ endwin();
int /*<<< orphan*/ getmaxyx(int /*<<< orphan*/, int, int);
int /*<<< orphan*/ initscr();
int /*<<< orphan*/ keypad(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ mvwprintw(int /*<<< orphan*/ *, int, int, char *, ...);
int /*<<< orphan*/ *newwin(int, int, int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ noecho();
int rand();
int /*<<< orphan*/ srand(unsigned int);
int /*<<< orphan*/ stdscr;
int /*<<< orphan*/ system(char *);
scalar_t__ time(int /*<<< orphan*/ *);
int /*<<< orphan*/ wclear(int /*<<< orphan*/ *);
int wgetch(int /*<<< orphan*/ *);
int /*<<< orphan*/ wrefresh(int /*<<< orphan*/ *);
int main(void) {
  WINDOW *win1;
  int x, y, i, j, k;
  int ridx;
  float ymufin = 0.0, ftemp = 0.0, deltamu = 0.0, deltavar = 0.0;
  float ymu[3500] = {}, yvar[3500] = {};
  int xrnd[3500] = {}, yhts[100] = {};
  int scnarr[35][100] = {};
  int slowness = 50;
  initscr();
  cbreak();
  keypad(stdscr, TRUE);
  noecho();
  curs_set(0);
  getmaxyx(stdscr, y, x);
  srand((unsigned)(int)time(NULL));
  win1 = newwin(y, x, 0, 0);
  for (i = 0; i < 3500; i++) {
    xrnd[i] = rand() % 100;
  }
  for (i = 0; i < 3500; i++) {
    ridx = i - 1;
    if (scnarr[0][xrnd[i]] == 1)
      break;
    for (j = 34; j >= 0; j--) {
      if (scnarr[j][xrnd[i]] != 1) {
        for (k = 0; k <= j; k++) {
          if (k > 0)
            mvwprintw(win1, k - 1, xrnd[i], " ");
          mvwprintw(win1, k, xrnd[i], "O");
          wrefresh(win1);
        }
        scnarr[j][xrnd[i]] = 1;
        break;
      }
    }
  }
  ymufin = ((float)ridx) / 100;
  for (i = 0; i <= ridx; i++) {
    yhts[xrnd[i]]++;
    if (i < 1) {
      ymu[0] = 0.0;
      yvar[0] = 0.0;
    } else {
      ymu[i] = (float)(i) / 100;
      yvar[i] = 0;
      for (j = 0; j < 100; j++) {
        ftemp = ((float)yhts[j] - ymu[i]);
        ftemp = ftemp * ftemp;
        yvar[i] = yvar[i] + ftemp;
      }
      yvar[i] = yvar[i] / 100;
    }
  }
  wgetch(win1);
  wclear(win1);
  wrefresh(win1);
  while (1) {
    k = wgetch(win1);
    if (k == 27) {
      k = wgetch(win1);
      k = wgetch(win1);
      if (k / 10 == 5)
        wgetch(win1);
    }
    if (k == 68) {
      wclear(win1);
      for (i = 0; i < 100; i++) {
        for (j = 34; j >= 0; j--) {
          if (scnarr[j][i] == 1)
            mvwprintw(win1, j, i, "O");
        }
      }
      if (ymufin - ((int)ymufin) < .5) {
        for (i = 0; i < 100; i++) {
          if (scnarr[36 - (int)ymufin][i] == 0)
            mvwprintw(win1, 36 - ymufin, i, "-");
          if (scnarr[36 - (int)ymufin][i] == 1)
            mvwprintw(win1, 36 - ymufin, i, "X");
        }
        mvwprintw(win1, 1, 2, "y_mu: %f", ymufin);
        mvwprintw(win1, 2, 2, "y_mu_remainder < .5");
        mvwprintw(win1, 35 - (int)ymufin, 0, "[%d]", (int)ymufin);
      } else {
        for (i = 0; i < 100; i++) {
          if (scnarr[35 - (int)ymufin][i] == 0)
            mvwprintw(win1, 35 - ymufin, i, "-");
          if (scnarr[35 - (int)ymufin][i] == 1)
            mvwprintw(win1, 35 - ymufin, i, "X");
        }
        mvwprintw(win1, 1, 2, "y_mu: %f", ymufin);
        mvwprintw(win1, 2, 2, "y_mu_remainder >= .5");
        mvwprintw(win1, 34 - (int)ymufin, 0, " [%d] ", (int)ymufin + 1);
      }
      wrefresh(win1);
    } else if (k == 67) {
      wclear(win1);
      mvwprintw(win1, 0, 0,
                " N=%d \twidth=100\tmu_final=%.3f"
                "\t\tvar_final=%.3f",
                ridx, ymu[ridx], yvar[ridx]);
      mvwprintw(win1, 1, 0, "\t\t\t\tdelta_mu=%.5f\tdelta_var=%.5f",
                (ridx, ymu[ridx] / ridx), (yvar[ridx] / ridx));
      mvwprintw(win1, 3, 0, " ymu[0:%d] (by 10%% bins):", ridx);
      mvwprintw(win1, 4, 0, " yvar[0:%d] (by 10%% bins):", ridx);
      for (i = 0; i <= 10; i++) {
        ftemp = (float)ridx / 10;
        mvwprintw(win1, 34, i * 9 + 3, "%02d%%", i * 10);
        mvwprintw(win1, 33 - (int)ymu[(int)(i * ftemp)], i * 9 + 2, "%.2f",
                  ymu[(int)(i * ftemp)]);
        mvwprintw(win1, 34 - (int)ymu[(int)(i * ftemp)], i * 9 + 2, "%.2f",
                  yvar[(int)(i * ftemp)]);
      }
      wrefresh(win1);
    } else if (k == 65) {
      wclear(win1);
      mvwprintw(win1, 0, 0, "i:");
      mvwprintw(win1, 7, 0, "yhts[i]:\t(final)");
      mvwprintw(win1, 14, 0, "ymu[1:%d]:\t(ymu, %%-wise)", ridx);
      mvwprintw(win1, 21, 0, "yvar[0:%d]:\t(yvar, %%-wise)", ridx);
      for (i = 0; i < 100; i++) {
        mvwprintw(win1, 1 + i / 20, (i % 20) * 5, " %2d", i);
        mvwprintw(win1, 8 + i / 20, (i % 20) * 5, " %2d", yhts[i]);
        mvwprintw(win1, 15 + i / 20, (i % 20) * 5, "%4.1f",
                  ymu[((i + 1) * ridx) / 100]);
        mvwprintw(win1, 22 + i / 20, (i % 20) * 5, "%4.1f",
                  yvar[((i + 1) * ridx) / 100]);
      }
      wrefresh(win1);
    } else if (k == 10) {
      delwin(win1);
      endwin();
      system("clear");
      break;
    }
  }
  return k;
  delwin(win1);
  endwin();
  system("clear");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xdca0,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
lea    -0x36f0(%rbp),%rdi
xor    %esi,%esi
mov    $0x36b0,%edx
call   1090 <memset@plt>
lea    -0x6da0(%rbp),%rdi
xor    %esi,%esi
mov    $0x36b0,%edx
call   1090 <memset@plt>
lea    -0xa450(%rbp),%rdi
xor    %esi,%esi
mov    $0x36b0,%edx
call   1090 <memset@plt>
lea    -0xa5e0(%rbp),%rdi
xor    %esi,%esi
mov    $0x190,%edx
call   1090 <memset@plt>
lea    -0xdc90(%rbp),%rdi
xor    %esi,%esi
mov    $0x36b0,%edx
call   1090 <memset@plt>
movl   $0x32,-0xdc94(%rbp)
mov    $0x0,%al
call   1070 <initscr@plt>
mov    $0x0,%al
call   1030 <cbreak@plt>
mov    0x2d18(%rip),%rax
mov    (%rax),%edi
mov    0x2d07(%rip),%rax
mov    (%rax),%esi
call   1060 <keypad@plt>
mov    $0x0,%al
call   1120 <noecho@plt>
xor    %edi,%edi
call   1130 <curs_set@plt>
mov    0x2cf3(%rip),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edx
call   10b0 <getmaxyx@plt>
xor    %eax,%eax
mov    %eax,%edi
call   10d0 <time@plt>
mov    %eax,%edi
call   10a0 <srand@plt>
mov    -0x18(%rbp),%edi
mov    -0x14(%rbp),%esi
xor    %ecx,%ecx
mov    %ecx,%edx
call   1080 <newwin@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xdac,-0x1c(%rbp)
jge    1361 <main+0x141>
mov    $0x0,%al
call   1140 <rand@plt>
mov    $0x64,%ecx
cltd
idiv   %ecx
movslq -0x1c(%rbp),%rax
mov    %edx,-0xa450(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    132c <main+0x10c>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xdac,-0x1c(%rbp)
jge    14a3 <main+0x283>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
movslq -0x1c(%rbp),%rax
movslq -0xa450(%rbp,%rax,4),%rax
ff
cmpl   $0x1,-0xdc90(%rbp,%rax,4)
01
jne    139d <main+0x17d>
jmp    14a3 <main+0x283>
movl   $0x22,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     1490 <main+0x270>
movslq -0x20(%rbp),%rcx
lea    -0xdc90(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movslq -0xa450(%rbp,%rcx,4),%rcx
ff
cmpl   $0x1,(%rax,%rcx,4)
je     147d <main+0x25d>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1450 <main+0x230>
cmpl   $0x0,-0x24(%rbp)
jle    1419 <main+0x1f9>
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%esi
sub    $0x1,%esi
movslq -0x1c(%rbp),%rax
mov    -0xa450(%rbp,%rax,4),%edx
lea    0xc48(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%esi
movslq -0x1c(%rbp),%rax
mov    -0xa450(%rbp,%rax,4),%edx
lea    0xbe6(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
call   1050 <wrefresh@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13e0 <main+0x1c0>
movslq -0x20(%rbp),%rcx
lea    -0xdc90(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movslq -0xa450(%rbp,%rcx,4),%rcx
ff
movl   $0x1,(%rax,%rcx,4)
jmp    1490 <main+0x270>
jmp    1482 <main+0x262>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    13a4 <main+0x184>
jmp    1495 <main+0x275>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1368 <main+0x148>
cvtsi2ssl -0x28(%rbp),%xmm0
movss  0xb50(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     15e1 <main+0x3c1>
movslq -0x1c(%rbp),%rax
movslq -0xa450(%rbp,%rax,4),%rax
ff
mov    -0xa5e0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0xa5e0(%rbp,%rax,4)
cmpl   $0x1,-0x1c(%rbp)
jge    150e <main+0x2ee>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x36f0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6da0(%rbp)
ff
jmp    15ce <main+0x3ae>
cvtsi2ssl -0x1c(%rbp),%xmm0
movss  0xae5(%rip),%xmm1
divss  %xmm1,%xmm0
movslq -0x1c(%rbp),%rax
movss  %xmm0,-0x36f0(%rbp,%rax,4)
ff ff
movslq -0x1c(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6da0(%rbp,%rax,4)
ff ff
movl   $0x0,-0x20(%rbp)
cmpl   $0x64,-0x20(%rbp)
jge    15a8 <main+0x388>
movslq -0x20(%rbp),%rax
cvtsi2ssl -0xa5e0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1c(%rbp),%rax
subss  -0x36f0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movslq -0x1c(%rbp),%rax
movss  -0x6da0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x30(%rbp),%xmm0
movslq -0x1c(%rbp),%rax
movss  %xmm0,-0x6da0(%rbp,%rax,4)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1543 <main+0x323>
movslq -0x1c(%rbp),%rax
movss  -0x6da0(%rbp,%rax,4),%xmm0
ff ff
movss  0xa43(%rip),%xmm1
divss  %xmm1,%xmm0
movslq -0x1c(%rbp),%rax
movss  %xmm0,-0x6da0(%rbp,%rax,4)
ff ff
jmp    15d3 <main+0x3b3>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14c0 <main+0x2a0>
mov    -0x10(%rbp),%rdi
call   10f0 <wgetch@plt>
mov    -0x10(%rbp),%rdi
call   1100 <wclear@plt>
mov    -0x10(%rbp),%rdi
call   1050 <wrefresh@plt>
mov    -0x10(%rbp),%rdi
call   10f0 <wgetch@plt>
mov    %eax,-0x24(%rbp)
cmpl   $0x1b,-0x24(%rbp)
jne    164c <main+0x42c>
mov    -0x10(%rbp),%rdi
call   10f0 <wgetch@plt>
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rdi
call   10f0 <wgetch@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x5,%eax
jne    1647 <main+0x427>
mov    -0x10(%rbp),%rdi
call   10f0 <wgetch@plt>
jmp    164c <main+0x42c>
cmpl   $0x44,-0x24(%rbp)
jne    1981 <main+0x761>
mov    -0x10(%rbp),%rdi
call   1100 <wclear@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x64,-0x1c(%rbp)
jge    16e2 <main+0x4c2>
movl   $0x22,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     16cf <main+0x4af>
movslq -0x20(%rbp),%rcx
lea    -0xdc90(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    16bc <main+0x49c>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0x963(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
jmp    16c1 <main+0x4a1>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1677 <main+0x457>
jmp    16d4 <main+0x4b4>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1666 <main+0x446>
movss  -0x2c(%rbp),%xmm0
cvttss2si -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x910(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    183f <main+0x61f>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x64,-0x1c(%rbp)
jge    17d6 <main+0x5b6>
cvttss2si -0x2c(%rbp),%ecx
mov    $0x24,%eax
sub    %ecx,%eax
movslq %eax,%rcx
lea    -0xdc90(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    176f <main+0x54f>
mov    -0x10(%rbp),%rdi
movss  0x8b7(%rip),%xmm0
subss  -0x2c(%rbp),%xmm0
cvttss2si %xmm0,%esi
mov    -0x1c(%rbp),%edx
lea    0x8b2(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
cvttss2si -0x2c(%rbp),%ecx
mov    $0x24,%eax
sub    %ecx,%eax
movslq %eax,%rcx
lea    -0xdc90(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    17c3 <main+0x5a3>
mov    -0x10(%rbp),%rdi
movss  0x863(%rip),%xmm0
subss  -0x2c(%rbp),%xmm0
cvttss2si %xmm0,%esi
mov    -0x1c(%rbp),%edx
lea    0x860(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
jmp    17c8 <main+0x5a8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1711 <main+0x4f1>
mov    -0x10(%rbp),%rdi
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%esi
mov    $0x2,%edx
lea    0x82a(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    $0x2,%edx
lea    0x81c(%rip),%rcx
mov    %edx,%esi
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
cvttss2si -0x2c(%rbp),%eax
mov    $0x23,%esi
sub    %eax,%esi
cvttss2si -0x2c(%rbp),%r8d
xor    %edx,%edx
lea    0x808(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
jmp    1973 <main+0x753>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x64,-0x1c(%rbp)
jge    190b <main+0x6eb>
cvttss2si -0x2c(%rbp),%ecx
mov    $0x23,%eax
sub    %ecx,%eax
movslq %eax,%rcx
lea    -0xdc90(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    18a4 <main+0x684>
mov    -0x10(%rbp),%rdi
movss  0x77e(%rip),%xmm0
subss  -0x2c(%rbp),%xmm0
cvttss2si %xmm0,%esi
mov    -0x1c(%rbp),%edx
lea    0x77d(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
cvttss2si -0x2c(%rbp),%ecx
mov    $0x23,%eax
sub    %ecx,%eax
movslq %eax,%rcx
lea    -0xdc90(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    18f8 <main+0x6d8>
mov    -0x10(%rbp),%rdi
movss  0x72a(%rip),%xmm0
subss  -0x2c(%rbp),%xmm0
cvttss2si %xmm0,%esi
mov    -0x1c(%rbp),%edx
lea    0x72b(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
jmp    18fd <main+0x6dd>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1846 <main+0x626>
mov    -0x10(%rbp),%rdi
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%esi
mov    $0x2,%edx
lea    0x6f5(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    $0x2,%edx
lea    0x700(%rip),%rcx
mov    %edx,%esi
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
cvttss2si -0x2c(%rbp),%eax
mov    $0x22,%esi
sub    %eax,%esi
cvttss2si -0x2c(%rbp),%r8d
add    $0x1,%r8d
xor    %edx,%edx
lea    0x6e9(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
call   1050 <wrefresh@plt>
jmp    1d76 <main+0xb56>
cmpl   $0x43,-0x24(%rbp)
jne    1b69 <main+0x949>
mov    -0x10(%rbp),%rdi
call   1100 <wclear@plt>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%r8d
movslq -0x28(%rbp),%rax
movss  -0x36f0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
movslq -0x28(%rbp),%rax
movss  -0x6da0(%rbp,%rax,4),%xmm1
ff ff
cvtss2sd %xmm1,%xmm1
xor    %edx,%edx
lea    0x695(%rip),%rcx
mov    %edx,%esi
mov    $0x2,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
movslq -0x28(%rbp),%rax
movss  -0x36f0(%rbp,%rax,4),%xmm0
ff ff
cvtsi2ssl -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x28(%rbp),%rax
movss  -0x6da0(%rbp,%rax,4),%xmm1
ff ff
cvtsi2ssl -0x28(%rbp),%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mov    $0x1,%esi
xor    %edx,%edx
lea    0x675(%rip),%rcx
mov    $0x2,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%r8d
mov    $0x3,%esi
xor    %edx,%edx
lea    0x679(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%r8d
mov    $0x4,%esi
xor    %edx,%edx
lea    0x677(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jg     1b5b <main+0x93b>
cvtsi2ssl -0x28(%rbp),%xmm0
movss  0x58f(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
imul   $0x9,-0x1c(%rbp),%edx
add    $0x3,%edx
imul   $0xa,-0x1c(%rbp),%r8d
mov    $0x22,%esi
lea    0x649(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
cvtsi2ssl -0x1c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
cvttss2si %xmm0,%eax
cltq
cvttss2si -0x36f0(%rbp,%rax,4),%eax
ff ff
mov    $0x21,%esi
sub    %eax,%esi
imul   $0x9,-0x1c(%rbp),%edx
add    $0x2,%edx
cvtsi2ssl -0x1c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
cvttss2si %xmm0,%eax
cltq
movss  -0x36f0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0x5fa(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
cvtsi2ssl -0x1c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
cvttss2si %xmm0,%eax
cltq
cvttss2si -0x36f0(%rbp,%rax,4),%eax
ff ff
mov    $0x22,%esi
sub    %eax,%esi
imul   $0x9,-0x1c(%rbp),%edx
add    $0x2,%edx
cvtsi2ssl -0x1c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
cvttss2si %xmm0,%eax
cltq
movss  -0x6da0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0x5a4(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1a5e <main+0x83e>
mov    -0x10(%rbp),%rdi
call   1050 <wrefresh@plt>
jmp    1d71 <main+0xb51>
cmpl   $0x41,-0x24(%rbp)
jne    1d3c <main+0xb1c>
mov    -0x10(%rbp),%rdi
call   1100 <wclear@plt>
mov    -0x10(%rbp),%rdi
xor    %edx,%edx
lea    0x566(%rip),%rcx
mov    %edx,%esi
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    $0x7,%esi
xor    %edx,%edx
lea    0x54e(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%r8d
mov    $0xe,%esi
xor    %edx,%edx
lea    0x542(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%r8d
mov    $0x15,%esi
xor    %edx,%edx
lea    0x53f(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x64,-0x1c(%rbp)
jge    1d2e <main+0xb0e>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
add    $0x1,%esi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
imul   $0x5,%edx,%edx
mov    -0x1c(%rbp),%r8d
lea    0x516(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
add    $0x8,%esi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
imul   $0x5,%edx,%edx
movslq -0x1c(%rbp),%rax
mov    -0xa5e0(%rbp,%rax,4),%r8d
ff
lea    0x4da(%rip),%rcx
mov    $0x0,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
add    $0xf,%esi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
imul   $0x5,%edx,%eax
mov    %eax,-0xdc9c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    -0xdc9c(%rbp),%edx
cltq
movss  -0x36f0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0x482(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
add    $0x16,%esi
mov    -0x1c(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
imul   $0x5,%edx,%eax
mov    %eax,-0xdc98(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    -0xdc98(%rbp),%edx
cltq
movss  -0x6da0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0x425(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1bec <main+0x9cc>
mov    -0x10(%rbp),%rdi
call   1050 <wrefresh@plt>
jmp    1d6c <main+0xb4c>
cmpl   $0xa,-0x24(%rbp)
jne    1d67 <main+0xb47>
mov    -0x10(%rbp),%rdi
call   10c0 <delwin@plt>
mov    $0x0,%al
call   10e0 <endwin@plt>
lea    0x3e7(%rip),%rdi
call   1040 <system@plt>
jmp    1d7b <main+0xb5b>
jmp    1d6c <main+0xb4c>
jmp    1d71 <main+0xb51>
jmp    1d76 <main+0xb56>
jmp    15fc <main+0x3dc>
mov    -0x24(%rbp),%eax
add    $0xdca0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xdcd8,%rsp
lea    0x6f70(%rsp),%rdi
mov    $0x36b0,%edx
xor    %esi,%esi
call   1090 <memset@plt>
lea    0x38c0(%rsp),%rdi
mov    $0x36b0,%edx
xor    %esi,%esi
call   1090 <memset@plt>
lea    0xa620(%rsp),%rdi
mov    $0x36b0,%edx
xor    %esi,%esi
call   1090 <memset@plt>
lea    0x80(%rsp),%rdi
mov    $0x190,%edx
xor    %esi,%esi
call   1090 <memset@plt>
lea    0x210(%rsp),%rdi
mov    $0x36b0,%edx
xor    %esi,%esi
call   1090 <memset@plt>
xor    %eax,%eax
call   1070 <initscr@plt>
xor    %eax,%eax
call   1030 <cbreak@plt>
mov    0x2d3e(%rip),%rbx
mov    (%rbx),%edi
mov    0x2d2d(%rip),%rax
mov    (%rax),%esi
call   1060 <keypad@plt>
xor    %eax,%eax
call   1120 <noecho@plt>
xor    %edi,%edi
call   1130 <curs_set@plt>
mov    (%rbx),%edi
call   10b0 <getmaxyx@plt>
xor    %edi,%edi
call   10d0 <time@plt>
mov    %eax,%edi
call   10a0 <srand@plt>
xor    %edx,%edx
xor    %ecx,%ecx
call   1080 <newwin@plt>
mov    %rax,%r12
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1140 <rand@plt>
cltq
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rcx
add    %edx,%ecx
imul   $0x64,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,0xa620(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0xdac,%rbx
jne    12f0 <main+0xd0>
movss  0xcd2(%rip),%xmm0
movss  %xmm0,0x18(%rsp)
movss  0xcc8(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
lea    0xd16(%rip),%r8
xor    %eax,%eax
jmp    1370 <main+0x150>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
movl   $0x1,(%rax)
mov    0x8(%rsp),%rdx
lea    0x1(%rdx),%rax
cmp    $0xdac,%rax
je     14e0 <main+0x2c0>
mov    %rax,%rdx
movslq 0xa620(%rsp,%rax,4),%rbp
cmpl   $0x1,0x210(%rsp,%rbp,4)
01
je     14e7 <main+0x2c7>
mov    $0x1e,%eax
xchg   %ax,%ax
lea    0x4(%rax),%r13d
imul   $0x190,%r13,%rcx
add    %rsp,%rcx
add    $0x210,%rcx
cmpl   $0x1,(%rcx,%rbp,4)
jne    1430 <main+0x210>
lea    0x3(%rax),%r13d
imul   $0x190,%r13,%rcx
add    %rsp,%rcx
add    $0x210,%rcx
cmpl   $0x1,(%rcx,%rbp,4)
jne    1430 <main+0x210>
lea    0x2(%rax),%r13d
imul   $0x190,%r13,%rcx
add    %rsp,%rcx
add    $0x210,%rcx
cmpl   $0x1,(%rcx,%rbp,4)
jne    1430 <main+0x210>
lea    0x1(%rax),%r13d
imul   $0x190,%r13,%rcx
add    %rsp,%rcx
add    $0x210,%rcx
cmpl   $0x1,(%rcx,%rbp,4)
jne    1430 <main+0x210>
mov    %eax,%ecx
imul   $0x190,%rcx,%rcx
add    %rsp,%rcx
add    $0x210,%rcx
cmpl   $0x1,(%rcx,%rbp,4)
jne    14c1 <main+0x2a1>
add    $0xfffffffb,%eax
cmp    $0xfffffffb,%eax
jne    1390 <main+0x170>
jmp    1360 <main+0x140>
xchg   %ax,%ax
mov    %rdx,0x8(%rsp)
lea    (%rcx,%rbp,4),%rax
mov    %rax,0x10(%rsp)
test   %r13d,%r13d
js     1350 <main+0x130>
mov    %r12,%rbx
mov    %r12,%rdi
xor    %esi,%esi
mov    %ebp,%edx
lea    0xbc4(%rip),%rcx
xor    %eax,%eax
mov    %r8,%r15
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
call   1050 <wrefresh@plt>
mov    %r15,%r8
test   %r13d,%r13d
je     1350 <main+0x130>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    0x1(%rsi),%ebx
mov    %r12,%r14
mov    %r12,%rdi
mov    %ebp,%edx
mov    %r8,%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    %ebx,%esi
mov    %ebp,%edx
lea    0xb79(%rip),%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
call   1050 <wrefresh@plt>
mov    %r15,%r8
mov    %ebx,%esi
cmp    %ebx,%r13d
jne    1480 <main+0x260>
jmp    1350 <main+0x130>
mov    %rdx,0x8(%rsp)
lea    (%rcx,%rbp,4),%rcx
mov    %rcx,0x10(%rsp)
mov    %eax,%r13d
test   %r13d,%r13d
jns    1447 <main+0x227>
jmp    1350 <main+0x130>
mov    $0xdaa,%eax
jmp    1511 <main+0x2f1>
mov    %edx,%eax
mov    $0xffffffff,%ebx
sub    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x18(%rsp)
divss  0xb02(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
jb     15eb <main+0x3cb>
mov    %edx,%ecx
xor    %edx,%edx
movss  0xaeb(%rip),%xmm0
jmp    152d <main+0x30d>
nop
add    $0x1,%rdx
cmp    %rcx,%rdx
je     15d3 <main+0x3b3>
movslq 0xa620(%rsp,%rdx,4),%rsi
addl   $0x1,0x80(%rsp,%rsi,4)
01
test   %rdx,%rdx
je     1520 <main+0x300>
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x6f70(%rsp,%rdx,4)
xorps  %xmm2,%xmm2
mov    $0x3,%esi
xchg   %ax,%ax
xorps  %xmm3,%xmm3
cvtsi2ssl 0x74(%rsp,%rsi,4),%xmm3
subss  %xmm1,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsi2ssl 0x78(%rsp,%rsi,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm2,%xmm2
xorps  %xmm4,%xmm4
cvtsi2ssl 0x7c(%rsp,%rsi,4),%xmm4
addss  %xmm3,%xmm2
subss  %xmm1,%xmm4
mulss  %xmm4,%xmm4
addss  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsi2ssl 0x80(%rsp,%rsi,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm4,%xmm2
add    $0x4,%rsi
cmp    $0x67,%rsi
jne    1560 <main+0x340>
divss  %xmm0,%xmm2
movss  %xmm2,0x38c0(%rsp,%rdx,4)
jmp    1520 <main+0x300>
movl   $0x0,0x6f70(%rsp)
movl   $0x0,0x38c0(%rsp)
mov    %eax,%ebx
mov    %r12,%rbp
mov    %r12,%rdi
call   10f0 <wgetch@plt>
mov    %r12,%rdi
call   1100 <wclear@plt>
mov    %r12,%rdi
call   1050 <wrefresh@plt>
mov    %ebx,0x10(%rsp)
movslq %ebx,%rax
mov    %rax,0x68(%rsp)
movss  0x18(%rsp),%xmm0
divss  0x9ec(%rip),%xmm0
movss  %xmm0,0x34(%rsp)
movaps 0x40(%rsp),%xmm2
cvttss2si %xmm2,%edx
cvttps2dq %xmm2,%xmm0
cvtdq2ps %xmm0,%xmm0
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
movaps %xmm1,0x70(%rsp)
mov    $0x23,%eax
movss  0x9c1(%rip),%xmm0
subss  %xmm2,%xmm0
cvttss2si %xmm0,%r13d
sub    %edx,%eax
mov    %eax,0x28(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movsd  %xmm0,0x38(%rsp)
mov    $0x22,%eax
sub    %edx,%eax
mov    %eax,0x24(%rsp)
lea    0x1(%rdx),%eax
mov    %eax,0x20(%rsp)
mov    $0x24,%eax
sub    %edx,%eax
cltq
movss  0x986(%rip),%xmm0
subss  %xmm2,%xmm0
cvttss2si %xmm0,%ecx
mov    %ecx,0x1c(%rsp)
imul   $0x190,%rax,%rax
lea    0x210(%rsp),%rcx
add    %rcx,%rax
add    $0xfffffffffffffe70,%rax
mov    %rax,0x58(%rsp)
mov    %rdx,0x60(%rsp)
movslq %edx,%rax
mov    $0x1,%ecx
sub    %rax,%rcx
imul   $0x190,%rcx,%rax
add    %rsp,%rax
add    $0x38c0,%rax
mov    %rax,0x50(%rsp)
mov    %r12,0x8(%rsp)
mov    %r13d,0x40(%rsp)
jmp    1750 <main+0x530>
mov    %r12,%rbx
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x2,%edx
lea    0x923(%rip),%rcx
movsd  0x38(%rsp),%xmm0
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
lea    0x90b(%rip),%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    0x28(%rsp),%esi
xor    %edx,%edx
lea    0x908(%rip),%rcx
mov    0x60(%rsp),%r8
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
call   1050 <wrefresh@plt>
mov    0x40(%rsp),%r13d
mov    %r12,%rdi
call   10f0 <wgetch@plt>
mov    %eax,%ebx
cmp    $0x1b,%eax
jne    1784 <main+0x564>
mov    %r12,%rbx
mov    %r12,%rdi
call   10f0 <wgetch@plt>
mov    %r12,%rdi
call   10f0 <wgetch@plt>
mov    %eax,%ebx
add    $0xffffffce,%eax
cmp    $0x9,%eax
ja     1784 <main+0x564>
mov    %r12,%rdi
call   10f0 <wgetch@plt>
cmp    $0x42,%ebx
jle    1810 <main+0x5f0>
cmp    $0x43,%ebx
je     1980 <main+0x760>
cmp    $0x44,%ebx
jne    1750 <main+0x530>
mov    %r12,%rdi
call   1100 <wclear@plt>
lea    0x210(%rsp),%r15
xor    %r14d,%r14d
jmp    17c2 <main+0x5a2>
add    $0x1,%r14
add    $0x4,%r15
cmp    $0x64,%r14
je     1b00 <main+0x8e0>
mov    $0x3520,%ebx
mov    $0x22,%ebp
jmp    17e3 <main+0x5c3>
xchg   %ax,%ax
add    $0xfffffffffffffe70,%rbx
add    $0xffffffff,%ebp
cmp    $0xfffffffffffffe70,%rbx
je     17b0 <main+0x590>
cmpl   $0x1,(%r15,%rbx,1)
jne    17d0 <main+0x5b0>
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
lea    0x823(%rip),%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
jmp    17d0 <main+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x41,%ebx
jne    1b66 <main+0x946>
mov    %r12,%rbp
mov    %r12,%rdi
call   1100 <wclear@plt>
xor    %r15d,%r15d
mov    %r12,%rdi
xor    %esi,%esi
xor    %edx,%edx
lea    0x8be(%rip),%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    $0x7,%esi
xor    %edx,%edx
lea    0x8a9(%rip),%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    $0xe,%esi
xor    %edx,%edx
lea    0x8a2(%rip),%rcx
mov    0x10(%rsp),%ebx
mov    %ebx,%r8d
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    $0x15,%esi
xor    %edx,%edx
lea    0x89d(%rip),%rcx
mov    %ebx,%r8d
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %ebx,%r13d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl %bpl,%eax
imul   $0xcd,%eax,%ebx
shr    $0xc,%ebx
imul   $0x64,%ebx,%eax
mov    %r15d,%ecx
sub    %al,%cl
lea    0x1(%rbx),%esi
movzbl %cl,%r14d
mov    %r12,%rdi
mov    %r14d,%edx
lea    0x874(%rip),%rcx
mov    %ebp,%r8d
xor    %eax,%eax
call   1110 <mvwprintw@plt>
lea    0x8(%rbx),%esi
mov    0x80(%rsp,%rbp,4),%r8d
mov    %r12,%rdi
mov    %r14d,%edx
lea    0x852(%rip),%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
lea    0xf(%rbx),%esi
add    $0x1,%rbp
movslq %r13d,%r13
imul   $0x51eb851f,%r13,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
movslq %eax,%r12
movss  0x6f70(%rsp,%r12,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x8(%rsp),%rdi
mov    %r14d,%edx
lea    0x812(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
add    $0x16,%ebx
movss  0x38c0(%rsp,%r12,4),%xmm0
mov    0x8(%rsp),%rdi
cvtss2sd %xmm0,%xmm0
mov    %rdi,%r12
mov    %ebx,%esi
mov    %r14d,%edx
lea    0x7e6(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
add    $0x5,%r15b
add    0x10(%rsp),%r13d
cmp    $0x64,%rbp
jne    18a0 <main+0x680>
jmp    1743 <main+0x523>
nopl   0x0(%rax,%rax,1)
mov    %r12,%rbx
mov    %r12,%rdi
call   1100 <wclear@plt>
mov    0x68(%rsp),%rax
movss  0x6f70(%rsp,%rax,4),%xmm0
movss  %xmm0,0x2c(%rsp)
cvtss2sd %xmm0,%xmm0
movss  0x38c0(%rsp,%rax,4),%xmm1
movss  %xmm1,0x30(%rsp)
cvtss2sd %xmm1,%xmm1
xor    %r14d,%r14d
mov    %r12,%rdi
xor    %esi,%esi
xor    %edx,%edx
lea    0x699(%rip),%rcx
mov    0x10(%rsp),%r15d
mov    %r15d,%r8d
mov    $0x2,%al
call   1110 <mvwprintw@plt>
movss  0x18(%rsp),%xmm1
movss  0x2c(%rsp),%xmm0
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x30(%rsp),%xmm2
divss  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
mov    %r12,%rdi
mov    $0x1,%esi
xor    %edx,%edx
lea    0x683(%rip),%rcx
mov    $0x2,%al
call   1110 <mvwprintw@plt>
mov    $0x3,%ebp
mov    %r12,%rdi
mov    $0x3,%esi
xor    %edx,%edx
lea    0x687(%rip),%rcx
mov    %r15d,%r8d
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    $0x4,%esi
xor    %edx,%edx
lea    0x687(%rip),%rcx
mov    %r15d,%r8d
xor    %eax,%eax
call   1110 <mvwprintw@plt>
xor    %ebx,%ebx
mov    %r12,%rdi
mov    $0x22,%esi
mov    %ebp,%edx
lea    0x686(%rip),%rcx
mov    %r14d,%r8d
xor    %eax,%eax
call   1110 <mvwprintw@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  0x34(%rsp),%xmm0
cvttss2si %xmm0,%eax
movslq %eax,%r13
movss  0x6f70(%rsp,%r13,4),%xmm0
cvttss2si %xmm0,%r12d
mov    $0x21,%esi
sub    %r12d,%esi
lea    -0x1(%rbp),%r15d
cvtss2sd %xmm0,%xmm0
mov    0x8(%rsp),%rdi
mov    %r15d,%edx
lea    0x641(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    $0x22,%esi
sub    %r12d,%esi
mov    0x8(%rsp),%rdi
movss  0x38c0(%rsp,%r13,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rdi,%r12
mov    %r15d,%edx
lea    0x612(%rip),%rcx
mov    $0x1,%al
call   1110 <mvwprintw@plt>
add    $0x1,%ebx
add    $0x9,%ebp
add    $0xa,%r14d
cmp    $0x66,%ebp
jne    1a50 <main+0x830>
jmp    1743 <main+0x523>
nopl   0x0(%rax,%rax,1)
movss  0x510(%rip),%xmm0
ucomiss 0x70(%rsp),%xmm0
jbe    1b74 <main+0x954>
xor    %ebx,%ebx
mov    0x1c(%rsp),%r14d
mov    0x50(%rsp),%rbp
lea    0x4fc(%rip),%r15
jmp    1b4d <main+0x92d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rdi
mov    %r14d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
add    $0x1,%rbx
cmp    $0x64,%rbx
je     16e8 <main+0x4c8>
mov    0x0(%rbp,%rbx,4),%eax
mov    %r15,%rcx
test   %eax,%eax
je     1b30 <main+0x910>
cmp    $0x1,%eax
jne    1b3f <main+0x91f>
lea    0x4bc(%rip),%rcx
jmp    1b30 <main+0x910>
cmp    $0xa,%ebx
jne    1750 <main+0x530>
jmp    1c1b <main+0x9fb>
xor    %ebx,%ebx
mov    0x58(%rsp),%rbp
lea    0x49c(%rip),%r14
jmp    1ba9 <main+0x989>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rdi
mov    %r13d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
add    $0x1,%rbx
cmp    $0x64,%rbx
je     1bc2 <main+0x9a2>
mov    0x0(%rbp,%rbx,4),%eax
mov    %r14,%rcx
test   %eax,%eax
je     1b90 <main+0x970>
cmp    $0x1,%eax
jne    1b9f <main+0x97f>
lea    0x460(%rip),%rcx
jmp    1b90 <main+0x970>
mov    %r12,%rbx
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x2,%edx
lea    0x449(%rip),%rcx
movsd  0x38(%rsp),%xmm0
mov    $0x1,%al
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
lea    0x44a(%rip),%rcx
xor    %eax,%eax
call   1110 <mvwprintw@plt>
mov    %r12,%rdi
mov    0x24(%rsp),%esi
xor    %edx,%edx
lea    0x448(%rip),%rcx
mov    0x20(%rsp),%r8d
jmp    173c <main+0x51c>
mov    %r12,%rdi
call   10c0 <delwin@plt>
xor    %eax,%eax
call   10e0 <endwin@plt>
lea    0x517(%rip),%rdi
call   1040 <system@plt>
mov    $0xa,%eax
add    $0xdcd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@stdscr = global i32 0
@TRUE = global i32 0
@.str = [2 x i8] c" \00"
@.str.1 = [2 x i8] c"O\00"
@.str.2 = [2 x i8] c"-\00"
@.str.3 = [2 x i8] c"X\00"
@.str.4 = [9 x i8] c"y_mu: %f\00"
@.str.5 = [20 x i8] c"y_mu_remainder < .5\00"
@.str.6 = [5 x i8] c"[%d]\00"
@.str.7 = [21 x i8] c"y_mu_remainder >= .5\00"
@.str.8 = [7 x i8] c" [%d] \00"
@.str.9 = [47 x i8] c" N=%d \09width=100\09mu_final=%.3f\09\09var_final=%.3f\00"
@.str.10 = [33 x i8] c"\09\09\09\09delta_mu=%.5f\09delta_var=%.5f\00"
@.str.11 = [27 x i8] c" ymu[0:%d] (by 10%% bins):\00"
@.str.12 = [28 x i8] c" yvar[0:%d] (by 10%% bins):\00"
@.str.13 = [7 x i8] c"%02d%%\00"
@.str.14 = [5 x i8] c"%.2f\00"
@.str.15 = [3 x i8] c"i:\00"
@.str.16 = [17 x i8] c"yhts[i]:\09(final)\00"
@.str.17 = [26 x i8] c"ymu[1:%d]:\09(ymu, %%-wise)\00"
@.str.18 = [28 x i8] c"yvar[0:%d]:\09(yvar, %%-wise)\00"
@.str.19 = [5 x i8] c" %2d\00"
@.str.20 = [6 x i8] c"%4.1f\00"
@.str.21 = [6 x i8] c"clear\00"
define i32 @main() {
%1 = alloca [3500 x float]
%2 = alloca [3500 x float]
%3 = alloca [3500 x i32]
%4 = alloca [100 x i32]
%5 = alloca [35 x [100 x i32]]
%6 = bitcast [3500 x float]* %1 to i8*
%7 = bitcast [3500 x float]* %2 to i8*
%8 = bitcast [3500 x i32]* %3 to i8*
%9 = bitcast [100 x i32]* %4 to i8*
%10 = bitcast [35 x [100 x i32]]* %5 to i8*
%11 = tail call i32 (...) @initscr()
%12 = tail call i32 (...) @cbreak()
%13 = load i32, i32* @stdscr
%14 = load i32, i32* @TRUE
%15 = tail call i32 @keypad(i32 %13, i32 %14)
%16 = tail call i32 (...) @noecho()
%17 = tail call i32 @curs_set(i32 0)
%18 = load i32, i32* @stdscr
%19 = tail call i32 @getmaxyx(i32 %18, i32 undef, i32 undef)
%20 = tail call i64 @time(i32* null)
%21 = trunc i64 %20 to i32
%22 = tail call i32 @srand(i32 %21)
%23 = tail call i32* @newwin(i32 undef, i32 undef, i32 0, i32 0)
br label %24
24: ; preds = %0, %24
%25 = phi i64 [ 0, %0 ], [ %29, %24 ]
%26 = tail call i32 (...) @rand()
%27 = srem i32 %26, 100
%28 = getelementptr inbounds [3500 x i32], [3500 x i32]* %3, i64 0, i64 %25
store i32 %27, i32* %28
%29 = add nuw nsw i64 %25, 1
%30 = icmp eq i64 %29, 3500
br i1 %30, label %31, label %24
31: ; preds = %24, %89
%32 = phi i64 [ %90, %89 ], [ 0, %24 ]
%33 = getelementptr inbounds [3500 x i32], [3500 x i32]* %3, i64 0, i64 %32
%34 = load i32, i32* %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 0, i64 %35
%37 = load i32, i32* %36
%38 = icmp eq i32 %37, 1
br i1 %38, label %92, label %39
39: ; preds = %31, %86
%40 = phi i32 [ %87, %86 ], [ 34, %31 ]
%41 = zext i32 %40 to i64
%42 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %41, i64 %35
%43 = load i32, i32* %42
%44 = icmp eq i32 %43, 1
br i1 %44, label %62, label %45
45: ; preds = %80, %74, %68, %62, %39
%46 = phi i32 [ %40, %39 ], [ %63, %62 ], [ %69, %68 ], [ %75, %74 ], [ %81, %80 ]
%47 = phi i32* [ %42, %39 ], [ %65, %62 ], [ %71, %68 ], [ %77, %74 ], [ %83, %80 ]
%48 = icmp slt i32 %46, 0
br i1 %48, label %61, label %49
49: ; preds = %45
%50 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 0, i32 %34, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%51 = tail call i32 @wrefresh(i32* %23)
%52 = icmp eq i32 %46, 0
br i1 %52, label %61, label %53
53: ; preds = %49, %53
%54 = phi i32 [ %59, %53 ], [ 1, %49 ]
%55 = add nsw i32 %54, -1
%56 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %55, i32 %34, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%57 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %54, i32 %34, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%58 = tail call i32 @wrefresh(i32* %23)
%59 = add nuw nsw i32 %54, 1
%60 = icmp eq i32 %54, %46
br i1 %60, label %61, label %53
61: ; preds = %53, %49, %45
store i32 1, i32* %47
br label %89
62: ; preds = %39
%63 = add nsw i32 %40, -1
%64 = zext i32 %63 to i64
%65 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %64, i64 %35
%66 = load i32, i32* %65
%67 = icmp eq i32 %66, 1
br i1 %67, label %68, label %45
68: ; preds = %62
%69 = add nsw i32 %40, -2
%70 = zext i32 %69 to i64
%71 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %70, i64 %35
%72 = load i32, i32* %71
%73 = icmp eq i32 %72, 1
br i1 %73, label %74, label %45
74: ; preds = %68
%75 = add nsw i32 %40, -3
%76 = zext i32 %75 to i64
%77 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %76, i64 %35
%78 = load i32, i32* %77
%79 = icmp eq i32 %78, 1
br i1 %79, label %80, label %45
80: ; preds = %74
%81 = add nsw i32 %40, -4
%82 = zext i32 %81 to i64
%83 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %82, i64 %35
%84 = load i32, i32* %83
%85 = icmp eq i32 %84, 1
br i1 %85, label %86, label %45
86: ; preds = %80
%87 = add nsw i32 %40, -5
%88 = icmp eq i32 %81, 0
br i1 %88, label %89, label %39
89: ; preds = %86, %61
%90 = add nuw nsw i64 %32, 1
%91 = icmp eq i64 %90, 3500
br i1 %91, label %98, label %31
92: ; preds = %31
%93 = trunc i64 %32 to i32
%94 = add nsw i32 %93, -1
%95 = sitofp i32 %94 to float
%96 = fdiv float %95, 1.000000e+02
%97 = icmp eq i32 %93, 0
br i1 %97, label %158, label %98
98: ; preds = %89, %92
%99 = phi float [ %96, %92 ], [ 0x40417D70A0000000, %89 ]
%100 = phi float [ %95, %92 ], [ 3.498000e+03, %89 ]
%101 = phi i32 [ %94, %92 ], [ 3498, %89 ]
%102 = getelementptr inbounds [3500 x float], [3500 x float]* %1, i64 0, i64 0
%103 = getelementptr inbounds [3500 x float], [3500 x float]* %2, i64 0, i64 0
%104 = and i64 %32, 4294967295
br label %105
105: ; preds = %98, %154
%106 = phi i64 [ 0, %98 ], [ %155, %154 ]
%107 = getelementptr inbounds [3500 x i32], [3500 x i32]* %3, i64 0, i64 %106
%108 = load i32, i32* %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %109
%111 = load i32, i32* %110
%112 = add nsw i32 %111, 1
store i32 %112, i32* %110
%113 = icmp eq i64 %106, 0
br i1 %113, label %154, label %114
114: ; preds = %105
%115 = trunc i64 %106 to i32
%116 = sitofp i32 %115 to float
%117 = fdiv float %116, 1.000000e+02
%118 = getelementptr inbounds [3500 x float], [3500 x float]* %1, i64 0, i64 %106
store float %117, float* %118
%119 = getelementptr inbounds [3500 x float], [3500 x float]* %2, i64 0, i64 %106
br label %120
120: ; preds = %120, %114
%121 = phi i64 [ 0, %114 ], [ %150, %120 ]
%122 = phi float [ 0.000000e+00, %114 ], [ %149, %120 ]
%123 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %121
%124 = load i32, i32* %123
%125 = sitofp i32 %124 to float
%126 = fsub float %125, %117
%127 = fmul float %126, %126
%128 = fadd float %122, %127
%129 = or i64 %121, 1
%130 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %129
%131 = load i32, i32* %130
%132 = sitofp i32 %131 to float
%133 = fsub float %132, %117
%134 = fmul float %133, %133
%135 = fadd float %128, %134
%136 = or i64 %121, 2
%137 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = sitofp i32 %138 to float
%140 = fsub float %139, %117
%141 = fmul float %140, %140
%142 = fadd float %135, %141
%143 = or i64 %121, 3
%144 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %143
%145 = load i32, i32* %144
%146 = sitofp i32 %145 to float
%147 = fsub float %146, %117
%148 = fmul float %147, %147
%149 = fadd float %142, %148
%150 = add nuw nsw i64 %121, 4
%151 = icmp eq i64 %150, 100
br i1 %151, label %152, label %120
152: ; preds = %120
%153 = fdiv float %149, 1.000000e+02
store float %153, float* %119
br label %154
154: ; preds = %105, %152
%155 = add nuw nsw i64 %106, 1
%156 = icmp eq i64 %155, %104
br i1 %156, label %157, label %105
157: ; preds = %154
store float 0.000000e+00, float* %102
store float 0.000000e+00, float* %103
br label %158
158: ; preds = %157, %92
%159 = phi float [ %99, %157 ], [ %96, %92 ]
%160 = phi float [ %100, %157 ], [ %95, %92 ]
%161 = phi i32 [ %101, %157 ], [ -1, %92 ]
%162 = tail call i32 @wgetch(i32* %23)
%163 = tail call i32 @wclear(i32* %23)
%164 = tail call i32 @wrefresh(i32* %23)
%165 = sext i32 %161 to i64
%166 = getelementptr inbounds [3500 x float], [3500 x float]* %1, i64 0, i64 %165
%167 = getelementptr inbounds [3500 x float], [3500 x float]* %2, i64 0, i64 %165
%168 = fdiv float %160, 1.000000e+01
%169 = fptosi float %159 to i32
%170 = sitofp i32 %169 to float
%171 = fsub float %159, %170
%172 = fcmp olt float %171, 5.000000e-01
%173 = sub nsw i32 35, %169
%174 = sext i32 %173 to i64
%175 = fsub float 3.500000e+01, %159
%176 = fptosi float %175 to i32
%177 = fpext float %159 to double
%178 = sub nsw i32 34, %169
%179 = add nsw i32 %169, 1
%180 = sub nsw i32 36, %169
%181 = sext i32 %180 to i64
%182 = fsub float 3.600000e+01, %159
%183 = fptosi float %182 to i32
br label %184
184: ; preds = %329, %158
%185 = tail call i32 @wgetch(i32* %23)
%186 = icmp eq i32 %185, 27
br i1 %186, label %187, label %194
187: ; preds = %184
%188 = tail call i32 @wgetch(i32* %23)
%189 = tail call i32 @wgetch(i32* %23)
%190 = add i32 %189, -50
%191 = icmp ult i32 %190, 10
br i1 %191, label %192, label %194
192: ; preds = %187
%193 = tail call i32 @wgetch(i32* %23)
br label %194
194: ; preds = %187, %192, %184
%195 = phi i32 [ %189, %192 ], [ %189, %187 ], [ %185, %184 ]
switch i32 %195, label %329 [
i32 68, label %196
i32 67, label %248
i32 65, label %286
i32 10, label %323
]
196: ; preds = %194
%197 = tail call i32 @wclear(i32* %23)
br label %198
198: ; preds = %196, %212
%199 = phi i64 [ 0, %196 ], [ %213, %212 ]
%200 = trunc i64 %199 to i32
br label %201
201: ; preds = %198, %209
%202 = phi i64 [ 34, %198 ], [ %210, %209 ]
%203 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %202, i64 %199
%204 = load i32, i32* %203
%205 = icmp eq i32 %204, 1
br i1 %205, label %206, label %209
206: ; preds = %201
%207 = trunc i64 %202 to i32
%208 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %207, i32 %200, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %209
209: ; preds = %201, %206
%210 = add nsw i64 %202, -1
%211 = icmp eq i64 %202, 0
br i1 %211, label %212, label %201
212: ; preds = %209
%213 = add nuw nsw i64 %199, 1
%214 = icmp eq i64 %213, 100
br i1 %214, label %215, label %198
215: ; preds = %212
br i1 %172, label %216, label %232
216: ; preds = %215, %225
%217 = phi i64 [ %226, %225 ], [ 0, %215 ]
%218 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %181, i64 %217
%219 = load i32, i32* %218
switch i32 %219, label %225 [
i32 0, label %221
i32 1, label %220
]
220: ; preds = %216
br label %221
221: ; preds = %216, %220
%222 = phi i8* [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), %220 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), %216 ]
%223 = trunc i64 %217 to i32
%224 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %183, i32 %223, i8* %222)
br label %225
225: ; preds = %221, %216
%226 = add nuw nsw i64 %217, 1
%227 = icmp eq i64 %226, 100
br i1 %227, label %228, label %216
228: ; preds = %225
%229 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 1, i32 2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), double %177)
%230 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 2, i32 2, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.5, i64 0, i64 0))
%231 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %173, i32 0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i32 %169)
br label %327
232: ; preds = %215, %241
%233 = phi i64 [ %242, %241 ], [ 0, %215 ]
%234 = getelementptr inbounds [35 x [100 x i32]], [35 x [100 x i32]]* %5, i64 0, i64 %174, i64 %233
%235 = load i32, i32* %234
switch i32 %235, label %241 [
i32 0, label %237
i32 1, label %236
]
236: ; preds = %232
br label %237
237: ; preds = %232, %236
%238 = phi i8* [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), %236 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), %232 ]
%239 = trunc i64 %233 to i32
%240 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %176, i32 %239, i8* %238)
br label %241
241: ; preds = %237, %232
%242 = add nuw nsw i64 %233, 1
%243 = icmp eq i64 %242, 100
br i1 %243, label %244, label %232
244: ; preds = %241
%245 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 1, i32 2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), double %177)
%246 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 2, i32 2, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.7, i64 0, i64 0))
%247 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %178, i32 0, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i32 %179)
br label %327
248: ; preds = %194
%249 = tail call i32 @wclear(i32* %23)
%250 = load float, float* %166
%251 = fpext float %250 to double
%252 = load float, float* %167
%253 = fpext float %252 to double
%254 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 0, i32 0, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.9, i64 0, i64 0), i32 %161, double %251, double %253)
%255 = fdiv float %250, %160
%256 = fpext float %255 to double
%257 = fdiv float %252, %160
%258 = fpext float %257 to double
%259 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 1, i32 0, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.10, i64 0, i64 0), double %256, double %258)
%260 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 3, i32 0, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i64 0, i64 0), i32 %161)
%261 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 4, i32 0, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.12, i64 0, i64 0), i32 %161)
br label %262
262: ; preds = %248, %262
%263 = phi i32 [ 0, %248 ], [ %284, %262 ]
%264 = mul nuw nsw i32 %263, 9
%265 = add nuw nsw i32 %264, 3
%266 = mul nuw nsw i32 %263, 10
%267 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 34, i32 %265, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.13, i64 0, i64 0), i32 %266)
%268 = sitofp i32 %263 to float
%269 = fmul float %168, %268
%270 = fptosi float %269 to i32
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds [3500 x float], [3500 x float]* %1, i64 0, i64 %271
%273 = load float, float* %272
%274 = fptosi float %273 to i32
%275 = sub nsw i32 33, %274
%276 = add nuw nsw i32 %264, 2
%277 = fpext float %273 to double
%278 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %275, i32 %276, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), double %277)
%279 = sub nsw i32 34, %274
%280 = getelementptr inbounds [3500 x float], [3500 x float]* %2, i64 0, i64 %271
%281 = load float, float* %280
%282 = fpext float %281 to double
%283 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %279, i32 %276, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), double %282)
%284 = add nuw nsw i32 %263, 1
%285 = icmp eq i32 %284, 11
br i1 %285, label %327, label %262
286: ; preds = %194
%287 = tail call i32 @wclear(i32* %23)
%288 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 0, i32 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0))
%289 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 7, i32 0, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.16, i64 0, i64 0))
%290 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 14, i32 0, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.17, i64 0, i64 0), i32 %161)
%291 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 21, i32 0, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0), i32 %161)
br label %292
292: ; preds = %286, %292
%293 = phi i64 [ 0, %286 ], [ %308, %292 ]
%294 = trunc i64 %293 to i32
%295 = trunc i64 %293 to i8
%296 = udiv i8 %295, 20
%297 = zext i8 %296 to i32
%298 = add nuw nsw i32 %297, 1
%299 = urem i8 %295, 20
%300 = mul nuw nsw i8 %299, 5
%301 = zext i8 %300 to i32
%302 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %298, i32 %301, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i32 %294)
%303 = add nuw nsw i32 %297, 8
%304 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %293
%305 = load i32, i32* %304
%306 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %303, i32 %301, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i32 %305)
%307 = add nuw nsw i32 %297, 15
%308 = add nuw nsw i64 %293, 1
%309 = trunc i64 %308 to i32
%310 = mul i32 %161, %309
%311 = sdiv i32 %310, 100
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [3500 x float], [3500 x float]* %1, i64 0, i64 %312
%314 = load float, float* %313
%315 = fpext float %314 to double
%316 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %307, i32 %301, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0), double %315)
%317 = add nuw nsw i32 %297, 22
%318 = getelementptr inbounds [3500 x float], [3500 x float]* %2, i64 0, i64 %312
%319 = load float, float* %318
%320 = fpext float %319 to double
%321 = tail call i32 (i32*, i32, i32, i8*, ...) @mvwprintw(i32* %23, i32 %317, i32 %301, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0), double %320)
%322 = icmp eq i64 %308, 100
br i1 %322, label %327, label %292
323: ; preds = %194
%324 = tail call i32 @delwin(i32* %23)
%325 = tail call i32 (...) @endwin()
%326 = tail call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.21, i64 0, i64 0))
ret i32 10
327: ; preds = %292, %262, %228, %244
%328 = tail call i32 @wrefresh(i32* %23)
br label %329
329: ; preds = %327, %194
br label %184
}