#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 */
float signbit(float);
float sqrtf(float);
void matrixToHessenbergForm_Householder_float(float *A) {
  float vk[2] = {
      0.0,
      0.0,
  };
  float vk_norm = 0.0;
  float dot_array[3] = {0.0, 0.0, 0.0};
  vk[0] = A[3];
  vk[1] = A[6];
  vk_norm = sqrtf(vk[0] * vk[0] + vk[1] * vk[1]);
  vk[0] += signbit(vk[0]) * vk_norm;
  vk_norm = sqrtf(vk[0] * vk[0] + vk[1] * vk[1]);
  vk[0] /= vk_norm;
  vk[1] /= vk_norm;
  dot_array[0] = vk[0] * A[3] + vk[1] * A[6];
  dot_array[1] = vk[0] * A[4] + vk[1] * A[7];
  dot_array[2] = vk[0] * A[5] + vk[1] * A[8];
  A[3] -= 2 * vk[0] * dot_array[0];
  A[4] -= 2 * vk[0] * dot_array[1];
  A[5] -= 2 * vk[0] * dot_array[2];
  A[6] -= 2 * vk[1] * dot_array[0];
  A[7] -= 2 * vk[1] * dot_array[1];
  A[8] -= 2 * vk[1] * dot_array[2];
  dot_array[0] = vk[0] * A[1] + vk[1] * A[2];
  dot_array[1] = vk[0] * A[4] + vk[1] * A[5];
  dot_array[2] = vk[0] * A[7] + vk[1] * A[8];
  A[1] -= 2 * vk[0] * dot_array[0];
  A[2] -= 2 * vk[1] * dot_array[0];
  A[4] -= 2 * vk[0] * dot_array[1];
  A[5] -= 2 * vk[1] * dot_array[1];
  A[7] -= 2 * vk[0] * dot_array[2];
  A[8] -= 2 * vk[1] * dot_array[2];
  A[2] = -A[2];
  A[5] = -A[5];
  A[7] = -A[7];
}


x86 assembly (clang, -O0):
<matrixToHessenbergForm_Householder_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,-0x14(%rbp)
lea    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x10(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm1
mulss  -0xc(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1040 <sqrtf@plt>
movss  %xmm0,-0x14(%rbp)
movss  -0x10(%rbp),%xmm0
call   1050 <signbit@plt>
movss  -0x14(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x10(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm1
mulss  -0xc(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1040 <sqrtf@plt>
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm1
movss  -0x10(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x14(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm2
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x20(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xd6a(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  0xd34(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  0xcfe(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  0xcc8(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movss  0xc92(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
movss  0xc5c(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rax)
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x20(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xbab(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  0xb75(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  0xb3f(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  0xb09(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  0xad3(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
movss  0xa9d(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrixToHessenbergForm_Householder_float>:
push   %rbx
sub    $0x10,%rsp
mov    %rdi,%rbx
movss  0xc(%rdi),%xmm2
movss  0x18(%rdi),%xmm0
movss  %xmm0,0xc(%rsp)
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm2,(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
movss  %xmm1,0x8(%rsp)
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1163 <matrixToHessenbergForm_Householder_float+0x43>
sqrtss %xmm0,%xmm0
jmp    1168 <matrixToHessenbergForm_Householder_float+0x48>
call   1030 <sqrtf@plt>
movss  %xmm0,0x4(%rsp)
movss  (%rsp),%xmm0
call   1040 <signbit@plt>
movaps %xmm0,%xmm1
mulss  0x4(%rsp),%xmm1
addss  (%rsp),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
addss  0x8(%rsp),%xmm0
ucomiss 0xe6a(%rip),%xmm0
jb     11a2 <matrixToHessenbergForm_Householder_float+0x82>
sqrtss %xmm0,%xmm0
jmp    11b1 <matrixToHessenbergForm_Householder_float+0x91>
movss  %xmm1,(%rsp)
call   1030 <sqrtf@plt>
movss  (%rsp),%xmm1
divss  %xmm0,%xmm1
movss  0xc(%rsp),%xmm3
divss  %xmm0,%xmm3
movss  0xc(%rbx),%xmm11
movss  0x18(%rbx),%xmm8
movaps %xmm3,%xmm0
mulss  %xmm8,%xmm0
movaps %xmm1,%xmm7
mulss  %xmm11,%xmm7
addss  %xmm0,%xmm7
movss  0x10(%rbx),%xmm4
movss  0x1c(%rbx),%xmm9
movaps %xmm3,%xmm0
mulss  %xmm9,%xmm0
movaps %xmm1,%xmm13
mulss  %xmm4,%xmm13
addss  %xmm0,%xmm13
movss  0x14(%rbx),%xmm6
movss  0x20(%rbx),%xmm10
movaps %xmm3,%xmm0
mulss  %xmm10,%xmm0
movaps %xmm1,%xmm2
mulss  %xmm6,%xmm2
addss  %xmm0,%xmm2
movss  0xdd9(%rip),%xmm12
movaps %xmm1,%xmm5
mulss  %xmm12,%xmm5
movaps %xmm5,%xmm0
mulss  %xmm7,%xmm0
addss  %xmm11,%xmm0
movss  %xmm0,0xc(%rbx)
movaps %xmm5,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm4,%xmm0
movaps %xmm5,%xmm11
mulss  %xmm2,%xmm11
addss  %xmm6,%xmm11
mulss  %xmm3,%xmm12
mulss  %xmm12,%xmm7
addss  %xmm8,%xmm7
movss  %xmm7,0x18(%rbx)
mulss  %xmm12,%xmm13
addss  %xmm9,%xmm13
mulss  %xmm12,%xmm2
addss  %xmm10,%xmm2
movss  0x4(%rbx),%xmm8
movss  0x8(%rbx),%xmm9
movaps %xmm3,%xmm7
mulss  %xmm9,%xmm7
movaps %xmm1,%xmm6
mulss  %xmm8,%xmm6
addss  %xmm7,%xmm6
movaps %xmm3,%xmm4
mulss  %xmm11,%xmm4
movaps %xmm1,%xmm7
mulss  %xmm0,%xmm7
addss  %xmm4,%xmm7
mulss  %xmm2,%xmm3
mulss  %xmm13,%xmm1
addss  %xmm3,%xmm1
movaps %xmm5,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm8,%xmm4
movss  %xmm4,0x4(%rbx)
mulss  %xmm12,%xmm6
addss  %xmm9,%xmm6
movaps %xmm5,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,0x10(%rbx)
mulss  %xmm12,%xmm7
addss  %xmm11,%xmm7
mulss  %xmm1,%xmm5
addss  %xmm13,%xmm5
mulss  %xmm12,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x20(%rbx)
movaps 0xcfb(%rip),%xmm0
xorps  %xmm0,%xmm6
movss  %xmm6,0x8(%rbx)
xorps  %xmm0,%xmm7
movss  %xmm7,0x14(%rbx)
xorps  %xmm0,%xmm5
movss  %xmm5,0x1c(%rbx)
add    $0x10,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @matrixToHessenbergForm_Householder_float(float* %0) {
%2 = alloca float*
%3 = alloca [2 x float]
%4 = alloca float
%5 = alloca [3 x float]
store float* %0, float** %2
%6 = bitcast [2 x float]* %3 to i8*
store float 0.000000e+00, float* %4
%7 = bitcast [3 x float]* %5 to i8*
%8 = load float*, float** %2
%9 = getelementptr inbounds float, float* %8, i64 3
%10 = load float, float* %9
%11 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
store float %10, float* %11
%12 = load float*, float** %2
%13 = getelementptr inbounds float, float* %12, i64 6
%14 = load float, float* %13
%15 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
store float %14, float* %15
%16 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%17 = load float, float* %16
%18 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%19 = load float, float* %18
%20 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%21 = load float, float* %20
%22 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%23 = load float, float* %22
%24 = fmul float %21, %23
%25 = call float @llvm.fmuladd.f32(float %17, float %19, float %24)
%26 = call float @sqrtf(float %25)
store float %26, float* %4
%27 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%28 = load float, float* %27
%29 = call float @signbit(float %28)
%30 = load float, float* %4
%31 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%32 = load float, float* %31
%33 = call float @llvm.fmuladd.f32(float %29, float %30, float %32)
store float %33, float* %31
%34 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%35 = load float, float* %34
%36 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%37 = load float, float* %36
%38 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%39 = load float, float* %38
%40 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%41 = load float, float* %40
%42 = fmul float %39, %41
%43 = call float @llvm.fmuladd.f32(float %35, float %37, float %42)
%44 = call float @sqrtf(float %43)
store float %44, float* %4
%45 = load float, float* %4
%46 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%47 = load float, float* %46
%48 = fdiv float %47, %45
store float %48, float* %46
%49 = load float, float* %4
%50 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%51 = load float, float* %50
%52 = fdiv float %51, %49
store float %52, float* %50
%53 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%54 = load float, float* %53
%55 = load float*, float** %2
%56 = getelementptr inbounds float, float* %55, i64 3
%57 = load float, float* %56
%58 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%59 = load float, float* %58
%60 = load float*, float** %2
%61 = getelementptr inbounds float, float* %60, i64 6
%62 = load float, float* %61
%63 = fmul float %59, %62
%64 = call float @llvm.fmuladd.f32(float %54, float %57, float %63)
%65 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
store float %64, float* %65
%66 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%67 = load float, float* %66
%68 = load float*, float** %2
%69 = getelementptr inbounds float, float* %68, i64 4
%70 = load float, float* %69
%71 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%72 = load float, float* %71
%73 = load float*, float** %2
%74 = getelementptr inbounds float, float* %73, i64 7
%75 = load float, float* %74
%76 = fmul float %72, %75
%77 = call float @llvm.fmuladd.f32(float %67, float %70, float %76)
%78 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 1
store float %77, float* %78
%79 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%80 = load float, float* %79
%81 = load float*, float** %2
%82 = getelementptr inbounds float, float* %81, i64 5
%83 = load float, float* %82
%84 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%85 = load float, float* %84
%86 = load float*, float** %2
%87 = getelementptr inbounds float, float* %86, i64 8
%88 = load float, float* %87
%89 = fmul float %85, %88
%90 = call float @llvm.fmuladd.f32(float %80, float %83, float %89)
%91 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 2
store float %90, float* %91
%92 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%93 = load float, float* %92
%94 = fmul float 2.000000e+00, %93
%95 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
%96 = load float, float* %95
%97 = load float*, float** %2
%98 = getelementptr inbounds float, float* %97, i64 3
%99 = load float, float* %98
%100 = fneg float %94
%101 = call float @llvm.fmuladd.f32(float %100, float %96, float %99)
store float %101, float* %98
%102 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%103 = load float, float* %102
%104 = fmul float 2.000000e+00, %103
%105 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 1
%106 = load float, float* %105
%107 = load float*, float** %2
%108 = getelementptr inbounds float, float* %107, i64 4
%109 = load float, float* %108
%110 = fneg float %104
%111 = call float @llvm.fmuladd.f32(float %110, float %106, float %109)
store float %111, float* %108
%112 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%113 = load float, float* %112
%114 = fmul float 2.000000e+00, %113
%115 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 2
%116 = load float, float* %115
%117 = load float*, float** %2
%118 = getelementptr inbounds float, float* %117, i64 5
%119 = load float, float* %118
%120 = fneg float %114
%121 = call float @llvm.fmuladd.f32(float %120, float %116, float %119)
store float %121, float* %118
%122 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%123 = load float, float* %122
%124 = fmul float 2.000000e+00, %123
%125 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
%126 = load float, float* %125
%127 = load float*, float** %2
%128 = getelementptr inbounds float, float* %127, i64 6
%129 = load float, float* %128
%130 = fneg float %124
%131 = call float @llvm.fmuladd.f32(float %130, float %126, float %129)
store float %131, float* %128
%132 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%133 = load float, float* %132
%134 = fmul float 2.000000e+00, %133
%135 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 1
%136 = load float, float* %135
%137 = load float*, float** %2
%138 = getelementptr inbounds float, float* %137, i64 7
%139 = load float, float* %138
%140 = fneg float %134
%141 = call float @llvm.fmuladd.f32(float %140, float %136, float %139)
store float %141, float* %138
%142 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%143 = load float, float* %142
%144 = fmul float 2.000000e+00, %143
%145 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 2
%146 = load float, float* %145
%147 = load float*, float** %2
%148 = getelementptr inbounds float, float* %147, i64 8
%149 = load float, float* %148
%150 = fneg float %144
%151 = call float @llvm.fmuladd.f32(float %150, float %146, float %149)
store float %151, float* %148
%152 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%153 = load float, float* %152
%154 = load float*, float** %2
%155 = getelementptr inbounds float, float* %154, i64 1
%156 = load float, float* %155
%157 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%158 = load float, float* %157
%159 = load float*, float** %2
%160 = getelementptr inbounds float, float* %159, i64 2
%161 = load float, float* %160
%162 = fmul float %158, %161
%163 = call float @llvm.fmuladd.f32(float %153, float %156, float %162)
%164 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
store float %163, float* %164
%165 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%166 = load float, float* %165
%167 = load float*, float** %2
%168 = getelementptr inbounds float, float* %167, i64 4
%169 = load float, float* %168
%170 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%171 = load float, float* %170
%172 = load float*, float** %2
%173 = getelementptr inbounds float, float* %172, i64 5
%174 = load float, float* %173
%175 = fmul float %171, %174
%176 = call float @llvm.fmuladd.f32(float %166, float %169, float %175)
%177 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 1
store float %176, float* %177
%178 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%179 = load float, float* %178
%180 = load float*, float** %2
%181 = getelementptr inbounds float, float* %180, i64 7
%182 = load float, float* %181
%183 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%184 = load float, float* %183
%185 = load float*, float** %2
%186 = getelementptr inbounds float, float* %185, i64 8
%187 = load float, float* %186
%188 = fmul float %184, %187
%189 = call float @llvm.fmuladd.f32(float %179, float %182, float %188)
%190 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 2
store float %189, float* %190
%191 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%192 = load float, float* %191
%193 = fmul float 2.000000e+00, %192
%194 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
%195 = load float, float* %194
%196 = load float*, float** %2
%197 = getelementptr inbounds float, float* %196, i64 1
%198 = load float, float* %197
%199 = fneg float %193
%200 = call float @llvm.fmuladd.f32(float %199, float %195, float %198)
store float %200, float* %197
%201 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%202 = load float, float* %201
%203 = fmul float 2.000000e+00, %202
%204 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
%205 = load float, float* %204
%206 = load float*, float** %2
%207 = getelementptr inbounds float, float* %206, i64 2
%208 = load float, float* %207
%209 = fneg float %203
%210 = call float @llvm.fmuladd.f32(float %209, float %205, float %208)
store float %210, float* %207
%211 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%212 = load float, float* %211
%213 = fmul float 2.000000e+00, %212
%214 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 1
%215 = load float, float* %214
%216 = load float*, float** %2
%217 = getelementptr inbounds float, float* %216, i64 4
%218 = load float, float* %217
%219 = fneg float %213
%220 = call float @llvm.fmuladd.f32(float %219, float %215, float %218)
store float %220, float* %217
%221 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%222 = load float, float* %221
%223 = fmul float 2.000000e+00, %222
%224 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 1
%225 = load float, float* %224
%226 = load float*, float** %2
%227 = getelementptr inbounds float, float* %226, i64 5
%228 = load float, float* %227
%229 = fneg float %223
%230 = call float @llvm.fmuladd.f32(float %229, float %225, float %228)
store float %230, float* %227
%231 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%232 = load float, float* %231
%233 = fmul float 2.000000e+00, %232
%234 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 2
%235 = load float, float* %234
%236 = load float*, float** %2
%237 = getelementptr inbounds float, float* %236, i64 7
%238 = load float, float* %237
%239 = fneg float %233
%240 = call float @llvm.fmuladd.f32(float %239, float %235, float %238)
store float %240, float* %237
%241 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%242 = load float, float* %241
%243 = fmul float 2.000000e+00, %242
%244 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 2
%245 = load float, float* %244
%246 = load float*, float** %2
%247 = getelementptr inbounds float, float* %246, i64 8
%248 = load float, float* %247
%249 = fneg float %243
%250 = call float @llvm.fmuladd.f32(float %249, float %245, float %248)
store float %250, float* %247
%251 = load float*, float** %2
%252 = getelementptr inbounds float, float* %251, i64 2
%253 = load float, float* %252
%254 = fneg float %253
%255 = load float*, float** %2
%256 = getelementptr inbounds float, float* %255, i64 2
store float %254, float* %256
%257 = load float*, float** %2
%258 = getelementptr inbounds float, float* %257, i64 5
%259 = load float, float* %258
%260 = fneg float %259
%261 = load float*, float** %2
%262 = getelementptr inbounds float, float* %261, i64 5
store float %260, float* %262
%263 = load float*, float** %2
%264 = getelementptr inbounds float, float* %263, i64 7
%265 = load float, float* %264
%266 = fneg float %265
%267 = load float*, float** %2
%268 = getelementptr inbounds float, float* %267, i64 7
store float %266, float* %268
ret void
}

LLVM IR (-O2):
define void @matrixToHessenbergForm_Householder_float(float* nocapture %0) {
%2 = getelementptr inbounds float, float* %0, i64 3
%3 = load float, float* %2
%4 = getelementptr inbounds float, float* %0, i64 6
%5 = load float, float* %4
%6 = fmul float %5, %5
%7 = tail call float @llvm.fmuladd.f32(float %3, float %3, float %6)
%8 = tail call float @sqrtf(float %7)
%9 = tail call float @signbit(float %3)
%10 = tail call float @llvm.fmuladd.f32(float %9, float %8, float %3)
%11 = tail call float @llvm.fmuladd.f32(float %10, float %10, float %6)
%12 = tail call float @sqrtf(float %11)
%13 = fdiv float %10, %12
%14 = fdiv float %5, %12
%15 = load float, float* %2
%16 = load float, float* %4
%17 = fmul float %14, %16
%18 = tail call float @llvm.fmuladd.f32(float %13, float %15, float %17)
%19 = getelementptr inbounds float, float* %0, i64 4
%20 = load float, float* %19
%21 = getelementptr inbounds float, float* %0, i64 7
%22 = load float, float* %21
%23 = fmul float %14, %22
%24 = tail call float @llvm.fmuladd.f32(float %13, float %20, float %23)
%25 = getelementptr inbounds float, float* %0, i64 5
%26 = load float, float* %25
%27 = getelementptr inbounds float, float* %0, i64 8
%28 = load float, float* %27
%29 = fmul float %14, %28
%30 = tail call float @llvm.fmuladd.f32(float %13, float %26, float %29)
%31 = fmul float %13, -2.000000e+00
%32 = tail call float @llvm.fmuladd.f32(float %31, float %18, float %15)
store float %32, float* %2
%33 = tail call float @llvm.fmuladd.f32(float %31, float %24, float %20)
%34 = tail call float @llvm.fmuladd.f32(float %31, float %30, float %26)
%35 = fmul float %14, -2.000000e+00
%36 = tail call float @llvm.fmuladd.f32(float %35, float %18, float %16)
store float %36, float* %4
%37 = tail call float @llvm.fmuladd.f32(float %35, float %24, float %22)
%38 = tail call float @llvm.fmuladd.f32(float %35, float %30, float %28)
%39 = getelementptr inbounds float, float* %0, i64 1
%40 = load float, float* %39
%41 = getelementptr inbounds float, float* %0, i64 2
%42 = load float, float* %41
%43 = fmul float %14, %42
%44 = tail call float @llvm.fmuladd.f32(float %13, float %40, float %43)
%45 = fmul float %14, %34
%46 = tail call float @llvm.fmuladd.f32(float %13, float %33, float %45)
%47 = fmul float %14, %38
%48 = tail call float @llvm.fmuladd.f32(float %13, float %37, float %47)
%49 = tail call float @llvm.fmuladd.f32(float %31, float %44, float %40)
store float %49, float* %39
%50 = tail call float @llvm.fmuladd.f32(float %35, float %44, float %42)
%51 = tail call float @llvm.fmuladd.f32(float %31, float %46, float %33)
store float %51, float* %19
%52 = tail call float @llvm.fmuladd.f32(float %35, float %46, float %34)
%53 = tail call float @llvm.fmuladd.f32(float %31, float %48, float %37)
%54 = tail call float @llvm.fmuladd.f32(float %35, float %48, float %38)
store float %54, float* %27
%55 = fneg float %50
store float %55, float* %41
%56 = fneg float %52
store float %56, float* %25
%57 = fneg float %53
store float %57, float* %21
ret void
}