#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 */
typedef double ldfP4_0;

/* Variables and functions */
double ldf_Gam(int, double, double, int);
scalar_t__ ldf_Mult(int, int, double *, int, int);
double compute_log_posterior(int D, int K, int **M, int *N, int V, double alpha,
                             double **beta, double eta, double **theta,
                             int ***w, int ***z) {
  double ldfP4_0;
  double ldfP4_1;
  double ldfP4_2;
  int m_22;
  int n_16;
  int d_10;
  double ldfP5_0;
  double ldfP5_1;
  double ldfP5_2;
  int m_23;
  int n_17;
  int d_11;
  ldfP4_0 = 0.0;
  for (d_10 = 1; d_10 <= D; d_10++) {
    ldfP4_1 = 0.0;
    for (n_16 = 1; n_16 <= N[d_10 - 1]; n_16++) {
      ldfP4_2 = 0.0;
      for (m_22 = 1; m_22 <= M[d_10 - 1][n_16 - 1]; m_22++) {
        ldfP4_2 +=
            ldf_Mult(1, z[d_10 - 1][n_16 - 1][m_22 - 1], theta[d_10 - 1], 1, K);
      }
      ldfP4_1 += ldfP4_2;
    }
    ldfP4_0 += ldfP4_1;
  }
  ldfP5_0 = 0.0;
  for (d_11 = 1; d_11 <= D; d_11++) {
    ldfP5_1 = 0.0;
    for (n_17 = 1; n_17 <= N[d_11 - 1]; n_17++) {
      ldfP5_2 = 0.0;
      for (m_23 = 1; m_23 <= M[d_11 - 1][n_17 - 1]; m_23++) {
        ldfP5_2 += ldf_Mult(1, w[d_11 - 1][n_17 - 1][m_23 - 1],
                            beta[z[d_11 - 1][n_17 - 1][m_23 - 1] - 1], 1, V);
      }
      ldfP5_1 += ldfP5_2;
    }
    ldfP5_0 += ldfP5_1;
  }
  return ((ldf_Gam(1, alpha, 0.1, 1)) +
          ((ldf_Gam(1, eta, 0.1, 1)) +
           ((0.0) + ((0.0) + ((ldfP4_0) + (ldfP5_0))))));
}


x86 assembly (clang, -O0):
<compute_log_posterior>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1271 <compute_log_posterior+0x151>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x5c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1254 <compute_log_posterior+0x134>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x5c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x58(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1237 <compute_log_posterior+0x117>
mov    0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
mov    0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%edi
call   1040 <ldf_Mult@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11a9 <compute_log_posterior+0x89>
movsd  -0x50(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1181 <compute_log_posterior+0x61>
movsd  -0x48(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1166 <compute_log_posterior+0x46>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13ca <compute_log_posterior+0x2aa>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x1,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     13a7 <compute_log_posterior+0x287>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x80(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     138a <compute_log_posterior+0x26a>
mov    0x18(%rbp),%rax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x80(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x30(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x80(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x7c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x1c(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%edi
call   1040 <ldf_Mult@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    12cc <compute_log_posterior+0x1ac>
movsd  -0x78(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    12a1 <compute_log_posterior+0x181>
movsd  -0x70(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1283 <compute_log_posterior+0x163>
movsd  -0x28(%rbp),%xmm0
mov    $0x1,%esi
movsd  0xc24(%rip),%xmm1
mov    %esi,%edi
call   1030 <ldf_Gam@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mov    $0x1,%esi
movsd  0xc03(%rip),%xmm1
mov    %esi,%edi
call   1030 <ldf_Gam@plt>
movaps %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x40(%rbp),%xmm2
addsd  -0x68(%rbp),%xmm2
xorps  %xmm3,%xmm3
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_log_posterior>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movsd  %xmm1,0x50(%rsp)
movsd  %xmm0,0x48(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rdx,0x20(%rsp)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
test   %edi,%edi
jle    13c4 <compute_log_posterior+0x2a4>
mov    %esi,%ebx
mov    %r9,0x40(%rsp)
mov    0xa0(%rsp),%r9
mov    0x98(%rsp),%rdx
mov    0x90(%rsp),%rbp
mov    %rdi,0x18(%rsp)
lea    0x1(%rdi),%eax
mov    %rax,0x38(%rsp)
xorpd  %xmm0,%xmm0
mov    $0x1,%r15d
mov    %r8d,0x34(%rsp)
mov    0x20(%rsp),%r13
jmp    11b3 <compute_log_posterior+0x93>
cs nopw 0x0(%rax,%rax,1)
addsd  %xmm1,%xmm0
add    $0x1,%r15
cmp    0x38(%rsp),%r15
je     128f <compute_log_posterior+0x16f>
mov    0x10(%rsp),%rax
mov    -0x4(%rax,%r15,4),%edi
xorpd  %xmm1,%xmm1
test   %edi,%edi
jle    11a0 <compute_log_posterior+0x80>
mov    0x20(%rsp),%rax
mov    -0x8(%rax,%r15,8),%rax
xorpd  %xmm1,%xmm1
mov    $0x1,%r14d
movsd  %xmm0,(%rsp)
jmp    11f3 <compute_log_posterior+0xd3>
addsd  %xmm2,%xmm1
lea    0x1(%r14),%rcx
movslq %edi,%rsi
cmp    %rsi,%r14
mov    %rcx,%r14
jge    11a0 <compute_log_posterior+0x80>
cmpl   $0x0,-0x4(%rax,%r14,4)
xorpd  %xmm2,%xmm2
jle    11e0 <compute_log_posterior+0xc0>
movsd  %xmm1,0x28(%rsp)
xorpd  %xmm2,%xmm2
xor    %r12d,%r12d
nopl   0x0(%rax)
movsd  %xmm2,0x8(%rsp)
mov    -0x8(%r9,%r15,8),%rax
mov    -0x8(%rax,%r14,8),%rax
mov    (%rax,%r12,4),%esi
mov    -0x8(%rbp,%r15,8),%rdx
mov    $0x1,%edi
mov    $0x1,%ecx
mov    %ebx,%r8d
call   1040 <ldf_Mult@plt>
movsd  0x8(%rsp),%xmm2
mov    0xa0(%rsp),%r9
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm2
mov    -0x8(%r13,%r15,8),%rax
movslq -0x4(%rax,%r14,4),%rcx
add    $0x1,%r12
cmp    %rcx,%r12
jl     1210 <compute_log_posterior+0xf0>
mov    0x10(%rsp),%rcx
mov    -0x4(%rcx,%r15,4),%edi
movsd  (%rsp),%xmm0
mov    0x34(%rsp),%r8d
mov    0x98(%rsp),%rdx
movsd  0x28(%rsp),%xmm1
jmp    11e0 <compute_log_posterior+0xc0>
cmpl   $0x0,0x18(%rsp)
jle    13c0 <compute_log_posterior+0x2a0>
xorpd  %xmm1,%xmm1
mov    $0x1,%r14d
mov    0x40(%rsp),%r15
mov    0x20(%rsp),%r13
jmp    12c3 <compute_log_posterior+0x1a3>
addsd  %xmm2,%xmm1
add    $0x1,%r14
cmp    0x38(%rsp),%r14
je     13c4 <compute_log_posterior+0x2a4>
mov    0x10(%rsp),%rax
mov    -0x4(%rax,%r14,4),%ecx
xorpd  %xmm2,%xmm2
test   %ecx,%ecx
jle    12b0 <compute_log_posterior+0x190>
mov    -0x8(%r13,%r14,8),%rax
xorpd  %xmm2,%xmm2
mov    $0x1,%r12d
movsd  %xmm0,(%rsp)
movsd  %xmm1,0x18(%rsp)
jmp    1314 <compute_log_posterior+0x1f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  %xmm3,%xmm2
lea    0x1(%r12),%rbp
movslq %ecx,%rsi
cmp    %rsi,%r12
mov    %rbp,%r12
jge    12b0 <compute_log_posterior+0x190>
cmpl   $0x0,-0x4(%rax,%r12,4)
xorpd  %xmm3,%xmm3
jle    1300 <compute_log_posterior+0x1e0>
movsd  %xmm2,0x28(%rsp)
xorpd  %xmm3,%xmm3
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  %xmm3,0x8(%rsp)
mov    -0x8(%rdx,%r14,8),%rax
mov    -0x8(%rax,%r12,8),%rax
mov    (%rax,%rbp,4),%esi
mov    -0x8(%r9,%r14,8),%rax
mov    -0x8(%rax,%r12,8),%rax
movslq (%rax,%rbp,4),%rax
mov    -0x8(%r15,%rax,8),%rdx
mov    $0x1,%edi
mov    $0x1,%ecx
mov    %r8d,%ebx
call   1040 <ldf_Mult@plt>
movsd  0x8(%rsp),%xmm3
mov    %ebx,%r8d
mov    0x98(%rsp),%rdx
mov    0xa0(%rsp),%r9
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm3
mov    -0x8(%r13,%r14,8),%rax
movslq -0x4(%rax,%r12,4),%rcx
add    $0x1,%rbp
cmp    %rcx,%rbp
jl     1330 <compute_log_posterior+0x210>
mov    0x10(%rsp),%rcx
mov    -0x4(%rcx,%r14,4),%ecx
movsd  (%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
movsd  0x28(%rsp),%xmm2
jmp    1300 <compute_log_posterior+0x1e0>
xorpd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  0xc2b(%rip),%xmm1
mov    $0x1,%edi
movsd  0x48(%rsp),%xmm0
mov    $0x1,%esi
call   1030 <ldf_Gam@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1,%edi
movsd  0x50(%rsp),%xmm0
movsd  0xbfd(%rip),%xmm1
mov    $0x1,%esi
call   1030 <ldf_Gam@plt>
movsd  (%rsp),%xmm1
addsd  0xbee(%rip),%xmm1
addsd  %xmm1,%xmm0
addsd  0x8(%rsp),%xmm0
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @compute_log_posterior(i32 %0, i32 %1, i32** nocapture %2, i32* nocapture %3, i32 %4, double %5, double** nocapture %6, double %7, double** nocapture %8, i32*** nocapture %9, i32*** nocapture %10) {
%12 = icmp slt i32 %0, 1
br i1 %12, label %138, label %13
13: ; preds = %11
%14 = add nuw i32 %0, 1
%15 = zext i32 %14 to i64
br label %16
16: ; preds = %13, %70
%17 = phi i64 [ 1, %13 ], [ %73, %70 ]
%18 = phi double [ 0.000000e+00, %13 ], [ %72, %70 ]
%19 = add nsw i64 %17, -1
%20 = getelementptr inbounds i32, i32* %3, i64 %19
%21 = load i32, i32* %20
%22 = icmp slt i32 %21, 1
br i1 %22, label %70, label %23
23: ; preds = %16
%24 = getelementptr inbounds i32*, i32** %2, i64 %19
%25 = getelementptr inbounds i32**, i32*** %10, i64 %19
%26 = getelementptr inbounds double*, double** %8, i64 %19
%27 = load i32*, i32** %24
br label %32
28: ; preds = %70
br i1 %12, label %138, label %29
29: ; preds = %28
%30 = add nuw i32 %0, 1
%31 = zext i32 %30 to i64
br label %75
32: ; preds = %23, %62
%33 = phi i32 [ %21, %23 ], [ %63, %62 ]
%34 = phi i32* [ %27, %23 ], [ %64, %62 ]
%35 = phi i64 [ 1, %23 ], [ %67, %62 ]
%36 = phi double [ 0.000000e+00, %23 ], [ %66, %62 ]
%37 = add nsw i64 %35, -1
%38 = getelementptr inbounds i32, i32* %34, i64 %37
%39 = load i32, i32* %38
%40 = icmp slt i32 %39, 1
br i1 %40, label %62, label %41
41: ; preds = %32, %41
%42 = phi i64 [ %54, %41 ], [ 1, %32 ]
%43 = phi double [ %53, %41 ], [ 0.000000e+00, %32 ]
%44 = load i32**, i32*** %25
%45 = getelementptr inbounds i32*, i32** %44, i64 %37
%46 = load i32*, i32** %45
%47 = add nsw i64 %42, -1
%48 = getelementptr inbounds i32, i32* %46, i64 %47
%49 = load i32, i32* %48
%50 = load double*, double** %26
%51 = tail call i64 @ldf_Mult(i32 1, i32 %49, double* %50, i32 1, i32 %1)
%52 = sitofp i64 %51 to double
%53 = fadd double %43, %52
%54 = add nuw nsw i64 %42, 1
%55 = load i32*, i32** %24
%56 = getelementptr inbounds i32, i32* %55, i64 %37
%57 = load i32, i32* %56
%58 = sext i32 %57 to i64
%59 = icmp slt i64 %42, %58
br i1 %59, label %41, label %60
60: ; preds = %41
%61 = load i32, i32* %20
br label %62
62: ; preds = %60, %32
%63 = phi i32 [ %33, %32 ], [ %61, %60 ]
%64 = phi i32* [ %34, %32 ], [ %55, %60 ]
%65 = phi double [ 0.000000e+00, %32 ], [ %53, %60 ]
%66 = fadd double %36, %65
%67 = add nuw nsw i64 %35, 1
%68 = sext i32 %63 to i64
%69 = icmp slt i64 %35, %68
br i1 %69, label %32, label %70
70: ; preds = %62, %16
%71 = phi double [ 0.000000e+00, %16 ], [ %66, %62 ]
%72 = fadd double %18, %71
%73 = add nuw nsw i64 %17, 1
%74 = icmp eq i64 %73, %15
br i1 %74, label %28, label %16
75: ; preds = %29, %133
%76 = phi i64 [ 1, %29 ], [ %136, %133 ]
%77 = phi double [ 0.000000e+00, %29 ], [ %135, %133 ]
%78 = add nsw i64 %76, -1
%79 = getelementptr inbounds i32, i32* %3, i64 %78
%80 = load i32, i32* %79
%81 = icmp slt i32 %80, 1
br i1 %81, label %133, label %82
82: ; preds = %75
%83 = getelementptr inbounds i32*, i32** %2, i64 %78
%84 = getelementptr inbounds i32**, i32*** %9, i64 %78
%85 = getelementptr inbounds i32**, i32*** %10, i64 %78
%86 = load i32*, i32** %83
br label %87
87: ; preds = %82, %125
%88 = phi i32 [ %80, %82 ], [ %126, %125 ]
%89 = phi i32* [ %86, %82 ], [ %127, %125 ]
%90 = phi i64 [ 1, %82 ], [ %130, %125 ]
%91 = phi double [ 0.000000e+00, %82 ], [ %129, %125 ]
%92 = add nsw i64 %90, -1
%93 = getelementptr inbounds i32, i32* %89, i64 %92
%94 = load i32, i32* %93
%95 = icmp slt i32 %94, 1
br i1 %95, label %125, label %96
96: ; preds = %87, %96
%97 = phi i64 [ %117, %96 ], [ 1, %87 ]
%98 = phi double [ %116, %96 ], [ 0.000000e+00, %87 ]
%99 = load i32**, i32*** %84
%100 = getelementptr inbounds i32*, i32** %99, i64 %92
%101 = load i32*, i32** %100
%102 = add nsw i64 %97, -1
%103 = getelementptr inbounds i32, i32* %101, i64 %102
%104 = load i32, i32* %103
%105 = load i32**, i32*** %85
%106 = getelementptr inbounds i32*, i32** %105, i64 %92
%107 = load i32*, i32** %106
%108 = getelementptr inbounds i32, i32* %107, i64 %102
%109 = load i32, i32* %108
%110 = add nsw i32 %109, -1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double*, double** %6, i64 %111
%113 = load double*, double** %112
%114 = tail call i64 @ldf_Mult(i32 1, i32 %104, double* %113, i32 1, i32 %4)
%115 = sitofp i64 %114 to double
%116 = fadd double %98, %115
%117 = add nuw nsw i64 %97, 1
%118 = load i32*, i32** %83
%119 = getelementptr inbounds i32, i32* %118, i64 %92
%120 = load i32, i32* %119
%121 = sext i32 %120 to i64
%122 = icmp slt i64 %97, %121
br i1 %122, label %96, label %123
123: ; preds = %96
%124 = load i32, i32* %79
br label %125
125: ; preds = %123, %87
%126 = phi i32 [ %88, %87 ], [ %124, %123 ]
%127 = phi i32* [ %89, %87 ], [ %118, %123 ]
%128 = phi double [ 0.000000e+00, %87 ], [ %116, %123 ]
%129 = fadd double %91, %128
%130 = add nuw nsw i64 %90, 1
%131 = sext i32 %126 to i64
%132 = icmp slt i64 %90, %131
br i1 %132, label %87, label %133
133: ; preds = %125, %75
%134 = phi double [ 0.000000e+00, %75 ], [ %129, %125 ]
%135 = fadd double %77, %134
%136 = add nuw nsw i64 %76, 1
%137 = icmp eq i64 %136, %31
br i1 %137, label %138, label %75
138: ; preds = %133, %11, %28
%139 = phi double [ %72, %28 ], [ 0.000000e+00, %11 ], [ %72, %133 ]
%140 = phi double [ 0.000000e+00, %28 ], [ 0.000000e+00, %11 ], [ %135, %133 ]
%141 = tail call double @ldf_Gam(i32 1, double %5, double 1.000000e-01, i32 1)
%142 = tail call double @ldf_Gam(i32 1, double %7, double 1.000000e-01, i32 1)
%143 = fadd double %139, %140
%144 = fadd double %143, 0.000000e+00
%145 = fadd double %144, %142
%146 = fadd double %141, %145
ret double %146
}