#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 */
scalar_t__ fabs(float);
void balanc(float **a, int n) {
  int last, i, j;
  float s, r, g, f, c, sqrdx;
  sqrdx = 2.0 * 2.0;
  last = 0;
  while (last == 0) {
    last = 1;
    for (i = 1; i <= n; i++) {
      r = c = 0.0;
      for (j = 1; j <= n; j++) {
        if (j != i) {
          c += fabs(a[j][i]);
          r += fabs(a[i][j]);
        }
      }
      if (c && r) {
        g = r / 2.0;
        f = 1.0;
        s = c + r;
        while (c < g) {
          f *= 2.0;
          c *= sqrdx;
        }
        g = r * 2.0;
        while (c > g) {
          f /= 2.0;
          c /= sqrdx;
        }
        if ((c + r) / f < 0.95 * s) {
          last = 0;
          g = 1.0 / f;
          for (j = 1; j <= n; j++)
            a[i][j] *= g;
          for (j = 1; j <= n; j++)
            a[j][i] *= f;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<balanc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movss  0xed9(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jne    13fe <balanc+0x2ee>
movl   $0x1,-0x10(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13f9 <balanc+0x2e9>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11eb <balanc+0xdb>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     11d8 <balanc+0xc8>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    11dd <balanc+0xcd>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    116e <balanc+0x5e>
movss  -0x2c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1207 <balanc+0xf7>
jp     1207 <balanc+0xf7>
jmp    13e6 <balanc+0x2d6>
movss  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1223 <balanc+0x113>
jp     1223 <balanc+0x113>
jmp    13e6 <balanc+0x2d6>
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdd4(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xdbb(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    12a2 <balanc+0x192>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd87(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    125d <balanc+0x14d>
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd55(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x2c(%rbp),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    1305 <balanc+0x1f5>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd28(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    12c0 <balanc+0x1b0>
movss  -0x2c(%rbp),%xmm0
addss  -0x20(%rbp),%xmm0
divss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xce7(%rip),%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    13e1 <balanc+0x2d1>
movl   $0x0,-0x10(%rbp)
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcc9(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     139c <balanc+0x28c>
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1363 <balanc+0x253>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13dc <balanc+0x2cc>
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13a3 <balanc+0x293>
jmp    13e1 <balanc+0x2d1>
jmp    13e6 <balanc+0x2d6>
jmp    13eb <balanc+0x2db>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    114b <balanc+0x3b>
jmp    1133 <balanc+0x23>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<balanc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rsi,0x20(%rsp)
test   %esi,%esi
jle    14cd <balanc+0x3bd>
mov    %rdi,%rbx
mov    0x20(%rsp),%rax
lea    0x1(%rax),%r15d
lea    -0x1(%r15),%rbp
lea    -0x9(%r15),%rax
mov    %rax,0x48(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
lea    -0x2(%r15),%rax
mov    %rax,0x50(%rsp)
mov    %rbp,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
add    $0x1,%rax
mov    %rax,0x30(%rsp)
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x28(%rsp)
mov    %ebp,%r12d
and    $0x3,%r12d
mov    %rbp,0x18(%rsp)
and    $0xfffffffffffffffc,%rbp
movl   $0x1,0x10(%rsp)
mov    $0x1,%r13d
xorps  %xmm8,%xmm8
movss  0xe58(%rip),%xmm7
movss  0xe57(%rip),%xmm9
movss  0xe52(%rip),%xmm10
nopw   0x0(%rax,%rax,1)
mov    $0x1,%r14d
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
xorps  %xmm3,%xmm3
jmp    11e9 <balanc+0xd9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
cmp    %r14,%r15
je     1260 <balanc+0x150>
cmp    %r14,%r13
je     11e0 <balanc+0xd0>
mov    (%rbx,%r14,8),%rax
movss  (%rax,%r13,4),%xmm0
movss  %xmm3,0x14(%rsp)
call   1030 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0xc(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
mov    (%rbx,%r13,8),%rax
movss  (%rax,%r14,4),%xmm0
call   1030 <fabs@plt>
movss  0x14(%rsp),%xmm3
movss  0xdd3(%rip),%xmm10
movss  0xdc6(%rip),%xmm9
movss  0xdb6(%rip),%xmm7
xorps  %xmm8,%xmm8
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  %xmm0,%xmm3
jmp    11e0 <balanc+0xd0>
nopl   0x0(%rax)
movss  0xc(%rsp),%xmm0
ucomiss %xmm8,%xmm0
jne    1272 <balanc+0x162>
jnp    14a0 <balanc+0x390>
ucomiss %xmm8,%xmm3
jne    127e <balanc+0x16e>
jnp    14a0 <balanc+0x390>
movaps %xmm3,%xmm2
mulss  %xmm7,%xmm2
movss  0xc(%rsp),%xmm1
ucomiss %xmm1,%xmm2
movss  0xd6e(%rip),%xmm0
jbe    12be <balanc+0x1ae>
movss  0xc(%rsp),%xmm1
movss  0xd5e(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
addss  %xmm0,%xmm0
mulss  %xmm9,%xmm1
ucomiss %xmm1,%xmm2
ja     12b0 <balanc+0x1a0>
movaps %xmm3,%xmm2
addss  %xmm3,%xmm2
ucomiss %xmm2,%xmm1
jbe    12de <balanc+0x1ce>
nopw   0x0(%rax,%rax,1)
mulss  %xmm7,%xmm0
mulss  %xmm10,%xmm1
ucomiss %xmm2,%xmm1
ja     12d0 <balanc+0x1c0>
movss  0xc(%rsp),%xmm2
addss  %xmm3,%xmm2
addss  %xmm3,%xmm1
divss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
mulsd  0xd10(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    14a0 <balanc+0x390>
movss  0xcf2(%rip),%xmm1
divss  %xmm0,%xmm1
mov    (%rbx,%r13,8),%rax
mov    $0x1,%ecx
cmpq   $0x8,0x18(%rsp)
jb     13d0 <balanc+0x2c0>
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
cmpq   $0x8,0x48(%rsp)
jae    133e <balanc+0x22e>
xor    %ecx,%ecx
jmp    138e <balanc+0x27e>
mov    0x28(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x4(%rax,%rcx,4),%xmm3
movups 0x14(%rax,%rcx,4),%xmm4
movups 0x24(%rax,%rcx,4),%xmm5
movups 0x34(%rax,%rcx,4),%xmm6
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,0x4(%rax,%rcx,4)
movups %xmm4,0x14(%rax,%rcx,4)
mulps  %xmm2,%xmm5
mulps  %xmm2,%xmm6
movups %xmm5,0x24(%rax,%rcx,4)
movups %xmm6,0x34(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1350 <balanc+0x240>
testb  $0x1,0x40(%rsp)
je     13b5 <balanc+0x2a5>
shl    $0x2,%rcx
or     $0x4,%rcx
movups (%rax,%rcx,1),%xmm3
movups 0x10(%rax,%rcx,1),%xmm4
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,(%rax,%rcx,1)
movups %xmm4,0x10(%rax,%rcx,1)
mov    0x30(%rsp),%rcx
mov    0x38(%rsp),%rdx
cmp    %rdx,0x18(%rsp)
je     13e7 <balanc+0x2d7>
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    13d0 <balanc+0x2c0>
mov    $0x1,%eax
cmpq   $0x3,0x50(%rsp)
jb     1461 <balanc+0x351>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rbx,%rax,8),%rcx
movss  (%rcx,%r13,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%r13,4)
mov    0x10(%rbx,%rax,8),%rcx
movss  (%rcx,%r13,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%r13,4)
mov    0x18(%rbx,%rax,8),%rcx
movss  (%rcx,%r13,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%r13,4)
mov    0x20(%rbx,%rax,8),%rcx
movss  (%rcx,%r13,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%r13,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1400 <balanc+0x2f0>
add    $0x1,%rax
movl   $0x0,0x10(%rsp)
test   %r12,%r12
je     14a0 <balanc+0x390>
lea    (%rbx,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax,%rcx,8),%rdx
movss  (%rdx,%r13,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%r13,4)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1480 <balanc+0x370>
nopl   (%rax)
add    $0x1,%r13
cmp    %r15,%r13
jne    11c0 <balanc+0xb0>
cmpl   $0x0,0x10(%rsp)
jne    14cd <balanc+0x3bd>
mov    $0x1,%r13d
movl   $0x1,0x10(%rsp)
cmpl   $0x0,0x20(%rsp)
jg     11c0 <balanc+0xb0>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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