#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*/ memcpy(float **, float **, int);
void mtrxTranspose(float (*matrix)[4][4]) {
  int q;
  float tmp[4][4];
  memcpy(tmp, *matrix, sizeof(float) * 16);
  for (q = 0; q != 4; q++) {
    (*matrix)[0][q] = tmp[q][0];
    (*matrix)[1][q] = tmp[q][1];
    (*matrix)[2][q] = tmp[q][2];
    (*matrix)[3][q] = tmp[q][3];
  }
}


x86 assembly (clang, -O0):
<mtrxTranspose>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x50(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
je     11d3 <mtrxTranspose+0xc3>
movslq -0xc(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0xc(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,0x10(%rax,%rcx,4)
movslq -0xc(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,0x20(%rax,%rcx,4)
movslq -0xc(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,0x30(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1135 <mtrxTranspose+0x25>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mtrxTranspose>:
push   %rbx
sub    $0x40,%rsp
mov    %rdi,%rbx
mov    %rsp,%rdi
mov    %rbx,%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
movss  (%rsp),%xmm0
movss  %xmm0,(%rbx)
movss  0x4(%rsp),%xmm0
movss  %xmm0,0x10(%rbx)
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x20(%rbx)
movss  0xc(%rsp),%xmm0
movss  %xmm0,0x30(%rbx)
movss  0x10(%rsp),%xmm0
movss  %xmm0,0x4(%rbx)
movss  0x14(%rsp),%xmm0
movss  %xmm0,0x14(%rbx)
movss  0x18(%rsp),%xmm0
movss  %xmm0,0x24(%rbx)
movss  0x1c(%rsp),%xmm0
movss  %xmm0,0x34(%rbx)
movss  0x20(%rsp),%xmm0
movss  %xmm0,0x8(%rbx)
movss  0x24(%rsp),%xmm0
movss  %xmm0,0x18(%rbx)
movss  0x28(%rsp),%xmm0
movss  %xmm0,0x28(%rbx)
movss  0x2c(%rsp),%xmm0
movss  %xmm0,0x38(%rbx)
movss  0x30(%rsp),%xmm0
movss  %xmm0,0xc(%rbx)
movss  0x34(%rsp),%xmm0
movss  %xmm0,0x1c(%rbx)
movss  0x38(%rsp),%xmm0
movss  %xmm0,0x2c(%rbx)
movss  0x3c(%rsp),%xmm0
movss  %xmm0,0x3c(%rbx)
add    $0x40,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @mtrxTranspose([4 x [4 x float]]* %0) {
%2 = alloca [4 x [4 x float]]*
%3 = alloca i32
%4 = alloca [4 x [4 x float]]
store [4 x [4 x float]]* %0, [4 x [4 x float]]** %2
%5 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %4, i64 0, i64 0
%6 = bitcast [4 x float]* %5 to float**
%7 = load [4 x [4 x float]]*, [4 x [4 x float]]** %2
%8 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0
%9 = bitcast [4 x float]* %8 to float**
%10 = call i32 @memcpy(float** %6, float** %9, i32 64)
store i32 0, i32* %3
br label %11
11: ; preds = %55, %1
%12 = load i32, i32* %3
%13 = icmp ne i32 %12, 4
br i1 %13, label %14, label %58
14: ; preds = %11
%15 = load i32, i32* %3
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %4, i64 0, i64 %16
%18 = getelementptr inbounds [4 x float], [4 x float]* %17, i64 0, i64 0
%19 = load float, float* %18
%20 = load [4 x [4 x float]]*, [4 x [4 x float]]** %2
%21 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %20, i64 0, i64 0
%22 = load i32, i32* %3
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 %23
store float %19, float* %24
%25 = load i32, i32* %3
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %4, i64 0, i64 %26
%28 = getelementptr inbounds [4 x float], [4 x float]* %27, i64 0, i64 1
%29 = load float, float* %28
%30 = load [4 x [4 x float]]*, [4 x [4 x float]]** %2
%31 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %30, i64 0, i64 1
%32 = load i32, i32* %3
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [4 x float], [4 x float]* %31, i64 0, i64 %33
store float %29, float* %34
%35 = load i32, i32* %3
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %4, i64 0, i64 %36
%38 = getelementptr inbounds [4 x float], [4 x float]* %37, i64 0, i64 2
%39 = load float, float* %38
%40 = load [4 x [4 x float]]*, [4 x [4 x float]]** %2
%41 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %40, i64 0, i64 2
%42 = load i32, i32* %3
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [4 x float], [4 x float]* %41, i64 0, i64 %43
store float %39, float* %44
%45 = load i32, i32* %3
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %4, i64 0, i64 %46
%48 = getelementptr inbounds [4 x float], [4 x float]* %47, i64 0, i64 3
%49 = load float, float* %48
%50 = load [4 x [4 x float]]*, [4 x [4 x float]]** %2
%51 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %50, i64 0, i64 3
%52 = load i32, i32* %3
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [4 x float], [4 x float]* %51, i64 0, i64 %53
store float %49, float* %54
br label %55
55: ; preds = %14
%56 = load i32, i32* %3
%57 = add nsw i32 %56, 1
store i32 %57, i32* %3
br label %11
58: ; preds = %11
ret void
}

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