#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(struct array3d *);
scalar_t__ malloc(int);
int probability(int, int, int, int);
double getptree(int h, int L, int N) {
  typedef struct array3d {
    int value;
    double prob;
  } array3d;
  array3d *array;
  int bound, i, start, target, j;
  double numerator, denominator;
  bound = 1;
  for (i = 1; i <= L; i++) {
    bound *= (h + 1);
  }
  bound = (bound - 1) / h;
  start = 1;
  for (i = 1; i < L; i++) {
    start *= (h + 1);
  }
  start = (start - 1) / h + 1;
  array = (array3d *)malloc((1 + bound) * sizeof(array3d));
  array[1].value = h;
  array[1].prob = 1.0;
  for (i = 1; i <= start - 1; i++) {
    target = (h + 1) * i - (h - 1);
    for (j = 0; j <= h; j++, target++) {
      array[target].value = array[i].value + j;
      array[target].prob = array[i].prob * probability(array[i].value, h, j, N);
    }
  }
  numerator = 0.0;
  denominator = 0.0;
  for (i = start; i <= bound; i++) {
    numerator += array[i].value * array[i].prob;
  }
  for (i = start; i <= bound; i++) {
    denominator += array[i].prob;
  }
  free(array);
  if (numerator < 0.000001) {
    return (0.0);
  } else {
    return (numerator / denominator);
  }
}


x86 assembly (clang, -O0):
<getptree>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x1,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1176 <getptree+0x46>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    114f <getptree+0x1f>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11b8 <getptree+0x88>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1191 <getptree+0x61>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0xc(%rbp)
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x4,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x20(%rbp),%rax
movsd  0xe0b(%rip),%xmm0
movsd  %xmm0,0x18(%rax)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12e2 <getptree+0x1b2>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
imul   -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12cf <getptree+0x19f>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%ecx
add    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%edi
mov    -0xc(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x14(%rbp),%ecx
call   1050 <probability@plt>
movsd  -0x50(%rbp),%xmm0
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    122e <getptree+0xfe>
jmp    12d4 <getptree+0x1a4>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1201 <getptree+0xd1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     134b <getptree+0x21b>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
cvtsi2sdl (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12f8 <getptree+0x1c8>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1389 <getptree+0x259>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1351 <getptree+0x221>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movsd  0xc6e(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    13b2 <getptree+0x282>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    13c1 <getptree+0x291>
movsd  -0x40(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getptree>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %edx,0x2c(%rsp)
mov    %edi,%r8d
xor    %ecx,%ecx
test   %esi,%esi
jle    119b <getptree+0x6b>
lea    0x1(%r8),%edi
mov    $0x1,%edx
mov    $0x1,%eax
cmp    $0x8,%esi
jb     12ee <getptree+0x1be>
mov    %esi,%edx
and    $0xfffffff8,%edx
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%ebx
mov    %ebx,%eax
shr    $0x3,%eax
add    $0x1,%eax
mov    %eax,%ebp
and    $0x7,%ebp
pshufd $0xf5,%xmm0,%xmm2
cmp    $0x38,%ebx
jae    11a3 <getptree+0x73>
movdqa 0xe6e(%rip),%xmm1
movdqa %xmm1,%xmm3
jmp    126f <getptree+0x13f>
xor    %r9d,%r9d
jmp    14bb <getptree+0x38b>
and    $0xfffffff8,%eax
movdqa 0xe52(%rip),%xmm1
movdqa %xmm1,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
pshufd $0xf5,%xmm1,%xmm5
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm2,%xmm4
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm2,%xmm4
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm2,%xmm4
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm1
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm3
add    $0xfffffff8,%eax
jne    11c0 <getptree+0x90>
test   %ebp,%ebp
je     12bb <getptree+0x18b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
pshufd $0xf5,%xmm1,%xmm4
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm1
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm3
add    $0xffffffff,%ebp
jne    1280 <getptree+0x150>
pshufd $0xf5,%xmm1,%xmm0
pshufd $0xf5,%xmm3,%xmm2
pmuludq %xmm0,%xmm2
pmuludq %xmm1,%xmm3
pshufd $0xee,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xaa,%xmm2,%xmm1
pmuludq %xmm2,%xmm1
pmuludq %xmm0,%xmm1
movd   %xmm1,%eax
cmp    %esi,%edx
je     1308 <getptree+0x1d8>
or     $0x1,%edx
mov    %esi,%ebp
sub    %edx,%ebp
add    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
imul   %edi,%eax
add    $0xffffffff,%ebp
jne    1300 <getptree+0x1d0>
add    $0xffffffff,%eax
cltd
idiv   %r8d
mov    %eax,%r9d
cmp    $0x2,%esi
jl     14bb <getptree+0x38b>
lea    -0x1(%rsi),%edx
mov    $0x1,%ecx
mov    $0x1,%eax
cmp    $0x8,%edx
jb     14ae <getptree+0x37e>
mov    %edx,%eax
and    $0xfffffff8,%eax
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%ebx
mov    %ebx,%ecx
shr    $0x3,%ecx
add    $0x1,%ecx
mov    %ecx,%ebp
and    $0x7,%ebp
pshufd $0xf5,%xmm0,%xmm2
cmp    $0x38,%ebx
jae    136a <getptree+0x23a>
movdqa 0xc9f(%rip),%xmm1
movdqa %xmm1,%xmm3
jmp    142f <getptree+0x2ff>
and    $0xfffffff8,%ecx
movdqa 0xc8b(%rip),%xmm1
movdqa %xmm1,%xmm3
nopl   0x0(%rax)
pshufd $0xf5,%xmm1,%xmm5
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm2,%xmm4
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm2,%xmm4
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm3
pmuludq %xmm2,%xmm4
pmuludq %xmm2,%xmm5
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm4
pmuludq %xmm0,%xmm3
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm1
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm3
add    $0xfffffff8,%ecx
jne    1380 <getptree+0x250>
test   %ebp,%ebp
je     147b <getptree+0x34b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
pshufd $0xf5,%xmm1,%xmm4
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm1
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm3
add    $0xffffffff,%ebp
jne    1440 <getptree+0x310>
pshufd $0xf5,%xmm1,%xmm0
pshufd $0xf5,%xmm3,%xmm2
pmuludq %xmm0,%xmm2
pmuludq %xmm1,%xmm3
pshufd $0xee,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xaa,%xmm2,%xmm1
pmuludq %xmm2,%xmm1
pmuludq %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %eax,%edx
je     14b8 <getptree+0x388>
or     $0x1,%eax
sub    %eax,%esi
imul   %edi,%ecx
add    $0xffffffff,%esi
jne    14b0 <getptree+0x380>
add    $0xffffffff,%ecx
mov    %ecx,%eax
cltd
idiv   %r8d
mov    %eax,%ebx
mov    %r9d,0x28(%rsp)
shl    $0x4,%r9d
add    $0x10,%r9d
mov    %r9d,%edi
mov    %r8,0x10(%rsp)
call   1040 <malloc@plt>
mov    0x10(%rsp),%rsi
mov    %esi,0x10(%rax)
movabs $0x3ff0000000000000,%rdx
mov    %rax,%rcx
mov    %rax,(%rsp)
mov    %rdx,0x18(%rax)
mov    %rbx,0x30(%rsp)
test   %ebx,%ebx
jle    15d8 <getptree+0x4a8>
lea    0x1(%rsi),%r12d
mov    0x30(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x40(%rsp)
mov    (%rsp),%rax
add    $0x8,%rax
mov    %rax,0x38(%rsp)
movl   $0x2,0xc(%rsp)
mov    $0x1,%eax
mov    %rax,0x20(%rsp)
mov    0x2c(%rsp),%r14d
jmp    155a <getptree+0x42a>
xchg   %ax,%ax
mov    0x20(%rsp),%rax
add    $0x1,%rax
add    %r12d,0xc(%rsp)
mov    %rax,0x20(%rsp)
cmp    0x40(%rsp),%rax
je     15d8 <getptree+0x4a8>
test   %esi,%esi
js     1540 <getptree+0x410>
movslq 0xc(%rsp),%r13
shl    $0x4,%r13
add    0x38(%rsp),%r13
mov    0x20(%rsp),%rax
shl    $0x4,%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,1),%rbx
lea    (%rcx,%rax,1),%r15
add    $0x8,%r15
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%eax
add    %ebp,%eax
mov    %eax,-0x8(%r13)
movsd  (%r15),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    (%rbx),%edi
mov    %ebp,%edx
mov    %r14d,%ecx
call   1050 <probability@plt>
mov    0x10(%rsp),%rsi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x0(%r13)
add    $0x1,%ebp
add    $0x10,%r13
cmp    %ebp,%r12d
jne    1590 <getptree+0x460>
jmp    1540 <getptree+0x410>
mov    0x28(%rsp),%ebp
mov    %ebp,%edx
pxor   %xmm1,%xmm1
pxor   %xmm0,%xmm0
mov    0x30(%rsp),%rax
sub    %eax,%edx
jle    170c <getptree+0x5dc>
movslq %eax,%r8
lea    0x1(%r8),%rsi
mov    %eax,%ecx
not    %ecx
add    %ebp,%ecx
test   $0x1,%dl
jne    160f <getptree+0x4df>
pxor   %xmm1,%xmm1
test   %ecx,%ecx
jne    1635 <getptree+0x505>
jmp    167a <getptree+0x54a>
shl    $0x4,%rsi
mov    (%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sdl (%rdi,%rsi,1),%xmm0
mulsd  0x8(%rdi,%rsi,1),%xmm0
pxor   %xmm1,%xmm1
addsd  %xmm0,%xmm1
lea    0x2(%r8),%rsi
test   %ecx,%ecx
je     167a <getptree+0x54a>
mov    %ebp,%edi
sub    %esi,%edi
add    $0x1,%edi
shl    $0x4,%rsi
mov    (%rsp),%rbx
add    %rbx,%rsi
add    $0x18,%rsi
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sdl -0x18(%rsi),%xmm0
mulsd  -0x10(%rsi),%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl -0x8(%rsi),%xmm1
mulsd  (%rsi),%xmm1
addsd  %xmm0,%xmm1
add    $0x20,%rsi
add    $0xfffffffe,%edi
jne    1650 <getptree+0x520>
xorpd  %xmm0,%xmm0
cmp    %eax,%ebp
jle    170c <getptree+0x5dc>
add    $0x1,%r8
and    $0x3,%edx
je     16ca <getptree+0x59a>
mov    %r8,%rsi
shl    $0x4,%rsi
mov    (%rsp),%rdi
add    %rdi,%rsi
add    $0x8,%rsi
neg    %edx
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax)
addsd  (%rsi),%xmm0
add    $0xffffffffffffffff,%rdi
add    $0x10,%rsi
cmp    %edi,%edx
jne    16b0 <getptree+0x580>
sub    %rdi,%r8
cmp    $0x3,%ecx
jae    16d3 <getptree+0x5a3>
jmp    170c <getptree+0x5dc>
xorpd  %xmm0,%xmm0
cmp    $0x3,%ecx
jb     170c <getptree+0x5dc>
sub    %r8d,%ebp
add    $0x1,%ebp
shl    $0x4,%r8
mov    (%rsp),%rcx
lea    (%r8,%rcx,1),%rax
add    $0x38,%rax
nopl   0x0(%rax)
addsd  -0x30(%rax),%xmm0
addsd  -0x20(%rax),%xmm0
addsd  -0x10(%rax),%xmm0
addsd  (%rax),%xmm0
add    $0x40,%rax
add    $0xfffffffc,%ebp
jne    16f0 <getptree+0x5c0>
movq   %xmm0,0x10(%rsp)
movq   %xmm1,0x18(%rsp)
mov    (%rsp),%rdi
call   1030 <free@plt>
pxor   %xmm0,%xmm0
movsd  0x8e3(%rip),%xmm1
ucomisd 0x18(%rsp),%xmm1
movsd  0x18(%rsp),%xmm1
ja     1745 <getptree+0x615>
divsd  0x10(%rsp),%xmm1
movapd %xmm1,%xmm0
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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