#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__ calloc(int, int);
int fabs(double);
int /*<<< orphan*/ fatalx(char *, int);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ free2D(double ***, int);
double ifall(int, int);
double **initarray_2Ddouble(int, int, double);
int /*<<< orphan*/ ivmaxmin(int *, int, int *, int /*<<< orphan*/ *);
int /*<<< orphan*/ ivzero(int *, int);
double unbiasedest(int *ndx, int ndsize, int **counts) {
  double xtop, xbot, yest, y;
  int popind[20];
  int popmax, j, k, n, nmax, a, t, s;
  int *tcounts;
  double **xmomest, yp;
  ivmaxmin(ndx, ndsize, &popmax, NULL);
  if ((tcounts = (int *)calloc((popmax + 1), sizeof(int))) == NULL)
    fatalx("Unable to allocate %d unit(s) for item \n", popmax + 1);
  for (j = 0; j <= popmax; ++j) {
    tcounts[j] = counts[j][0] + counts[j][1];
  }
  xmomest = initarray_2Ddouble(popmax + 1, ndsize, 0.0);
  for (j = 0; j <= popmax; ++j) {
    xmomest[j][0] = 1.0;
    for (k = 1; k <= ndsize; ++k) {
      xtop = ifall(counts[j][0], k);
      xbot = ifall(tcounts[j], k);
      if (xbot <= 0.1)
        xmomest[j][k] = -10000.0;
      else
        xmomest[j][k] = (double)xtop / (double)xbot;
    }
  }
  nmax = (1 << (ndsize)) - 1;
  yest = 0.0;
  for (n = 0; n <= nmax; ++n) {
    t = n;
    ivzero(popind, popmax + 1);
    for (k = 0; k < ndsize; ++k) {
      a = 0;
      s = t & 1;
      t = t >> 1;
      if (s == 1)
        a = ndx[k];
      ++popind[a];
    }
    yp = 1.0;
    for (j = 0; j <= popmax; ++j) {
      t = popind[j];
      s = 0;
      if (j > 0)
        s = t % 2;
      y = xmomest[j][t];
      if (y < -1.0) {
        free(tcounts);
        free2D(&xmomest, popmax + 1);
        return (-10000.0);
      }
      if (s == 1)
        y = -y;
      yp *= y;
    }
    yest += yp;
  }
  if (fabs(yest) >= 100)
    yest = -10000;
  free(tcounts);
  free2D(&xmomest, popmax + 1);
  return (yest);
}


x86 assembly (clang, -O0):
<unbiasedest>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
lea    -0x94(%rbp),%rdx
xor    %eax,%eax
mov    %eax,%ecx
call   1060 <ivmaxmin@plt>
mov    -0x94(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0xb8(%rbp)
cmp    $0x0,%rax
jne    11f6 <unbiasedest+0x66>
mov    -0x94(%rbp),%esi
add    $0x1,%esi
lea    0xe2f(%rip),%rdi
call   1050 <fatalx@plt>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x94(%rbp),%eax
jg     125a <unbiasedest+0xca>
mov    -0x20(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%edx
mov    -0x20(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    0x4(%rax),%edx
mov    -0xb8(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1200 <unbiasedest+0x70>
mov    -0x94(%rbp),%edi
add    $0x1,%edi
mov    -0x14(%rbp),%esi
xorps  %xmm0,%xmm0
call   1080 <initarray_2Ddouble@plt>
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x94(%rbp),%eax
jg     13a2 <unbiasedest+0x212>
mov    -0xc0(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0xd5d(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1389 <unbiasedest+0x1f9>
mov    -0x20(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%edi
mov    -0x9c(%rbp),%esi
call   10a0 <ifall@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x9c(%rbp),%esi
call   10a0 <ifall@plt>
movsd  %xmm0,-0x30(%rbp)
movsd  0xd06(%rip),%xmm0
ucomisd -0x30(%rbp),%xmm0
jb     1348 <unbiasedest+0x1b8>
mov    -0xc0(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  0xcc2(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1370 <unbiasedest+0x1e0>
movsd  -0x28(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1375 <unbiasedest+0x1e5>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    12b9 <unbiasedest+0x129>
jmp    138e <unbiasedest+0x1fe>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    127f <unbiasedest+0xef>
mov    -0x14(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jg     15d9 <unbiasedest+0x449>
mov    -0xa0(%rbp),%eax
mov    %eax,-0xac(%rbp)
lea    -0x90(%rbp),%rdi
mov    -0x94(%rbp),%esi
add    $0x1,%esi
call   1040 <ivzero@plt>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1488 <unbiasedest+0x2f8>
movl   $0x0,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xac(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x1,-0xb0(%rbp)
jne    145c <unbiasedest+0x2cc>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
movslq -0xa8(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x90(%rbp,%rax,4)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1404 <unbiasedest+0x274>
movsd  0xb78(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x94(%rbp),%eax
jg     15b3 <unbiasedest+0x423>
movslq -0x98(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%eax
mov    %eax,-0xac(%rbp)
movl   $0x0,-0xb0(%rbp)
cmpl   $0x0,-0x98(%rbp)
jle    14f3 <unbiasedest+0x363>
mov    -0xac(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0xb0(%rbp)
mov    -0xc0(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xaf2(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    155c <unbiasedest+0x3cc>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x94(%rbp),%esi
add    $0x1,%esi
lea    -0xc0(%rbp),%rdi
call   10b0 <free2D@plt>
movsd  0xaae(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1624 <unbiasedest+0x494>
cmpl   $0x1,-0xb0(%rbp)
jne    158a <unbiasedest+0x3fa>
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    14a2 <unbiasedest+0x312>
movsd  -0xc8(%rbp),%xmm0
ff
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    13c7 <unbiasedest+0x237>
movsd  -0x38(%rbp),%xmm0
call   1090 <fabs@plt>
cmp    $0x64,%eax
jl     15f9 <unbiasedest+0x469>
movsd  0xa0c(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x94(%rbp),%esi
add    $0x1,%esi
lea    -0xc0(%rbp),%rdi
call   10b0 <free2D@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unbiasedest>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rdx,%rbx
mov    %rdi,%r14
lea    0xc(%rsp),%rdx
mov    %rsi,0x18(%rsp)
xor    %ecx,%ecx
call   1060 <ivmaxmin@plt>
mov    0xc(%rsp),%edi
add    $0x1,%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,%r12
test   %rax,%rax
jne    11e4 <unbiasedest+0x54>
mov    0xc(%rsp),%esi
add    $0x1,%esi
lea    0xe51(%rip),%rdi
call   1050 <fatalx@plt>
mov    0xc(%rsp),%edi
test   %edi,%edi
mov    0x18(%rsp),%rsi
js     121d <unbiasedest+0x8d>
mov    $0xffffffffffffffff,%rax
nopl   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rax,8),%rcx
mov    0x4(%rcx),%edx
add    (%rcx),%edx
mov    %edx,0x4(%r12,%rax,4)
movslq 0xc(%rsp),%rdi
add    $0x1,%rax
cmp    %rdi,%rax
jl     1200 <unbiasedest+0x70>
add    $0x1,%edi
xorpd  %xmm0,%xmm0
mov    %rsi,%rbp
call   1080 <initarray_2Ddouble@plt>
mov    %rax,%r13
mov    %rax,0x38(%rsp)
mov    0xc(%rsp),%esi
test   %esi,%esi
mov    %r14,0x28(%rsp)
js     12f3 <unbiasedest+0x163>
lea    0x1(%rbp),%r14d
xor    %r15d,%r15d
mov    %rbp,%rcx
xorpd  %xmm0,%xmm0
jmp    127c <unbiasedest+0xec>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xc(%rsp),%esi
mov    0x18(%rsp),%rcx
xorpd  %xmm0,%xmm0
lea    0x1(%r15),%rax
movslq %esi,%rdx
cmp    %rdx,%r15
mov    %rax,%r15
jge    12fa <unbiasedest+0x16a>
mov    0x0(%r13,%r15,8),%rax
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rax)
test   %ecx,%ecx
jle    126d <unbiasedest+0xdd>
mov    $0x1,%ebp
jmp    12b3 <unbiasedest+0x123>
nopl   0x0(%rax)
mov    0x0(%r13,%r15,8),%rax
movsd  %xmm1,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
je     1260 <unbiasedest+0xd0>
mov    (%rbx,%r15,8),%rax
mov    (%rax),%edi
mov    %ebp,%esi
call   10a0 <ifall@plt>
movsd  %xmm0,0x10(%rsp)
mov    (%r12,%r15,4),%edi
mov    %ebp,%esi
call   10a0 <ifall@plt>
movsd  0xd2f(%rip),%xmm1
ucomisd %xmm0,%xmm1
movsd  0xd1b(%rip),%xmm1
jae    12a0 <unbiasedest+0x110>
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
jmp    12a0 <unbiasedest+0x110>
mov    %rbp,%rcx
xorpd  %xmm0,%xmm0
mov    $0x1,%r15d
shl    %cl,%r15d
mov    %ecx,%ebx
mov    %rbx,0x30(%rsp)
and    $0xfffffffe,%ebx
xor    %r14d,%r14d
movsd  0xce8(%rip),%xmm1
movsd  %xmm1,0x20(%rsp)
mov    0x28(%rsp),%rbp
jmp    134b <unbiasedest+0x1bb>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x1,%r14d
cmp    %r15d,%r14d
je     145b <unbiasedest+0x2cb>
movsd  %xmm0,0x10(%rsp)
add    $0x1,%esi
lea    0x40(%rsp),%rdi
call   1040 <ivzero@plt>
mov    0x18(%rsp),%rax
test   %eax,%eax
jle    138f <unbiasedest+0x1ff>
cmp    $0x1,%eax
jne    1410 <unbiasedest+0x280>
xor    %eax,%eax
mov    %r14d,%ecx
testb  $0x1,0x30(%rsp)
je     138f <unbiasedest+0x1ff>
xor    %edx,%edx
test   $0x1,%cl
je     1387 <unbiasedest+0x1f7>
mov    0x0(%rbp,%rax,4),%edx
movslq %edx,%rax
addl   $0x1,0x40(%rsp,%rax,4)
mov    0xc(%rsp),%esi
movsd  0xc75(%rip),%xmm0
test   %esi,%esi
movsd  0xc73(%rip),%xmm3
movapd 0xc73(%rip),%xmm4
js     1330 <unbiasedest+0x1a0>
lea    0x1(%rsi),%rax
xor    %ecx,%ecx
movsd  0xc53(%rip),%xmm0
jmp    13d1 <unbiasedest+0x241>
nop
mulsd  %xmm2,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rax
je     1330 <unbiasedest+0x1a0>
movslq 0x40(%rsp,%rcx,4),%rdx
mov    0x0(%r13,%rcx,8),%rdi
movsd  (%rdi,%rdx,8),%xmm1
ucomisd %xmm1,%xmm3
ja     1481 <unbiasedest+0x2f1>
mov    %edx,%edi
shr    $0x1f,%edi
add    %edx,%edi
and    $0xfffffffe,%edi
sub    %edi,%edx
movapd %xmm1,%xmm2
cmp    $0x1,%edx
jne    1403 <unbiasedest+0x273>
xorpd  %xmm4,%xmm2
test   %rcx,%rcx
jne    13c0 <unbiasedest+0x230>
movapd %xmm1,%xmm2
jmp    13c0 <unbiasedest+0x230>
xchg   %ax,%ax
xor    %eax,%eax
mov    %r14d,%ecx
jmp    1438 <unbiasedest+0x2a8>
nopw   0x0(%rax,%rax,1)
movslq %edx,%rdx
addl   $0x1,0x40(%rsp,%rdx,4)
shr    $0x2,%ecx
add    $0x2,%rax
cmp    %rax,%rbx
je     1375 <unbiasedest+0x1e5>
xor    %edx,%edx
mov    $0x0,%esi
test   $0x1,%cl
je     1448 <unbiasedest+0x2b8>
mov    0x0(%rbp,%rax,4),%esi
movslq %esi,%rsi
addl   $0x1,0x40(%rsp,%rsi,4)
test   $0x2,%cl
je     1420 <unbiasedest+0x290>
mov    0x4(%rbp,%rax,4),%edx
jmp    1420 <unbiasedest+0x290>
movsd  %xmm0,0x10(%rsp)
call   1090 <fabs@plt>
cmp    $0x64,%eax
jge    1473 <unbiasedest+0x2e3>
movsd  0x10(%rsp),%xmm0
jmp    147b <unbiasedest+0x2eb>
movsd  0xb85(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xc(%rsp),%esi
add    $0x1,%esi
lea    0x38(%rsp),%rdi
call   10b0 <free2D@plt>
movsd  0x20(%rsp),%xmm0
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [41 x i8] c"Unable to allocate %d unit(s) for item \0A\00"
define double @unbiasedest(i32* %0, i32 %1, i32** %2) {
%4 = alloca double
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32**
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca [20 x i32]
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32*
%22 = alloca double**
%23 = alloca double
store i32* %0, i32** %5
store i32 %1, i32* %6
store i32** %2, i32*** %7
%24 = load i32*, i32** %5
%25 = load i32, i32* %6
%26 = call i32 @ivmaxmin(i32* %24, i32 %25, i32* %13, i32* null)
%27 = load i32, i32* %13
%28 = add nsw i32 %27, 1
%29 = call i64 @calloc(i32 %28, i32 4)
%30 = inttoptr i64 %29 to i32*
store i32* %30, i32** %21
%31 = icmp eq i32* %30, null
br i1 %31, label %32, label %36
32: ; preds = %3
%33 = load i32, i32* %13
%34 = add nsw i32 %33, 1
%35 = call i32 @fatalx(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 %34)
br label %36
36: ; preds = %32, %3
store i32 0, i32* %14
br label %37
37: ; preds = %61, %36
%38 = load i32, i32* %14
%39 = load i32, i32* %13
%40 = icmp sle i32 %38, %39
br i1 %40, label %41, label %64
41: ; preds = %37
%42 = load i32**, i32*** %7
%43 = load i32, i32* %14
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i32*, i32** %42, i64 %44
%46 = load i32*, i32** %45
%47 = getelementptr inbounds i32, i32* %46, i64 0
%48 = load i32, i32* %47
%49 = load i32**, i32*** %7
%50 = load i32, i32* %14
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32*, i32** %49, i64 %51
%53 = load i32*, i32** %52
%54 = getelementptr inbounds i32, i32* %53, i64 1
%55 = load i32, i32* %54
%56 = add nsw i32 %48, %55
%57 = load i32*, i32** %21
%58 = load i32, i32* %14
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %57, i64 %59
store i32 %56, i32* %60
br label %61
61: ; preds = %41
%62 = load i32, i32* %14
%63 = add nsw i32 %62, 1
store i32 %63, i32* %14
br label %37
64: ; preds = %37
%65 = load i32, i32* %13
%66 = add nsw i32 %65, 1
%67 = load i32, i32* %6
%68 = call double** @initarray_2Ddouble(i32 %66, i32 %67, double 0.000000e+00)
store double** %68, double*** %22
store i32 0, i32* %14
br label %69
69: ; preds = %129, %64
%70 = load i32, i32* %14
%71 = load i32, i32* %13
%72 = icmp sle i32 %70, %71
br i1 %72, label %73, label %132
73: ; preds = %69
%74 = load double**, double*** %22
%75 = load i32, i32* %14
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double*, double** %74, i64 %76
%78 = load double*, double** %77
%79 = getelementptr inbounds double, double* %78, i64 0
store double 1.000000e+00, double* %79
store i32 1, i32* %15
br label %80
80: ; preds = %125, %73
%81 = load i32, i32* %15
%82 = load i32, i32* %6
%83 = icmp sle i32 %81, %82
br i1 %83, label %84, label %128
84: ; preds = %80
%85 = load i32**, i32*** %7
%86 = load i32, i32* %14
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i32*, i32** %85, i64 %87
%89 = load i32*, i32** %88
%90 = getelementptr inbounds i32, i32* %89, i64 0
%91 = load i32, i32* %90
%92 = load i32, i32* %15
%93 = call double @ifall(i32 %91, i32 %92)
store double %93, double* %8
%94 = load i32*, i32** %21
%95 = load i32, i32* %14
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %94, i64 %96
%98 = load i32, i32* %97
%99 = load i32, i32* %15
%100 = call double @ifall(i32 %98, i32 %99)
store double %100, double* %9
%101 = load double, double* %9
%102 = fcmp ole double %101, 1.000000e-01
br i1 %102, label %103, label %112
103: ; preds = %84
%104 = load double**, double*** %22
%105 = load i32, i32* %14
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double*, double** %104, i64 %106
%108 = load double*, double** %107
%109 = load i32, i32* %15
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %108, i64 %110
store double -1.000000e+04, double* %111
br label %124
112: ; preds = %84
%113 = load double, double* %8
%114 = load double, double* %9
%115 = fdiv double %113, %114
%116 = load double**, double*** %22
%117 = load i32, i32* %14
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double*, double** %116, i64 %118
%120 = load double*, double** %119
%121 = load i32, i32* %15
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %120, i64 %122
store double %115, double* %123
br label %124
124: ; preds = %112, %103
br label %125
125: ; preds = %124
%126 = load i32, i32* %15
%127 = add nsw i32 %126, 1
store i32 %127, i32* %15
br label %80
128: ; preds = %80
br label %129
129: ; preds = %128
%130 = load i32, i32* %14
%131 = add nsw i32 %130, 1
store i32 %131, i32* %14
br label %69
132: ; preds = %69
%133 = load i32, i32* %6
%134 = shl i32 1, %133
%135 = sub nsw i32 %134, 1
store i32 %135, i32* %17
store double 0.000000e+00, double* %10
store i32 0, i32* %16
br label %136
136: ; preds = %222, %132
%137 = load i32, i32* %16
%138 = load i32, i32* %17
%139 = icmp sle i32 %137, %138
br i1 %139, label %140, label %225
140: ; preds = %136
%141 = load i32, i32* %16
store i32 %141, i32* %19
%142 = getelementptr inbounds [20 x i32], [20 x i32]* %12, i64 0, i64 0
%143 = load i32, i32* %13
%144 = add nsw i32 %143, 1
%145 = call i32 @ivzero(i32* %142, i32 %144)
store i32 0, i32* %15
br label %146
146: ; preds = %169, %140
%147 = load i32, i32* %15
%148 = load i32, i32* %6
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %172
150: ; preds = %146
store i32 0, i32* %18
%151 = load i32, i32* %19
%152 = and i32 %151, 1
store i32 %152, i32* %20
%153 = load i32, i32* %19
%154 = ashr i32 %153, 1
store i32 %154, i32* %19
%155 = load i32, i32* %20
%156 = icmp eq i32 %155, 1
br i1 %156, label %157, label %163
157: ; preds = %150
%158 = load i32*, i32** %5
%159 = load i32, i32* %15
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %158, i64 %160
%162 = load i32, i32* %161
store i32 %162, i32* %18
br label %163
163: ; preds = %157, %150
%164 = load i32, i32* %18
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [20 x i32], [20 x i32]* %12, i64 0, i64 %165
%167 = load i32, i32* %166
%168 = add nsw i32 %167, 1
store i32 %168, i32* %166
br label %169
169: ; preds = %163
%170 = load i32, i32* %15
%171 = add nsw i32 %170, 1
store i32 %171, i32* %15
br label %146
172: ; preds = %146
store double 1.000000e+00, double* %23
store i32 0, i32* %14
br label %173
173: ; preds = %215, %172
%174 = load i32, i32* %14
%175 = load i32, i32* %13
%176 = icmp sle i32 %174, %175
br i1 %176, label %177, label %218
177: ; preds = %173
%178 = load i32, i32* %14
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [20 x i32], [20 x i32]* %12, i64 0, i64 %179
%181 = load i32, i32* %180
store i32 %181, i32* %19
store i32 0, i32* %20
%182 = load i32, i32* %14
%183 = icmp sgt i32 %182, 0
br i1 %183, label %184, label %187
184: ; preds = %177
%185 = load i32, i32* %19
%186 = srem i32 %185, 2
store i32 %186, i32* %20
br label %187
187: ; preds = %184, %177
%188 = load double**, double*** %22
%189 = load i32, i32* %14
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double*, double** %188, i64 %190
%192 = load double*, double** %191
%193 = load i32, i32* %19
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %192, i64 %194
%196 = load double, double* %195
store double %196, double* %11
%197 = load double, double* %11
%198 = fcmp olt double %197, -1.000000e+00
br i1 %198, label %199, label %205
199: ; preds = %187
%200 = load i32*, i32** %21
%201 = call i32 @free(i32* %200)
%202 = load i32, i32* %13
%203 = add nsw i32 %202, 1
%204 = call i32 @free2D(double*** %22, i32 %203)
store double -1.000000e+04, double* %4
br label %237
205: ; preds = %187
%206 = load i32, i32* %20
%207 = icmp eq i32 %206, 1
br i1 %207, label %208, label %211
208: ; preds = %205
%209 = load double, double* %11
%210 = fneg double %209
store double %210, double* %11
br label %211
211: ; preds = %208, %205
%212 = load double, double* %11
%213 = load double, double* %23
%214 = fmul double %213, %212
store double %214, double* %23
br label %215
215: ; preds = %211
%216 = load i32, i32* %14
%217 = add nsw i32 %216, 1
store i32 %217, i32* %14
br label %173
218: ; preds = %173
%219 = load double, double* %23
%220 = load double, double* %10
%221 = fadd double %220, %219
store double %221, double* %10
br label %222
222: ; preds = %218
%223 = load i32, i32* %16
%224 = add nsw i32 %223, 1
store i32 %224, i32* %16
br label %136
225: ; preds = %136
%226 = load double, double* %10
%227 = call i32 @fabs(double %226)
%228 = icmp sge i32 %227, 100
br i1 %228, label %229, label %230
229: ; preds = %225
store double -1.000000e+04, double* %10
br label %230
230: ; preds = %229, %225
%231 = load i32*, i32** %21
%232 = call i32 @free(i32* %231)
%233 = load i32, i32* %13
%234 = add nsw i32 %233, 1
%235 = call i32 @free2D(double*** %22, i32 %234)
%236 = load double, double* %10
store double %236, double* %4
br label %237
237: ; preds = %230, %199
%238 = load double, double* %4
ret double %238
}

LLVM IR (-O2):
@.str = [41 x i8] c"Unable to allocate %d unit(s) for item \0A\00"
define double @unbiasedest(i32* %0, i32 %1, i32** nocapture %2) {
%4 = alloca [20 x i32]
%5 = alloca i32
%6 = alloca double**
%7 = bitcast [20 x i32]* %4 to i8*
%8 = bitcast i32* %5 to i8*
%9 = bitcast double*** %6 to i8*
%10 = call i32 @ivmaxmin(i32* %0, i32 %1, i32* %5, i32* null)
%11 = load i32, i32* %5
%12 = add nsw i32 %11, 1
%13 = call i64 @calloc(i32 %12, i32 4)
%14 = inttoptr i64 %13 to i32*
%15 = icmp eq i64 %13, 0
br i1 %15, label %16, label %20
16: ; preds = %3
%17 = load i32, i32* %5
%18 = add nsw i32 %17, 1
%19 = call i32 @fatalx(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i32 %18)
br label %20
20: ; preds = %16, %3
%21 = load i32, i32* %5
%22 = icmp slt i32 %21, 0
br i1 %22, label %36, label %23
23: ; preds = %20, %23
%24 = phi i64 [ %32, %23 ], [ 0, %20 ]
%25 = getelementptr inbounds i32*, i32** %2, i64 %24
%26 = load i32*, i32** %25
%27 = load i32, i32* %26
%28 = getelementptr inbounds i32, i32* %26, i64 1
%29 = load i32, i32* %28
%30 = add nsw i32 %29, %27
%31 = getelementptr inbounds i32, i32* %14, i64 %24
store i32 %30, i32* %31
%32 = add nuw nsw i64 %24, 1
%33 = load i32, i32* %5
%34 = sext i32 %33 to i64
%35 = icmp slt i64 %24, %34
br i1 %35, label %23, label %36
36: ; preds = %23, %20
%37 = phi i32 [ %21, %20 ], [ %33, %23 ]
%38 = add nsw i32 %37, 1
%39 = call double** @initarray_2Ddouble(i32 %38, i32 %1, double 0.000000e+00)
store double** %39, double*** %6
%40 = load i32, i32* %5
%41 = icmp slt i32 %40, 0
br i1 %41, label %77, label %42
42: ; preds = %36
%43 = icmp slt i32 %1, 1
%44 = add i32 %1, 1
%45 = zext i32 %44 to i64
br label %46
46: ; preds = %42, %72
%47 = phi i32 [ %40, %42 ], [ %73, %72 ]
%48 = phi i64 [ 0, %42 ], [ %74, %72 ]
%49 = getelementptr inbounds double*, double** %39, i64 %48
%50 = load double*, double** %49
store double 1.000000e+00, double* %50
br i1 %43, label %72, label %51
51: ; preds = %46
%52 = getelementptr inbounds i32*, i32** %2, i64 %48
%53 = getelementptr inbounds i32, i32* %14, i64 %48
%54 = getelementptr inbounds double*, double** %39, i64 %48
br label %55
55: ; preds = %51, %55
%56 = phi i64 [ 1, %51 ], [ %68, %55 ]
%57 = load i32*, i32** %52
%58 = load i32, i32* %57
%59 = trunc i64 %56 to i32
%60 = call double @ifall(i32 %58, i32 %59)
%61 = load i32, i32* %53
%62 = call double @ifall(i32 %61, i32 %59)
%63 = fcmp ugt double %62, 1.000000e-01
%64 = fdiv double %60, %62
%65 = select i1 %63, double %64, double -1.000000e+04
%66 = load double*, double** %54
%67 = getelementptr inbounds double, double* %66, i64 %56
store double %65, double* %67
%68 = add nuw nsw i64 %56, 1
%69 = icmp eq i64 %68, %45
br i1 %69, label %70, label %55
70: ; preds = %55
%71 = load i32, i32* %5
br label %72
72: ; preds = %70, %46
%73 = phi i32 [ %71, %70 ], [ %47, %46 ]
%74 = add nuw nsw i64 %48, 1
%75 = sext i32 %73 to i64
%76 = icmp slt i64 %48, %75
br i1 %76, label %46, label %77
77: ; preds = %72, %36
%78 = phi i32 [ %40, %36 ], [ %73, %72 ]
%79 = shl nuw i32 1, %1
%80 = getelementptr inbounds [20 x i32], [20 x i32]* %4, i64 0, i64 0
%81 = icmp sgt i32 %1, 0
%82 = zext i32 %1 to i64
%83 = and i64 %82, 1
%84 = icmp eq i32 %1, 1
%85 = and i64 %82, 4294967294
%86 = icmp eq i64 %83, 0
br label %87
87: ; preds = %77, %167
%88 = phi i32 [ %78, %77 ], [ %110, %167 ]
%89 = phi double [ 0.000000e+00, %77 ], [ %169, %167 ]
%90 = phi i32 [ 0, %77 ], [ %170, %167 ]
%91 = add nsw i32 %88, 1
%92 = call i32 @ivzero(i32* %80, i32 %91)
br i1 %81, label %93, label %109
93: ; preds = %87
br i1 %84, label %94, label %115
94: ; preds = %137, %93
%95 = phi i64 [ 0, %93 ], [ %143, %137 ]
%96 = phi i32 [ %90, %93 ], [ %130, %137 ]
br i1 %86, label %109, label %97
97: ; preds = %94
%98 = and i32 %96, 1
%99 = icmp eq i32 %98, 0
br i1 %99, label %103, label %100
100: ; preds = %97
%101 = getelementptr inbounds i32, i32* %0, i64 %95
%102 = load i32, i32* %101
br label %103
103: ; preds = %100, %97
%104 = phi i32 [ %102, %100 ], [ 0, %97 ]
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [20 x i32], [20 x i32]* %4, i64 0, i64 %105
%107 = load i32, i32* %106
%108 = add nsw i32 %107, 1
store i32 %108, i32* %106
br label %109
109: ; preds = %103, %94, %87
%110 = load i32, i32* %5
%111 = icmp slt i32 %110, 0
br i1 %111, label %167, label %112
112: ; preds = %109
%113 = add nuw i32 %110, 1
%114 = zext i32 %113 to i64
br label %146
115: ; preds = %93, %137
%116 = phi i64 [ %143, %137 ], [ 0, %93 ]
%117 = phi i32 [ %130, %137 ], [ %90, %93 ]
%118 = phi i64 [ %144, %137 ], [ 0, %93 ]
%119 = and i32 %117, 1
%120 = icmp eq i32 %119, 0
br i1 %120, label %124, label %121
121: ; preds = %115
%122 = getelementptr inbounds i32, i32* %0, i64 %116
%123 = load i32, i32* %122
br label %124
124: ; preds = %121, %115
%125 = phi i32 [ %123, %121 ], [ 0, %115 ]
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [20 x i32], [20 x i32]* %4, i64 0, i64 %126
%128 = load i32, i32* %127
%129 = add nsw i32 %128, 1
store i32 %129, i32* %127
%130 = lshr i32 %117, 2
%131 = and i32 %117, 2
%132 = icmp eq i32 %131, 0
br i1 %132, label %137, label %133
133: ; preds = %124
%134 = or i64 %116, 1
%135 = getelementptr inbounds i32, i32* %0, i64 %134
%136 = load i32, i32* %135
br label %137
137: ; preds = %133, %124
%138 = phi i32 [ %136, %133 ], [ 0, %124 ]
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [20 x i32], [20 x i32]* %4, i64 0, i64 %139
%141 = load i32, i32* %140
%142 = add nsw i32 %141, 1
store i32 %142, i32* %140
%143 = add nuw nsw i64 %116, 2
%144 = add i64 %118, 2
%145 = icmp eq i64 %144, %85
br i1 %145, label %94, label %115
146: ; preds = %112, %157
%147 = phi i64 [ 0, %112 ], [ %165, %157 ]
%148 = phi double [ 1.000000e+00, %112 ], [ %164, %157 ]
%149 = getelementptr inbounds [20 x i32], [20 x i32]* %4, i64 0, i64 %147
%150 = load i32, i32* %149
%151 = getelementptr inbounds double*, double** %39, i64 %147
%152 = load double*, double** %151
%153 = sext i32 %150 to i64
%154 = getelementptr inbounds double, double* %152, i64 %153
%155 = load double, double* %154
%156 = fcmp olt double %155, -1.000000e+00
br i1 %156, label %176, label %157
157: ; preds = %146
%158 = icmp ne i64 %147, 0
%159 = srem i32 %150, 2
%160 = icmp eq i32 %159, 1
%161 = select i1 %158, i1 %160, i1 false
%162 = fneg double %155
%163 = select i1 %161, double %162, double %155
%164 = fmul double %148, %163
%165 = add nuw nsw i64 %147, 1
%166 = icmp eq i64 %165, %114
br i1 %166, label %167, label %146
167: ; preds = %157, %109
%168 = phi double [ 1.000000e+00, %109 ], [ %164, %157 ]
%169 = fadd double %89, %168
%170 = add nuw i32 %90, 1
%171 = icmp eq i32 %170, %79
br i1 %171, label %172, label %87
172: ; preds = %167
%173 = call i32 @fabs(double %169)
%174 = icmp sgt i32 %173, 99
%175 = select i1 %174, double -1.000000e+04, double %169
br label %176
176: ; preds = %146, %172
%177 = phi double [ %175, %172 ], [ -1.000000e+04, %146 ]
%178 = call i32 @free(i32* %14)
%179 = load i32, i32* %5
%180 = add nsw i32 %179, 1
%181 = call i32 @free2D(double*** %6, i32 %180)
ret double %177
}