#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, double, double,
                           double);
int /*<<< orphan*/ printf(char *, int);
int main() {
  double xL = 0., xR = 1., hx, t, Tmax = 2., CFL = 0.9, dt, a = 1.;
  int Nx = 256;
  hx = (xR - xL) / (Nx - 1);
  dt = CFL * hx / a;
  int i;
  double Uarr[Nx], UarrN[Nx], dUarr[Nx], dUarrN[Nx], x;
  double A, B, C, D, ksi;
  for (i = 0; i < Nx; i++) {
    x = (double)i * hx + xL;
    if (x > 0.1 && x < 0.3)
      Uarr[i] = 1.;
    else
      Uarr[i] = 0.;
  }
  for (i = 0; i < Nx; i++) {
    if (i == 0) {
      dUarr[0] = (Uarr[1] - Uarr[0]) / hx;
    } else if (i == Nx - 1) {
      dUarr[Nx - 1] = (Uarr[Nx - 1] - Uarr[Nx - 2]) / hx;
    } else {
      dUarr[i] = (Uarr[i - 1] + Uarr[i + 1] - 2. * Uarr[i]) / hx;
    }
  }
  printf("%f\n", dt);
  FILE *op;
  op = fopen("output", "w");
  int ts;
  for (t = 0.; t < Tmax; t += dt) {
    for (i = 0; i < Nx - 1; i++) {
      A = -2. * (Uarr[i + 1] - Uarr[i]) / hx / hx / hx +
          (dUarr[i + 1] + dUarr[i]) / hx / hx;
      B = 3. * (Uarr[i + 1] - Uarr[i]) / hx / hx -
          (2. * dUarr[i] + dUarr[i + 1]) / hx;
      C = dUarr[i];
      D = Uarr[i];
      ksi = a * dt;
      UarrN[i] = ((A * ksi + B) * ksi + C) * ksi + D;
      dUarrN[i] = ((3. * A * ksi + 2. * B) * ksi + C);
    }
    UarrN[Nx - 1] = UarrN[0];
    dUarrN[Nx - 1] = dUarrN[0];
    for (i = 0; i < Nx; i++) {
      Uarr[i] = UarrN[i];
      dUarr[i] = dUarrN[i];
      fprintf(op, "%f %f %f\n", (double)i * hx + xL, t, Uarr[i]);
    }
    ts++;
  }
  fclose(op);
  printf("%d\n", ts);
  op = fopen("output.l", "w");
  for (i = 0; i < Nx; i++) {
    fprintf(op, "%f %f %f\n", (double)i * hx + xL, t, Uarr[i]);
  }
  fclose(op);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0x10(%rbp)
movabs $0x3ff0000000000000,%rax
mov    %rax,-0x18(%rbp)
movabs $0x4000000000000000,%rcx
mov    %rcx,-0x30(%rbp)
movabs $0x3feccccccccccccd,%rcx
cc ec 3f
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x48(%rbp)
movl   $0x100,-0x4c(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x58(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x68(%rbp)
mov    -0x4c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xc8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
mov    -0x4c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xc0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    12fb <main+0x1bb>
cvtsi2sdl -0x50(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x10(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  0xd7d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12d5 <main+0x195>
movsd  0xd73(%rip),%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    12d5 <main+0x195>
mov    -0xd8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  0xd5d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12e8 <main+0x1a8>
mov    -0xd8(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12ed <main+0x1ad>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1266 <main+0x126>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13f1 <main+0x2b1>
cmpl   $0x0,-0x50(%rbp)
jne    133d <main+0x1fd>
mov    -0xc8(%rbp),%rax
mov    -0xd8(%rbp),%rcx
movsd  0x8(%rcx),%xmm0
subsd  (%rcx),%xmm0
divsd  -0x20(%rbp),%xmm0
movsd  %xmm0,(%rax)
jmp    13de <main+0x29e>
mov    -0x50(%rbp),%eax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1390 <main+0x250>
mov    -0xc8(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x4c(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
subsd  (%rcx,%rdx,8),%xmm0
divsd  -0x20(%rbp),%xmm0
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13d9 <main+0x299>
mov    -0xc8(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x50(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
addsd  (%rcx,%rdx,8),%xmm0
movslq -0x50(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
divsd  -0x20(%rbp),%xmm0
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13de <main+0x29e>
jmp    13e3 <main+0x2a3>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1302 <main+0x1c2>
cvttsd2si -0x40(%rbp),%esi
lea    0xc42(%rip),%rdi
call   1040 <printf@plt>
lea    0xc27(%rip),%rdi
lea    0xc27(%rip),%rsi
call   1060 <fopen@plt>
mov    %rax,-0xb0(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1702 <main+0x5c2>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1614 <main+0x4d4>
mov    -0xc0(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    -0xd8(%rbp),%rdx
mov    -0xc8(%rbp),%rsi
mov    -0x50(%rbp),%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  (%rdx,%rdi,8),%xmm1
movslq -0x50(%rbp),%rdi
subsd  (%rdx,%rdi,8),%xmm1
movsd  0xb85(%rip),%xmm0
mulsd  %xmm1,%xmm0
divsd  -0x20(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
mov    -0x50(%rbp),%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm1
movslq -0x50(%rbp),%rdi
addsd  (%rsi,%rdi,8),%xmm1
divsd  -0x20(%rbp),%xmm1
divsd  -0x20(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x50(%rbp),%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  (%rdx,%rdi,8),%xmm1
movslq -0x50(%rbp),%rdi
subsd  (%rdx,%rdi,8),%xmm1
movsd  0xb1e(%rip),%xmm0
mulsd  %xmm1,%xmm0
divsd  -0x20(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
movslq -0x50(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm1
mov    -0x50(%rbp),%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm2
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  -0x20(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movslq -0x50(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movslq -0x50(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x50(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0xa4b(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  0xa2b(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    143f <main+0x2ff>
mov    -0xc0(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movsd  (%rax),%xmm0
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    16df <main+0x59f>
mov    -0xd8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    -0xc0(%rbp),%rdx
mov    -0xd0(%rbp),%rsi
movslq -0x50(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movslq -0x50(%rbp),%rsi
movsd  %xmm0,(%rax,%rsi,8)
movslq -0x50(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movslq -0x50(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0xb0(%rbp),%rdi
cvtsi2sdl -0x50(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x10(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm1
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
lea    0x96d(%rip),%rsi
call   1050 <fprintf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    164d <main+0x50d>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
movsd  -0x40(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1424 <main+0x2e4>
mov    -0xb0(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0xb4(%rbp),%esi
lea    0x928(%rip),%rdi
call   1040 <printf@plt>
lea    0x920(%rip),%rdi
lea    0x909(%rip),%rsi
call   1060 <fopen@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    179a <main+0x65a>
mov    -0xd8(%rbp),%rax
mov    -0xb0(%rbp),%rdi
cvtsi2sdl -0x50(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x10(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm1
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
lea    0x8b2(%rip),%rsi
call   1050 <fprintf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1741 <main+0x601>
mov    -0xb0(%rbp),%rdi
call   1030 <fclose@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x2018,%rsp
movdqa 0xeab(%rip),%xmm0
xor    %eax,%eax
movdqa 0xeb0(%rip),%xmm8
movapd 0xeb7(%rip),%xmm11
xorpd  %xmm10,%xmm10
movapd 0xeba(%rip),%xmm2
movapd 0xec2(%rip),%xmm4
movapd 0xeca(%rip),%xmm5
movdqa 0xed1(%rip),%xmm9
nop
movdqa %xmm0,%xmm7
cvtdq2pd %xmm0,%xmm1
paddd  %xmm8,%xmm7
cvtdq2pd %xmm7,%xmm7
mulpd  %xmm11,%xmm1
addpd  %xmm10,%xmm1
mulpd  %xmm11,%xmm7
addpd  %xmm10,%xmm7
movapd %xmm2,%xmm3
cmpltpd %xmm1,%xmm3
movapd %xmm2,%xmm6
cmpltpd %xmm7,%xmm6
cmpltpd %xmm4,%xmm1
andpd  %xmm3,%xmm1
cmpltpd %xmm4,%xmm7
andpd  %xmm6,%xmm7
andpd  %xmm5,%xmm1
andpd  %xmm5,%xmm7
movapd %xmm1,0x10(%rsp,%rax,8)
movapd %xmm7,0x20(%rsp,%rax,8)
add    $0x4,%rax
paddd  %xmm9,%xmm0
cmp    $0x100,%rax
jne    1190 <main+0x50>
movsd  0x808(%rsp),%xmm0
subsd  0x800(%rsp),%xmm0
movsd  0xe78(%rip),%xmm4
divsd  %xmm4,%xmm0
movsd  0x10(%rsp),%xmm2
movsd  0x18(%rsp),%xmm1
movapd %xmm2,(%rsp)
subsd  %xmm2,%xmm1
divsd  %xmm4,%xmm1
xor    %eax,%eax
jmp    1273 <main+0x133>
nopl   0x0(%rax)
movsd  0x8(%rsp,%rax,8),%xmm2
movsd  0x10(%rsp,%rax,8),%xmm3
addsd  0x18(%rsp,%rax,8),%xmm2
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm4,%xmm2
movsd  %xmm2,0x810(%rsp,%rax,8)
add    $0x1,%rax
cmp    $0x100,%rax
je     129b <main+0x15b>
cmp    $0xff,%eax
je     1290 <main+0x150>
test   %eax,%eax
jne    1240 <main+0x100>
movsd  %xmm1,0x810(%rsp)
jmp    1267 <main+0x127>
nopl   0x0(%rax)
movsd  %xmm0,0x1008(%rsp)
jmp    1267 <main+0x127>
lea    0xe25(%rip),%rdi
xor    %esi,%esi
call   1040 <printf@plt>
lea    0xe08(%rip),%rdi
lea    0xe08(%rip),%rsi
call   1060 <fopen@plt>
mov    %rax,%rbx
movapd 0xda8(%rip),%xmm9
movapd 0xdaf(%rip),%xmm10
movsd  0xdc6(%rip),%xmm11
lea    0xde0(%rip),%r15
xorpd  %xmm1,%xmm1
movdqa (%rsp),%xmm0
nopw   0x0(%rax,%rax,1)
punpcklqdq %xmm0,%xmm8
movhpd 0x810(%rsp),%xmm0
xor    %eax,%eax
movapd 0xd18(%rip),%xmm7
nopl   0x0(%rax,%rax,1)
movdqa %xmm8,%xmm4
movapd %xmm0,%xmm2
movupd 0x18(%rsp,%rax,8),%xmm8
shufpd $0x1,%xmm8,%xmm4
movapd %xmm8,%xmm3
subpd  %xmm4,%xmm3
movapd %xmm3,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm7,%xmm6
divpd  %xmm7,%xmm6
divpd  %xmm7,%xmm6
movupd 0x818(%rsp,%rax,8),%xmm0
shufpd $0x1,%xmm0,%xmm2
movapd %xmm0,%xmm5
addpd  %xmm2,%xmm5
divpd  %xmm7,%xmm5
divpd  %xmm7,%xmm5
subpd  %xmm6,%xmm5
mulpd  %xmm9,%xmm3
divpd  %xmm7,%xmm3
divpd  %xmm7,%xmm3
movapd %xmm2,%xmm6
addpd  %xmm2,%xmm6
addpd  %xmm0,%xmm6
divpd  %xmm7,%xmm6
subpd  %xmm6,%xmm3
movapd %xmm5,%xmm6
mulpd  %xmm10,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm10,%xmm6
addpd  %xmm2,%xmm6
mulpd  %xmm10,%xmm6
addpd  %xmm4,%xmm6
movapd %xmm6,0x1810(%rsp,%rax,8)
mulpd  %xmm9,%xmm5
addpd  %xmm3,%xmm3
mulpd  %xmm10,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm10,%xmm5
addpd  %xmm2,%xmm5
movapd %xmm5,0x1010(%rsp,%rax,8)
add    $0x2,%rax
cmp    $0xfe,%rax
jne    1310 <main+0x1d0>
unpckhpd %xmm0,%xmm0
unpckhpd %xmm8,%xmm8
movsd  0x808(%rsp),%xmm2
subsd  %xmm8,%xmm2
movapd %xmm2,%xmm3
addsd  %xmm2,%xmm3
movsd  0xc87(%rip),%xmm7
divsd  %xmm7,%xmm3
divsd  %xmm7,%xmm3
divsd  %xmm7,%xmm3
movsd  0x1008(%rsp),%xmm4
movapd %xmm0,%xmm5
addsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
addsd  %xmm0,%xmm4
divsd  %xmm7,%xmm4
divsd  %xmm7,%xmm4
subsd  %xmm3,%xmm4
movsd  0xc56(%rip),%xmm6
mulsd  %xmm6,%xmm2
divsd  %xmm7,%xmm2
divsd  %xmm7,%xmm2
divsd  %xmm7,%xmm5
subsd  %xmm5,%xmm2
movapd %xmm4,%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm8,%xmm3
movsd  %xmm3,0x2000(%rsp)
mulsd  %xmm6,%xmm4
addsd  %xmm2,%xmm2
mulsd  %xmm11,%xmm4
addsd  %xmm2,%xmm4
mulsd  %xmm11,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,0x1800(%rsp)
movsd  0x1810(%rsp),%xmm2
movsd  %xmm2,0x2008(%rsp)
movsd  0x1010(%rsp),%xmm0
movsd  %xmm0,0x1808(%rsp)
movsd  %xmm2,0x10(%rsp)
movsd  %xmm0,0x810(%rsp)
xorps  %xmm0,%xmm0
mov    %rbx,%rdi
mov    %r15,%rsi
movsd  %xmm1,(%rsp)
call   1050 <fprintf@plt>
mov    $0xffffffffffffff01,%rbp
nop
movsd  0x2010(%rsp,%rbp,8),%xmm2
movsd  0x1810(%rsp,%rbp,8),%xmm0
movsd  %xmm2,0x810(%rsp,%rbp,8)
movsd  %xmm0,0x1010(%rsp,%rbp,8)
lea    0x100(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xb67(%rip),%xmm0
addsd  0xb7f(%rip),%xmm0
mov    %rbx,%rdi
mov    %r15,%rsi
movsd  (%rsp),%xmm1
call   1050 <fprintf@plt>
inc    %rbp
jne    14f0 <main+0x3b0>
add    $0x1,%r14d
movsd  0xb4d(%rip),%xmm11
movsd  (%rsp),%xmm1
addsd  %xmm11,%xmm1
movsd  0xb43(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1588 <main+0x448>
movq   0x10(%rsp),%xmm0
movapd 0xaf6(%rip),%xmm9
movapd 0xafd(%rip),%xmm10
jmp    12f0 <main+0x1b0>
mov    %rbx,%rdi
movsd  %xmm1,(%rsp)
call   1030 <fclose@plt>
lea    0xb2f(%rip),%rdi
mov    %r14d,%esi
call   1040 <printf@plt>
lea    0xb24(%rip),%rdi
lea    0xb0d(%rip),%rsi
call   1060 <fopen@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
lea    0xafe(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0xab1(%rip),%xmm0
addsd  0xac9(%rip),%xmm0
movsd  0x10(%rsp,%rbp,8),%xmm2
mov    %rbx,%rdi
mov    %r14,%rsi
movsd  (%rsp),%xmm1
call   1050 <fprintf@plt>
add    $0x1,%rbp
cmp    $0x100,%rbp
jne    15d0 <main+0x490>
mov    %rbx,%rdi
call   1030 <fclose@plt>
xor    %eax,%eax
add    $0x2018,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [4 x i8] c"%f\0A\00"
@.str.1 = [7 x i8] c"output\00"
@.str.2 = [2 x i8] c"w\00"
@.str.3 = [10 x i8] c"%f %f %f\0A\00"
@.str.4 = [4 x i8] c"%d\0A\00"
@.str.5 = [9 x i8] c"output.l\00"
define i32 @main() {
%1 = alloca [256 x double]
%2 = alloca [256 x double]
%3 = alloca [256 x double]
%4 = alloca [256 x double]
%5 = getelementptr inbounds [256 x double], [256 x double]* %4, i64 0, i64 0
%6 = getelementptr inbounds [256 x double], [256 x double]* %2, i64 0, i64 0
br label %7
7: ; preds = %7, %0
%8 = phi i64 [ 0, %0 ], [ %27, %7 ]
%9 = phi <2 x i32> [ <i32 0, i32 1>, %0 ], [ %28, %7 ]
%10 = add <2 x i32> %9, <i32 2, i32 2>
%11 = sitofp <2 x i32> %9 to <2 x double>
%12 = sitofp <2 x i32> %10 to <2 x double>
%13 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %11, <2 x double> <double 0x3F70101010101010, double 0x3F70101010101010>, <2 x double> zeroinitializer)
%14 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %12, <2 x double> <double 0x3F70101010101010, double 0x3F70101010101010>, <2 x double> zeroinitializer)
%15 = fcmp ogt <2 x double> %13, <double 1.000000e-01, double 1.000000e-01>
%16 = fcmp ogt <2 x double> %14, <double 1.000000e-01, double 1.000000e-01>
%17 = fcmp olt <2 x double> %13, <double 3.000000e-01, double 3.000000e-01>
%18 = fcmp olt <2 x double> %14, <double 3.000000e-01, double 3.000000e-01>
%19 = and <2 x i1> %15, %17
%20 = and <2 x i1> %16, %18
%21 = select <2 x i1> %19, <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double> zeroinitializer
%22 = select <2 x i1> %20, <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double> zeroinitializer
%23 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 %8
%24 = bitcast double* %23 to <2 x double>*
store <2 x double> %21, <2 x double>* %24
%25 = getelementptr inbounds double, double* %23, i64 2
%26 = bitcast double* %25 to <2 x double>*
store <2 x double> %22, <2 x double>* %26
%27 = add nuw i64 %8, 4
%28 = add <2 x i32> %9, <i32 4, i32 4>
%29 = icmp eq i64 %27, 256
br i1 %29, label %30, label %7
30: ; preds = %7
%31 = getelementptr inbounds [256 x double], [256 x double]* %3, i64 0, i64 0
%32 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 0
%33 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 255
%34 = load double, double* %33
%35 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 254
%36 = load double, double* %35
%37 = fsub double %34, %36
%38 = fdiv double %37, 0x3F70101010101010
%39 = getelementptr inbounds [256 x double], [256 x double]* %3, i64 0, i64 255
%40 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 1
%41 = load double, double* %40
%42 = load double, double* %32
%43 = fsub double %41, %42
%44 = fdiv double %43, 0x3F70101010101010
br label %45
45: ; preds = %30, %63
%46 = phi i64 [ 0, %30 ], [ %64, %63 ]
%47 = trunc i64 %46 to i32
switch i32 %47, label %50 [
i32 0, label %48
i32 255, label %49
]
48: ; preds = %45
store double %44, double* %31
br label %63
49: ; preds = %45
store double %38, double* %39
br label %63
50: ; preds = %45
%51 = add nsw i64 %46, -1
%52 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 %51
%53 = load double, double* %52
%54 = add nuw nsw i64 %46, 1
%55 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 %54
%56 = load double, double* %55
%57 = fadd double %53, %56
%58 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 %46
%59 = load double, double* %58
%60 = tail call double @llvm.fmuladd.f64(double %59, double -2.000000e+00, double %57)
%61 = fdiv double %60, 0x3F70101010101010
%62 = getelementptr inbounds [256 x double], [256 x double]* %3, i64 0, i64 %46
store double %61, double* %62
br label %63
63: ; preds = %48, %50, %49
%64 = add nuw nsw i64 %46, 1
%65 = icmp eq i64 %64, 256
br i1 %65, label %66, label %45
66: ; preds = %63
%67 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 0)
%68 = tail call i32* @fopen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%69 = getelementptr inbounds [256 x double], [256 x double]* %2, i64 0, i64 255
%70 = getelementptr inbounds [256 x double], [256 x double]* %4, i64 0, i64 255
%71 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 255
%72 = getelementptr inbounds [256 x double], [256 x double]* %3, i64 0, i64 255
%73 = getelementptr inbounds [256 x double], [256 x double]* %2, i64 0, i64 254
%74 = getelementptr inbounds [256 x double], [256 x double]* %4, i64 0, i64 254
%75 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 0
%76 = getelementptr inbounds [256 x double], [256 x double]* %3, i64 0, i64 0
br label %77
77: ; preds = %173, %66
%78 = phi double [ %42, %66 ], [ %174, %173 ]
%79 = phi i32 [ undef, %66 ], [ %170, %173 ]
%80 = phi double [ 0.000000e+00, %66 ], [ %171, %173 ]
%81 = load double, double* %31
%82 = insertelement <2 x double> poison, double %81, i64 1
%83 = insertelement <2 x double> poison, double %78, i64 1
br label %84
84: ; preds = %84, %77
%85 = phi i64 [ 0, %77 ], [ %123, %84 ]
%86 = phi <2 x double> [ %82, %77 ], [ %100, %84 ]
%87 = phi <2 x double> [ %83, %77 ], [ %91, %84 ]
%88 = or i64 %85, 1
%89 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 %88
%90 = bitcast double* %89 to <2 x double>*
%91 = load <2 x double>, <2 x double>* %90
%92 = shufflevector <2 x double> %87, <2 x double> %91, <2 x i32> <i32 1, i32 2>
%93 = fsub <2 x double> %91, %92
%94 = fmul <2 x double> %93, <double 2.000000e+00, double 2.000000e+00>
%95 = fdiv <2 x double> %94, <double 0x3F70101010101010, double 0x3F70101010101010>
%96 = fdiv <2 x double> %95, <double 0x3F70101010101010, double 0x3F70101010101010>
%97 = fdiv <2 x double> %96, <double 0x3F70101010101010, double 0x3F70101010101010>
%98 = getelementptr inbounds [256 x double], [256 x double]* %3, i64 0, i64 %88
%99 = bitcast double* %98 to <2 x double>*
%100 = load <2 x double>, <2 x double>* %99
%101 = shufflevector <2 x double> %86, <2 x double> %100, <2 x i32> <i32 1, i32 2>
%102 = fadd <2 x double> %100, %101
%103 = fdiv <2 x double> %102, <double 0x3F70101010101010, double 0x3F70101010101010>
%104 = fdiv <2 x double> %103, <double 0x3F70101010101010, double 0x3F70101010101010>
%105 = fsub <2 x double> %104, %97
%106 = fmul <2 x double> %93, <double 3.000000e+00, double 3.000000e+00>
%107 = fdiv <2 x double> %106, <double 0x3F70101010101010, double 0x3F70101010101010>
%108 = fdiv <2 x double> %107, <double 0x3F70101010101010, double 0x3F70101010101010>
%109 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %100)
%110 = fdiv <2 x double> %109, <double 0x3F70101010101010, double 0x3F70101010101010>
%111 = fsub <2 x double> %108, %110
%112 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %105, <2 x double> <double 0x3F6CE9B683501CEA, double 0x3F6CE9B683501CEA>, <2 x double> %111)
%113 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %112, <2 x double> <double 0x3F6CE9B683501CEA, double 0x3F6CE9B683501CEA>, <2 x double> %101)
%114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %113, <2 x double> <double 0x3F6CE9B683501CEA, double 0x3F6CE9B683501CEA>, <2 x double> %92)
%115 = getelementptr inbounds [256 x double], [256 x double]* %2, i64 0, i64 %85
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %114, <2 x double>* %116
%117 = fmul <2 x double> %105, <double 3.000000e+00, double 3.000000e+00>
%118 = fmul <2 x double> %111, <double 2.000000e+00, double 2.000000e+00>
%119 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %117, <2 x double> <double 0x3F6CE9B683501CEA, double 0x3F6CE9B683501CEA>, <2 x double> %118)
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> <double 0x3F6CE9B683501CEA, double 0x3F6CE9B683501CEA>, <2 x double> %101)
%121 = getelementptr inbounds [256 x double], [256 x double]* %4, i64 0, i64 %85
%122 = bitcast double* %121 to <2 x double>*
store <2 x double> %120, <2 x double>* %122
%123 = add nuw i64 %85, 2
%124 = icmp eq i64 %123, 254
br i1 %124, label %125, label %84
125: ; preds = %84
%126 = extractelement <2 x double> %100, i64 1
%127 = extractelement <2 x double> %91, i64 1
%128 = load double, double* %71
%129 = fsub double %128, %127
%130 = fmul double %129, 2.000000e+00
%131 = fdiv double %130, 0x3F70101010101010
%132 = fdiv double %131, 0x3F70101010101010
%133 = fdiv double %132, 0x3F70101010101010
%134 = load double, double* %72
%135 = fadd double %134, %126
%136 = fdiv double %135, 0x3F70101010101010
%137 = fdiv double %136, 0x3F70101010101010
%138 = fsub double %137, %133
%139 = fmul double %129, 3.000000e+00
%140 = fdiv double %139, 0x3F70101010101010
%141 = fdiv double %140, 0x3F70101010101010
%142 = tail call double @llvm.fmuladd.f64(double %126, double 2.000000e+00, double %134)
%143 = fdiv double %142, 0x3F70101010101010
%144 = fsub double %141, %143
%145 = tail call double @llvm.fmuladd.f64(double %138, double 0x3F6CE9B683501CEA, double %144)
%146 = tail call double @llvm.fmuladd.f64(double %145, double 0x3F6CE9B683501CEA, double %126)
%147 = tail call double @llvm.fmuladd.f64(double %146, double 0x3F6CE9B683501CEA, double %127)
store double %147, double* %73
%148 = fmul double %138, 3.000000e+00
%149 = fmul double %144, 2.000000e+00
%150 = tail call double @llvm.fmuladd.f64(double %148, double 0x3F6CE9B683501CEA, double %149)
%151 = tail call double @llvm.fmuladd.f64(double %150, double 0x3F6CE9B683501CEA, double %126)
store double %151, double* %74
%152 = load double, double* %6
store double %152, double* %69
%153 = load double, double* %5
store double %153, double* %70
store double %152, double* %75
store double %153, double* %76
%154 = tail call i32 @fprintf(i32* %68, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double 0.000000e+00, double %80, double %152)
br label %155
155: ; preds = %125, %155
%156 = phi i64 [ 1, %125 ], [ %167, %155 ]
%157 = getelementptr inbounds [256 x double], [256 x double]* %2, i64 0, i64 %156
%158 = load double, double* %157
%159 = getelementptr inbounds [256 x double], [256 x double]* %4, i64 0, i64 %156
%160 = load double, double* %159
%161 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 %156
store double %158, double* %161
%162 = getelementptr inbounds [256 x double], [256 x double]* %3, i64 0, i64 %156
store double %160, double* %162
%163 = trunc i64 %156 to i32
%164 = sitofp i32 %163 to double
%165 = tail call double @llvm.fmuladd.f64(double %164, double 0x3F70101010101010, double 0.000000e+00)
%166 = tail call i32 @fprintf(i32* %68, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double %165, double %80, double %158)
%167 = add nuw nsw i64 %156, 1
%168 = icmp eq i64 %167, 256
br i1 %168, label %169, label %155
169: ; preds = %155
%170 = add nsw i32 %79, 1
%171 = fadd double %80, 0x3F6CE9B683501CEA
%172 = fcmp olt double %171, 2.000000e+00
br i1 %172, label %173, label %175
173: ; preds = %169
%174 = load double, double* %32
br label %77
175: ; preds = %169
%176 = tail call i32 @fclose(i32* %68)
%177 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %170)
%178 = tail call i32* @fopen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %179
179: ; preds = %175, %179
%180 = phi i64 [ 0, %175 ], [ %187, %179 ]
%181 = trunc i64 %180 to i32
%182 = sitofp i32 %181 to double
%183 = tail call double @llvm.fmuladd.f64(double %182, double 0x3F70101010101010, double 0.000000e+00)
%184 = getelementptr inbounds [256 x double], [256 x double]* %1, i64 0, i64 %180
%185 = load double, double* %184
%186 = tail call i32 @fprintf(i32* %178, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), double %183, double %171, double %185)
%187 = add nuw nsw i64 %180, 1
%188 = icmp eq i64 %187, 256
br i1 %188, label %189, label %179
189: ; preds = %179
%190 = tail call i32 @fclose(i32* %178)
ret i32 0
}