#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 *, float const, float const, float const,
                          float const, float const, float const, float const,
                          float const, float const, float const, float const,
                          float const, float const, float const, float const,
                          float const);
void mlMatrixPrint(const float *a) {
  printf("[(%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, "
         "%f)]\n",
         a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10],
         a[11], a[12], a[13], a[14], a[15]);
}


x86 assembly (clang, -O0):
<mlMatrixPrint>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm3
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm4
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm5
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm6
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm7
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm15
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm14
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm13
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm12
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm11
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm10
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm9
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm8
lea    0xe46(%rip),%rdi
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 <printf@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mlMatrixPrint>:
sub    $0x48,%rsp
movss  (%rdi),%xmm0
movss  0x4(%rdi),%xmm1
movss  0x8(%rdi),%xmm2
movss  0xc(%rdi),%xmm3
movss  0x10(%rdi),%xmm4
movss  0x14(%rdi),%xmm5
movss  0x18(%rdi),%xmm6
movss  0x1c(%rdi),%xmm7
movss  0x20(%rdi),%xmm8
movss  0x24(%rdi),%xmm9
movss  0x28(%rdi),%xmm10
movss  0x2c(%rdi),%xmm11
movss  0x30(%rdi),%xmm12
movss  0x34(%rdi),%xmm13
movss  0x38(%rdi),%xmm14
movss  0x3c(%rdi),%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)
lea    0xe57(%rip),%rdi
call   1030 <printf@plt>
add    $0x48,%rsp
ret

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

LLVM IR (-O2):
@.str = [74 x i8] c"[(%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f)]\0A\00"
define void @mlMatrixPrint(float* nocapture %0) {
%2 = load float, float* %0
%3 = getelementptr inbounds float, float* %0, i64 1
%4 = load float, float* %3
%5 = getelementptr inbounds float, float* %0, i64 2
%6 = load float, float* %5
%7 = getelementptr inbounds float, float* %0, i64 3
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %0, i64 4
%10 = load float, float* %9
%11 = getelementptr inbounds float, float* %0, i64 5
%12 = load float, float* %11
%13 = getelementptr inbounds float, float* %0, i64 6
%14 = load float, float* %13
%15 = getelementptr inbounds float, float* %0, i64 7
%16 = load float, float* %15
%17 = getelementptr inbounds float, float* %0, i64 8
%18 = load float, float* %17
%19 = getelementptr inbounds float, float* %0, i64 9
%20 = load float, float* %19
%21 = getelementptr inbounds float, float* %0, i64 10
%22 = load float, float* %21
%23 = getelementptr inbounds float, float* %0, i64 11
%24 = load float, float* %23
%25 = getelementptr inbounds float, float* %0, i64 12
%26 = load float, float* %25
%27 = getelementptr inbounds float, float* %0, i64 13
%28 = load float, float* %27
%29 = getelementptr inbounds float, float* %0, i64 14
%30 = load float, float* %29
%31 = getelementptr inbounds float, float* %0, i64 15
%32 = load float, float* %31
%33 = tail call i32 @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str, i64 0, i64 0), float %2, float %4, float %6, float %8, float %10, float %12, float %14, float %16, float %18, float %20, float %22, float %24, float %26, float %28, float %30, float %32)
ret void
}