#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 */
struct mat4 {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ mat4(float *, float, float, float, float, float, float,
                        float, float, float, float, float, float, float, float,
                        float, float);
__attribute__((always_)) struct mat4 *
psmat4(struct mat4 *result, float m11, float m12, float m13, float m14,
       float m21, float m22, float m23, float m24, float m31, float m32,
       float m33, float m34, float m41, float m42, float m43, float m44) {
  mat4((float *)result, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33,
       m34, m41, m42, m43, m44);
  return result;
}


x86 assembly (clang, -O0):
<psmat4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movss  0x48(%rbp),%xmm8
movss  0x40(%rbp),%xmm8
movss  0x38(%rbp),%xmm8
movss  0x30(%rbp),%xmm8
movss  0x28(%rbp),%xmm8
movss  0x20(%rbp),%xmm8
movss  0x18(%rbp),%xmm8
movss  0x10(%rbp),%xmm8
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  %xmm4,-0x1c(%rbp)
movss  %xmm5,-0x20(%rbp)
movss  %xmm6,-0x24(%rbp)
movss  %xmm7,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
movss  -0xc(%rbp),%xmm0
movss  -0x10(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x18(%rbp),%xmm3
movss  -0x1c(%rbp),%xmm4
movss  -0x20(%rbp),%xmm5
movss  -0x24(%rbp),%xmm6
movss  -0x28(%rbp),%xmm7
movss  0x10(%rbp),%xmm15
movss  0x18(%rbp),%xmm14
movss  0x20(%rbp),%xmm13
movss  0x28(%rbp),%xmm12
movss  0x30(%rbp),%xmm11
movss  0x38(%rbp),%xmm10
movss  0x40(%rbp),%xmm9
movss  0x48(%rbp),%xmm8
movss  %xmm15,(%rsp)
movss  %xmm14,0x8(%rsp)
movss  %xmm13,0x10(%rsp)
movss  %xmm12,0x18(%rsp)
movss  %xmm11,0x20(%rsp)
movss  %xmm10,0x28(%rsp)
movss  %xmm9,0x30(%rsp)
movss  %xmm8,0x38(%rsp)
call   1030 <mat4@plt>
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<psmat4>:
push   %rbx
sub    $0x40,%rsp
mov    %rdi,%rbx
movss  0x50(%rsp),%xmm8
movss  0x58(%rsp),%xmm9
movss  0x60(%rsp),%xmm10
movss  0x68(%rsp),%xmm11
movss  0x70(%rsp),%xmm12
movss  0x78(%rsp),%xmm13
movss  0x80(%rsp),%xmm14
movss  0x88(%rsp),%xmm15
movss  %xmm15,0x38(%rsp)
movss  %xmm14,0x30(%rsp)
movss  %xmm13,0x28(%rsp)
movss  %xmm12,0x20(%rsp)
movss  %xmm11,0x18(%rsp)
movss  %xmm10,0x10(%rsp)
movss  %xmm9,0x8(%rsp)
movss  %xmm8,(%rsp)
call   1030 <mat4@plt>
mov    %rbx,%rax
add    $0x40,%rsp
pop    %rbx
ret

LLVM IR (-O0):
%struct.mat4 = type { i32 }
define %struct.mat4* @psmat4(%struct.mat4* %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float %9, float %10, float %11, float %12, float %13, float %14, float %15, float %16) {
%18 = alloca %struct.mat4*
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
store %struct.mat4* %0, %struct.mat4** %18
store float %1, float* %19
store float %2, float* %20
store float %3, float* %21
store float %4, float* %22
store float %5, float* %23
store float %6, float* %24
store float %7, float* %25
store float %8, float* %26
store float %9, float* %27
store float %10, float* %28
store float %11, float* %29
store float %12, float* %30
store float %13, float* %31
store float %14, float* %32
store float %15, float* %33
store float %16, float* %34
%35 = load %struct.mat4*, %struct.mat4** %18
%36 = bitcast %struct.mat4* %35 to float*
%37 = load float, float* %19
%38 = load float, float* %20
%39 = load float, float* %21
%40 = load float, float* %22
%41 = load float, float* %23
%42 = load float, float* %24
%43 = load float, float* %25
%44 = load float, float* %26
%45 = load float, float* %27
%46 = load float, float* %28
%47 = load float, float* %29
%48 = load float, float* %30
%49 = load float, float* %31
%50 = load float, float* %32
%51 = load float, float* %33
%52 = load float, float* %34
%53 = call i32 @mat4(float* %36, float %37, float %38, float %39, float %40, float %41, float %42, float %43, float %44, float %45, float %46, float %47, float %48, float %49, float %50, float %51, float %52)
%54 = load %struct.mat4*, %struct.mat4** %18
ret %struct.mat4* %54
}

LLVM IR (-O2):
%struct.mat4 = type { i32 }
define %struct.mat4* @psmat4(%struct.mat4* returned %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float %9, float %10, float %11, float %12, float %13, float %14, float %15, float %16) {
%18 = bitcast %struct.mat4* %0 to float*
%19 = tail call i32 @mat4(float* %18, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float %9, float %10, float %11, float %12, float %13, float %14, float %15, float %16)
ret %struct.mat4* %0
}