#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*/ givensRotation_float(float *, float, float);
void matrixToHessenbergForm_Givens_float(float *A) {
  float givensValues[2] = {0.0, 0.0};
  int i;
  float tau_one = 0.0;
  float tau_two = 0.0;
  givensRotation_float(givensValues, A[3], A[6]);
  for (i = 0; i < 3; i++) {
    tau_one = A[3 + i];
    tau_two = A[6 + i];
    A[3 + i] = tau_one * givensValues[0] - tau_two * givensValues[1];
    A[6 + i] = tau_one * givensValues[1] + tau_two * givensValues[0];
  }
  for (i = 0; i < 9; i += 3) {
    tau_one = A[i + 1];
    tau_two = A[i + 2];
    A[i + 1] = tau_one * givensValues[0] - tau_two * givensValues[1];
    A[i + 2] = tau_one * givensValues[1] + tau_two * givensValues[0];
  }
}


x86 assembly (clang, -O0):
<matrixToHessenbergForm_Givens_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x10(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
lea    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
call   1040 <givensRotation_float@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    121d <matrixToHessenbergForm_Givens_float+0xfd>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0xc(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x10(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    116e <matrixToHessenbergForm_Givens_float+0x4e>
movl   $0x0,-0x14(%rbp)
cmpl   $0x9,-0x14(%rbp)
jge    12d3 <matrixToHessenbergForm_Givens_float+0x1b3>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0xc(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x10(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x14(%rbp)
jmp    1224 <matrixToHessenbergForm_Givens_float+0x104>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrixToHessenbergForm_Givens_float>:
push   %rbx
sub    $0x10,%rsp
mov    %rdi,%rbx
movq   $0x0,0x8(%rsp)
movss  0xc(%rdi),%xmm0
movss  0x18(%rdi),%xmm1
lea    0x8(%rsp),%rdi
call   1030 <givensRotation_float@plt>
movsd  0x8(%rsp),%xmm3
movaps %xmm3,%xmm9
shufps $0x4,%xmm3,%xmm9
movaps %xmm3,%xmm7
shufps $0x55,%xmm3,%xmm7
movss  0x10(%rbx),%xmm11
movss  0x1c(%rbx),%xmm5
movaps %xmm7,%xmm6
mulss  %xmm5,%xmm6
movaps %xmm11,%xmm12
mulss  %xmm3,%xmm12
subss  %xmm6,%xmm12
mulss  %xmm3,%xmm5
mulss  %xmm7,%xmm11
addss  %xmm5,%xmm11
movss  0x14(%rbx),%xmm5
movss  0x20(%rbx),%xmm6
movaps %xmm7,%xmm0
mulss  %xmm6,%xmm0
mulss  %xmm5,%xmm7
mulss  %xmm3,%xmm5
subss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
addss  %xmm6,%xmm7
movaps 0xe5b(%rip),%xmm1
movss  0x4(%rbx),%xmm6
movss  0x8(%rbx),%xmm4
movss  0xc(%rbx),%xmm8
movss  0x18(%rbx),%xmm10
movaps %xmm10,%xmm2
unpcklps %xmm5,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm3,%xmm0
movss  %xmm4,%xmm0
xorps  %xmm1,%xmm4
movlhps %xmm3,%xmm4
shufps $0x48,%xmm2,%xmm4
shufps $0x51,%xmm0,%xmm0
mulps  %xmm4,%xmm0
movaps %xmm8,%xmm2
unpcklps %xmm12,%xmm2
shufps $0x40,%xmm2,%xmm6
mulps  %xmm9,%xmm6
addps  %xmm0,%xmm6
movups %xmm6,0x4(%rbx)
xorps  %xmm7,%xmm1
unpcklps %xmm7,%xmm1
unpcklps %xmm10,%xmm5
movlhps %xmm1,%xmm5
movaps %xmm3,%xmm0
shufps $0x10,%xmm3,%xmm0
mulps  %xmm5,%xmm0
unpcklps %xmm8,%xmm12
shufps $0x4,%xmm11,%xmm12
shufps $0x45,%xmm3,%xmm3
mulps  %xmm12,%xmm3
addps  %xmm0,%xmm3
movups %xmm3,0x14(%rbx)
add    $0x10,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @matrixToHessenbergForm_Givens_float(float* %0) {
%2 = alloca float*
%3 = alloca [2 x float]
%4 = alloca i32
%5 = alloca float
%6 = alloca float
store float* %0, float** %2
%7 = bitcast [2 x float]* %3 to i8*
store float 0.000000e+00, float* %5
store float 0.000000e+00, float* %6
%8 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%9 = load float*, float** %2
%10 = getelementptr inbounds float, float* %9, i64 3
%11 = load float, float* %10
%12 = load float*, float** %2
%13 = getelementptr inbounds float, float* %12, i64 6
%14 = load float, float* %13
%15 = call i32 @givensRotation_float(float* %8, float %11, float %14)
store i32 0, i32* %4
br label %16
16: ; preds = %59, %1
%17 = load i32, i32* %4
%18 = icmp slt i32 %17, 3
br i1 %18, label %19, label %62
19: ; preds = %16
%20 = load float*, float** %2
%21 = load i32, i32* %4
%22 = add nsw i32 3, %21
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %20, i64 %23
%25 = load float, float* %24
store float %25, float* %5
%26 = load float*, float** %2
%27 = load i32, i32* %4
%28 = add nsw i32 6, %27
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float, float* %26, i64 %29
%31 = load float, float* %30
store float %31, float* %6
%32 = load float, float* %5
%33 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%34 = load float, float* %33
%35 = load float, float* %6
%36 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%37 = load float, float* %36
%38 = fmul float %35, %37
%39 = fneg float %38
%40 = call float @llvm.fmuladd.f32(float %32, float %34, float %39)
%41 = load float*, float** %2
%42 = load i32, i32* %4
%43 = add nsw i32 3, %42
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %41, i64 %44
store float %40, float* %45
%46 = load float, float* %5
%47 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%48 = load float, float* %47
%49 = load float, float* %6
%50 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%51 = load float, float* %50
%52 = fmul float %49, %51
%53 = call float @llvm.fmuladd.f32(float %46, float %48, float %52)
%54 = load float*, float** %2
%55 = load i32, i32* %4
%56 = add nsw i32 6, %55
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %54, i64 %57
store float %53, float* %58
br label %59
59: ; preds = %19
%60 = load i32, i32* %4
%61 = add nsw i32 %60, 1
store i32 %61, i32* %4
br label %16
62: ; preds = %16
store i32 0, i32* %4
br label %63
63: ; preds = %106, %62
%64 = load i32, i32* %4
%65 = icmp slt i32 %64, 9
br i1 %65, label %66, label %109
66: ; preds = %63
%67 = load float*, float** %2
%68 = load i32, i32* %4
%69 = add nsw i32 %68, 1
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %67, i64 %70
%72 = load float, float* %71
store float %72, float* %5
%73 = load float*, float** %2
%74 = load i32, i32* %4
%75 = add nsw i32 %74, 2
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %73, i64 %76
%78 = load float, float* %77
store float %78, float* %6
%79 = load float, float* %5
%80 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%81 = load float, float* %80
%82 = load float, float* %6
%83 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%84 = load float, float* %83
%85 = fmul float %82, %84
%86 = fneg float %85
%87 = call float @llvm.fmuladd.f32(float %79, float %81, float %86)
%88 = load float*, float** %2
%89 = load i32, i32* %4
%90 = add nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float, float* %88, i64 %91
store float %87, float* %92
%93 = load float, float* %5
%94 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%95 = load float, float* %94
%96 = load float, float* %6
%97 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%98 = load float, float* %97
%99 = fmul float %96, %98
%100 = call float @llvm.fmuladd.f32(float %93, float %95, float %99)
%101 = load float*, float** %2
%102 = load i32, i32* %4
%103 = add nsw i32 %102, 2
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %101, i64 %104
store float %100, float* %105
br label %106
106: ; preds = %66
%107 = load i32, i32* %4
%108 = add nsw i32 %107, 3
store i32 %108, i32* %4
br label %63
109: ; preds = %63
ret void
}

LLVM IR (-O2):
define void @matrixToHessenbergForm_Givens_float(float* nocapture %0) {
%2 = alloca i64
%3 = bitcast i64* %2 to i8*
store i64 0, i64* %2
%4 = bitcast i64* %2 to float*
%5 = getelementptr inbounds float, float* %0, i64 3
%6 = load float, float* %5
%7 = getelementptr inbounds float, float* %0, i64 6
%8 = load float, float* %7
%9 = call i32 @givensRotation_float(float* %4, float %6, float %8)
%10 = bitcast i64* %2 to <2 x float>*
%11 = load <2 x float>, <2 x float>* %10
%12 = shufflevector <2 x float> %11, <2 x float> poison, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%13 = shufflevector <2 x float> %11, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 0>
%14 = load float, float* %5
%15 = load float, float* %7
%16 = extractelement <2 x float> %11, i64 0
%17 = extractelement <2 x float> %11, i64 1
%18 = getelementptr inbounds float, float* %0, i64 4
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %0, i64 7
%21 = load float, float* %20
%22 = fneg float %21
%23 = fmul float %17, %22
%24 = call float @llvm.fmuladd.f32(float %19, float %16, float %23)
%25 = fmul float %21, %16
%26 = call float @llvm.fmuladd.f32(float %19, float %17, float %25)
%27 = getelementptr inbounds float, float* %0, i64 5
%28 = load float, float* %27
%29 = getelementptr inbounds float, float* %0, i64 8
%30 = load float, float* %29
%31 = fneg float %30
%32 = fmul float %17, %31
%33 = call float @llvm.fmuladd.f32(float %28, float %16, float %32)
%34 = fmul float %30, %16
%35 = call float @llvm.fmuladd.f32(float %28, float %17, float %34)
%36 = getelementptr inbounds float, float* %0, i64 1
%37 = load float, float* %36
%38 = getelementptr inbounds float, float* %0, i64 2
%39 = load float, float* %38
%40 = fneg float %39
%41 = insertelement <2 x float> poison, float %15, i64 0
%42 = insertelement <2 x float> %41, float %33, i64 1
%43 = fneg <2 x float> %42
%44 = insertelement <4 x float> %12, float %39, i64 0
%45 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%46 = shufflevector <2 x float> %11, <2 x float> poison, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%47 = insertelement <4 x float> %46, float %40, i64 1
%48 = shufflevector <2 x float> %43, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%49 = shufflevector <4 x float> %47, <4 x float> %48, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%50 = fmul <4 x float> %45, %49
%51 = shufflevector <4 x float> %50, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 2, i32 3>
%52 = insertelement <4 x float> poison, float %37, i64 0
%53 = insertelement <4 x float> %52, float %37, i64 1
%54 = insertelement <4 x float> %53, float %14, i64 2
%55 = insertelement <4 x float> %54, float %24, i64 3
%56 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %55, <4 x float> %13, <4 x float> %51)
%57 = bitcast float* %36 to <4 x float>*
store <4 x float> %56, <4 x float>* %57
%58 = fneg float %35
%59 = insertelement <4 x float> poison, float %33, i64 0
%60 = insertelement <4 x float> %59, float %15, i64 1
%61 = insertelement <4 x float> %60, float %58, i64 2
%62 = insertelement <4 x float> %61, float %35, i64 3
%63 = shufflevector <2 x float> %11, <2 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 0>
%64 = fmul <4 x float> %62, %63
%65 = insertelement <4 x float> poison, float %24, i64 0
%66 = insertelement <4 x float> %65, float %14, i64 1
%67 = insertelement <4 x float> %66, float %26, i64 2
%68 = insertelement <4 x float> %67, float %26, i64 3
%69 = shufflevector <2 x float> %11, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 0, i32 1>
%70 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %68, <4 x float> %69, <4 x float> %64)
%71 = bitcast float* %27 to <4 x float>*
store <4 x float> %70, <4 x float>* %71
ret void
}