#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*/ __errexit(char *, int);
scalar_t__ fabs(float);
float __BetterVBalance(int ncon, int norm, float *vwgt, float *u1wgt,
                       float *u2wgt) {
  int i;
  float sum1, sum2, max1, max2, min1, min2, diff1, diff2;
  if (norm == -1) {
    max1 = min1 = vwgt[0] + u1wgt[0];
    max2 = min2 = vwgt[0] + u2wgt[0];
    sum1 = vwgt[0] + u1wgt[0];
    sum2 = vwgt[0] + u2wgt[0];
    for (i = 1; i < ncon; i++) {
      if (max1 < vwgt[i] + u1wgt[i])
        max1 = vwgt[i] + u1wgt[i];
      if (min1 > vwgt[i] + u1wgt[i])
        min1 = vwgt[i] + u1wgt[i];
      if (max2 < vwgt[i] + u2wgt[i])
        max2 = vwgt[i] + u2wgt[i];
      if (min2 > vwgt[i] + u2wgt[i])
        min2 = vwgt[i] + u2wgt[i];
      sum1 += vwgt[i] + u1wgt[i];
      sum2 += vwgt[i] + u2wgt[i];
    }
    return ((max1 - min1) / sum1) - ((max2 - min2) / sum2);
  } else if (norm == 1) {
    sum1 = sum2 = 0.0;
    for (i = 0; i < ncon; i++) {
      sum1 += vwgt[i] + u1wgt[i];
      sum2 += vwgt[i] + u2wgt[i];
    }
    sum1 = sum1 / (1.0 * ncon);
    sum2 = sum2 / (1.0 * ncon);
    diff1 = diff2 = 0.0;
    for (i = 0; i < ncon; i++) {
      diff1 += fabs(sum1 - (vwgt[i] + u1wgt[i]));
      diff2 += fabs(sum2 - (vwgt[i] + u2wgt[i]));
    }
    return diff1 - diff2;
  } else {
    __errexit("Unknown norm: %d\n", norm);
  }
  return 0.0;
}


x86 assembly (clang, -O0):
<__BetterVBalance>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
cmpl   $0xffffffff,-0xc(%rbp)
jne    1353 <__BetterVBalance+0x233>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1327 <__BetterVBalance+0x207>
movss  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    11fc <__BetterVBalance+0xdc>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
jbe    1243 <__BetterVBalance+0x123>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    128a <__BetterVBalance+0x16a>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
jbe    12d1 <__BetterVBalance+0x1b1>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a9 <__BetterVBalance+0x89>
movss  -0x38(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
divss  -0x30(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
subss  -0x44(%rbp),%xmm1
divss  -0x34(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    14f3 <__BetterVBalance+0x3d3>
cmpl   $0x1,-0xc(%rbp)
jne    14d7 <__BetterVBalance+0x3b7>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13d6 <__BetterVBalance+0x2b6>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1374 <__BetterVBalance+0x254>
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x8(%rbp),%xmm2
movsd  0xc14(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x8(%rbp),%xmm2
movsd  0xbed(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14c3 <__BetterVBalance+0x3a3>
movss  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
subss  %xmm1,%xmm0
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
subss  %xmm1,%xmm0
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    143b <__BetterVBalance+0x31b>
movss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    14f3 <__BetterVBalance+0x3d3>
mov    -0xc(%rbp),%esi
lea    0xb27(%rip),%rdi
call   1030 <__errexit@plt>
jmp    14eb <__BetterVBalance+0x3cb>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<__BetterVBalance>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r13
cmp    $0xffffffff,%esi
je     115d <__BetterVBalance+0x3d>
cmp    $0x1,%esi
jne    119b <__BetterVBalance+0x7b>
xorps  %xmm0,%xmm0
test   %edi,%edi
jle    13fd <__BetterVBalance+0x2dd>
mov    %edi,%r12d
cmp    $0x1,%edi
jne    11ba <__BetterVBalance+0x9a>
xorps  %xmm6,%xmm6
xor    %eax,%eax
jmp    121e <__BetterVBalance+0xfe>
movss  0x0(%r13),%xmm2
shufps $0x0,%xmm2,%xmm2
movss  (%r14),%xmm1
movss  (%r15),%xmm0
unpcklps %xmm1,%xmm0
addps  %xmm2,%xmm0
cmp    $0x2,%edi
jl     11af <__BetterVBalance+0x8f>
mov    %edi,%eax
add    $0xffffffffffffffff,%rax
cmp    $0x2,%edi
jne    132c <__BetterVBalance+0x20c>
mov    $0x1,%ecx
movaps %xmm0,%xmm1
movaps %xmm0,%xmm7
jmp    13b9 <__BetterVBalance+0x299>
lea    0xe5e(%rip),%rdi
call   1030 <__errexit@plt>
xorps  %xmm0,%xmm0
jmp    13fd <__BetterVBalance+0x2dd>
movaps %xmm0,%xmm1
movaps %xmm0,%xmm7
jmp    13ec <__BetterVBalance+0x2cc>
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
xorps  %xmm1,%xmm1
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%r13,%rax,4),%xmm2
movss  0x4(%r13,%rax,4),%xmm6
shufps $0x0,%xmm2,%xmm2
movss  (%r15,%rax,4),%xmm3
movss  0x4(%r15,%rax,4),%xmm4
movss  (%r14,%rax,4),%xmm5
unpcklps %xmm3,%xmm5
addps  %xmm2,%xmm5
addps  %xmm1,%xmm5
movss  0x4(%r14,%rax,4),%xmm1
unpcklps %xmm4,%xmm1
shufps $0x0,%xmm6,%xmm6
addps  %xmm1,%xmm6
addps  %xmm5,%xmm6
add    $0x2,%rax
movaps %xmm6,%xmm1
cmp    %rax,%rcx
jne    11d0 <__BetterVBalance+0xb0>
test   $0x1,%r12b
je     1244 <__BetterVBalance+0x124>
movss  0x0(%r13,%rax,4),%xmm1
shufps $0x0,%xmm1,%xmm1
movss  (%r15,%rax,4),%xmm2
movss  (%r14,%rax,4),%xmm3
unpcklps %xmm2,%xmm3
addps  %xmm1,%xmm3
addps  %xmm3,%xmm6
test   %edi,%edi
jle    13fd <__BetterVBalance+0x2dd>
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
shufps $0x55,%xmm6,%xmm6
xorps  %xmm2,%xmm2
cvtsi2sd %edi,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
divsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
divsd  %xmm2,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
xor    %ebx,%ebx
xorps  %xmm1,%xmm1
movaps %xmm1,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm0,0x4(%rsp)
movss  0x0(%r13,%rbx,4),%xmm1
addss  (%r15,%rbx,4),%xmm1
movss  0xc(%rsp),%xmm0
subss  %xmm1,%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movaps 0x10(%rsp),%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,0x10(%rsp)
movss  0x0(%r13,%rbx,4),%xmm1
addss  (%r14,%rbx,4),%xmm1
movss  0x8(%rsp),%xmm0
subss  %xmm1,%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0x4(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsp)
movss  0x4(%rsp),%xmm0
add    $0x1,%rbx
cmp    %rbx,%r12
jne    12a0 <__BetterVBalance+0x180>
movaps 0x10(%rsp),%xmm1
subss  %xmm0,%xmm1
movaps %xmm1,%xmm0
jmp    13fd <__BetterVBalance+0x2dd>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
movaps %xmm0,%xmm2
movaps %xmm0,%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rcx,4),%xmm3
movss  0x4(%r13,%rcx,4),%xmm1
shufps $0x0,%xmm3,%xmm3
movss  (%r14,%rcx,4),%xmm4
movss  0x4(%r14,%rcx,4),%xmm5
movss  (%r15,%rcx,4),%xmm6
unpcklps %xmm4,%xmm6
addps  %xmm3,%xmm6
movss  0x4(%r15,%rcx,4),%xmm3
unpcklps %xmm5,%xmm3
movaps %xmm6,%xmm4
maxps  %xmm0,%xmm4
addps  %xmm6,%xmm7
minps  %xmm2,%xmm6
shufps $0x0,%xmm1,%xmm1
addps  %xmm3,%xmm1
movaps %xmm1,%xmm0
maxps  %xmm4,%xmm0
addps  %xmm1,%xmm7
minps  %xmm6,%xmm1
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
movaps %xmm1,%xmm2
cmp    $0x1,%rsi
jne    1350 <__BetterVBalance+0x230>
test   $0x1,%al
je     13ec <__BetterVBalance+0x2cc>
movss  0x0(%r13,%rcx,4),%xmm2
shufps $0x0,%xmm2,%xmm2
movss  (%r14,%rcx,4),%xmm3
movss  (%r15,%rcx,4),%xmm4
unpcklps %xmm3,%xmm4
addps  %xmm2,%xmm4
movaps %xmm4,%xmm2
maxps  %xmm0,%xmm2
addps  %xmm4,%xmm7
minps  %xmm1,%xmm4
movaps %xmm2,%xmm0
movaps %xmm4,%xmm1
subps  %xmm1,%xmm0
divps  %xmm7,%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
subss  %xmm1,%xmm0
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@.str = [18 x i8] c"Unknown norm: %d\0A\00"
define float @__BetterVBalance(i32 %0, i32 %1, float* nocapture %2, float* nocapture %3, float* nocapture %4) {
switch i32 %1, label %196 [
i32 -1, label %14
i32 1, label %6
]
6: ; preds = %5
%7 = icmp sgt i32 %0, 0
br i1 %7, label %8, label %198
8: ; preds = %6
%9 = zext i32 %0 to i64
%10 = and i64 %9, 1
%11 = icmp eq i32 %0, 1
br i1 %11, label %140, label %12
12: ; preds = %8
%13 = and i64 %9, 4294967294
br label %108
14: ; preds = %5
%15 = load float, float* %2
%16 = load float, float* %3
%17 = load float, float* %4
%18 = insertelement <2 x float> poison, float %15, i64 0
%19 = shufflevector <2 x float> %18, <2 x float> poison, <2 x i32> zeroinitializer
%20 = insertelement <2 x float> poison, float %16, i64 0
%21 = insertelement <2 x float> %20, float %17, i64 1
%22 = fadd <2 x float> %19, %21
%23 = icmp sgt i32 %0, 1
br i1 %23, label %24, label %99
24: ; preds = %14
%25 = zext i32 %0 to i64
%26 = add nsw i64 %25, -1
%27 = and i64 %26, 1
%28 = icmp eq i32 %0, 2
br i1 %28, label %73, label %29
29: ; preds = %24
%30 = and i64 %26, -2
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 1, %29 ], [ %70, %31 ]
%33 = phi <2 x float> [ %22, %29 ], [ %66, %31 ]
%34 = phi <2 x float> [ %22, %29 ], [ %68, %31 ]
%35 = phi <2 x float> [ %22, %29 ], [ %69, %31 ]
%36 = phi i64 [ 0, %29 ], [ %71, %31 ]
%37 = getelementptr inbounds float, float* %2, i64 %32
%38 = load float, float* %37
%39 = getelementptr inbounds float, float* %3, i64 %32
%40 = load float, float* %39
%41 = getelementptr inbounds float, float* %4, i64 %32
%42 = load float, float* %41
%43 = insertelement <2 x float> poison, float %38, i64 0
%44 = shufflevector <2 x float> %43, <2 x float> poison, <2 x i32> zeroinitializer
%45 = insertelement <2 x float> poison, float %40, i64 0
%46 = insertelement <2 x float> %45, float %42, i64 1
%47 = fadd <2 x float> %44, %46
%48 = fcmp olt <2 x float> %33, %47
%49 = select <2 x i1> %48, <2 x float> %47, <2 x float> %33
%50 = fcmp ogt <2 x float> %34, %47
%51 = select <2 x i1> %50, <2 x float> %47, <2 x float> %34
%52 = fadd <2 x float> %35, %47
%53 = add nuw nsw i64 %32, 1
%54 = getelementptr inbounds float, float* %2, i64 %53
%55 = load float, float* %54
%56 = getelementptr inbounds float, float* %3, i64 %53
%57 = load float, float* %56
%58 = getelementptr inbounds float, float* %4, i64 %53
%59 = load float, float* %58
%60 = insertelement <2 x float> poison, float %55, i64 0
%61 = shufflevector <2 x float> %60, <2 x float> poison, <2 x i32> zeroinitializer
%62 = insertelement <2 x float> poison, float %57, i64 0
%63 = insertelement <2 x float> %62, float %59, i64 1
%64 = fadd <2 x float> %61, %63
%65 = fcmp olt <2 x float> %49, %64
%66 = select <2 x i1> %65, <2 x float> %64, <2 x float> %49
%67 = fcmp ogt <2 x float> %51, %64
%68 = select <2 x i1> %67, <2 x float> %64, <2 x float> %51
%69 = fadd <2 x float> %52, %64
%70 = add nuw nsw i64 %32, 2
%71 = add i64 %36, 2
%72 = icmp eq i64 %71, %30
br i1 %72, label %73, label %31
73: ; preds = %31, %24
%74 = phi <2 x float> [ undef, %24 ], [ %66, %31 ]
%75 = phi <2 x float> [ undef, %24 ], [ %68, %31 ]
%76 = phi <2 x float> [ undef, %24 ], [ %69, %31 ]
%77 = phi i64 [ 1, %24 ], [ %70, %31 ]
%78 = phi <2 x float> [ %22, %24 ], [ %66, %31 ]
%79 = phi <2 x float> [ %22, %24 ], [ %68, %31 ]
%80 = phi <2 x float> [ %22, %24 ], [ %69, %31 ]
%81 = icmp eq i64 %27, 0
br i1 %81, label %99, label %82
82: ; preds = %73
%83 = getelementptr inbounds float, float* %2, i64 %77
%84 = load float, float* %83
%85 = getelementptr inbounds float, float* %3, i64 %77
%86 = load float, float* %85
%87 = getelementptr inbounds float, float* %4, i64 %77
%88 = load float, float* %87
%89 = insertelement <2 x float> poison, float %84, i64 0
%90 = shufflevector <2 x float> %89, <2 x float> poison, <2 x i32> zeroinitializer
%91 = insertelement <2 x float> poison, float %86, i64 0
%92 = insertelement <2 x float> %91, float %88, i64 1
%93 = fadd <2 x float> %90, %92
%94 = fcmp olt <2 x float> %78, %93
%95 = select <2 x i1> %94, <2 x float> %93, <2 x float> %78
%96 = fcmp ogt <2 x float> %79, %93
%97 = select <2 x i1> %96, <2 x float> %93, <2 x float> %79
%98 = fadd <2 x float> %80, %93
br label %99
99: ; preds = %82, %73, %14
%100 = phi <2 x float> [ %22, %14 ], [ %74, %73 ], [ %95, %82 ]
%101 = phi <2 x float> [ %22, %14 ], [ %75, %73 ], [ %97, %82 ]
%102 = phi <2 x float> [ %22, %14 ], [ %76, %73 ], [ %98, %82 ]
%103 = fsub <2 x float> %100, %101
%104 = fdiv <2 x float> %103, %102
%105 = shufflevector <2 x float> %104, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%106 = fsub <2 x float> %104, %105
%107 = extractelement <2 x float> %106, i64 0
br label %198
108: ; preds = %108, %12
%109 = phi i64 [ 0, %12 ], [ %137, %108 ]
%110 = phi <2 x float> [ zeroinitializer, %12 ], [ %136, %108 ]
%111 = phi i64 [ 0, %12 ], [ %138, %108 ]
%112 = getelementptr inbounds float, float* %2, i64 %109
%113 = load float, float* %112
%114 = getelementptr inbounds float, float* %3, i64 %109
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %4, i64 %109
%117 = load float, float* %116
%118 = insertelement <2 x float> poison, float %113, i64 0
%119 = shufflevector <2 x float> %118, <2 x float> poison, <2 x i32> zeroinitializer
%120 = insertelement <2 x float> poison, float %117, i64 0
%121 = insertelement <2 x float> %120, float %115, i64 1
%122 = fadd <2 x float> %119, %121
%123 = fadd <2 x float> %110, %122
%124 = or i64 %109, 1
%125 = getelementptr inbounds float, float* %2, i64 %124
%126 = load float, float* %125
%127 = getelementptr inbounds float, float* %3, i64 %124
%128 = load float, float* %127
%129 = getelementptr inbounds float, float* %4, i64 %124
%130 = load float, float* %129
%131 = insertelement <2 x float> poison, float %126, i64 0
%132 = shufflevector <2 x float> %131, <2 x float> poison, <2 x i32> zeroinitializer
%133 = insertelement <2 x float> poison, float %130, i64 0
%134 = insertelement <2 x float> %133, float %128, i64 1
%135 = fadd <2 x float> %132, %134
%136 = fadd <2 x float> %123, %135
%137 = add nuw nsw i64 %109, 2
%138 = add i64 %111, 2
%139 = icmp eq i64 %138, %13
br i1 %139, label %140, label %108
140: ; preds = %108, %8
%141 = phi <2 x float> [ undef, %8 ], [ %136, %108 ]
%142 = phi i64 [ 0, %8 ], [ %137, %108 ]
%143 = phi <2 x float> [ zeroinitializer, %8 ], [ %136, %108 ]
%144 = icmp eq i64 %10, 0
br i1 %144, label %158, label %145
145: ; preds = %140
%146 = getelementptr inbounds float, float* %2, i64 %142
%147 = load float, float* %146
%148 = getelementptr inbounds float, float* %3, i64 %142
%149 = load float, float* %148
%150 = getelementptr inbounds float, float* %4, i64 %142
%151 = load float, float* %150
%152 = insertelement <2 x float> poison, float %147, i64 0
%153 = shufflevector <2 x float> %152, <2 x float> poison, <2 x i32> zeroinitializer
%154 = insertelement <2 x float> poison, float %151, i64 0
%155 = insertelement <2 x float> %154, float %149, i64 1
%156 = fadd <2 x float> %153, %155
%157 = fadd <2 x float> %143, %156
br label %158
158: ; preds = %140, %145
%159 = phi <2 x float> [ %141, %140 ], [ %157, %145 ]
%160 = extractelement <2 x float> %159, i64 1
%161 = fpext float %160 to double
%162 = extractelement <2 x float> %159, i64 0
%163 = fpext float %162 to double
%164 = sitofp i32 %0 to double
%165 = fdiv double %161, %164
%166 = fptrunc double %165 to float
%167 = fdiv double %163, %164
%168 = fptrunc double %167 to float
br i1 %7, label %169, label %198
169: ; preds = %158
%170 = zext i32 %0 to i64
br label %171
171: ; preds = %169, %171
%172 = phi i64 [ 0, %169 ], [ %192, %171 ]
%173 = phi float [ 0.000000e+00, %169 ], [ %191, %171 ]
%174 = phi float [ 0.000000e+00, %169 ], [ %183, %171 ]
%175 = getelementptr inbounds float, float* %2, i64 %172
%176 = load float, float* %175
%177 = getelementptr inbounds float, float* %3, i64 %172
%178 = load float, float* %177
%179 = fadd float %176, %178
%180 = fsub float %166, %179
%181 = tail call i64 @fabs(float %180)
%182 = sitofp i64 %181 to float
%183 = fadd float %174, %182
%184 = load float, float* %175
%185 = getelementptr inbounds float, float* %4, i64 %172
%186 = load float, float* %185
%187 = fadd float %184, %186
%188 = fsub float %168, %187
%189 = tail call i64 @fabs(float %188)
%190 = sitofp i64 %189 to float
%191 = fadd float %173, %190
%192 = add nuw nsw i64 %172, 1
%193 = icmp eq i64 %192, %170
br i1 %193, label %194, label %171
194: ; preds = %171
%195 = fsub float %183, %191
br label %198
196: ; preds = %5
%197 = tail call i32 @__errexit(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i32 %1)
br label %198
198: ; preds = %6, %158, %194, %196, %99
%199 = phi float [ %107, %99 ], [ 0.000000e+00, %196 ], [ %195, %194 ], [ 0.000000e+00, %158 ], [ 0.000000e+00, %6 ]
ret float %199
}