#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*/ printf(char *, int, float, int, float, int, float, int,
                          float, int, float, int, float, int, float, int, float,
                          int, float);
f(int i1, float f1, int i2, float f2, int i3, float f3, int i4, float f4,
  int i5, float f5, int i6, float f6, int i7, float f7, int i8, float f8,
  int i9, float f9) {
  printf("%d\n%.0f\n"
         "%d\n%.0f\n"
         "%d\n%.0f\n"
         "%d\n%.0f\n"
         "%d\n%.0f\n"
         "%d\n%.0f\n"
         "%d\n%.0f\n"
         "%d\n%.0f\n"
         "%d\n%.0f\n",
         i1, f1, i2, f2, i3, f3, i4, f4, i5, f5, i6, f6, i7, f7, i8, f8, i9,
         f9);
}


x86 assembly (clang, -O0):
<f>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x68,%rsp
movss  0x28(%rbp),%xmm8
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %esi,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
movss  %xmm2,-0x24(%rbp)
mov    %ecx,-0x28(%rbp)
movss  %xmm3,-0x2c(%rbp)
mov    %r8d,-0x30(%rbp)
movss  %xmm4,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
movss  %xmm5,-0x3c(%rbp)
movss  %xmm6,-0x40(%rbp)
movss  %xmm7,-0x44(%rbp)
mov    -0x10(%rbp),%esi
movss  -0x14(%rbp),%xmm0
mov    -0x18(%rbp),%edx
movss  -0x1c(%rbp),%xmm1
mov    -0x20(%rbp),%ecx
movss  -0x24(%rbp),%xmm2
mov    -0x28(%rbp),%r8d
movss  -0x2c(%rbp),%xmm3
mov    -0x30(%rbp),%r9d
movss  -0x34(%rbp),%xmm4
mov    -0x38(%rbp),%ebx
movss  -0x3c(%rbp),%xmm5
mov    0x10(%rbp),%r11d
movss  -0x40(%rbp),%xmm6
mov    0x18(%rbp),%r10d
movss  -0x44(%rbp),%xmm7
mov    0x20(%rbp),%eax
movss  0x28(%rbp),%xmm8
lea    0xe48(%rip),%rdi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
movss  %xmm8,0x20(%rsp)
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x68,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<f>:
sub    $0x28,%rsp
mov    %r8d,%eax
mov    %ecx,%r8d
mov    %edx,%ecx
mov    %esi,%edx
mov    %edi,%esi
mov    0x30(%rsp),%r10d
mov    0x38(%rsp),%r11d
mov    0x40(%rsp),%edi
movss  0x48(%rsp),%xmm8
movss  %xmm8,0x20(%rsp)
mov    %edi,0x18(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10d,0x8(%rsp)
mov    %r9d,(%rsp)
lea    0xeab(%rip),%rdi
mov    %eax,%r9d
call   1030 <printf@plt>
add    $0x28,%rsp
ret

LLVM IR (-O0):
@.str = [73 x i8] c"%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A\00"
define i32 @f(i32 %0, float %1, i32 %2, float %3, i32 %4, float %5, i32 %6, float %7, i32 %8, float %9, i32 %10, float %11, i32 %12, float %13, i32 %14, float %15, i32 %16, float %17) {
%19 = alloca i32
%20 = alloca i32
%21 = alloca float
%22 = alloca i32
%23 = alloca float
%24 = alloca i32
%25 = alloca float
%26 = alloca i32
%27 = alloca float
%28 = alloca i32
%29 = alloca float
%30 = alloca i32
%31 = alloca float
%32 = alloca i32
%33 = alloca float
%34 = alloca i32
%35 = alloca float
%36 = alloca i32
%37 = alloca float
store i32 %0, i32* %20
store float %1, float* %21
store i32 %2, i32* %22
store float %3, float* %23
store i32 %4, i32* %24
store float %5, float* %25
store i32 %6, i32* %26
store float %7, float* %27
store i32 %8, i32* %28
store float %9, float* %29
store i32 %10, i32* %30
store float %11, float* %31
store i32 %12, i32* %32
store float %13, float* %33
store i32 %14, i32* %34
store float %15, float* %35
store i32 %16, i32* %36
store float %17, float* %37
%38 = load i32, i32* %20
%39 = load float, float* %21
%40 = load i32, i32* %22
%41 = load float, float* %23
%42 = load i32, i32* %24
%43 = load float, float* %25
%44 = load i32, i32* %26
%45 = load float, float* %27
%46 = load i32, i32* %28
%47 = load float, float* %29
%48 = load i32, i32* %30
%49 = load float, float* %31
%50 = load i32, i32* %32
%51 = load float, float* %33
%52 = load i32, i32* %34
%53 = load float, float* %35
%54 = load i32, i32* %36
%55 = load float, float* %37
%56 = call i32 @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0), i32 %38, float %39, i32 %40, float %41, i32 %42, float %43, i32 %44, float %45, i32 %46, float %47, i32 %48, float %49, i32 %50, float %51, i32 %52, float %53, i32 %54, float %55)
%57 = load i32, i32* %19
ret i32 %57
}

LLVM IR (-O2):
@.str = [73 x i8] c"%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A%d\0A%.0f\0A\00"
define i32 @f(i32 %0, float %1, i32 %2, float %3, i32 %4, float %5, i32 %6, float %7, i32 %8, float %9, i32 %10, float %11, i32 %12, float %13, i32 %14, float %15, i32 %16, float %17) {
%19 = tail call i32 @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0), i32 %0, float %1, i32 %2, float %3, i32 %4, float %5, i32 %6, float %7, i32 %8, float %9, i32 %10, float %11, i32 %12, float %13, i32 %14, float %15, i32 %16, float %17)
ret i32 undef
}