main() {
  int i, j, k, i1, j1, num, tnum;
  int atomnum, nn;
  int bit[200000];
  double sx, sy, sz;
  double sumx, sumy, sumz;
  double di, dj, dk;
  double m, n, l, C, r, theta, phi, dtheta;
  double x, y, z, length, dum;
  double dx, dy, dz, scaleF;
  double gx[200000], gy[200000];
  double nx[200000], ny[200000], nz[200000];
  double tx[5], ty[5], ax[3], ay[3];
  double xyz[10000][4];
  double curveR;
  scanf("%lf %lf", &m, &n);
  scanf("%lf", &length);
  scanf("%lf", &curveR);
  l = 1.42;
  theta = atan((n * sqrt(3.0) / 2.0) / (m + 0.50 * n));
  phi = 3.1415926535897932384626 / 6.0 - theta;
  C = l * sqrt((m + 0.50 * n) * (m + 0.50 * n) * 3.0 + 9.0 / 4.0 * n * n);
  r = 0.50 * (C - 0.0000000000000) / 3.1415926535897932384626;
  tx[1] = 0.0;
  ty[1] = 0.0;
  tx[2] = l * 0.50;
  ty[2] = sqrt(3.0) / 2.0 * l;
  tx[3] = 1.50 * l;
  ty[3] = sqrt(3.0) / 2.0 * l;
  tx[4] = 2.0 * l;
  ty[4] = 0.0;
  ax[1] = 0.0;
  ay[1] = sqrt(3.0) * l;
  ax[2] = 3.0 * l;
  ay[2] = 0.0;
  num = 0;
  di = -31;
  for (i = -30; i <= 100; i++) {
    di = di + 1.0;
    dj = -31;
    for (j = -30; j <= 10; j++) {
      dj = dj + 1.0;
      for (k = 1; k <= 4; k++) {
        num++;
        if (200000 <= num) {
          printf("asize1 is small.\n");
          exit(0);
        }
        gx[num] = tx[k] + di * ax[1] + dj * ax[2];
        gy[num] = ty[k] + di * ay[1] + dj * ay[2];
      }
    }
  }
  for (i = 1; i <= num; i++) {
    x = gx[i] * cos(-phi) - gy[i] * sin(-phi);
    y = gx[i] * sin(-phi) + gy[i] * cos(-phi);
    gx[i] = x;
    gy[i] = y;
  }
  tnum = 0;
  for (i = 1; i <= num; i++) {
    if (0 <= gy[i] && gy[i] <= length) {
      if (0 <= gx[i] && gx[i] <= C) {
        tnum++;
        dtheta = gx[i] / r;
        nx[tnum] = r * cos(dtheta);
        ny[tnum] = r * sin(dtheta);
        nz[tnum] = gy[i];
      }
    }
  }
  for (i = 1; i <= tnum; i++) {
    bit[i] = 0;
  }
  nn = 0;
  for (i = 1; i <= tnum; i++) {
    for (j = i + 1; j <= tnum; j++) {
      if (i != j) {
        dx = nx[i] - nx[j];
        dy = ny[i] - ny[j];
        dz = nz[i] - nz[j];
        dum = dx * dx + dy * dy + dz * dz;
        if (sqrt(dum) < 0.3) {
          bit[j] = 1;
          nn++;
        }
      }
    }
  }
  atomnum = tnum - nn;
  sumx = 0.0;
  sumy = 0.0;
  sumz = 0.0;
  for (i = 1; i <= tnum; i++) {
    if (bit[i] == 0) {
      sumx = sumx + nx[i];
      sumy = sumy + ny[i];
      sumz = sumz + nz[i];
    }
  }
  sx = sumx / (double)atomnum;
  sy = sumy / (double)atomnum;
  sz = sumz / (double)atomnum;
  num = 0;
  for (i = 1; i <= tnum; i++) {
    if (bit[i] == 0) {
      num++;
      xyz[num][1] = nx[i] - sx + rd();
      xyz[num][2] = ny[i] - sy + rd();
      xyz[num][3] = nz[i] - sz + rd();
    }
  }
  for (i = 1; i <= atomnum; i++) {
    dx = fabs(curveR - xyz[i][1]);
    theta = xyz[i][3] / dx;
    x = curveR + dx * cos(theta);
    y = xyz[i][2];
    z = dx * sin(theta);
    xyz[i][1] = x;
    xyz[i][2] = y;
    xyz[i][3] = z;
  }
  sumx = 0.0;
  sumy = 0.0;
  sumz = 0.0;
  for (i = 1; i <= atomnum; i++) {
    sumx = sumx + xyz[i][1];
    sumy = sumy + xyz[i][2];
    sumz = sumz + xyz[i][3];
  }
  sx = sumx / (double)atomnum;
  sy = sumy / (double)atomnum;
  sz = sumz / (double)atomnum;
  for (i = 1; i <= atomnum; i++) {
    xyz[i][1] = xyz[i][1] - sx;
    xyz[i][2] = xyz[i][2] - sy;
    xyz[i][3] = xyz[i][3] - sz;
  }
  printf("%i\n", atomnum);
  for (i = 1; i <= atomnum; i++) {
    printf("%4d  C  %15.10f %15.10f %15.10f  2.0 2.0\n", i, xyz[i][3],
           xyz[i][1], xyz[i][2]);
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x8b2b30,%rsp
movl   $0x0,-0x4(%rbp)
lea    0x1ed7(%rip),%rdi
lea    -0xc3580(%rbp),%rsi
lea    -0xc3588(%rbp),%rdx
mov    $0x0,%al
call   1070 <scanf@plt>
lea    0x1ebf(%rip),%rdi
lea    -0xc35d8(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
lea    0x1eaa(%rip),%rdi
lea    -0x8b2aa8(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
movsd  0x1e60(%rip),%xmm0
movsd  %xmm0,-0xc3590(%rbp)
ff
movsd  -0xc3588(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2ab8(%rbp)
ff
movsd  0x1e08(%rip),%xmm0
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x8b2ab8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x1df4(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  -0xc3580(%rbp),%xmm2
ff
movsd  -0xc3588(%rbp),%xmm1
ff
movsd  0x1de8(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1050 <atan@plt>
movsd  %xmm0,-0xc35a8(%rbp)
ff
movsd  0x1ddf(%rip),%xmm0
subsd  -0xc35a8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc35b0(%rbp)
ff
movsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2ab0(%rbp)
ff
movsd  -0xc3580(%rbp),%xmm1
ff
movsd  -0xc3588(%rbp),%xmm0
ff
movsd  0x1d8f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xc3580(%rbp),%xmm2
ff
movsd  -0xc3588(%rbp),%xmm1
ff
movsd  0x1d6f(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1d6b(%rip),%xmm1
mulsd  -0xc3588(%rbp),%xmm1
ff
mulsd  -0xc3588(%rbp),%xmm1
ff
movsd  0x1d2b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x8b2ab0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc3598(%rbp)
movsd  -0xc3598(%rbp),%xmm1
ff
xorps  %xmm0,%xmm0
subsd  %xmm0,%xmm1
movsd  0x1d08(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1d04(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc35a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x864828(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x864858(%rbp)
ff
movsd  0x1cd2(%rip),%xmm0
mulsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x864820(%rbp)
ff
movsd  0x1ca2(%rip),%xmm0
call   1090 <sqrt@plt>
movsd  0x1c9d(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x864850(%rbp)
ff
movsd  0x1c89(%rip),%xmm0
mulsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x864818(%rbp)
ff
movsd  0x1c61(%rip),%xmm0
call   1090 <sqrt@plt>
movsd  0x1c5c(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x864848(%rbp)
ff
movsd  0x1c40(%rip),%xmm0
mulsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x864810(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x864840(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x864878(%rbp)
ff
movsd  0x1c0a(%rip),%xmm0
call   1090 <sqrt@plt>
mulsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x864898(%rbp)
ff
movsd  0x1bed(%rip),%xmm0
mulsd  -0xc3590(%rbp),%xmm0
ff
movsd  %xmm0,-0x864870(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x864890(%rbp)
ff
movl   $0x0,-0x1c(%rbp)
movsd  0x1bbb(%rip),%xmm0
movsd  %xmm0,-0xc3568(%rbp)
ff
movl   $0xffffffe2,-0x8(%rbp)
cmpl   $0x64,-0x8(%rbp)
jg     15b4 <main+0x434>
movsd  0x1bea(%rip),%xmm0
addsd  -0xc3568(%rbp),%xmm0
ff
movsd  %xmm0,-0xc3568(%rbp)
ff
movsd  0x1b82(%rip),%xmm0
movsd  %xmm0,-0xc3570(%rbp)
ff
movl   $0xffffffe2,-0xc(%rbp)
cmpl   $0xa,-0xc(%rbp)
jg     15a1 <main+0x421>
movsd  0x1bb1(%rip),%xmm0
addsd  -0xc3570(%rbp),%xmm0
ff
movsd  %xmm0,-0xc3570(%rbp)
ff
movl   $0x1,-0x10(%rbp)
cmpl   $0x4,-0x10(%rbp)
jg     158e <main+0x40e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    $0x30d40,%eax
cmp    -0x1c(%rbp),%eax
jg     14ec <main+0x36c>
lea    0x1b9a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   10a0 <exit@plt>
movslq -0x10(%rbp),%rax
movsd  -0x864830(%rbp,%rax,8),%xmm0
79 ff
movsd  -0xc3568(%rbp),%xmm1
movsd  -0x864878(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc3570(%rbp),%xmm0
ff
movsd  -0x864870(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rax
movsd  %xmm0,-0x24a000(%rbp,%rax,8)
db ff
movslq -0x10(%rbp),%rax
movsd  -0x864860(%rbp,%rax,8),%xmm0
79 ff
movsd  -0xc3568(%rbp),%xmm1
ff
movsd  -0x864898(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc3570(%rbp),%xmm0
ff
movsd  -0x864890(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rax
movsd  %xmm0,-0x3d0a00(%rbp,%rax,8)
c2 ff
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14b6 <main+0x336>
jmp    1593 <main+0x413>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    148d <main+0x30d>
jmp    15a6 <main+0x426>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1454 <main+0x2d4>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1768 <main+0x5e8>
movslq -0x8(%rbp),%rax
movsd  -0x24a000(%rbp,%rax,8),%xmm0
db ff
movsd  %xmm0,-0x8b2ad8(%rbp)
ff
movsd  -0xc35b0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1080 <cos@plt>
movsd  %xmm0,-0x8b2ae0(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0x3d0a00(%rbp,%rax,8),%xmm0
c2 ff
movsd  %xmm0,-0x8b2ae8(%rbp)
ff
movsd  -0xc35b0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1040 <sin@plt>
movsd  -0x8b2ae8(%rbp),%xmm1
ff
movsd  -0x8b2ae0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x8b2ad8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc35c0(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0x24a000(%rbp,%rax,8),%xmm0
db ff
movsd  %xmm0,-0x8b2ac0(%rbp)
ff
movsd  -0xc35b0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x8b2ac8(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0x3d0a00(%rbp,%rax,8),%xmm0
c2 ff
movsd  %xmm0,-0x8b2ad0(%rbp)
ff
movsd  -0xc35b0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1080 <cos@plt>
movsd  -0x8b2ad0(%rbp),%xmm1
ff
movsd  -0x8b2ac8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x8b2ac0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc35c8(%rbp)
ff
movsd  -0xc35c0(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rax
movsd  %xmm0,-0x24a000(%rbp,%rax,8)
db ff
movsd  -0xc35c8(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rax
movsd  %xmm0,-0x3d0a00(%rbp,%rax,8)
c2 ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    15bb <main+0x43b>
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     18be <main+0x73e>
movslq -0x8(%rbp),%rax
movsd  -0x3d0a00(%rbp,%rax,8),%xmm0
c2 ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     18ab <main+0x72b>
movslq -0x8(%rbp),%rax
movsd  -0x3d0a00(%rbp,%rax,8),%xmm1
c2 ff
movsd  -0xc35d8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     18ab <main+0x72b>
movslq -0x8(%rbp),%rax
movsd  -0x24a000(%rbp,%rax,8),%xmm0
db ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     18a6 <main+0x726>
movslq -0x8(%rbp),%rax
movsd  -0x24a000(%rbp,%rax,8),%xmm1
db ff
movsd  -0xc3598(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     18a6 <main+0x726>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
movslq -0x8(%rbp),%rax
movsd  -0x24a000(%rbp,%rax,8),%xmm0
db ff
divsd  -0xc35a0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc35b8(%rbp)
ff
movsd  -0xc35a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2af8(%rbp)
ff
movsd  -0xc35b8(%rbp),%xmm0
ff
call   1080 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x8b2af8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x557400(%rbp,%rax,8)
aa ff
movsd  -0xc35a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2af0(%rbp)
ff
movsd  -0xc35b8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x8b2af0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x6dde00(%rbp,%rax,8)
92 ff
movslq -0x8(%rbp),%rax
movsd  -0x3d0a00(%rbp,%rax,8),%xmm0
c2 ff
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x864800(%rbp,%rax,8)
79 ff
jmp    18ab <main+0x72b>
jmp    18b0 <main+0x730>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1776 <main+0x5f6>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     18ee <main+0x76e>
movslq -0x8(%rbp),%rax
movl   $0x0,-0xc3530(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    18c5 <main+0x745>
movl   $0x0,-0x28(%rbp)
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1a3c <main+0x8bc>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1a29 <main+0x8a9>
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
je     1a16 <main+0x896>
movslq -0x8(%rbp),%rax
movsd  -0x557400(%rbp,%rax,8),%xmm0
aa ff
movslq -0xc(%rbp),%rax
subsd  -0x557400(%rbp,%rax,8),%xmm0
aa ff
movsd  %xmm0,-0xc35e8(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0x6dde00(%rbp,%rax,8),%xmm0
92 ff
movslq -0xc(%rbp),%rax
subsd  -0x6dde00(%rbp,%rax,8),%xmm0
92 ff
movsd  %xmm0,-0xc35f0(%rbp)
ff
movslq -0x8(%rbp),%rax
movsd  -0x864800(%rbp,%rax,8),%xmm0
79 ff
movslq -0xc(%rbp),%rax
subsd  -0x864800(%rbp,%rax,8),%xmm0
79 ff
movsd  %xmm0,-0xc35f8(%rbp)
ff
movsd  -0xc35e8(%rbp),%xmm1
ff
movsd  -0xc35e8(%rbp),%xmm2
ff
movsd  -0xc35f0(%rbp),%xmm0
ff
mulsd  -0xc35f0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc35f8(%rbp),%xmm0
ff
movsd  -0xc35f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc35e0(%rbp)
ff
movsd  -0xc35e0(%rbp),%xmm0
ff
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x1659(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a11 <main+0x891>
movslq -0xc(%rbp),%rax
movl   $0x1,-0xc3530(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a16 <main+0x896>
jmp    1a1b <main+0x89b>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1911 <main+0x791>
jmp    1a2e <main+0x8ae>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    18fc <main+0x77c>
mov    -0x20(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc3550(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc3558(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc3560(%rbp)
ff
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1af5 <main+0x975>
movslq -0x8(%rbp),%rax
cmpl   $0x0,-0xc3530(%rbp,%rax,4)
jne    1ae2 <main+0x962>
movsd  -0xc3550(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rax
addsd  -0x557400(%rbp,%rax,8),%xmm0
aa ff
movsd  %xmm0,-0xc3550(%rbp)
ff
movsd  -0xc3558(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rax
addsd  -0x6dde00(%rbp,%rax,8),%xmm0
92 ff
movsd  %xmm0,-0xc3558(%rbp)
ff
movsd  -0xc3560(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rax
addsd  -0x864800(%rbp,%rax,8),%xmm0
79 ff
movsd  %xmm0,-0xc3560(%rbp)
ff
jmp    1ae7 <main+0x967>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1a6d <main+0x8ed>
movsd  -0xc3550(%rbp),%xmm0
ff
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc3538(%rbp)
ff
movsd  -0xc3558(%rbp),%xmm0
ff
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc3540(%rbp)
ff
movsd  -0xc3560(%rbp),%xmm0
ff
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc3548(%rbp)
ff
movl   $0x0,-0x1c(%rbp)
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1c69 <main+0xae9>
movslq -0x8(%rbp),%rax
cmpl   $0x0,-0xc3530(%rbp,%rax,4)
jne    1c56 <main+0xad6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x8(%rbp),%rax
movsd  -0x557400(%rbp,%rax,8),%xmm0
aa ff
subsd  -0xc3538(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2b10(%rbp)
ff
mov    $0x0,%al
call   1060 <rd@plt>
movsd  -0x8b2b10(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movslq -0x8(%rbp),%rax
movsd  -0x6dde00(%rbp,%rax,8),%xmm0
92 ff
subsd  -0xc3540(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2b08(%rbp)
ff
mov    $0x0,%al
call   1060 <rd@plt>
movsd  -0x8b2b08(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movslq -0x8(%rbp),%rax
movsd  -0x864800(%rbp,%rax,8),%xmm0
79 ff
subsd  -0xc3548(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2b00(%rbp)
ff
mov    $0x0,%al
call   1060 <rd@plt>
movsd  -0x8b2b00(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
jmp    1c5b <main+0xadb>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1b4e <main+0x9ce>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1de3 <main+0xc63>
movsd  -0x8b2aa8(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
subsd  0x8(%rax),%xmm0
movaps 0x13be(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc35e8(%rbp)
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
divsd  -0xc35e8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc35a8(%rbp)
ff
movsd  -0x8b2aa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2b28(%rbp)
ff
movsd  -0xc35e8(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2b20(%rbp)
ff
movsd  -0xc35a8(%rbp),%xmm0
ff
call   1080 <cos@plt>
movsd  -0x8b2b28(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x8b2b20(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc35c0(%rbp)
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xc35c8(%rbp)
ff
movsd  -0xc35e8(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b2b18(%rbp)
ff
movsd  -0xc35a8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x8b2b18(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc35d0(%rbp)
ff
movsd  -0xc35c0(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xc35c8(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xc35d0(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1c70 <main+0xaf0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc3550(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc3558(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc3560(%rbp)
ff
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1e9a <main+0xd1a>
movsd  -0xc3550(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc3550(%rbp)
ff
movsd  -0xc3558(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xc3558(%rbp)
ff
movsd  -0xc3560(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
addsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xc3560(%rbp)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1e0b <main+0xc8b>
movsd  -0xc3550(%rbp),%xmm0
ff
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc3538(%rbp)
ff
movsd  -0xc3558(%rbp),%xmm0
ff
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc3540(%rbp)
ff
movsd  -0xc3560(%rbp),%xmm0
ff
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc3548(%rbp)
ff
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1fa8 <main+0xe28>
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
subsd  -0xc3538(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
subsd  -0xc3540(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
subsd  -0xc3548(%rbp),%xmm0
ff
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1eec <main+0xd6c>
mov    -0x24(%rbp),%esi
lea    0x10d8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     2030 <main+0xeb0>
mov    -0x8(%rbp),%esi
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm1
movslq -0x8(%rbp),%rcx
lea    -0x8b2aa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
lea    0x1073(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1fc0 <main+0xe40>
mov    -0x4(%rbp),%eax
add    $0x8b2b30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x8b29a8,%rsp
lea    0xee8(%rip),%rdi
xor    %ebp,%ebp
lea    0x88(%rsp),%rsi
lea    0x80(%rsp),%rdx
xor    %eax,%eax
call   1090 <scanf@plt>
lea    0xecc(%rip),%rbx
lea    0x98(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1090 <scanf@plt>
lea    0x90(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1090 <scanf@plt>
movsd  0x80(%rsp),%xmm1
movsd  0xdf3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0xdef(%rip),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm1
addsd  0x88(%rsp),%xmm1
divsd  %xmm1,%xmm0
call   1070 <atan@plt>
movapd %xmm0,%xmm3
movsd  0xdd1(%rip),%xmm2
movsd  0x80(%rsp),%xmm0
movsd  0xdb8(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  0x88(%rsp),%xmm4
mulsd  %xmm4,%xmm4
movsd  0xdaf(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  0xda7(%rip),%xmm4
addsd  %xmm1,%xmm4
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm4
movapd %xmm4,%xmm0
jb     1291 <main+0xf1>
sqrtsd %xmm0,%xmm0
jmp    12a8 <main+0x108>
movsd  %xmm3,(%rsp)
call   10b0 <sqrt@plt>
movsd  (%rsp),%xmm3
movsd  0xd68(%rip),%xmm2
subsd  %xmm3,%xmm2
movapd %xmm2,0x40(%rsp)
mulsd  0xd6e(%rip),%xmm0
movsd  0xd46(%rip),%xmm1
movsd  %xmm0,0x78(%rsp)
mulsd  %xmm0,%xmm1
divsd  0xd5c(%rip),%xmm1
movsd  %xmm1,0x58(%rsp)
movsd  0xd55(%rip),%xmm14
mov    $0xffffffe2,%eax
movsd  0xd4f(%rip),%xmm15
movsd  0xd77(%rip),%xmm7
movapd %xmm14,%xmm13
xorpd  %xmm12,%xmm12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%ebx
addsd  %xmm15,%xmm14
movapd %xmm14,%xmm0
xorpd  %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm0,%xmm10
addsd  %xmm1,%xmm10
movapd %xmm14,%xmm2
mulsd  0xd0d(%rip),%xmm2
movapd %xmm2,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm0,%xmm6
addsd  0xd01(%rip),%xmm6
addsd  0xd01(%rip),%xmm2
movapd %xmm0,%xmm3
addsd  0xcfd(%rip),%xmm3
addsd  0xcfd(%rip),%xmm0
xor    %ecx,%ecx
movapd %xmm13,%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rbx,%rcx,1),%edx
addsd  %xmm15,%xmm9
movslq %edx,%rbp
cmp    $0x30d40,%ebp
mov    $0x30d3f,%edx
cmovge %ebp,%edx
cmp    %rdx,%rbp
je     1c5a <main+0xaba>
lea    0x1(%rbp),%rsi
movapd %xmm9,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm10,%xmm1
movsd  %xmm1,0x72bfa8(%rsp,%rbp,8)
movapd %xmm9,%xmm1
mulsd  %xmm12,%xmm1
movapd %xmm1,%xmm8
addsd  %xmm5,%xmm8
movsd  %xmm8,0x5a55a8(%rsp,%rbp,8)
cmp    %rdx,%rsi
je     1c5a <main+0xaba>
lea    0x2(%rbp),%rsi
movapd %xmm9,%xmm11
mulsd  %xmm7,%xmm11
addsd  %xmm6,%xmm11
movsd  %xmm11,0x72bfb0(%rsp,%rbp,8)
addsd  %xmm2,%xmm1
movsd  %xmm1,0x5a55b0(%rsp,%rbp,8)
cmp    %rdx,%rsi
je     1c5a <main+0xaba>
lea    0x3(%rbp),%rsi
movapd %xmm9,%xmm4
mulsd  %xmm7,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x72bfb8(%rsp,%rbp,8)
movsd  %xmm1,0x5a55b8(%rsp,%rbp,8)
cmp    %rdx,%rsi
je     1c5a <main+0xaba>
movapd %xmm9,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x72bfc0(%rsp,%rbp,8)
movsd  %xmm8,0x5a55c0(%rsp,%rbp,8)
add    $0x4,%ecx
cmp    $0xa4,%ecx
jne    1380 <main+0x1e0>
add    $0x4,%rbp
add    $0x1,%eax
cmp    $0x65,%eax
jne    1310 <main+0x170>
xor    %r12d,%r12d
mov    %ebx,%r14d
add    $0xa3,%r14d
js     1790 <main+0x5f0>
movapd 0xbe3(%rip),%xmm0
movapd 0x40(%rsp),%xmm1
xorpd  %xmm1,%xmm0
movapd %xmm0,0x60(%rsp)
add    $0xa5,%ebx
mov    $0x1,%ebp
nopl   0x0(%rax,%rax,1)
movsd  0x72bfa0(%rsp,%rbp,8),%xmm0
movsd  %xmm0,0x20(%rsp)
movapd %xmm1,%xmm0
call   10a0 <cos@plt>
movsd  %xmm0,(%rsp)
movsd  0x5a55a0(%rsp,%rbp,8),%xmm0
movsd  %xmm0,0x18(%rsp)
movapd 0x60(%rsp),%xmm0
call   1060 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  (%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movaps 0x60(%rsp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movapd 0x40(%rsp),%xmm0
call   10a0 <cos@plt>
movapd 0x40(%rsp),%xmm1
mulsd  0x18(%rsp),%xmm0
movsd  0x38(%rsp),%xmm2
mulsd  0x20(%rsp),%xmm2
addsd  %xmm0,%xmm2
movsd  (%rsp),%xmm0
movsd  %xmm0,0x72bfa0(%rsp,%rbp,8)
movsd  %xmm2,0x5a55a0(%rsp,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    14c0 <main+0x320>
mov    $0x0,%r13d
mov    $0x0,%r15d
test   %r14d,%r14d
js     190f <main+0x76f>
xor    %r15d,%r15d
mov    $0x1,%ebp
xorpd  %xmm2,%xmm2
movsd  0x78(%rsp),%xmm1
jmp    15ad <main+0x40d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    %rbp,%rbx
je     1649 <main+0x4a9>
movsd  0x5a55a0(%rsp,%rbp,8),%xmm3
ucomisd %xmm2,%xmm3
jb     15a0 <main+0x400>
movsd  0x98(%rsp),%xmm0
ucomisd %xmm3,%xmm0
jb     15a0 <main+0x400>
movsd  0x72bfa0(%rsp,%rbp,8),%xmm0
ucomisd %xmm2,%xmm0
jb     15a0 <main+0x400>
ucomisd %xmm0,%xmm1
jb     15a0 <main+0x400>
lea    0x1(%r15),%r14d
divsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  %xmm3,(%rsp)
call   10a0 <cos@plt>
mulsd  0x58(%rsp),%xmm0
movslq %r15d,%r15
movsd  %xmm0,0x41eba8(%rsp,%r15,8)
movsd  0x20(%rsp),%xmm0
call   1060 <sin@plt>
xorpd  %xmm2,%xmm2
movsd  0x78(%rsp),%xmm1
mulsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x2981a8(%rsp,%r15,8)
movsd  (%rsp),%xmm0
movsd  %xmm0,0x1117a8(%rsp,%r15,8)
mov    %r14d,%r15d
jmp    15a0 <main+0x400>
test   %r15d,%r15d
jle    1909 <main+0x769>
lea    0x4e2a4(%rsp),%rdi
mov    %r15d,%r14d
lea    0x0(,%r14,4),%rdx
xor    %r12d,%r12d
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x1(%r15),%eax
mov    %rax,0x40(%rsp)
mov    %r15,0x38(%rsp)
lea    -0x1(%r15),%ebp
mov    $0x1,%r15d
xorpd  %xmm3,%xmm3
movsd  0x9e5(%rip),%xmm4
xor    %r13d,%r13d
jmp    16af <main+0x50f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    0x40(%rsp),%r15
je     179b <main+0x5fb>
mov    %r15,%rax
add    $0x1,%r15
cmp    %r14,%rax
jae    16a0 <main+0x500>
movsd  0x41eba0(%rsp,%rax,8),%xmm5
movsd  0x2981a0(%rsp,%rax,8),%xmm6
movsd  0x1117a0(%rsp,%rax,8),%xmm7
mov    %r12,%rbx
movsd  %xmm5,(%rsp)
movsd  %xmm6,0x20(%rsp)
movsd  %xmm7,0x18(%rsp)
jmp    16f8 <main+0x558>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    %ebx,%ebp
je     16a0 <main+0x500>
movapd %xmm5,%xmm1
subsd  0x41ebb0(%rsp,%rbx,8),%xmm1
movapd %xmm6,%xmm2
subsd  0x2981b0(%rsp,%rbx,8),%xmm2
movapd %xmm7,%xmm0
subsd  0x1117b0(%rsp,%rbx,8),%xmm0
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1750 <main+0x5b0>
sqrtsd %xmm0,%xmm0
ucomisd %xmm0,%xmm4
jbe    16f0 <main+0x550>
jmp    177c <main+0x5dc>
cs nopw 0x0(%rax,%rax,1)
nop
call   10b0 <sqrt@plt>
movsd  0x18(%rsp),%xmm7
movsd  0x20(%rsp),%xmm6
movsd  (%rsp),%xmm5
movsd  0x90a(%rip),%xmm4
xorpd  %xmm3,%xmm3
ucomisd %xmm0,%xmm4
jbe    16f0 <main+0x550>
movl   $0x1,0x4e2a8(%rsp,%rbx,4)
add    $0x1,%r13d
jmp    16f0 <main+0x550>
xor    %r13d,%r13d
xor    %r15d,%r15d
jmp    190f <main+0x76f>
mov    0x38(%rsp),%r15
mov    %r15d,%r12d
sub    %r13d,%r12d
test   %r15d,%r15d
jle    190f <main+0x76f>
mov    0x40(%rsp),%rax
lea    -0x1(%rax),%rcx
cmp    $0x2,%eax
jne    1bb9 <main+0xa19>
xorpd  %xmm1,%xmm1
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
test   $0x1,%cl
je     17fc <main+0x65c>
cmpl   $0x0,0x4e2a0(%rsp,%rax,4)
jne    17fc <main+0x65c>
movsd  0x41eba0(%rsp,%rax,8),%xmm0
movhpd 0x2981a0(%rsp,%rax,8),%xmm0
addpd  %xmm0,%xmm1
addsd  0x1117a0(%rsp,%rax,8),%xmm3
movapd %xmm1,0x20(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %r12d,%xmm1
test   %r15d,%r15d
movapd %xmm1,0x60(%rsp)
jle    191d <main+0x77d>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
movapd 0x20(%rsp),%xmm2
divpd  %xmm0,%xmm2
movapd %xmm2,0x20(%rsp)
divsd  %xmm1,%xmm3
mov    $0x1,%ebp
xor    %r14d,%r14d
movsd  %xmm3,0x18(%rsp)
jmp    185f <main+0x6bf>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    %rbp,0x40(%rsp)
je     1b74 <main+0x9d4>
cmpl   $0x0,0x4e2a0(%rsp,%rbp,4)
jne    1850 <main+0x6b0>
movslq %r14d,%rbx
add    $0x1,%r14d
shl    $0x5,%rbx
movsd  0x41eba0(%rsp,%rbp,8),%xmm0
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1080 <rd@plt>
mov    %r12d,%r15d
mov    %eax,%r12d
movapd (%rsp),%xmm0
movhpd 0x2981a0(%rsp,%rbp,8),%xmm0
subpd  0x20(%rsp),%xmm0
movapd %xmm0,(%rsp)
xor    %eax,%eax
call   1080 <rd@plt>
movd   %r12d,%xmm0
mov    %r15d,%r12d
movd   %eax,%xmm1
punpckldq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm0
addpd  (%rsp),%xmm0
lea    0xa0(%rsp),%r15
movupd %xmm0,0x28(%rbx,%r15,1)
movsd  0x1117a0(%rsp,%rbp,8),%xmm0
subsd  0x18(%rsp),%xmm0
movsd  %xmm0,(%rsp)
xor    %eax,%eax
call   1080 <rd@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,0x38(%rbx,%r15,1)
jmp    1850 <main+0x6b0>
xor    %r13d,%r13d
mov    %r15d,%r12d
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movapd %xmm0,0x60(%rsp)
test   %r12d,%r12d
jle    1b82 <main+0x9e2>
sub    %r13d,%r15d
add    $0x1,%r15d
mov    %r15d,%r14d
lea    0xd8(%rsp),%rbp
lea    -0x1(%r14),%rbx
nopl   0x0(%rax)
movsd  0x90(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movapd %xmm0,%xmm1
subsd  -0x10(%rbp),%xmm1
andpd  0x730(%rip),%xmm1
movapd %xmm1,(%rsp)
movsd  0x0(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
call   10a0 <cos@plt>
mulsd  (%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x18(%rsp),%xmm0
call   1060 <sin@plt>
mulsd  (%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm0,0x0(%rbp)
add    $0x20,%rbp
add    $0xffffffffffffffff,%rbx
jne    1940 <main+0x7a0>
test   %r12d,%r12d
jle    1b82 <main+0x9e2>
lea    -0x1(%r14),%rax
add    $0xfffffffffffffffe,%r14
je     1b5a <main+0x9ba>
lea    0xf8(%rsp),%rdx
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx),%xmm2
addpd  %xmm1,%xmm2
movupd -0x10(%rdx),%xmm1
addpd  %xmm2,%xmm1
addsd  -0x20(%rdx),%xmm0
addsd  (%rdx),%xmm0
add    $0x40,%rdx
lea    (%rsi,%rcx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rcx
cmp    $0x1,%rdi
jne    19f0 <main+0x850>
test   $0x1,%al
je     1a3f <main+0x89f>
shl    $0x5,%rcx
movupd 0xa8(%rsp,%rcx,1),%xmm2
addpd  %xmm2,%xmm1
addsd  0xb8(%rsp,%rcx,1),%xmm0
test   %r12d,%r12d
jle    1b82 <main+0x9e2>
movapd 0x60(%rsp),%xmm2
divsd  %xmm2,%xmm0
unpcklpd %xmm2,%xmm2
divpd  %xmm2,%xmm1
test   %r14,%r14
je     1ba7 <main+0xa07>
lea    0xf8(%rsp),%rdx
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx),%xmm2
subpd  %xmm1,%xmm2
movupd %xmm2,-0x30(%rdx)
movsd  -0x20(%rdx),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,-0x20(%rdx)
movupd -0x10(%rdx),%xmm2
subpd  %xmm1,%xmm2
movupd %xmm2,-0x10(%rdx)
movsd  (%rdx),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,(%rdx)
add    $0x40,%rdx
lea    (%rsi,%rcx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rcx
cmp    $0x1,%rdi
jne    1a80 <main+0x8e0>
test   $0x1,%al
je     1b00 <main+0x960>
shl    $0x5,%rcx
movupd 0xa8(%rsp,%rcx,1),%xmm2
subpd  %xmm1,%xmm2
movupd %xmm2,0xa8(%rsp,%rcx,1)
movsd  0xb8(%rsp,%rcx,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0xb8(%rsp,%rcx,1)
lea    0x5a1(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
test   %r12d,%r12d
jle    1b93 <main+0x9f3>
lea    0xd8(%rsp),%rbp
mov    $0x1,%ebx
lea    0x582(%rip),%r14
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movsd  -0x8(%rbp),%xmm2
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x3,%al
call   1040 <printf@plt>
add    $0x1,%rbx
add    $0x20,%rbp
cmp    %rbx,%r15
jne    1b30 <main+0x990>
jmp    1b93 <main+0x9f3>
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
mov    $0x1,%ecx
test   $0x1,%al
jne    1a25 <main+0x885>
jmp    1a3f <main+0x89f>
mov    0x38(%rsp),%r15
test   %r12d,%r12d
jg     1926 <main+0x786>
lea    0x51f(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x8b29a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ecx
test   $0x1,%al
jne    1ad0 <main+0x930>
jmp    1b00 <main+0x960>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
xorpd  %xmm1,%xmm1
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
jmp    1bf6 <main+0xa56>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdx,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
je     17ce <main+0x62e>
cmpl   $0x0,0x4e2a0(%rsp,%rax,4)
je     1c10 <main+0xa70>
cmpl   $0x0,0x4e2a4(%rsp,%rax,4)
jne    1be0 <main+0xa40>
jmp    1c39 <main+0xa99>
nopl   0x0(%rax)
movsd  0x41eba0(%rsp,%rax,8),%xmm0
movhpd 0x2981a0(%rsp,%rax,8),%xmm0
addpd  %xmm0,%xmm1
addsd  0x1117a0(%rsp,%rax,8),%xmm3
cmpl   $0x0,0x4e2a4(%rsp,%rax,4)
jne    1be0 <main+0xa40>
movsd  0x41eba8(%rsp,%rax,8),%xmm0
movhpd 0x2981a8(%rsp,%rax,8),%xmm0
addpd  %xmm0,%xmm1
addsd  0x1117a8(%rsp,%rax,8),%xmm3
jmp    1be0 <main+0xa40>
lea    0x475(%rip),%rdi
call   1030 <puts@plt>
xor    %edi,%edi
call   10c0 <exit@plt>

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

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