#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*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mmult(float *, float *, float *, int, int, int);
float sqrtf(float);
float house_2(float *x, int N, float *v) {
  float sgn, beta, sc;
  float *sigma, *e;
  int i;
  sigma = (float *)malloc(sizeof(float) * 1);
  e = (float *)malloc(sizeof(float) * N);
  beta = 2.0;
  sgn = 1.0;
  mmult(x, x, sigma, 1, N, 1);
  sigma[0] = sqrtf(sigma[0]);
  e[0] = 1.;
  for (i = 1; i < N; ++i) {
    e[i] = 0.;
  }
  if (x[0] > 0.) {
    sgn = 1.0;
  } else if (x[0] < 0.) {
    sgn = -1.0;
  } else if (x[0] == 0.) {
    sgn = 0.;
  }
  sc = sigma[0] * sgn;
  e[0] *= sc;
  for (i = 0; i < N; ++i) {
    v[i] = e[i] + x[i];
  }
  mmult(v, v, sigma, 1, N, 1);
  sigma[0] = sqrtf(sigma[0]);
  for (i = 0; i < N; ++i) {
    v[i] = v[i] / sigma[0];
  }
  free(sigma);
  free(e);
  return beta;
}


x86 assembly (clang, -O0):
<house_2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    $0x4,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movss  0xe88(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  0xe77(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0xc(%rbp),%r8d
mov    $0x1,%r9d
mov    %r9d,%ecx
call   1040 <mmult@plt>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
call   1060 <sqrtf@plt>
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movss  0xe33(%rip),%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1202 <house_2+0xc2>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d8 <house_2+0x98>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    122d <house_2+0xed>
movss  0xddd(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1289 <house_2+0x149>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1258 <house_2+0x118>
movss  0xdba(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1284 <house_2+0x144>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    127f <house_2+0x13f>
jp     127f <house_2+0x13f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1284 <house_2+0x144>
jmp    1289 <house_2+0x149>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12f4 <house_2+0x1b4>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12b3 <house_2+0x173>
mov    -0x18(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0xc(%rbp),%r8d
mov    $0x1,%r9d
mov    %r9d,%ecx
call   1040 <mmult@plt>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
call   1060 <sqrtf@plt>
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    136a <house_2+0x22a>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
divss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    132e <house_2+0x1ee>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movss  -0x20(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<house_2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%rbx
mov    %esi,%r12d
mov    %rdi,%r13
mov    $0x4,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%r12,4),%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    %r13,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    $0x1,%ecx
mov    %r12d,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
movss  (%r14),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     11b0 <house_2+0x60>
sqrtss %xmm0,%xmm0
jmp    11b5 <house_2+0x65>
call   1070 <sqrtf@plt>
movss  %xmm0,(%r14)
movl   $0x3f800000,(%r15)
cmp    $0x2,%r12d
jl     11db <house_2+0x8b>
lea    0x4(%r15),%rdi
lea    -0x1(%r12),%edx
shl    $0x2,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
movss  0x0(%r13),%xmm1
movss  0xe17(%rip),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
ja     120d <house_2+0xbd>
ucomiss %xmm1,%xmm2
jbe    1200 <house_2+0xb0>
movss  0xe06(%rip),%xmm0
jmp    120d <house_2+0xbd>
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
jne    120d <house_2+0xbd>
jp     120d <house_2+0xbd>
xorps  %xmm0,%xmm0
mulss  (%r14),%xmm0
movss  %xmm0,(%r15)
mov    %r12d,%ebp
test   %r12d,%r12d
jle    1407 <house_2+0x2b7>
addss  0x0(%r13),%xmm0
movss  %xmm0,(%rbx)
cmp    $0x1,%r12d
je     1407 <house_2+0x2b7>
lea    -0x1(%rbp),%r8
mov    $0x1,%eax
cmp    $0x8,%r8
jae    12ec <house_2+0x19c>
mov    %ebp,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
and    $0x3,%rdx
je     127c <house_2+0x12c>
nopl   (%rax)
movss  (%r15,%rax,4),%xmm0
addss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1260 <house_2+0x110>
cmp    $0x3,%rcx
jb     1407 <house_2+0x2b7>
cs nopw 0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm0
addss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
addss  0x4(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  0x8(%r15,%rax,4),%xmm0
addss  0x8(%r13,%rax,4),%xmm0
movss  %xmm0,0x8(%rbx,%rax,4)
movss  0xc(%r15,%rax,4),%xmm0
addss  0xc(%r13,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1290 <house_2+0x140>
jmp    1407 <house_2+0x2b7>
lea    0x4(%rbx),%rcx
lea    (%rbx,%rbp,4),%rsi
lea    (%r15,%rbp,4),%rdx
mov    %r15,%rdi
add    $0x4,%rdi
lea    0x4(%r13),%r9
lea    0x0(,%rbp,4),%r10
add    %r13,%r10
cmp    %rdx,%rcx
setb   %r11b
cmp    %rsi,%rdi
setb   %dil
cmp    %r10,%rcx
setb   %dl
cmp    %rsi,%r9
setb   %cl
test   %dil,%r11b
jne    124a <house_2+0xfa>
and    %cl,%dl
jne    124a <house_2+0xfa>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rcx,%rcx
je     159c <house_2+0x44c>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%r15,%rdx,4),%xmm0
movups 0x14(%r15,%rdx,4),%xmm1
movups 0x4(%r13,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x14(%r13,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x4(%rbx,%rdx,4)
movups %xmm0,0x14(%rbx,%rdx,4)
movups 0x24(%r15,%rdx,4),%xmm0
movups 0x34(%r15,%rdx,4),%xmm1
movups 0x24(%r13,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x34(%r13,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x24(%rbx,%rdx,4)
movups %xmm0,0x34(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1370 <house_2+0x220>
test   $0x1,%sil
je     13fe <house_2+0x2ae>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%r15,%rdx,1),%xmm0
movups 0x10(%r15,%rdx,1),%xmm1
movups 0x0(%r13,%rdx,1),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r13,%rdx,1),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rbx,%rdx,1)
movups %xmm0,0x10(%rbx,%rdx,1)
cmp    %rax,%r8
jne    1580 <house_2+0x430>
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    $0x1,%ecx
mov    %r12d,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
movss  (%r14),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1436 <house_2+0x2e6>
sqrtss %xmm0,%xmm0
jmp    143b <house_2+0x2eb>
call   1070 <sqrtf@plt>
movss  %xmm0,(%r14)
test   %r12d,%r12d
jle    1559 <house_2+0x409>
movss  (%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rbx)
cmp    $0x1,%r12d
je     1559 <house_2+0x409>
lea    -0x1(%rbp),%rcx
mov    $0x1,%eax
cmp    $0x4,%rcx
jb     1504 <house_2+0x3b4>
cmp    %rbx,%r14
jbe    1484 <house_2+0x334>
lea    (%rbx,%rbp,4),%rdx
cmp    %rdx,%r14
jb     1504 <house_2+0x3b4>
mov    %rcx,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1589 <house_2+0x439>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
movss  (%r14),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    $0x1,%esi
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rsi,4),%xmm1
movups 0x10(%rbx,%rsi,4),%xmm2
divps  %xmm0,%xmm1
movups %xmm1,(%rbx,%rsi,4)
divps  %xmm0,%xmm2
movups %xmm2,0x10(%rbx,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    14c0 <house_2+0x370>
test   $0x1,%dl
je     14fb <house_2+0x3ab>
movss  (%r14),%xmm0
shufps $0x0,%xmm0,%xmm0
movups (%rbx,%rsi,4),%xmm1
divps  %xmm0,%xmm1
movups %xmm1,(%rbx,%rsi,4)
cmp    %rax,%rcx
je     1559 <house_2+0x409>
or     $0x1,%rax
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
jne    1523 <house_2+0x3d3>
movss  (%rbx,%rax,4),%xmm0
divss  (%r14),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    %rbp,%rcx
je     1559 <house_2+0x409>
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm0
divss  (%r14),%xmm0
movss  0x4(%rbx,%rax,4),%xmm1
movss  %xmm0,(%rbx,%rax,4)
divss  (%r14),%xmm1
movss  %xmm1,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1530 <house_2+0x3e0>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
movss  0xa97(%rip),%xmm0
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rax
jmp    124a <house_2+0xfa>
mov    $0x1,%esi
test   $0x1,%dl
jne    14e7 <house_2+0x397>
jmp    14fb <house_2+0x3ab>
xor    %edx,%edx
test   $0x1,%sil
jne    13d0 <house_2+0x280>
jmp    13fe <house_2+0x2ae>

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

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