#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 sqrt(float);
void householder(float **mat, unsigned int rows, unsigned int cols,
                 unsigned int row_pos, unsigned int col_pos, float *result) {
  int i;
  float norm;
  norm = 0;
  for (i = row_pos; i < rows; i++)
    norm += mat[i][col_pos] * mat[i][col_pos];
  if (norm == 0)
    return;
  norm = sqrt(norm);
  result[0] = (mat[row_pos][col_pos] - norm);
  for (i = 1; i < (rows - row_pos); i++)
    result[i] = mat[i + row_pos][col_pos];
  norm = 0;
  for (i = 0; i < (rows - row_pos); i++)
    norm += result[i] * result[i];
  if (norm == 0)
    return;
  norm = sqrt(norm);
  for (i = 0; i < (rows - row_pos); i++)
    result[i] *= (1.0 / norm);
}


x86 assembly (clang, -O0):
<householder>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    118f <householder+0x7f>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    113b <householder+0x2b>
movss  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11ab <householder+0x9b>
jp     11ab <householder+0x9b>
jmp    1303 <householder+0x1f3>
movss  -0x28(%rbp),%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jae    1225 <householder+0x115>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x14(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11e1 <householder+0xd1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jae    127f <householder+0x16f>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1234 <householder+0x124>
movss  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    129b <householder+0x18b>
jp     129b <householder+0x18b>
jmp    1303 <householder+0x1f3>
movss  -0x28(%rbp),%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jae    1303 <householder+0x1f3>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd2d(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b1 <householder+0x1a1>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<householder>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r13d
sub    %ecx,%r13d
jbe    11c9 <householder+0xb9>
mov    %r9,%r15
mov    %ecx,%r14d
mov    %rdi,%rbx
mov    %r8d,%ebp
movslq %ecx,%rax
not    %ecx
add    %esi,%ecx
mov    %r13d,%edx
xorps  %xmm0,%xmm0
and    $0x3,%edx
je     116a <householder+0x5a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rax,8),%rdi
movss  (%rdi,%rbp,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rax
add    $0xffffffff,%edx
jne    1150 <householder+0x40>
cmp    $0x3,%ecx
jb     11bf <householder+0xaf>
nop
mov    (%rbx,%rax,8),%rcx
mov    0x8(%rbx,%rax,8),%rdx
movss  (%rcx,%rbp,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  (%rdx,%rbp,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    0x10(%rbx,%rax,8),%rcx
movss  (%rcx,%rbp,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbx,%rax,8),%rcx
movss  (%rcx,%rbp,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rax
cmp    %esi,%eax
jb     1170 <householder+0x60>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11d8 <householder+0xc8>
jp     11d8 <householder+0xc8>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
jb     11e3 <householder+0xd3>
xorps  %xmm1,%xmm1
sqrtss %xmm0,%xmm1
jmp    11eb <householder+0xdb>
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
mov    %r14d,%ecx
mov    (%rbx,%rcx,8),%rax
movss  (%rax,%rbp,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%r15)
mov    %r13d,%r12d
cmp    $0x2,%r13d
jb     12bb <householder+0x1ab>
lea    -0x1(%r12),%rsi
lea    -0x2(%r12),%rdi
mov    %esi,%eax
and    $0x3,%eax
mov    $0x1,%edx
cmp    $0x3,%rdi
jb     128f <householder+0x17f>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopl   (%rax)
lea    (%rcx,%rdx,1),%edi
add    $0x1,%edi
mov    (%rbx,%rdi,8),%rdi
movss  (%rdi,%rbp,4),%xmm1
movss  %xmm1,0x4(%r15,%rdx,4)
lea    0x2(%rcx,%rdx,1),%edi
mov    (%rbx,%rdi,8),%rdi
movss  (%rdi,%rbp,4),%xmm1
movss  %xmm1,0x8(%r15,%rdx,4)
lea    0x3(%rcx,%rdx,1),%edi
mov    (%rbx,%rdi,8),%rdi
movss  (%rdi,%rbp,4),%xmm1
movss  %xmm1,0xc(%r15,%rdx,4)
lea    0x4(%rcx,%rdx,1),%edi
mov    (%rbx,%rdi,8),%rdi
movss  (%rdi,%rbp,4),%xmm1
movss  %xmm1,0x10(%r15,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1230 <householder+0x120>
add    $0x1,%rdx
test   %rax,%rax
je     12bb <householder+0x1ab>
lea    (%r15,%rdx,4),%rcx
add    %edx,%r14d
xor    %edx,%edx
nopl   (%rax)
lea    (%r14,%rdx,1),%esi
mov    (%rbx,%rsi,8),%rsi
movss  (%rsi,%rbp,4),%xmm1
movss  %xmm1,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12a0 <householder+0x190>
test   %r13d,%r13d
je     11c9 <householder+0xb9>
mulss  %xmm0,%xmm0
xorps  %xmm1,%xmm1
addss  %xmm1,%xmm0
cmp    $0x1,%r13d
je     1376 <householder+0x266>
lea    -0x1(%r12),%rdx
lea    -0x2(%r12),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    12f5 <householder+0x1e5>
mov    $0x1,%ecx
jmp    1349 <householder+0x239>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  0x4(%r15,%rcx,4),%xmm2
movss  0x8(%r15,%rcx,4),%xmm3
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
movss  0xc(%r15,%rcx,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm3,%xmm2
movss  0x10(%r15,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1300 <householder+0x1f0>
add    $0x1,%rcx
test   %rax,%rax
je     1376 <householder+0x266>
lea    (%r15,%rcx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%rdx,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1360 <householder+0x250>
ucomiss %xmm1,%xmm0
jne    1381 <householder+0x271>
jnp    11c9 <householder+0xb9>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     138f <householder+0x27f>
sqrtss %xmm0,%xmm0
jmp    1394 <householder+0x284>
call   1030 <sqrt@plt>
test   %r13d,%r13d
je     11c9 <householder+0xb9>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xc54(%rip),%xmm0
divsd  %xmm1,%xmm0
cmp    $0x8,%r13d
jae    13bd <householder+0x2ad>
xor    %eax,%eax
jmp    1500 <householder+0x3f0>
mov    %r12d,%eax
and    $0xfffffff8,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     149a <householder+0x38a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
cvtps2pd 0x8(%r15,%rcx,4),%xmm2
cvtps2pd (%r15,%rcx,4),%xmm3
cvtps2pd 0x18(%r15,%rcx,4),%xmm4
cvtps2pd 0x10(%r15,%rcx,4),%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,(%r15,%rcx,4)
movupd %xmm2,0x10(%r15,%rcx,4)
cvtps2pd 0x28(%r15,%rcx,4),%xmm2
cvtps2pd 0x20(%r15,%rcx,4),%xmm3
cvtps2pd 0x38(%r15,%rcx,4),%xmm4
cvtps2pd 0x30(%r15,%rcx,4),%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,0x20(%r15,%rcx,4)
movupd %xmm2,0x30(%r15,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13f0 <householder+0x2e0>
jmp    149c <householder+0x38c>
xor    %ecx,%ecx
test   $0x1,%dl
je     14ed <householder+0x3dd>
cvtps2pd 0x8(%r15,%rcx,4),%xmm2
cvtps2pd (%r15,%rcx,4),%xmm3
cvtps2pd 0x18(%r15,%rcx,4),%xmm4
cvtps2pd 0x10(%r15,%rcx,4),%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm4
cvtpd2ps %xmm2,%xmm1
cvtpd2ps %xmm3,%xmm2
cvtpd2ps %xmm4,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm1,%xmm2
unpcklpd %xmm3,%xmm4
movupd %xmm2,(%r15,%rcx,4)
movupd %xmm4,0x10(%r15,%rcx,4)
cmp    %r12,%rax
je     11c9 <householder+0xb9>
cs nopw 0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%r12
jne    1500 <householder+0x3f0>
jmp    11c9 <householder+0xb9>

LLVM IR (-O0):
define void @householder(float** %0, i32 %1, i32 %2, i32 %3, i32 %4, float* %5) {
%7 = alloca float**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float*
%13 = alloca i32
%14 = alloca float
store float** %0, float*** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store float* %5, float** %12
store float 0.000000e+00, float* %14
%15 = load i32, i32* %10
store i32 %15, i32* %13
br label %16
16: ; preds = %41, %6
%17 = load i32, i32* %13
%18 = load i32, i32* %8
%19 = icmp ult i32 %17, %18
br i1 %19, label %20, label %44
20: ; preds = %16
%21 = load float**, float*** %7
%22 = load i32, i32* %13
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float*, float** %21, i64 %23
%25 = load float*, float** %24
%26 = load i32, i32* %11
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds float, float* %25, i64 %27
%29 = load float, float* %28
%30 = load float**, float*** %7
%31 = load i32, i32* %13
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float*, float** %30, i64 %32
%34 = load float*, float** %33
%35 = load i32, i32* %11
%36 = zext i32 %35 to i64
%37 = getelementptr inbounds float, float* %34, i64 %36
%38 = load float, float* %37
%39 = load float, float* %14
%40 = call float @llvm.fmuladd.f32(float %29, float %38, float %39)
store float %40, float* %14
br label %41
41: ; preds = %20
%42 = load i32, i32* %13
%43 = add nsw i32 %42, 1
store i32 %43, i32* %13
br label %16
44: ; preds = %16
%45 = load float, float* %14
%46 = fcmp oeq float %45, 0.000000e+00
br i1 %46, label %47, label %48
47: ; preds = %44
br label %140
48: ; preds = %44
%49 = load float, float* %14
%50 = call float @sqrt(float %49)
store float %50, float* %14
%51 = load float**, float*** %7
%52 = load i32, i32* %10
%53 = zext i32 %52 to i64
%54 = getelementptr inbounds float*, float** %51, i64 %53
%55 = load float*, float** %54
%56 = load i32, i32* %11
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds float, float* %55, i64 %57
%59 = load float, float* %58
%60 = load float, float* %14
%61 = fsub float %59, %60
%62 = load float*, float** %12
%63 = getelementptr inbounds float, float* %62, i64 0
store float %61, float* %63
store i32 1, i32* %13
br label %64
64: ; preds = %86, %48
%65 = load i32, i32* %13
%66 = load i32, i32* %8
%67 = load i32, i32* %10
%68 = sub i32 %66, %67
%69 = icmp ult i32 %65, %68
br i1 %69, label %70, label %89
70: ; preds = %64
%71 = load float**, float*** %7
%72 = load i32, i32* %13
%73 = load i32, i32* %10
%74 = add i32 %72, %73
%75 = zext i32 %74 to i64
%76 = getelementptr inbounds float*, float** %71, i64 %75
%77 = load float*, float** %76
%78 = load i32, i32* %11
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds float, float* %77, i64 %79
%81 = load float, float* %80
%82 = load float*, float** %12
%83 = load i32, i32* %13
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %82, i64 %84
store float %81, float* %85
br label %86
86: ; preds = %70
%87 = load i32, i32* %13
%88 = add nsw i32 %87, 1
store i32 %88, i32* %13
br label %64
89: ; preds = %64
store float 0.000000e+00, float* %14
store i32 0, i32* %13
br label %90
90: ; preds = %109, %89
%91 = load i32, i32* %13
%92 = load i32, i32* %8
%93 = load i32, i32* %10
%94 = sub i32 %92, %93
%95 = icmp ult i32 %91, %94
br i1 %95, label %96, label %112
96: ; preds = %90
%97 = load float*, float** %12
%98 = load i32, i32* %13
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %97, i64 %99
%101 = load float, float* %100
%102 = load float*, float** %12
%103 = load i32, i32* %13
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %102, i64 %104
%106 = load float, float* %105
%107 = load float, float* %14
%108 = call float @llvm.fmuladd.f32(float %101, float %106, float %107)
store float %108, float* %14
br label %109
109: ; preds = %96
%110 = load i32, i32* %13
%111 = add nsw i32 %110, 1
store i32 %111, i32* %13
br label %90
112: ; preds = %90
%113 = load float, float* %14
%114 = fcmp oeq float %113, 0.000000e+00
br i1 %114, label %115, label %116
115: ; preds = %112
br label %140
116: ; preds = %112
%117 = load float, float* %14
%118 = call float @sqrt(float %117)
store float %118, float* %14
store i32 0, i32* %13
br label %119
119: ; preds = %137, %116
%120 = load i32, i32* %13
%121 = load i32, i32* %8
%122 = load i32, i32* %10
%123 = sub i32 %121, %122
%124 = icmp ult i32 %120, %123
br i1 %124, label %125, label %140
125: ; preds = %119
%126 = load float, float* %14
%127 = fpext float %126 to double
%128 = fdiv double 1.000000e+00, %127
%129 = load float*, float** %12
%130 = load i32, i32* %13
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %129, i64 %131
%133 = load float, float* %132
%134 = fpext float %133 to double
%135 = fmul double %134, %128
%136 = fptrunc double %135 to float
store float %136, float* %132
br label %137
137: ; preds = %125
%138 = load i32, i32* %13
%139 = add nsw i32 %138, 1
store i32 %139, i32* %13
br label %119
140: ; preds = %47, %115, %119
ret void
}

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