#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 */
int /*<<< orphan*/ i_d(double volatile);
int /*<<< orphan*/ i_dd(double volatile, double volatile);
int /*<<< orphan*/ i_df(double volatile, float volatile);
int /*<<< orphan*/ i_f(float volatile);
int /*<<< orphan*/ i_fd(float volatile, double volatile);
int /*<<< orphan*/ i_ff(float volatile, float volatile);
int /*<<< orphan*/ v_d(double volatile);
int /*<<< orphan*/ v_dd(double volatile, double volatile);
int /*<<< orphan*/ v_df(double volatile, float volatile);
int /*<<< orphan*/ v_f(float volatile);
int /*<<< orphan*/ v_fd(float volatile, double volatile);
int /*<<< orphan*/ v_ff(float volatile, float volatile);
int main(void) {
  volatile float x = 1.3;
  volatile double y = 2.5;
  volatile float z = 3.5;
  volatile double a = 4.5;
  v_f(x);
  v_f(z);
  v_d(y);
  v_d(a);
  v_ff(x, z);
  v_fd(x, y);
  v_df(a, x);
  v_dd(y, a);
  i_f(x);
  i_f(z);
  i_d(y);
  i_d(a);
  i_ff(x, z);
  i_fd(x, y);
  i_df(a, x);
  i_dd(y, a);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movss  0xe44(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
movsd  0xe2b(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
movss  0xe26(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
movsd  0xe09(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movss  -0x4(%rbp),%xmm0
call   10c0 <v_f@plt>
movss  -0x14(%rbp),%xmm0
call   10c0 <v_f@plt>
movsd  -0x10(%rbp),%xmm0
call   10b0 <v_d@plt>
movsd  -0x20(%rbp),%xmm0
call   10b0 <v_d@plt>
movss  -0x4(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
call   1040 <v_ff@plt>
movss  -0x4(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
call   1030 <v_fd@plt>
movsd  -0x20(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
call   1060 <v_df@plt>
movsd  -0x10(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
call   1050 <v_dd@plt>
movss  -0x4(%rbp),%xmm0
call   10a0 <i_f@plt>
movss  -0x14(%rbp),%xmm0
call   10a0 <i_f@plt>
movsd  -0x10(%rbp),%xmm0
call   1090 <i_d@plt>
movsd  -0x20(%rbp),%xmm0
call   1090 <i_d@plt>
movss  -0x4(%rbp),%xmm0
movss  -0x14(%rbp),%xmm1
call   1070 <i_ff@plt>
movss  -0x4(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
call   1080 <i_fd@plt>
movsd  -0x20(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
call   10d0 <i_df@plt>
movsd  -0x10(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
call   10e0 <i_dd@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x18,%rsp
movl   $0x3fa66666,(%rsp)
movabs $0x4004000000000000,%rax
mov    %rax,0x10(%rsp)
movl   $0x40600000,0x4(%rsp)
40
movabs $0x4012000000000000,%rax
mov    %rax,0x8(%rsp)
movss  (%rsp),%xmm0
call   10c0 <v_f@plt>
movss  0x4(%rsp),%xmm0
call   10c0 <v_f@plt>
movsd  0x10(%rsp),%xmm0
call   10b0 <v_d@plt>
movsd  0x8(%rsp),%xmm0
call   10b0 <v_d@plt>
movss  (%rsp),%xmm0
movss  0x4(%rsp),%xmm1
call   1040 <v_ff@plt>
movss  (%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1030 <v_fd@plt>
movsd  0x8(%rsp),%xmm0
movss  (%rsp),%xmm1
call   1060 <v_df@plt>
movsd  0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
call   1050 <v_dd@plt>
movss  (%rsp),%xmm0
call   10a0 <i_f@plt>
movss  0x4(%rsp),%xmm0
call   10a0 <i_f@plt>
movsd  0x10(%rsp),%xmm0
call   1090 <i_d@plt>
movsd  0x8(%rsp),%xmm0
call   1090 <i_d@plt>
movss  (%rsp),%xmm0
movss  0x4(%rsp),%xmm1
call   1070 <i_ff@plt>
movss  (%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1080 <i_fd@plt>
movsd  0x8(%rsp),%xmm0
movss  (%rsp),%xmm1
call   10d0 <i_df@plt>
movsd  0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
call   10e0 <i_dd@plt>
xor    %eax,%eax
add    $0x18,%rsp
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca float
%2 = alloca double
%3 = alloca float
%4 = alloca double
store volatile float 0x3FF4CCCCC0000000, float* %1
store volatile double 2.500000e+00, double* %2
store volatile float 3.500000e+00, float* %3
store volatile double 4.500000e+00, double* %4
%5 = load volatile float, float* %1
%6 = call i32 @v_f(float %5)
%7 = load volatile float, float* %3
%8 = call i32 @v_f(float %7)
%9 = load volatile double, double* %2
%10 = call i32 @v_d(double %9)
%11 = load volatile double, double* %4
%12 = call i32 @v_d(double %11)
%13 = load volatile float, float* %1
%14 = load volatile float, float* %3
%15 = call i32 @v_ff(float %13, float %14)
%16 = load volatile float, float* %1
%17 = load volatile double, double* %2
%18 = call i32 @v_fd(float %16, double %17)
%19 = load volatile double, double* %4
%20 = load volatile float, float* %1
%21 = call i32 @v_df(double %19, float %20)
%22 = load volatile double, double* %2
%23 = load volatile double, double* %4
%24 = call i32 @v_dd(double %22, double %23)
%25 = load volatile float, float* %1
%26 = call i32 @i_f(float %25)
%27 = load volatile float, float* %3
%28 = call i32 @i_f(float %27)
%29 = load volatile double, double* %2
%30 = call i32 @i_d(double %29)
%31 = load volatile double, double* %4
%32 = call i32 @i_d(double %31)
%33 = load volatile float, float* %1
%34 = load volatile float, float* %3
%35 = call i32 @i_ff(float %33, float %34)
%36 = load volatile float, float* %1
%37 = load volatile double, double* %2
%38 = call i32 @i_fd(float %36, double %37)
%39 = load volatile double, double* %4
%40 = load volatile float, float* %1
%41 = call i32 @i_df(double %39, float %40)
%42 = load volatile double, double* %2
%43 = load volatile double, double* %4
%44 = call i32 @i_dd(double %42, double %43)
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
%1 = alloca float
%2 = alloca double
%3 = alloca float
%4 = alloca double
%5 = bitcast float* %1 to i8*
store volatile float 0x3FF4CCCCC0000000, float* %1
%6 = bitcast double* %2 to i8*
store volatile double 2.500000e+00, double* %2
%7 = bitcast float* %3 to i8*
store volatile float 3.500000e+00, float* %3
%8 = bitcast double* %4 to i8*
store volatile double 4.500000e+00, double* %4
%9 = load volatile float, float* %1
%10 = tail call i32 @v_f(float %9)
%11 = load volatile float, float* %3
%12 = tail call i32 @v_f(float %11)
%13 = load volatile double, double* %2
%14 = tail call i32 @v_d(double %13)
%15 = load volatile double, double* %4
%16 = tail call i32 @v_d(double %15)
%17 = load volatile float, float* %1
%18 = load volatile float, float* %3
%19 = tail call i32 @v_ff(float %17, float %18)
%20 = load volatile float, float* %1
%21 = load volatile double, double* %2
%22 = tail call i32 @v_fd(float %20, double %21)
%23 = load volatile double, double* %4
%24 = load volatile float, float* %1
%25 = tail call i32 @v_df(double %23, float %24)
%26 = load volatile double, double* %2
%27 = load volatile double, double* %4
%28 = tail call i32 @v_dd(double %26, double %27)
%29 = load volatile float, float* %1
%30 = tail call i32 @i_f(float %29)
%31 = load volatile float, float* %3
%32 = tail call i32 @i_f(float %31)
%33 = load volatile double, double* %2
%34 = tail call i32 @i_d(double %33)
%35 = load volatile double, double* %4
%36 = tail call i32 @i_d(double %35)
%37 = load volatile float, float* %1
%38 = load volatile float, float* %3
%39 = tail call i32 @i_ff(float %37, float %38)
%40 = load volatile float, float* %1
%41 = load volatile double, double* %2
%42 = tail call i32 @i_fd(float %40, double %41)
%43 = load volatile double, double* %4
%44 = load volatile float, float* %1
%45 = tail call i32 @i_df(double %43, float %44)
%46 = load volatile double, double* %2
%47 = load volatile double, double* %4
%48 = tail call i32 @i_dd(double %46, double %47)
ret i32 0
}