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

/* Variables and functions */
long double f(long double, long double);
long double abm4(long double x, long double y[], double h) {
  long double f0, f1, f2, f3, f4;
  long double yp;
  f0 = f(x - 3.0 * h, y[0]);
  f1 = f(x - 2.0 * h, y[1]);
  f2 = f(x - 1.0 * h, y[2]);
  f3 = f(x, y[3]);
  yp = y[3] + (h / 24.0) * (55.0 * f3 - 59.0 * f2 + 37.0 * f1 - 9.0 * f0);
  f4 = f(x + h, yp);
  yp = y[3] + (h / 24.0) * (9.0 * f4 + 19.0 * f3 - 5.0 * f2 + f1);
  f4 = f(x + h, yp);
  yp = y[3] + (h / 24.0) * (9.0 * f4 + 19.0 * f3 - 5.0 * f2 + f1);
  return yp;
}


x86 assembly (clang, -O0):
<abm4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
fldt   0x10(%rbp)
fstpt  -0x10(%rbp)
mov    %rdi,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
fldt   -0x10(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xec6(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
fldl   -0x88(%rbp)
faddp  %st,%st(1)
mov    -0x18(%rbp),%rax
fldt   (%rax)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <f@plt>
fstpt  -0x30(%rbp)
fldt   -0x10(%rbp)
movsd  -0x20(%rbp),%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
fldl   -0x90(%rbp)
fsubrp %st,%st(1)
mov    -0x18(%rbp),%rax
fldt   0x10(%rax)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <f@plt>
fstpt  -0x40(%rbp)
fldt   -0x10(%rbp)
fldl   -0x20(%rbp)
fsubrp %st,%st(1)
mov    -0x18(%rbp),%rax
fldt   0x20(%rax)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <f@plt>
fstpt  -0x50(%rbp)
fldt   -0x10(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x30(%rax)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <f@plt>
fstpt  -0x60(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x30(%rax)
movsd  -0x20(%rbp),%xmm0
movsd  0xe24(%rip),%xmm1
movsd  %xmm1,-0xd8(%rbp)
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
fldl   -0x98(%rbp)
fldt   -0x60(%rbp)
fldt   -0x50(%rbp)
flds   0xe06(%rip)
fmulp  %st,%st(1)
flds   0xe02(%rip)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fldt   -0x40(%rbp)
flds   0xdf9(%rip)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldt   -0x30(%rbp)
flds   0xdf0(%rip)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x80(%rbp)
fldt   -0x10(%rbp)
fldl   -0x20(%rbp)
faddp  %st,%st(1)
fldt   -0x80(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <f@plt>
movsd  -0xd8(%rbp),%xmm1
ff
fstpt  -0x70(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x30(%rax)
movsd  -0x20(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
fldl   -0xa0(%rbp)
fldt   -0x70(%rbp)
fldt   -0x60(%rbp)
flds   0xd9c(%rip)
fld    %st(0)
fstpt  -0xcc(%rbp)
fmulp  %st,%st(1)
flds   0xd90(%rip)
fld    %st(0)
fstpt  -0xc0(%rbp)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fldt   -0x50(%rbp)
flds   0xd7f(%rip)
fld    %st(0)
fstpt  -0xb4(%rbp)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldt   -0x40(%rbp)
faddp  %st,%st(1)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x80(%rbp)
fldt   -0x10(%rbp)
fldl   -0x20(%rbp)
faddp  %st,%st(1)
fldt   -0x80(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <f@plt>
movsd  -0xd8(%rbp),%xmm1
ff
fldt   -0xcc(%rbp)
fldt   -0xc0(%rbp)
fldt   -0xb4(%rbp)
fxch   %st(3)
fstpt  -0x70(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x30(%rax)
movsd  -0x20(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
fldl   -0xa8(%rbp)
fldt   -0x70(%rbp)
fldt   -0x60(%rbp)
fmulp  %st,%st(5)
fmulp  %st,%st(3)
fxch   %st(2)
faddp  %st,%st(3)
fldt   -0x50(%rbp)
fmulp  %st,%st(4)
fxch   %st(3)
faddp  %st,%st(2)
fldt   -0x40(%rbp)
faddp  %st,%st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x80(%rbp)
fldt   -0x80(%rbp)
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<abm4>:
push   %rbx
sub    $0xa0,%rsp
movsd  %xmm0,0x28(%rsp)
mov    %rdi,%rbx
fldt   0xb0(%rsp)
fld    %st(0)
fstpt  0x34(%rsp)
movsd  0xeca(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x80(%rsp)
faddl  0x80(%rsp)
fldt   (%rdi)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   1030 <f@plt>
fstpt  0x58(%rsp)
movsd  0x28(%rsp),%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
fldt   0x34(%rsp)
fsubl  0x78(%rsp)
fldt   0x10(%rbx)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   1030 <f@plt>
fstpt  0x64(%rsp)
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x88(%rsp)
fldl   0x88(%rsp)
fld    %st(0)
fstpt  0x4c(%rsp)
fldt   0x34(%rsp)
fsubp  %st,%st(1)
fldt   0x20(%rbx)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   1030 <f@plt>
fstpt  0x40(%rsp)
fldt   0x30(%rbx)
fstpt  0x10(%rsp)
fldt   0x34(%rsp)
fstpt  (%rsp)
call   1030 <f@plt>
fld    %st(0)
fxch   %st(1)
fstpt  0x94(%rsp)
fldt   0x40(%rsp)
fmuls  0xe2c(%rip)
fxch   %st(1)
fmuls  0xe28(%rip)
faddp  %st,%st(1)
fldt   0x64(%rsp)
fmuls  0xe20(%rip)
faddp  %st,%st(1)
fldt   0x30(%rbx)
movsd  0x28(%rsp),%xmm0
divsd  0xdfd(%rip),%xmm0
movsd  %xmm0,0x70(%rsp)
fldt   0x58(%rsp)
fmuls  0xe01(%rip)
faddp  %st,%st(2)
fldl   0x70(%rsp)
fld    %st(0)
fstpt  0x28(%rsp)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fldt   0x34(%rsp)
fldt   0x4c(%rsp)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x34(%rsp)
fstpt  (%rsp)
fstpt  0x10(%rsp)
call   1030 <f@plt>
fldt   0x30(%rbx)
fldt   0x94(%rsp)
fmuls  0xdc9(%rip)
fld    %st(0)
fstpt  0x58(%rsp)
flds   0xdc1(%rip)
fld    %st(0)
fstpt  0x4c(%rsp)
fmulp  %st,%st(3)
faddp  %st,%st(2)
fldt   0x40(%rsp)
fmuls  0xdb1(%rip)
fld    %st(0)
fstpt  0x40(%rsp)
faddp  %st,%st(2)
fldt   0x64(%rsp)
faddp  %st,%st(2)
fldt   0x28(%rsp)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fldt   0x34(%rsp)
fstpt  (%rsp)
fstpt  0x10(%rsp)
call   1030 <f@plt>
fldt   0x30(%rbx)
fldt   0x4c(%rsp)
fmulp  %st,%st(2)
fldt   0x58(%rsp)
faddp  %st,%st(2)
fldt   0x40(%rsp)
faddp  %st,%st(2)
fldt   0x64(%rsp)
faddp  %st,%st(2)
fldt   0x28(%rsp)
fmulp  %st,%st(2)
faddp  %st,%st(1)
add    $0xa0,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define x86_fp80 @abm4(x86_fp80 %0, x86_fp80* %1, double %2) {
%4 = alloca x86_fp80
%5 = alloca x86_fp80*
%6 = alloca double
%7 = alloca x86_fp80
%8 = alloca x86_fp80
%9 = alloca x86_fp80
%10 = alloca x86_fp80
%11 = alloca x86_fp80
%12 = alloca x86_fp80
store x86_fp80 %0, x86_fp80* %4
store x86_fp80* %1, x86_fp80** %5
store double %2, double* %6
%13 = load x86_fp80, x86_fp80* %4
%14 = load double, double* %6
%15 = fmul double 3.000000e+00, %14
%16 = fpext double %15 to x86_fp80
%17 = fsub x86_fp80 %13, %16
%18 = load x86_fp80*, x86_fp80** %5
%19 = getelementptr inbounds x86_fp80, x86_fp80* %18, i64 0
%20 = load x86_fp80, x86_fp80* %19
%21 = call x86_fp80 @f(x86_fp80 %17, x86_fp80 %20)
store x86_fp80 %21, x86_fp80* %7
%22 = load x86_fp80, x86_fp80* %4
%23 = load double, double* %6
%24 = fmul double 2.000000e+00, %23
%25 = fpext double %24 to x86_fp80
%26 = fsub x86_fp80 %22, %25
%27 = load x86_fp80*, x86_fp80** %5
%28 = getelementptr inbounds x86_fp80, x86_fp80* %27, i64 1
%29 = load x86_fp80, x86_fp80* %28
%30 = call x86_fp80 @f(x86_fp80 %26, x86_fp80 %29)
store x86_fp80 %30, x86_fp80* %8
%31 = load x86_fp80, x86_fp80* %4
%32 = load double, double* %6
%33 = fmul double 1.000000e+00, %32
%34 = fpext double %33 to x86_fp80
%35 = fsub x86_fp80 %31, %34
%36 = load x86_fp80*, x86_fp80** %5
%37 = getelementptr inbounds x86_fp80, x86_fp80* %36, i64 2
%38 = load x86_fp80, x86_fp80* %37
%39 = call x86_fp80 @f(x86_fp80 %35, x86_fp80 %38)
store x86_fp80 %39, x86_fp80* %9
%40 = load x86_fp80, x86_fp80* %4
%41 = load x86_fp80*, x86_fp80** %5
%42 = getelementptr inbounds x86_fp80, x86_fp80* %41, i64 3
%43 = load x86_fp80, x86_fp80* %42
%44 = call x86_fp80 @f(x86_fp80 %40, x86_fp80 %43)
store x86_fp80 %44, x86_fp80* %10
%45 = load x86_fp80*, x86_fp80** %5
%46 = getelementptr inbounds x86_fp80, x86_fp80* %45, i64 3
%47 = load x86_fp80, x86_fp80* %46
%48 = load double, double* %6
%49 = fdiv double %48, 2.400000e+01
%50 = fpext double %49 to x86_fp80
%51 = load x86_fp80, x86_fp80* %10
%52 = load x86_fp80, x86_fp80* %9
%53 = fmul x86_fp80 0xK4004EC00000000000000, %52
%54 = fneg x86_fp80 %53
%55 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xK4004DC00000000000000, x86_fp80 %51, x86_fp80 %54)
%56 = load x86_fp80, x86_fp80* %8
%57 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xK40049400000000000000, x86_fp80 %56, x86_fp80 %55)
%58 = load x86_fp80, x86_fp80* %7
%59 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xKC0029000000000000000, x86_fp80 %58, x86_fp80 %57)
%60 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %50, x86_fp80 %59, x86_fp80 %47)
store x86_fp80 %60, x86_fp80* %12
%61 = load x86_fp80, x86_fp80* %4
%62 = load double, double* %6
%63 = fpext double %62 to x86_fp80
%64 = fadd x86_fp80 %61, %63
%65 = load x86_fp80, x86_fp80* %12
%66 = call x86_fp80 @f(x86_fp80 %64, x86_fp80 %65)
store x86_fp80 %66, x86_fp80* %11
%67 = load x86_fp80*, x86_fp80** %5
%68 = getelementptr inbounds x86_fp80, x86_fp80* %67, i64 3
%69 = load x86_fp80, x86_fp80* %68
%70 = load double, double* %6
%71 = fdiv double %70, 2.400000e+01
%72 = fpext double %71 to x86_fp80
%73 = load x86_fp80, x86_fp80* %11
%74 = load x86_fp80, x86_fp80* %10
%75 = fmul x86_fp80 0xK40039800000000000000, %74
%76 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xK40029000000000000000, x86_fp80 %73, x86_fp80 %75)
%77 = load x86_fp80, x86_fp80* %9
%78 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xKC001A000000000000000, x86_fp80 %77, x86_fp80 %76)
%79 = load x86_fp80, x86_fp80* %8
%80 = fadd x86_fp80 %78, %79
%81 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %72, x86_fp80 %80, x86_fp80 %69)
store x86_fp80 %81, x86_fp80* %12
%82 = load x86_fp80, x86_fp80* %4
%83 = load double, double* %6
%84 = fpext double %83 to x86_fp80
%85 = fadd x86_fp80 %82, %84
%86 = load x86_fp80, x86_fp80* %12
%87 = call x86_fp80 @f(x86_fp80 %85, x86_fp80 %86)
store x86_fp80 %87, x86_fp80* %11
%88 = load x86_fp80*, x86_fp80** %5
%89 = getelementptr inbounds x86_fp80, x86_fp80* %88, i64 3
%90 = load x86_fp80, x86_fp80* %89
%91 = load double, double* %6
%92 = fdiv double %91, 2.400000e+01
%93 = fpext double %92 to x86_fp80
%94 = load x86_fp80, x86_fp80* %11
%95 = load x86_fp80, x86_fp80* %10
%96 = fmul x86_fp80 0xK40039800000000000000, %95
%97 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xK40029000000000000000, x86_fp80 %94, x86_fp80 %96)
%98 = load x86_fp80, x86_fp80* %9
%99 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 0xKC001A000000000000000, x86_fp80 %98, x86_fp80 %97)
%100 = load x86_fp80, x86_fp80* %8
%101 = fadd x86_fp80 %99, %100
%102 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %93, x86_fp80 %101, x86_fp80 %90)
store x86_fp80 %102, x86_fp80* %12
%103 = load x86_fp80, x86_fp80* %12
ret x86_fp80 %103
}

LLVM IR (-O2):
define x86_fp80 @abm4(x86_fp80 %0, x86_fp80* nocapture %1, double %2) {
%4 = fmul double %2, 3.000000e+00
%5 = fpext double %4 to x86_fp80
%6 = fsub x86_fp80 %0, %5
%7 = load x86_fp80, x86_fp80* %1
%8 = tail call x86_fp80 @f(x86_fp80 %6, x86_fp80 %7)
%9 = fmul double %2, 2.000000e+00
%10 = fpext double %9 to x86_fp80
%11 = fsub x86_fp80 %0, %10
%12 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 1
%13 = load x86_fp80, x86_fp80* %12
%14 = tail call x86_fp80 @f(x86_fp80 %11, x86_fp80 %13)
%15 = fpext double %2 to x86_fp80
%16 = fsub x86_fp80 %0, %15
%17 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 2
%18 = load x86_fp80, x86_fp80* %17
%19 = tail call x86_fp80 @f(x86_fp80 %16, x86_fp80 %18)
%20 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 3
%21 = load x86_fp80, x86_fp80* %20
%22 = tail call x86_fp80 @f(x86_fp80 %0, x86_fp80 %21)
%23 = load x86_fp80, x86_fp80* %20
%24 = fdiv double %2, 2.400000e+01
%25 = fpext double %24 to x86_fp80
%26 = fmul x86_fp80 %19, 0xKC004EC00000000000000
%27 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %22, x86_fp80 0xK4004DC00000000000000, x86_fp80 %26)
%28 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %14, x86_fp80 0xK40049400000000000000, x86_fp80 %27)
%29 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %8, x86_fp80 0xKC0029000000000000000, x86_fp80 %28)
%30 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %25, x86_fp80 %29, x86_fp80 %23)
%31 = fadd x86_fp80 %15, %0
%32 = tail call x86_fp80 @f(x86_fp80 %31, x86_fp80 %30)
%33 = load x86_fp80, x86_fp80* %20
%34 = fmul x86_fp80 %22, 0xK40039800000000000000
%35 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %32, x86_fp80 0xK40029000000000000000, x86_fp80 %34)
%36 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %19, x86_fp80 0xKC001A000000000000000, x86_fp80 %35)
%37 = fadd x86_fp80 %14, %36
%38 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %25, x86_fp80 %37, x86_fp80 %33)
%39 = tail call x86_fp80 @f(x86_fp80 %31, x86_fp80 %38)
%40 = load x86_fp80, x86_fp80* %20
%41 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %39, x86_fp80 0xK40029000000000000000, x86_fp80 %34)
%42 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %19, x86_fp80 0xKC001A000000000000000, x86_fp80 %41)
%43 = fadd x86_fp80 %14, %42
%44 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %25, x86_fp80 %43, x86_fp80 %40)
ret x86_fp80 %44
}