#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];
    }
    if (sum1 == 0.0)
      return 1;
    else if (sum2 == 0.0)
      return -1;
    else
      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    13af <__BetterVBalance+0x28f>
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  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1355 <__BetterVBalance+0x235>
jp     1355 <__BetterVBalance+0x235>
movss  0xcc1(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    154f <__BetterVBalance+0x42f>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1383 <__BetterVBalance+0x263>
jp     1383 <__BetterVBalance+0x263>
movss  0xc8f(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    154f <__BetterVBalance+0x42f>
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    154f <__BetterVBalance+0x42f>
cmpl   $0x1,-0xc(%rbp)
jne    1533 <__BetterVBalance+0x413>
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    1432 <__BetterVBalance+0x312>
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    13d0 <__BetterVBalance+0x2b0>
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x8(%rbp),%xmm2
movsd  0xbb8(%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  0xb91(%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    151f <__BetterVBalance+0x3ff>
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    1497 <__BetterVBalance+0x377>
movss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    154f <__BetterVBalance+0x42f>
mov    -0xc(%rbp),%esi
lea    0xad3(%rip),%rdi
call   1030 <__errexit@plt>
jmp    1547 <__BetterVBalance+0x427>
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    1429 <__BetterVBalance+0x309>
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    0xe66(%rip),%rdi
call   1030 <__errexit@plt>
xorps  %xmm0,%xmm0
jmp    1429 <__BetterVBalance+0x309>
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    1429 <__BetterVBalance+0x309>
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    1429 <__BetterVBalance+0x309>
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
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm7
jne    1400 <__BetterVBalance+0x2e0>
jp     1400 <__BetterVBalance+0x2e0>
movss  0xc02(%rip),%xmm0
jmp    1429 <__BetterVBalance+0x309>
movaps %xmm7,%xmm3
shufps $0x55,%xmm7,%xmm3
ucomiss %xmm2,%xmm3
jne    1418 <__BetterVBalance+0x2f8>
jp     1418 <__BetterVBalance+0x2f8>
movss  0xbee(%rip),%xmm0
jmp    1429 <__BetterVBalance+0x309>
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 %212
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* %13
%192 = fpext float %191 to double
%193 = fcmp oeq double %192, 0.000000e+00
br i1 %193, label %194, label %195
194: ; preds = %190
store float 1.000000e+00, float* %6
br label %316
195: ; preds = %190
%196 = load float, float* %14
%197 = fpext float %196 to double
%198 = fcmp oeq double %197, 0.000000e+00
br i1 %198, label %199, label %200
199: ; preds = %195
store float -1.000000e+00, float* %6
br label %316
200: ; preds = %195
%201 = load float, float* %15
%202 = load float, float* %17
%203 = fsub float %201, %202
%204 = load float, float* %13
%205 = fdiv float %203, %204
%206 = load float, float* %16
%207 = load float, float* %18
%208 = fsub float %206, %207
%209 = load float, float* %14
%210 = fdiv float %208, %209
%211 = fsub float %205, %210
store float %211, float* %6
br label %316
212: ; preds = %5
%213 = load i32, i32* %8
%214 = icmp eq i32 %213, 1
br i1 %214, label %215, label %311
215: ; preds = %212
store float 0.000000e+00, float* %14
store float 0.000000e+00, float* %13
store i32 0, i32* %12
br label %216
216: ; preds = %247, %215
%217 = load i32, i32* %12
%218 = load i32, i32* %7
%219 = icmp slt i32 %217, %218
br i1 %219, label %220, label %250
220: ; preds = %216
%221 = load float*, float** %9
%222 = load i32, i32* %12
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float, float* %221, i64 %223
%225 = load float, float* %224
%226 = load float*, float** %10
%227 = load i32, i32* %12
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %226, i64 %228
%230 = load float, float* %229
%231 = fadd float %225, %230
%232 = load float, float* %13
%233 = fadd float %232, %231
store float %233, float* %13
%234 = load float*, float** %9
%235 = load i32, i32* %12
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %234, i64 %236
%238 = load float, float* %237
%239 = load float*, float** %11
%240 = load i32, i32* %12
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float, float* %239, i64 %241
%243 = load float, float* %242
%244 = fadd float %238, %243
%245 = load float, float* %14
%246 = fadd float %245, %244
store float %246, float* %14
br label %247
247: ; preds = %220
%248 = load i32, i32* %12
%249 = add nsw i32 %248, 1
store i32 %249, i32* %12
br label %216
250: ; preds = %216
%251 = load float, float* %13
%252 = fpext float %251 to double
%253 = load i32, i32* %7
%254 = sitofp i32 %253 to double
%255 = fmul double 1.000000e+00, %254
%256 = fdiv double %252, %255
%257 = fptrunc double %256 to float
store float %257, float* %13
%258 = load float, float* %14
%259 = fpext float %258 to double
%260 = load i32, i32* %7
%261 = sitofp i32 %260 to double
%262 = fmul double 1.000000e+00, %261
%263 = fdiv double %259, %262
%264 = fptrunc double %263 to float
store float %264, float* %14
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %19
store i32 0, i32* %12
br label %265
265: ; preds = %304, %250
%266 = load i32, i32* %12
%267 = load i32, i32* %7
%268 = icmp slt i32 %266, %267
br i1 %268, label %269, label %307
269: ; preds = %265
%270 = load float, float* %13
%271 = load float*, float** %9
%272 = load i32, i32* %12
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds float, float* %271, i64 %273
%275 = load float, float* %274
%276 = load float*, float** %10
%277 = load i32, i32* %12
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds float, float* %276, i64 %278
%280 = load float, float* %279
%281 = fadd float %275, %280
%282 = fsub float %270, %281
%283 = call i64 @fabs(float %282)
%284 = sitofp i64 %283 to float
%285 = load float, float* %19
%286 = fadd float %285, %284
store float %286, float* %19
%287 = load float, float* %14
%288 = load float*, float** %9
%289 = load i32, i32* %12
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds float, float* %288, i64 %290
%292 = load float, float* %291
%293 = load float*, float** %11
%294 = load i32, i32* %12
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds float, float* %293, i64 %295
%297 = load float, float* %296
%298 = fadd float %292, %297
%299 = fsub float %287, %298
%300 = call i64 @fabs(float %299)
%301 = sitofp i64 %300 to float
%302 = load float, float* %20
%303 = fadd float %302, %301
store float %303, float* %20
br label %304
304: ; preds = %269
%305 = load i32, i32* %12
%306 = add nsw i32 %305, 1
store i32 %306, i32* %12
br label %265
307: ; preds = %265
%308 = load float, float* %19
%309 = load float, float* %20
%310 = fsub float %308, %309
store float %310, float* %6
br label %316
311: ; preds = %212
%312 = load i32, i32* %8
%313 = call i32 @__errexit(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i32 %312)
br label %314
314: ; preds = %311
br label %315
315: ; preds = %314
store float 0.000000e+00, float* %6
br label %316
316: ; preds = %315, %307, %200, %199, %194
%317 = load float, float* %6
ret float %317
}

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 %202 [
i32 -1, label %14
i32 1, label %6
]
6: ; preds = %5
%7 = icmp sgt i32 %0, 0
br i1 %7, label %8, label %204
8: ; preds = %6
%9 = zext i32 %0 to i64
%10 = and i64 %9, 1
%11 = icmp eq i32 %0, 1
br i1 %11, label %146, label %12
12: ; preds = %8
%13 = and i64 %9, 4294967294
br label %114
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 = extractelement <2 x float> %102, i64 0
%104 = fcmp oeq float %103, 0.000000e+00
br i1 %104, label %204, label %105
105: ; preds = %99
%106 = extractelement <2 x float> %102, i64 1
%107 = fcmp oeq float %106, 0.000000e+00
br i1 %107, label %204, label %108
108: ; preds = %105
%109 = fsub <2 x float> %100, %101
%110 = fdiv <2 x float> %109, %102
%111 = shufflevector <2 x float> %110, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%112 = fsub <2 x float> %110, %111
%113 = extractelement <2 x float> %112, i64 0
br label %204
114: ; preds = %114, %12
%115 = phi i64 [ 0, %12 ], [ %143, %114 ]
%116 = phi <2 x float> [ zeroinitializer, %12 ], [ %142, %114 ]
%117 = phi i64 [ 0, %12 ], [ %144, %114 ]
%118 = getelementptr inbounds float, float* %2, i64 %115
%119 = load float, float* %118
%120 = getelementptr inbounds float, float* %3, i64 %115
%121 = load float, float* %120
%122 = getelementptr inbounds float, float* %4, i64 %115
%123 = load float, float* %122
%124 = insertelement <2 x float> poison, float %119, i64 0
%125 = shufflevector <2 x float> %124, <2 x float> poison, <2 x i32> zeroinitializer
%126 = insertelement <2 x float> poison, float %123, i64 0
%127 = insertelement <2 x float> %126, float %121, i64 1
%128 = fadd <2 x float> %125, %127
%129 = fadd <2 x float> %116, %128
%130 = or i64 %115, 1
%131 = getelementptr inbounds float, float* %2, i64 %130
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %3, i64 %130
%134 = load float, float* %133
%135 = getelementptr inbounds float, float* %4, i64 %130
%136 = load float, float* %135
%137 = insertelement <2 x float> poison, float %132, i64 0
%138 = shufflevector <2 x float> %137, <2 x float> poison, <2 x i32> zeroinitializer
%139 = insertelement <2 x float> poison, float %136, i64 0
%140 = insertelement <2 x float> %139, float %134, i64 1
%141 = fadd <2 x float> %138, %140
%142 = fadd <2 x float> %129, %141
%143 = add nuw nsw i64 %115, 2
%144 = add i64 %117, 2
%145 = icmp eq i64 %144, %13
br i1 %145, label %146, label %114
146: ; preds = %114, %8
%147 = phi <2 x float> [ undef, %8 ], [ %142, %114 ]
%148 = phi i64 [ 0, %8 ], [ %143, %114 ]
%149 = phi <2 x float> [ zeroinitializer, %8 ], [ %142, %114 ]
%150 = icmp eq i64 %10, 0
br i1 %150, label %164, label %151
151: ; preds = %146
%152 = getelementptr inbounds float, float* %2, i64 %148
%153 = load float, float* %152
%154 = getelementptr inbounds float, float* %3, i64 %148
%155 = load float, float* %154
%156 = getelementptr inbounds float, float* %4, i64 %148
%157 = load float, float* %156
%158 = insertelement <2 x float> poison, float %153, i64 0
%159 = shufflevector <2 x float> %158, <2 x float> poison, <2 x i32> zeroinitializer
%160 = insertelement <2 x float> poison, float %157, i64 0
%161 = insertelement <2 x float> %160, float %155, i64 1
%162 = fadd <2 x float> %159, %161
%163 = fadd <2 x float> %149, %162
br label %164
164: ; preds = %146, %151
%165 = phi <2 x float> [ %147, %146 ], [ %163, %151 ]
%166 = extractelement <2 x float> %165, i64 1
%167 = fpext float %166 to double
%168 = extractelement <2 x float> %165, i64 0
%169 = fpext float %168 to double
%170 = sitofp i32 %0 to double
%171 = fdiv double %167, %170
%172 = fptrunc double %171 to float
%173 = fdiv double %169, %170
%174 = fptrunc double %173 to float
br i1 %7, label %175, label %204
175: ; preds = %164
%176 = zext i32 %0 to i64
br label %177
177: ; preds = %175, %177
%178 = phi i64 [ 0, %175 ], [ %198, %177 ]
%179 = phi float [ 0.000000e+00, %175 ], [ %197, %177 ]
%180 = phi float [ 0.000000e+00, %175 ], [ %189, %177 ]
%181 = getelementptr inbounds float, float* %2, i64 %178
%182 = load float, float* %181
%183 = getelementptr inbounds float, float* %3, i64 %178
%184 = load float, float* %183
%185 = fadd float %182, %184
%186 = fsub float %172, %185
%187 = tail call i64 @fabs(float %186)
%188 = sitofp i64 %187 to float
%189 = fadd float %180, %188
%190 = load float, float* %181
%191 = getelementptr inbounds float, float* %4, i64 %178
%192 = load float, float* %191
%193 = fadd float %190, %192
%194 = fsub float %174, %193
%195 = tail call i64 @fabs(float %194)
%196 = sitofp i64 %195 to float
%197 = fadd float %179, %196
%198 = add nuw nsw i64 %178, 1
%199 = icmp eq i64 %198, %176
br i1 %199, label %200, label %177
200: ; preds = %177
%201 = fsub float %189, %197
br label %204
202: ; preds = %5
%203 = tail call i32 @__errexit(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i32 %1)
br label %204
204: ; preds = %6, %164, %200, %105, %99, %202, %108
%205 = phi float [ %113, %108 ], [ 0.000000e+00, %202 ], [ 1.000000e+00, %99 ], [ -1.000000e+00, %105 ], [ %201, %200 ], [ 0.000000e+00, %164 ], [ 0.000000e+00, %6 ]
ret float %205
}