int ScatterPlot(int n, int nseries, int yLorR[], double x[], double y[],
                int nrow, int ncol, int ForE) {
  char *chart, ch, *fmt[2] = {"%*.*e ", "%*.*f "}, symbol[] = "*~^@",
                   overlap = '&';
  int i, j, is, iy, ny = 1, ncolr = ncol + 3, irow = 0, icol = 0, w = 10,
                    wd = 2;
  double large = 1e32, xmin, xmax, xgap, ymin[2], ymax[2], ygap[2];
  for (i = 1, xmin = xmax = x[0]; i < n; i++) {
    if (xmin > x[i])
      xmin = x[i];
    if (xmax < x[i])
      xmax = x[i];
  }
  for (i = 0; i < 2; i++) {
    ymin[i] = large;
    ymax[i] = -large;
  }
  for (j = 0; j < (nseries > 1) * nseries; j++)
    if (yLorR[j] == 1)
      ny = 2;
    else if (yLorR[j] != 0)
      printf("err: y axis %d", yLorR[j]);
  for (j = 0; j < nseries; j++) {
    for (i = 0, iy = (nseries == 1 ? 0 : yLorR[j]); i < n; i++) {
      if (ymin[iy] > y[j * n + i])
        ymin[iy] = y[j * n + i];
      if (ymax[iy] < y[j * n + i])
        ymax[iy] = y[j * n + i];
    }
  }
  if (xmin == xmax) {
    puts("no variation in x?");
  }
  xgap = (xmax - xmin) / ncol;
  for (iy = 0; iy < ny; iy++)
    ygap[iy] = (ymax[iy] - ymin[iy]) / nrow;
  printf("\n%10s", "legend: ");
  for (is = 0; is < nseries; is++)
    printf("%2c", symbol[is]);
  printf("\n%10s", "y axies: ");
  if (ny == 2)
    for (is = 0; is < nseries; is++)
      printf("%2d", yLorR[is]);
  printf("\nx   : (%10.2e, %10.2e)", xmin, xmax);
  printf("\ny[1]: (%10.2e, %10.2e)\n", ymin[0], ymax[0]);
  if (ny == 2)
    printf("y[2]: (%10.2e, %10.2e)  \n", ymin[1], ymax[1]);
  chart = (char *)malloc((nrow + 1) * ncolr * sizeof(char));
  for (i = 0; i < nrow + 1; i++) {
    for (j = 1; j < ncol; j++)
      chart[i * ncolr + j] = ' ';
    if (i % 5 == 0)
      chart[i * ncolr + 0] = chart[i * ncolr + j++] = '+';
    else
      chart[i * ncolr + 0] = chart[i * ncolr + j++] = '|';
    chart[i * ncolr + j] = '\0';
    if (i == 0 || i == nrow)
      for (j = 0; j < ncol + 1; j++)
        chart[i * ncolr + j] = (char)(j % 10 == 0 ? '+' : '-');
  }
  for (is = 0; is < nseries; is++) {
    for (i = 0, iy = (nseries == 1 ? 0 : yLorR[is]); i < n; i++) {
      for (j = 0; j < ncol + 1; j++)
        if (x[i] <= xmin + (j + 0.5) * xgap) {
          icol = j;
          break;
        }
      for (j = 0; j < nrow + 1; j++)
        if (y[is * n + i] <= ymin[iy] + (j + 0.5) * ygap[iy]) {
          irow = nrow - j;
          break;
        }
      if ((ch = chart[irow * ncolr + icol]) == ' ' || ch == '-' || ch == '+')
        chart[irow * ncolr + icol] = symbol[is];
      else
        chart[irow * ncolr + icol] = overlap;
    }
  }
  printf("\n");
  for (i = 0; i < nrow + 1; i++) {
    if (i % 5 == 0)
      printf(fmt[ForE], w - 1, wd, ymin[0] + (nrow - i) * ygap[0]);
    else
      printf("%*s", w, "");
    printf("%s", chart + i * ncolr);
    if (ny == 2 && i % 5 == 0)
      printf(fmt[ForE], w - 1, wd, ymin[1] + (nrow - i) * ygap[1]);
    printf("\n");
  }
  printf("%*s", w - 6, "");
  for (j = 0; j < ncol + 1; j++)
    if (j % 10 == 0)
      printf(fmt[ForE], 10 - 1, wd, xmin + j * xgap);
  printf("\n%*s\n", ncol / 2 + 1 + w, "x");
  free(chart);
  return (0);
}


x86 assembly (clang, -O0):
<ScatterPlot>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    0x2ca2(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0x2c9f(%rip),%rax
mov    %rax,-0x48(%rbp)
mov    0xe9b(%rip),%eax
mov    %eax,-0x55(%rbp)
mov    0xe96(%rip),%al
mov    %al,-0x51(%rbp)
movb   $0x26,-0x56(%rbp)
movl   $0x1,-0x6c(%rbp)
mov    0x10(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
movl   $0xa,-0x7c(%rbp)
movl   $0x2,-0x80(%rbp)
movsd  0xe39(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1271 <ScatterPlot+0x131>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    122a <ScatterPlot+0xea>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    125e <ScatterPlot+0x11e>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1263 <ScatterPlot+0x123>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11ee <ScatterPlot+0xae>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x2,-0x5c(%rbp)
jge    12d1 <ScatterPlot+0x191>
movsd  -0x88(%rbp),%xmm0
ff
movslq -0x5c(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movslq -0x5c(%rbp),%rax
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1278 <ScatterPlot+0x138>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmpl   $0x1,-0x8(%rbp)
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    1355 <ScatterPlot+0x215>
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1312 <ScatterPlot+0x1d2>
movl   $0x2,-0x6c(%rbp)
jmp    1342 <ScatterPlot+0x202>
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     133d <ScatterPlot+0x1fd>
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xced(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1342 <ScatterPlot+0x202>
jmp    1347 <ScatterPlot+0x207>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12d8 <ScatterPlot+0x198>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    146e <ScatterPlot+0x32e>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x1,-0x8(%rbp)
jne    1386 <ScatterPlot+0x246>
xor    %eax,%eax
mov    %eax,-0xd4(%rbp)
jmp    1397 <ScatterPlot+0x257>
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    145b <ScatterPlot+0x31b>
movslq -0x68(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    13f8 <ScatterPlot+0x2b8>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x68(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1448 <ScatterPlot+0x308>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x68(%rbp),%rax
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
jmp    144d <ScatterPlot+0x30d>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13a0 <ScatterPlot+0x260>
jmp    1460 <ScatterPlot+0x320>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    135c <ScatterPlot+0x21c>
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jne    1498 <ScatterPlot+0x358>
jp     1498 <ScatterPlot+0x358>
lea    0xba1(%rip),%rdi
mov    $0x0,%al
call   1040 <puts@plt>
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
cvtsi2sdl 0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    150a <ScatterPlot+0x3ca>
movslq -0x68(%rbp),%rax
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x68(%rbp),%rax
subsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0x68(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    14c0 <ScatterPlot+0x380>
lea    0xb34(%rip),%rdi
lea    0xb33(%rip),%rsi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1557 <ScatterPlot+0x417>
movslq -0x64(%rbp),%rax
movsbl -0x55(%rbp,%rax,1),%esi
lea    0xb12(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1526 <ScatterPlot+0x3e6>
lea    0xae7(%rip),%rdi
lea    0xaf3(%rip),%rsi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x2,-0x6c(%rbp)
jne    15b5 <ScatterPlot+0x475>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15b0 <ScatterPlot+0x470>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xac7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    157d <ScatterPlot+0x43d>
jmp    15b5 <ScatterPlot+0x475>
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
lea    0xa9a(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
lea    0xa94(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
cmpl   $0x2,-0x6c(%rbp)
jne    1619 <ScatterPlot+0x4d9>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
lea    0xa85(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
imul   -0x70(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    179c <ScatterPlot+0x65c>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1681 <ScatterPlot+0x541>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1652 <ScatterPlot+0x512>
mov    -0x5c(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    16ce <ScatterPlot+0x58e>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
mov    -0x60(%rbp),%edx
mov    %edx,%esi
add    $0x1,%esi
mov    %esi,-0x60(%rbp)
add    %edx,%ecx
movslq %ecx,%rcx
movb   $0x2b,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x2b,(%rax,%rcx,1)
jmp    1702 <ScatterPlot+0x5c2>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
mov    -0x60(%rbp),%edx
mov    %edx,%esi
add    $0x1,%esi
mov    %esi,-0x60(%rbp)
add    %edx,%ecx
movslq %ecx,%rcx
movb   $0x7c,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x7c,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
cmpl   $0x0,-0x5c(%rbp)
je     172d <ScatterPlot+0x5ed>
mov    -0x5c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1789 <ScatterPlot+0x649>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1784 <ScatterPlot+0x644>
mov    -0x60(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    $0x2d,%eax
mov    $0x2b,%ecx
cmp    $0x0,%edx
cmove  %ecx,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1734 <ScatterPlot+0x5f4>
jmp    1789 <ScatterPlot+0x649>
jmp    178e <ScatterPlot+0x64e>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    163a <ScatterPlot+0x4fa>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1990 <ScatterPlot+0x850>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x1,-0x8(%rbp)
jne    17cd <ScatterPlot+0x68d>
xor    %eax,%eax
mov    %eax,-0xd8(%rbp)
jmp    17de <ScatterPlot+0x69e>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    197d <ScatterPlot+0x83d>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1869 <ScatterPlot+0x729>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
cvtsi2sdl -0x60(%rbp),%xmm0
movsd  0x7db(%rip),%xmm3
addsd  %xmm3,%xmm0
movsd  -0xa0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1856 <ScatterPlot+0x716>
mov    -0x60(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    1869 <ScatterPlot+0x729>
jmp    185b <ScatterPlot+0x71b>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    17fa <ScatterPlot+0x6ba>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    18f5 <ScatterPlot+0x7b5>
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x68(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm2
ff ff
cvtsi2sdl -0x60(%rbp),%xmm0
movsd  0x757(%rip),%xmm3
addsd  %xmm3,%xmm0
movslq -0x68(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm3
ff ff
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     18e2 <ScatterPlot+0x7a2>
mov    -0x24(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    18f5 <ScatterPlot+0x7b5>
jmp    18e7 <ScatterPlot+0x7a7>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1870 <ScatterPlot+0x730>
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x31(%rbp)
movsbl %al,%eax
cmp    $0x20,%eax
je     1932 <ScatterPlot+0x7f2>
movsbl -0x31(%rbp),%eax
cmp    $0x2d,%eax
je     1932 <ScatterPlot+0x7f2>
movsbl -0x31(%rbp),%eax
cmp    $0x2b,%eax
jne    1953 <ScatterPlot+0x813>
movslq -0x64(%rbp),%rax
mov    -0x55(%rbp,%rax,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    196a <ScatterPlot+0x82a>
mov    -0x56(%rbp),%dl
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x70(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    196f <ScatterPlot+0x82f>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    17e7 <ScatterPlot+0x6a7>
jmp    1982 <ScatterPlot+0x842>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17a3 <ScatterPlot+0x663>
lea    0x718(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1ab5 <ScatterPlot+0x975>
mov    -0x5c(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1a0a <ScatterPlot+0x8ca>
movslq 0x18(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rdi
mov    -0x7c(%rbp),%esi
sub    $0x1,%esi
mov    -0x80(%rbp),%edx
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x24(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
jmp    1a22 <ScatterPlot+0x8e2>
mov    -0x7c(%rbp),%esi
lea    0x69d(%rip),%rdi
lea    0x695(%rip),%rdx
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%rsi
mov    -0x5c(%rbp),%eax
imul   -0x70(%rbp),%eax
cltq
add    %rax,%rsi
lea    0x67c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x2,-0x6c(%rbp)
jne    1a99 <ScatterPlot+0x959>
mov    -0x5c(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1a99 <ScatterPlot+0x959>
movslq 0x18(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rdi
mov    -0x7c(%rbp),%esi
sub    $0x1,%esi
mov    -0x80(%rbp),%edx
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x24(%rbp),%eax
sub    -0x5c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x60f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    19a5 <ScatterPlot+0x865>
mov    -0x7c(%rbp),%esi
sub    $0x6,%esi
lea    0x5ef(%rip),%rdi
lea    0x5e7(%rip),%rdx
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1b44 <ScatterPlot+0xa04>
mov    -0x60(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1b31 <ScatterPlot+0x9f1>
movslq 0x18(%rbp),%rax
mov    -0x50(%rbp,%rax,8),%rdi
mov    -0x80(%rbp),%edx
movsd  -0x90(%rbp),%xmm1
ff
cvtsi2sdl -0x60(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    $0x9,%esi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    1b36 <ScatterPlot+0x9f6>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1ad7 <ScatterPlot+0x997>
mov    0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
add    $0x1,%esi
add    -0x7c(%rbp),%esi
lea    0x55a(%rip),%rdi
lea    0x559(%rip),%rdx
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ScatterPlot>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9,0x20(%rsp)
mov    %r8,0x38(%rsp)
mov    %rcx,%r12
mov    %rdx,%r13
mov    %esi,0x18(%rsp)
mov    %edi,0x4c(%rsp)
movsd  (%rcx),%xmm0
mov    %edi,%eax
cmp    $0x2,%edi
mov    %rax,0x40(%rsp)
jl     11b7 <ScatterPlot+0x57>
lea    -0x1(%rax),%rdx
lea    -0x2(%rax),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11c4 <ScatterPlot+0x64>
mov    $0x1,%ecx
movapd %xmm0,%xmm1
jmp    1229 <ScatterPlot+0xc9>
movapd %xmm0,%xmm5
movapd %xmm0,%xmm6
jmp    1262 <ScatterPlot+0x102>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
movapd %xmm0,%xmm1
xchg   %ax,%ax
movsd  0x8(%r12,%rcx,8),%xmm2
movsd  0x10(%r12,%rcx,8),%xmm3
movapd %xmm2,%xmm4
minsd  %xmm1,%xmm4
maxsd  %xmm0,%xmm2
movapd %xmm3,%xmm0
minsd  %xmm4,%xmm0
maxsd  %xmm2,%xmm3
movsd  0x18(%r12,%rcx,8),%xmm2
movapd %xmm2,%xmm4
minsd  %xmm0,%xmm4
maxsd  %xmm3,%xmm2
movsd  0x20(%r12,%rcx,8),%xmm0
movapd %xmm0,%xmm1
minsd  %xmm4,%xmm1
maxsd  %xmm2,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    11d0 <ScatterPlot+0x70>
add    $0x1,%rcx
movapd %xmm1,%xmm5
movapd %xmm0,%xmm6
test   %rax,%rax
je     1262 <ScatterPlot+0x102>
lea    (%r12,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rcx,%rdx,8),%xmm6
movapd %xmm6,%xmm5
minsd  %xmm1,%xmm5
maxsd  %xmm0,%xmm6
add    $0x1,%rdx
movapd %xmm6,%xmm0
movapd %xmm5,%xmm1
cmp    %rdx,%rax
jne    1240 <ScatterPlot+0xe0>
movaps 0x1d97(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movapd 0x1d9a(%rip),%xmm0
movapd %xmm0,0x70(%rsp)
mov    $0x1,%r14d
mov    0x18(%rsp),%eax
mov    %eax,%r10d
cmp    $0x2,%eax
movsd  %xmm5,0x28(%rsp)
movsd  %xmm6,0x10(%rsp)
mov    %r10,0x30(%rsp)
jge    13e3 <ScatterPlot+0x283>
mov    0x4c(%rsp),%edx
movslq %edx,%rax
mov    %rax,0x88(%rsp)
cmpl   $0x0,0x18(%rsp)
mov    0x40(%rsp),%r9
jle    13ac <ScatterPlot+0x24c>
mov    %r9d,%eax
and    $0xfffffffe,%eax
mov    0x38(%rsp),%rcx
add    $0x8,%rcx
mov    0x88(%rsp),%rsi
lea    0x0(,%rsi,8),%r8
xor    %ebx,%ebx
jmp    130c <ScatterPlot+0x1ac>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,0x50(%rsp,%rdi,8)
movsd  %xmm1,0x70(%rsp,%rdi,8)
add    $0x1,%rbx
add    %r8,%rcx
cmp    %r10,%rbx
je     13ac <ScatterPlot+0x24c>
mov    $0x0,%edi
cmpl   $0x1,0x18(%rsp)
je     131d <ScatterPlot+0x1bd>
mov    0x0(%r13,%rbx,4),%edi
test   %edx,%edx
jle    12fc <ScatterPlot+0x19c>
movslq %edi,%rdi
movsd  0x50(%rsp,%rdi,8),%xmm0
movsd  0x70(%rsp,%rdi,8),%xmm1
xor    %ebp,%ebp
cmp    $0x1,%edx
je     1370 <ScatterPlot+0x210>
movapd %xmm1,%xmm2
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbp,8),%xmm3
movsd  (%rcx,%rbp,8),%xmm1
movapd %xmm3,%xmm4
minsd  %xmm0,%xmm4
maxsd  %xmm2,%xmm3
movapd %xmm1,%xmm0
minsd  %xmm4,%xmm0
maxsd  %xmm3,%xmm1
add    $0x2,%rbp
movapd %xmm1,%xmm2
cmp    %rbp,%rax
jne    1340 <ScatterPlot+0x1e0>
test   $0x1,%r9b
je     12f0 <ScatterPlot+0x190>
mov    %rbx,%rsi
imul   0x88(%rsp),%rsi
add    %rsi,%rbp
mov    0x38(%rsp),%rsi
movsd  (%rsi,%rbp,8),%xmm2
movapd %xmm2,%xmm3
minsd  %xmm0,%xmm3
maxsd  %xmm1,%xmm2
movapd %xmm3,%xmm0
movapd %xmm2,%xmm1
jmp    12f0 <ScatterPlot+0x190>
ucomisd %xmm6,%xmm5
jne    13c2 <ScatterPlot+0x262>
jp     13c2 <ScatterPlot+0x262>
lea    0x1d3f(%rip),%rdi
xor    %eax,%eax
call   1050 <puts@plt>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x20(%rsp),%xmm0
mov    %r14d,%eax
cmp    $0x2,%r14d
mov    %r13,0xb8(%rsp)
jae    1444 <ScatterPlot+0x2e4>
xor    %ecx,%ecx
jmp    14f0 <ScatterPlot+0x390>
mov    $0x1,%ebp
lea    0x1cfc(%rip),%r15
xor    %ebx,%ebx
jmp    1413 <ScatterPlot+0x2b3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%r14d
add    $0x1,%rbx
mov    %r14d,%ebp
cmp    %rbx,%r10
je     12a3 <ScatterPlot+0x143>
mov    0x0(%r13,%rbx,4),%esi
test   %esi,%esi
je     1400 <ScatterPlot+0x2a0>
mov    $0x2,%r14d
cmp    $0x1,%esi
je     1403 <ScatterPlot+0x2a3>
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x30(%rsp),%r10
movsd  0x10(%rsp),%xmm6
movsd  0x28(%rsp),%xmm5
jmp    1400 <ScatterPlot+0x2a0>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     20ad <ScatterPlot+0xf4d>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd 0x70(%rsp,%rsi,8),%xmm2
movapd 0x80(%rsp,%rsi,8),%xmm3
subpd  0x50(%rsp,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,0xa0(%rsp,%rsi,8)
subpd  0x60(%rsp,%rsi,8),%xmm3
divpd  %xmm1,%xmm3
movapd %xmm3,0xb0(%rsp,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1480 <ScatterPlot+0x320>
test   $0x1,%dl
je     14dd <ScatterPlot+0x37d>
movapd 0x70(%rsp,%rsi,8),%xmm2
subpd  0x50(%rsp,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,0xa0(%rsp,%rsi,8)
cmp    %rax,%rcx
je     1512 <ScatterPlot+0x3b2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x70(%rsp,%rcx,8),%xmm1
subsd  0x50(%rsp,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xa0(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    14f0 <ScatterPlot+0x390>
lea    0x1bf4(%rip),%rdi
lea    0x1bf3(%rip),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
cmpl   $0x0,0x18(%rsp)
mov    %r12,0x98(%rsp)
jle    15c9 <ScatterPlot+0x469>
lea    0x1ba5(%rip),%r15
lea    0x1bd4(%rip),%rbp
xor    %ebx,%ebx
mov    0x30(%rsp),%r13
nop
movsbl (%rbx,%r15,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1550 <ScatterPlot+0x3f0>
lea    0x1b9e(%rip),%rdi
lea    0x1baa(%rip),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    $0x2,%r14d
sete   %r15b
jne    15e6 <ScatterPlot+0x486>
cmpl   $0x0,0x18(%rsp)
mov    0xb8(%rsp),%r12
jle    15e6 <ScatterPlot+0x486>
lea    0x1b8d(%rip),%r14
xor    %ebx,%ebx
mov    0x30(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    15b0 <ScatterPlot+0x450>
jmp    15e6 <ScatterPlot+0x486>
lea    0x1b3d(%rip),%rdi
lea    0x1b49(%rip),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    $0x2,%r14d
sete   %r15b
movsd  0x28(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mov    0x140(%rsp),%ebp
lea    0x3(%rbp),%r12d
lea    0x1b2a(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x50(%rsp),%xmm0
movq   0x70(%rsp),%xmm1
lea    0x1b28(%rip),%rdi
movsd  %xmm0,0xf0(%rsp)
mov    $0x2,%al
call   1060 <printf@plt>
mov    %r15b,0xf(%rsp)
test   %r15b,%r15b
je     1652 <ScatterPlot+0x4f2>
movsd  0x58(%rsp),%xmm0
movq   0x78(%rsp),%xmm1
lea    0x1b14(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movsd  %xmm0,0xc8(%rsp)
movsd  0x10(%rsp),%xmm0
subsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x20(%rsp),%rbx
lea    0x1(%rbx),%r14d
mov    %r12d,%eax
imul   %r14d,%eax
movslq %eax,%rdi
call   1080 <malloc@plt>
mov    %rax,%r13
movslq %r12d,%rax
mov    %rax,0x90(%rsp)
mov    %r14d,%eax
mov    %rax,0xc0(%rsp)
test   %ebx,%ebx
js     1cbd <ScatterPlot+0xb5d>
mov    %rbp,%r8
lea    -0x1(%rbp),%eax
mov    %rax,0xf8(%rsp)
lea    0x1(%rbp),%r9d
mov    0x20(%rsp),%r10d
mov    %r9d,%eax
and    $0xfffffff0,%eax
mov    %rax,0xe8(%rsp)
add    $0xfffffffffffffff0,%rax
mov    %rax,0xe0(%rsp)
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0xd8(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xd0(%rsp)
lea    0x10(%r13),%r15
xor    %r11d,%r11d
mov    $0xcccccccd,%ebx
movdqa 0x194b(%rip),%xmm12
movdqa 0x1952(%rip),%xmm13
movdqa 0x1959(%rip),%xmm14
pcmpeqd %xmm15,%xmm15
movdqa 0x195c(%rip),%xmm5
movdqa 0x1964(%rip),%xmm7
mov    %r13,0x68(%rsp)
jmp    1772 <ScatterPlot+0x612>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r11
mov    0x90(%rsp),%rax
add    %rax,%r15
add    %rax,0x68(%rsp)
cmp    0xc0(%rsp),%r11
je     1cbd <ScatterPlot+0xb5d>
mov    $0x1,%ecx
cmp    $0x2,%r8d
jl     180b <ScatterPlot+0x6ab>
mov    %r12d,%eax
imul   %r11d,%eax
add    $0x1,%eax
movslq %eax,%rdi
add    %r13,%rdi
mov    $0x20,%esi
mov    0xf8(%rsp),%rdx
mov    %r9,%rbx
mov    %r10,%rbp
mov    %r15,0x100(%rsp)
mov    %r12d,%r15d
mov    %r11,%r12
call   1070 <memset@plt>
movdqa 0x18e1(%rip),%xmm7
movdqa 0x18c9(%rip),%xmm5
pcmpeqd %xmm15,%xmm15
movdqa 0x18ab(%rip),%xmm14
movdqa 0x1892(%rip),%xmm13
movdqa 0x1879(%rip),%xmm12
mov    %r12,%r11
mov    %r15d,%r12d
mov    0x100(%rsp),%r15
mov    %rbp,%r10
mov    %rbx,%r9
mov    $0xcccccccd,%ebx
mov    0x140(%rsp),%r8d
mov    %r8d,%ecx
imul   $0xcccccccd,%r11d,%edx
mov    %r11,%rax
imul   0x90(%rsp),%rax
mov    %ecx,%ecx
add    %rax,%rcx
cmp    $0x33333334,%edx
mov    $0x7c,%edx
mov    $0x2b,%esi
cmovb  %esi,%edx
mov    %dl,0x0(%r13,%rcx,1)
mov    %dl,0x0(%r13,%rax,1)
movb   $0x0,0x1(%r13,%rcx,1)
test   %r11,%r11
setne  %cl
cmp    %r10,%r11
setne  %dl
test   %dl,%cl
jne    1750 <ScatterPlot+0x5f0>
test   %r8d,%r8d
js     1750 <ScatterPlot+0x5f0>
cmp    $0x10,%r9d
jae    1870 <ScatterPlot+0x710>
xor    %eax,%eax
jmp    1c33 <ScatterPlot+0xad3>
cmpq   $0x0,0xe0(%rsp)
je     1c84 <ScatterPlot+0xb24>
mov    0xd0(%rsp),%rdx
xor    %ecx,%ecx
movdqa 0x17be(%rip),%xmm11
movdqa 0x17a5(%rip),%xmm10
movdqa 0x178c(%rip),%xmm9
movdqa 0x1773(%rip),%xmm8
nopl   (%rax)
movdqa %xmm11,%xmm0
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm11,%xmm1
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x1,%xmm1
movdqa %xmm0,%xmm4
pslld  $0x1f,%xmm4
por    %xmm1,%xmm4
pxor   %xmm13,%xmm4
pcmpgtd %xmm14,%xmm4
pxor   %xmm15,%xmm4
movdqa %xmm10,%xmm1
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm6
pshufd $0xf5,%xmm10,%xmm1
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm6
movdqa %xmm6,%xmm1
psrld  $0x1,%xmm1
movdqa %xmm6,%xmm5
pslld  $0x1f,%xmm5
por    %xmm1,%xmm5
pxor   %xmm13,%xmm5
pcmpgtd %xmm14,%xmm5
pxor   %xmm15,%xmm5
packssdw %xmm5,%xmm4
movdqa %xmm9,%xmm1
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm9,%xmm5
pmuludq %xmm12,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm1
movdqa %xmm1,%xmm7
psrld  $0x1,%xmm7
movdqa %xmm1,%xmm5
pslld  $0x1f,%xmm5
por    %xmm7,%xmm5
movdqa %xmm8,%xmm7
pmuludq %xmm12,%xmm7
pshufd $0xe8,%xmm7,%xmm3
pshufd $0xf5,%xmm8,%xmm2
pmuludq %xmm12,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm3
movdqa %xmm3,%xmm2
psrld  $0x1,%xmm2
movdqa %xmm3,%xmm7
pslld  $0x1f,%xmm7
por    %xmm2,%xmm7
pxor   %xmm13,%xmm5
pcmpgtd %xmm14,%xmm5
pxor   %xmm15,%xmm5
pxor   %xmm13,%xmm7
pcmpgtd %xmm14,%xmm7
pxor   %xmm15,%xmm7
packssdw %xmm7,%xmm5
movdqa 0x16c0(%rip),%xmm7
packsswb %xmm5,%xmm4
movdqa 0x16a4(%rip),%xmm5
movdqa %xmm4,%xmm2
pandn  %xmm5,%xmm2
pand   %xmm7,%xmm4
por    %xmm2,%xmm4
movdqu %xmm4,-0x10(%r15,%rcx,1)
movdqa 0x16a5(%rip),%xmm4
paddd  %xmm4,%xmm0
movdqa %xmm0,%xmm2
psrld  $0x1,%xmm2
pslld  $0x1f,%xmm0
por    %xmm2,%xmm0
paddd  %xmm4,%xmm6
movdqa %xmm6,%xmm2
psrld  $0x1,%xmm2
pslld  $0x1f,%xmm6
por    %xmm2,%xmm6
pxor   %xmm13,%xmm0
pcmpgtd %xmm14,%xmm0
pxor   %xmm15,%xmm0
pxor   %xmm13,%xmm6
pcmpgtd %xmm14,%xmm6
pxor   %xmm15,%xmm6
packssdw %xmm6,%xmm0
paddd  %xmm4,%xmm1
movdqa %xmm1,%xmm2
psrld  $0x1,%xmm2
pslld  $0x1f,%xmm1
por    %xmm2,%xmm1
paddd  %xmm4,%xmm3
movdqa 0x1645(%rip),%xmm4
movdqa %xmm3,%xmm2
psrld  $0x1,%xmm2
pslld  $0x1f,%xmm3
por    %xmm2,%xmm3
pxor   %xmm13,%xmm1
pcmpgtd %xmm14,%xmm1
pxor   %xmm15,%xmm1
pxor   %xmm13,%xmm3
pcmpgtd %xmm14,%xmm3
pxor   %xmm15,%xmm3
packssdw %xmm3,%xmm1
packsswb %xmm1,%xmm0
movdqa %xmm0,%xmm1
pandn  %xmm5,%xmm1
pand   %xmm7,%xmm0
por    %xmm1,%xmm0
movdqu %xmm0,(%r15,%rcx,1)
add    $0x20,%rcx
paddd  %xmm4,%xmm11
paddd  %xmm4,%xmm10
paddd  %xmm4,%xmm9
paddd  %xmm4,%xmm8
add    $0xfffffffffffffffe,%rdx
jne    18b0 <ScatterPlot+0x750>
testb  $0x1,0xd8(%rsp)
01
je     1c1f <ScatterPlot+0xabf>
pshufd $0xf5,%xmm11,%xmm0
pmuludq %xmm12,%xmm11
pshufd $0xe8,%xmm11,%xmm3
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm3
movdqa %xmm3,%xmm0
psrld  $0x1,%xmm0
pslld  $0x1f,%xmm3
por    %xmm0,%xmm3
pxor   %xmm13,%xmm3
pcmpgtd %xmm14,%xmm3
pxor   %xmm15,%xmm3
pshufd $0xf5,%xmm10,%xmm0
pmuludq %xmm12,%xmm10
pshufd $0xe8,%xmm10,%xmm1
pmuludq %xmm12,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrld  $0x1,%xmm0
pslld  $0x1f,%xmm1
por    %xmm0,%xmm1
pxor   %xmm13,%xmm1
pcmpgtd %xmm14,%xmm1
pxor   %xmm15,%xmm1
packssdw %xmm1,%xmm3
pshufd $0xf5,%xmm9,%xmm1
pmuludq %xmm12,%xmm9
pshufd $0xe8,%xmm9,%xmm0
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x1,%xmm1
pslld  $0x1f,%xmm0
por    %xmm1,%xmm0
pxor   %xmm13,%xmm0
pcmpgtd %xmm14,%xmm0
pxor   %xmm15,%xmm0
pshufd $0xf5,%xmm8,%xmm1
pmuludq %xmm12,%xmm8
pshufd $0xe8,%xmm8,%xmm2
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
movdqa %xmm2,%xmm1
psrld  $0x1,%xmm1
pslld  $0x1f,%xmm2
por    %xmm1,%xmm2
pxor   %xmm13,%xmm2
pcmpgtd %xmm14,%xmm2
pxor   %xmm15,%xmm2
packssdw %xmm2,%xmm0
packsswb %xmm0,%xmm3
movdqa %xmm3,%xmm0
pandn  %xmm5,%xmm0
pand   %xmm7,%xmm3
por    %xmm0,%xmm3
add    %rax,%rcx
movdqu %xmm3,0x0(%r13,%rcx,1)
mov    0xe8(%rsp),%rcx
mov    %rcx,%rax
cmp    %r9,%rcx
je     1750 <ScatterPlot+0x5f0>
mov    0x68(%rsp),%rcx
add    %rax,%rcx
mov    %eax,%edx
neg    %edx
mov    %r9,%rsi
sub    %rax,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    %eax,%ebp
imul   %rbx,%rbp
shr    $0x23,%rbp
lea    0x0(%rbp,%rbp,4),%ebp
lea    (%rdx,%rbp,2),%ebp
cmp    %edi,%ebp
setne  %bl
add    %bl,%bl
add    $0x2b,%bl
mov    %bl,(%rcx,%rdi,1)
mov    $0xcccccccd,%ebx
add    $0x1,%rdi
add    $0x1,%eax
cmp    %rdi,%rsi
jne    1c50 <ScatterPlot+0xaf0>
jmp    1750 <ScatterPlot+0x5f0>
xor    %ecx,%ecx
movdqa 0x13c1(%rip),%xmm11
movdqa 0x13a8(%rip),%xmm10
movdqa 0x138f(%rip),%xmm9
movdqa 0x1376(%rip),%xmm8
testb  $0x1,0xd8(%rsp)
01
jne    1af9 <ScatterPlot+0x999>
jmp    1c1f <ScatterPlot+0xabf>
movsd  0x10(%rsp),%xmm6
divsd  0xc8(%rsp),%xmm6
cmpl   $0x0,0x18(%rsp)
movsd  0x28(%rsp),%xmm5
jle    1e5a <ScatterPlot+0xcfa>
mov    0x140(%rsp),%eax
add    $0x1,%eax
xor    %r11d,%r11d
movabs $0x280100000000,%r9
lea    0x13eb(%rip),%r8
movsd  0x13cd(%rip),%xmm0
xor    %r15d,%r15d
xor    %ebx,%ebx
jmp    1d1f <ScatterPlot+0xbbf>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    0x30(%rsp),%r11
je     1e5a <ScatterPlot+0xcfa>
mov    $0x0,%ecx
cmpl   $0x1,0x18(%rsp)
je     1d37 <ScatterPlot+0xbd7>
mov    0xb8(%rsp),%rcx
mov    (%rcx,%r11,4),%ecx
cmpl   $0x0,0x4c(%rsp)
jle    1d10 <ScatterPlot+0xbb0>
mov    %r11,%r10
imul   0x88(%rsp),%r10
movslq %ecx,%rsi
xor    %edx,%edx
jmp    1d70 <ScatterPlot+0xc10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %cl,0x0(%r13,%rdi,1)
add    $0x1,%rdx
cmp    0x40(%rsp),%rdx
je     1d10 <ScatterPlot+0xbb0>
mov    0x140(%rsp),%ecx
test   %ecx,%ecx
js     1db0 <ScatterPlot+0xc50>
mov    0x98(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
xorps  %xmm2,%xmm2
cvtsi2sd %edi,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm5,%xmm2
ucomisd %xmm1,%xmm2
jae    1dc0 <ScatterPlot+0xc60>
add    $0x1,%edi
cmp    %edi,%eax
jne    1d90 <ScatterPlot+0xc30>
cmpl   $0x0,0x20(%rsp)
jns    1dca <ScatterPlot+0xc6a>
jmp    1e29 <ScatterPlot+0xcc9>
nopl   0x0(%rax)
mov    %edi,%r15d
cmpl   $0x0,0x20(%rsp)
js     1e29 <ScatterPlot+0xcc9>
lea    (%rdx,%r10,1),%rcx
mov    0x38(%rsp),%rdi
movsd  (%rdi,%rcx,8),%xmm1
movsd  0x50(%rsp,%rsi,8),%xmm2
movsd  0xa0(%rsp,%rsi,8),%xmm3
xor    %ebp,%ebp
nopl   0x0(%rax)
xorps  %xmm4,%xmm4
cvtsi2sd %ebp,%xmm4
addsd  %xmm0,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm2,%xmm4
ucomisd %xmm1,%xmm4
jae    1e20 <ScatterPlot+0xcc0>
add    $0x1,%ebp
cmp    %ebp,%r14d
jne    1df0 <ScatterPlot+0xc90>
jmp    1e29 <ScatterPlot+0xcc9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rcx
mov    %ecx,%ebx
sub    %ebp,%ebx
mov    %ebx,%ecx
imul   %r12d,%ecx
add    %r15d,%ecx
movslq %ecx,%rdi
movzbl 0x0(%r13,%rdi,1),%ebp
mov    $0x26,%cl
cmp    $0x2d,%rbp
ja     1d60 <ScatterPlot+0xc00>
bt     %rbp,%r9
jae    1d60 <ScatterPlot+0xc00>
mov    (%r11,%r8,1),%cl
jmp    1d60 <ScatterPlot+0xc00>
movsd  %xmm6,0x10(%rsp)
mov    $0xa,%edi
call   1040 <putchar@plt>
movslq 0x148(%rsp),%rax
mov    %rax,0x40(%rsp)
cmpl   $0x0,0x20(%rsp)
mov    0xc0(%rsp),%rbx
js     1fe0 <ScatterPlot+0xe80>
movsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0xa8(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
movsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    $0xcccccccd,%r15d
xor    %r12d,%r12d
xor    %r14d,%r14d
mov    %r13,%rbp
jmp    1f2c <ScatterPlot+0xdcc>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x12a2(%rip),%rdi
mov    $0xa,%esi
lea    0x1295(%rip),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x128c(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
add    0x90(%rsp),%rbp
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x20(%rsp)
add    $0xffffffff,%r14d
add    $0x1,%r12d
add    $0xffffffffffffffff,%rbx
je     1fe0 <ScatterPlot+0xe80>
mov    %r12d,%eax
imul   %r15,%rax
shr    $0x22,%rax
lea    (%rax,%rax,4),%eax
add    %r14d,%eax
jne    1ed0 <ScatterPlot+0xd70>
sete   %r15b
mov    0x40(%rsp),%rax
lea    0x2ec1(%rip),%rcx
mov    (%rcx,%rax,8),%rdi
xorps  %xmm0,%xmm0
cvtsi2sdl 0x20(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
mulsd  0x18(%rsp),%xmm0
addsd  0xf0(%rsp),%xmm0
mov    %rdi,0x98(%rsp)
mov    $0x9,%esi
mov    $0x2,%edx
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x11ec(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
and    0xf(%rsp),%r15b
cmp    $0x1,%r15b
mov    $0xcccccccd,%r15d
jne    1efb <ScatterPlot+0xd9b>
movsd  0x38(%rsp),%xmm0
mulsd  0x68(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
mov    0x98(%rsp),%rdi
mov    $0x9,%esi
mov    $0x2,%edx
mov    $0x1,%al
call   1060 <printf@plt>
jmp    1efb <ScatterPlot+0xd9b>
lea    0x1192(%rip),%rdi
lea    0x118a(%rip),%rdx
xor    %ebx,%ebx
mov    $0x4,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x140(%rsp),%ecx
test   %ecx,%ecx
js     2070 <ScatterPlot+0xf10>
lea    0x1(%rcx),%ebp
mov    $0xcccccccd,%r14d
lea    0x2df9(%rip),%r12
jmp    2027 <ScatterPlot+0xec7>
nopl   0x0(%rax)
add    $0x1,%ebx
cmp    %ebx,%ebp
je     2070 <ScatterPlot+0xf10>
mov    %ebx,%eax
imul   %r14,%rax
shr    $0x23,%rax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
cmp    %ebx,%eax
jne    2020 <ScatterPlot+0xec0>
mov    0x40(%rsp),%rax
mov    (%r12,%rax,8),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x28(%rsp),%xmm0
mov    $0x9,%esi
mov    $0x2,%edx
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x140(%rsp),%ecx
jmp    2020 <ScatterPlot+0xec0>
mov    %ecx,%esi
shr    $0x1f,%esi
add    %ecx,%esi
sar    %esi
add    $0xb,%esi
lea    0x10fd(%rip),%rdi
lea    0x10fc(%rip),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    14c4 <ScatterPlot+0x364>
jmp    14dd <ScatterPlot+0x37d>

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

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