#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*/ allocate_all(double **, double **, double **, double **,
                                double **, double **, double **, double **,
                                double **, double **, double **, double **,
                                double **, int, int, int, int);
int /*<<< orphan*/ calc_dp_deviance(float *, double *, double *, double *,
                                    double *, double *, double *, int, int, int,
                                    int, int, int);
scalar_t__ check_mat(double *, int, int /*<<< orphan*/, int);
int /*<<< orphan*/ create_CCt(double *, double *, int, int);
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ free_all(double *, double *, double *, double *, double *,
                            double *, double *, double *, double *, double *,
                            double *, double *, double *);
int /*<<< orphan*/ init_bar(int *, int *);
int /*<<< orphan*/ inputation(float *, double *, double *, double *, double *,
                              int *, int, int, int, int);
int /*<<< orphan*/ print_bar(int *, int *, int);
int /*<<< orphan*/ print_error_global(char *, int /*<<< orphan*/ *,
                                      int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ rand_matrix_double(double *, int, int);
int /*<<< orphan*/ stdout;
int /*<<< orphan*/ update_U(double *, float *, double *, double *, double *,
                            double *, double *, double, double, int, int, int,
                            int, int);
int /*<<< orphan*/ update_V(double *, float *, double *, double *, double *,
                            double *, double *, double, double, int, int, int,
                            int, int);
int /*<<< orphan*/ update_alpha_U(double *, double *, double, int, int);
int /*<<< orphan*/ update_alpha_beta(double *, double *, double, int, int);
int /*<<< orphan*/ update_beta(double *, float *, double *, double *, double *,
                               double *, double *, double *, double *, double,
                               int, int, int, int, int);
int /*<<< orphan*/ update_sums(double *, double *, double *, double *, double *,
                               double *, double *, double *, double, int, int,
                               int, int, double);
double var_data(float *, double *, double *, double *, double *, int, int, int,
                int, double *, int);
int /*<<< orphan*/ write_DIC(char *, double, int);
int /*<<< orphan*/ write_zscore_double(char *, int, double *);
int /*<<< orphan*/ zscore_calc(double *, double *, double *, int, int);
void lfmm_emcmc(float *dat, int *I, double *C, double *zscore, double *beta,
                double *U, double *V, double *alpha_beta, double *alpha_R,
                double *alpha_U, int N, int M, int K, int D, double epsilon,
                int Niter, int burn, int missing_data, int num_thrd,
                char *output_file, char *dev_file) {
  double *m_beta, *inv_cov_beta, *m_U, *inv_cov_U, *m_V, *inv_cov_V;
  double *mean, *mean_U, *mean_V, *sum, *sum2, *bb, *CCt;
  int i, j, n;
  double deviance = 0;
  double dp = 0;
  double thrd_m2;
  allocate_all(&m_beta, &inv_cov_beta, &m_U, &inv_cov_U, &m_V, &inv_cov_V,
               &mean, &mean_U, &mean_V, &sum2, &sum, &bb, &CCt, N, M, K, D);
  printf("\t\tStart of the Gibbs Sampler algorithm.\n\n");
  create_CCt(CCt, C, D, N);
  rand_matrix_double(beta, D, M);
  rand_matrix_double(U, K, N);
  rand_matrix_double(V, K, M);
  *alpha_R = 1.0 / var_data(dat, U, V, C, beta, N, M, K, D, &thrd_m2, num_thrd);
  init_bar(&i, &j);
  n = 0;
  while (n < Niter) {
    print_bar(&i, &j, Niter);
    if (missing_data)
      inputation(dat, U, V, C, beta, I, N, M, K, D);
    update_alpha_U(U, alpha_U, epsilon, K, N);
    update_alpha_beta(beta, alpha_beta, epsilon, D, M);
    update_beta(C, dat, U, V, beta, CCt, m_beta, inv_cov_beta, alpha_beta,
                *alpha_R, M, N, K, D, num_thrd);
    update_U(C, dat, U, V, beta, m_U, inv_cov_U, *alpha_U, *alpha_R, M, N, K, D,
             num_thrd);
    update_V(C, dat, U, V, beta, m_V, inv_cov_V, (double)(1), *alpha_R, M, N, K,
             D, num_thrd);
    *alpha_R =
        1.0 / var_data(dat, U, V, C, beta, N, M, K, D, &thrd_m2, num_thrd);
    if (n >= burn) {
      update_sums(beta, U, V, sum, sum2, mean_U, mean_V, &deviance, thrd_m2, N,
                  M, K, D, *alpha_R);
    }
    n++;
  }
  printf("\n\n");
  printf("\t\tEnd of the Gibbs Sampler algorithm.\n\n");
  zscore_calc(zscore, sum, sum2, M, Niter - burn);
  if (check_mat(zscore, M, 0, 1))
    print_error_global("nan", NULL, 0);
  calc_dp_deviance(dat, sum, mean_U, mean_V, C, &deviance, &dp, Niter - burn, N,
                   M, K, D, num_thrd);
  printf("\tED:%10.10G\t DIC: %10.10G \n\n", deviance, 2 * deviance - dp);
  fflush(stdout);
  write_DIC(dev_file, deviance, 2 * deviance - dp);
  write_zscore_double(output_file, M, zscore);
  printf("\tThe zscores were registered in:\n \t\t%s.\n\n", output_file);
  free_all(m_beta, inv_cov_beta, m_U, inv_cov_U, m_V, inv_cov_V, mean, mean_U,
           mean_V, sum2, sum, bb, CCt);
}


x86 assembly (clang, -O0):
<lfmm_emcmc>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%eax
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    %eax,-0xf4(%rbp)
lea    -0x68(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
lea    -0x90(%rbp),%r9
lea    -0x98(%rbp),%rax
lea    -0xa0(%rbp),%r14
mov    %r14,-0x108(%rbp)
lea    -0xa8(%rbp),%r14
mov    %r14,-0x100(%rbp)
lea    -0xb8(%rbp),%r13
lea    -0xb0(%rbp),%r12
lea    -0xc0(%rbp),%r15
lea    -0xc8(%rbp),%r14
mov    %rax,(%rsp)
mov    -0x108(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x100(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xf4(%rbp),%eax
mov    %r13,0x18(%rsp)
mov    %r12,0x20(%rsp)
mov    %r15,0x28(%rsp)
mov    %r14,0x30(%rsp)
mov    %ebx,0x38(%rsp)
mov    %r11d,0x40(%rsp)
mov    %r10d,0x48(%rsp)
mov    %eax,0x50(%rsp)
call   1180 <allocate_all@plt>
lea    0xc6c(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0xc8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    0x48(%rbp),%edx
mov    0x30(%rbp),%ecx
call   1040 <create_CCt@plt>
mov    -0x50(%rbp),%rdi
mov    0x48(%rbp),%esi
mov    0x38(%rbp),%edx
call   1050 <rand_matrix_double@plt>
mov    -0x58(%rbp),%rdi
mov    0x40(%rbp),%esi
mov    0x30(%rbp),%edx
call   1050 <rand_matrix_double@plt>
mov    0x10(%rbp),%rdi
mov    0x40(%rbp),%esi
mov    0x38(%rbp),%edx
call   1050 <rand_matrix_double@plt>
mov    -0x30(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    0x30(%rbp),%r9d
mov    0x38(%rbp),%r14d
mov    0x40(%rbp),%ebx
mov    0x48(%rbp),%r11d
mov    0x68(%rbp),%eax
lea    -0xf0(%rbp),%r10
mov    %r14d,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %eax,0x20(%rsp)
call   1120 <var_data@plt>
movaps %xmm0,%xmm1
movsd  0xbc7(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
lea    -0xcc(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
call   10a0 <init_bar@plt>
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    171a <lfmm_emcmc+0x4ba>
mov    0x50(%rbp),%edx
lea    -0xcc(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
call   1140 <print_bar@plt>
cmpl   $0x0,0x60(%rbp)
je     14cd <lfmm_emcmc+0x26d>
mov    -0x30(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1100 <inputation@plt>
mov    -0x58(%rbp),%rdi
mov    0x28(%rbp),%rsi
movsd  -0x60(%rbp),%xmm0
mov    0x40(%rbp),%edx
mov    0x30(%rbp),%ecx
call   1130 <update_alpha_U@plt>
mov    -0x50(%rbp),%rdi
mov    0x18(%rbp),%rsi
movsd  -0x60(%rbp),%xmm0
mov    0x48(%rbp),%edx
mov    0x38(%rbp),%ecx
call   10c0 <update_alpha_beta@plt>
mov    -0x40(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    0x10(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0xc8(%rbp),%r9
mov    -0x68(%rbp),%r13
mov    -0x70(%rbp),%r12
mov    0x18(%rbp),%r15
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x38(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x40(%rbp),%r11d
mov    0x48(%rbp),%r10d
mov    0x68(%rbp),%eax
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   10b0 <update_beta@plt>
mov    -0x40(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    0x10(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x78(%rbp),%r9
mov    -0x80(%rbp),%r15
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x38(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x40(%rbp),%r11d
mov    0x48(%rbp),%r10d
mov    0x68(%rbp),%eax
mov    %r15,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11d,0x18(%rsp)
mov    %r10d,0x20(%rsp)
mov    %eax,0x28(%rsp)
call   10f0 <update_U@plt>
mov    -0x40(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    0x10(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    -0x88(%rbp),%r9
mov    -0x90(%rbp),%r15
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x38(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x40(%rbp),%r11d
mov    0x48(%rbp),%r10d
mov    0x68(%rbp),%eax
movsd  0x9f6(%rip),%xmm0
mov    %r15,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11d,0x18(%rsp)
mov    %r10d,0x20(%rsp)
mov    %eax,0x28(%rsp)
call   1030 <update_V@plt>
mov    -0x30(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0x50(%rbp),%r8
mov    0x30(%rbp),%r9d
mov    0x38(%rbp),%r14d
mov    0x40(%rbp),%ebx
mov    0x48(%rbp),%r11d
mov    0x68(%rbp),%eax
lea    -0xf0(%rbp),%r10
mov    %r14d,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %eax,0x20(%rsp)
call   1120 <var_data@plt>
movaps %xmm0,%xmm1
movsd  0x983(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xd4(%rbp),%eax
cmp    0x58(%rbp),%eax
jl     1706 <lfmm_emcmc+0x4a6>
mov    -0x50(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    -0xb0(%rbp),%rcx
mov    -0xb8(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0xa8(%rbp),%r15
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    0x20(%rbp),%r14
movsd  (%r14),%xmm1
lea    -0xe0(%rbp),%r14
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11d,0x18(%rsp)
mov    %r10d,0x20(%rsp)
mov    %eax,0x28(%rsp)
call   1170 <update_sums@plt>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1462 <lfmm_emcmc+0x202>
lea    0x957(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x903(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x48(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    0x38(%rbp),%ecx
mov    0x50(%rbp),%r8d
sub    0x58(%rbp),%r8d
call   10e0 <zscore_calc@plt>
mov    -0x48(%rbp),%rdi
mov    0x38(%rbp),%esi
xor    %edx,%edx
mov    $0x1,%ecx
call   1150 <check_mat@plt>
cmp    $0x0,%rax
je     1787 <lfmm_emcmc+0x527>
lea    0x8de(%rip),%rdi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1160 <print_error_global@plt>
mov    -0x30(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
mov    -0x40(%rbp),%r8
mov    0x50(%rbp),%r15d
sub    0x58(%rbp),%r15d
mov    0x30(%rbp),%r14d
mov    0x38(%rbp),%ebx
mov    0x40(%rbp),%r11d
mov    0x48(%rbp),%r10d
mov    0x68(%rbp),%eax
lea    -0xe0(%rbp),%r9
lea    -0xe8(%rbp),%r12
mov    %r12,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10d0 <calc_dp_deviance@plt>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
movsd  -0xe8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
lea    0x82f(%rip),%rdi
mov    $0x2,%al
call   1080 <printf@plt>
mov    0x27a3(%rip),%rax
mov    (%rax),%edi
call   1110 <fflush@plt>
mov    0x78(%rbp),%rdi
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvttsd2si %xmm1,%esi
call   1060 <write_DIC@plt>
mov    0x70(%rbp),%rdi
mov    0x38(%rbp),%esi
mov    -0x48(%rbp),%rdx
call   1070 <write_zscore_double@plt>
mov    0x70(%rbp),%rsi
lea    0x7d8(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x68(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x80(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x90(%rbp),%r9
mov    -0x98(%rbp),%r12
mov    -0xa0(%rbp),%r15
mov    -0xa8(%rbp),%r14
mov    -0xb8(%rbp),%rbx
mov    -0xb0(%rbp),%r11
mov    -0xc0(%rbp),%r10
mov    -0xc8(%rbp),%rax
mov    %r12,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
call   1090 <free_all@plt>
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<lfmm_emcmc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
movsd  %xmm0,0x60(%rsp)
mov    %r9,0x58(%rsp)
mov    %r8,%r14
mov    %rcx,0xa0(%rsp)
mov    %rdx,%r15
mov    %rdx,0x18(%rsp)
mov    %rsi,0xa8(%rsp)
mov    %rdi,0x10(%rsp)
mov    0x138(%rsp),%r13d
mov    0x130(%rsp),%eax
mov    0x128(%rsp),%r10d
mov    0x120(%rsp),%ebx
movq   $0x0,(%rsp)
movq   $0x0,0x20(%rsp)
sub    $0x8,%rsp
lea    0x30(%rsp),%r11
lea    0xc0(%rsp),%rbp
lea    0x38(%rsp),%r12
lea    0xa0(%rsp),%rdi
lea    0x98(%rsp),%rsi
lea    0x90(%rsp),%rdx
lea    0x88(%rsp),%rcx
lea    0x80(%rsp),%r8
lea    0x78(%rsp),%r9
push   %r13
push   %rax
push   %r10
push   %rbx
push   %r11
push   %rbp
lea    0x40(%rsp),%rax
push   %rax
push   %r12
mov    0x188(%rsp),%ebp
lea    0x80(%rsp),%rax
push   %rax
lea    0x90(%rsp),%rax
push   %rax
lea    0x118(%rsp),%rax
push   %rax
call   1190 <allocate_all@plt>
add    $0x60,%rsp
lea    0xcf2(%rip),%rdi
call   1050 <puts@plt>
mov    0x28(%rsp),%rdi
mov    %r15,%rsi
mov    %r13d,%edx
mov    %ebx,%ecx
call   1040 <create_CCt@plt>
mov    %r14,%r15
mov    %r14,%rdi
mov    %r13d,%esi
mov    0x128(%rsp),%r12d
mov    %r12d,%edx
call   1060 <rand_matrix_double@plt>
mov    0x58(%rsp),%r14
mov    %r14,%rdi
mov    0x130(%rsp),%esi
mov    %ebx,%edx
call   1060 <rand_matrix_double@plt>
mov    0x100(%rsp),%rbx
mov    %rbx,%rdi
mov    0x130(%rsp),%esi
mov    %r12d,%edx
call   1060 <rand_matrix_double@plt>
sub    $0x8,%rsp
lea    0x70(%rsp),%rax
mov    0x18(%rsp),%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
mov    0x20(%rsp),%rcx
mov    %r15,0xb8(%rsp)
mov    %r15,%r8
mov    0x128(%rsp),%r9d
mov    0x160(%rsp),%ebx
push   %rbx
push   %rax
push   %r13
mov    0x150(%rsp),%eax
push   %rax
push   %r12
call   1130 <var_data@plt>
add    $0x30,%rsp
movsd  0xbed(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x110(%rsp),%rax
movsd  %xmm1,(%rax)
lea    0x54(%rsp),%rdi
lea    0x50(%rsp),%rsi
call   10b0 <init_bar@plt>
test   %ebp,%ebp
jle    16f0 <lfmm_emcmc+0x480>
xor    %ebx,%ebx
mov    0x10(%rsp),%r12
mov    0x58(%rsp),%r14
mov    0xb0(%rsp),%r15
jmp    1462 <lfmm_emcmc+0x1f2>
add    $0x1,%ebx
mov    0x140(%rsp),%ebp
cmp    %ebx,%ebp
je     16f0 <lfmm_emcmc+0x480>
mov    %ebx,0x4c(%rsp)
lea    0x54(%rsp),%rdi
lea    0x50(%rsp),%rsi
mov    %ebp,%edx
call   1150 <print_bar@plt>
cmpl   $0x0,0x150(%rsp)
mov    0x130(%rsp),%ebx
mov    0x18(%rsp),%rbp
je     14c5 <lfmm_emcmc+0x255>
mov    %r12,%rdi
mov    %r14,%rsi
mov    0x100(%rsp),%rdx
mov    %rbp,%rcx
mov    %r15,%r8
mov    0xa8(%rsp),%r9
push   %r13
push   %rbx
mov    0x138(%rsp),%eax
push   %rax
mov    0x138(%rsp),%eax
push   %rax
call   1110 <inputation@plt>
add    $0x20,%rsp
mov    %r14,%rdi
mov    0x118(%rsp),%rsi
movsd  0x60(%rsp),%xmm0
mov    %ebx,%edx
mov    0x120(%rsp),%eax
mov    %rax,%rcx
call   1140 <update_alpha_U@plt>
mov    %r15,%rdi
mov    0x108(%rsp),%rsi
movsd  0x60(%rsp),%xmm0
mov    %r13d,%edx
mov    0x128(%rsp),%eax
mov    %rax,%rcx
call   10d0 <update_alpha_beta@plt>
mov    0x28(%rsp),%r9
mov    0x110(%rsp),%rax
movsd  (%rax),%xmm0
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    0x100(%rsp),%rcx
mov    %r15,%r8
mov    0x158(%rsp),%r13d
push   %r13
mov    0x140(%rsp),%eax
push   %rax
push   %rbx
mov    0x138(%rsp),%eax
push   %rax
mov    0x148(%rsp),%eax
push   %rax
push   0x130(%rsp)
push   0xc0(%rsp)
push   0xd0(%rsp)
call   10c0 <update_beta@plt>
add    $0x40,%rsp
mov    0x88(%rsp),%r9
mov    0x118(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x110(%rsp),%r13
movsd  0x0(%r13),%xmm1
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    0x100(%rsp),%rcx
mov    %r15,%r8
mov    0x158(%rsp),%eax
push   %rax
mov    0x140(%rsp),%eax
push   %rax
push   %rbx
mov    0x138(%rsp),%eax
push   %rax
mov    0x148(%rsp),%eax
push   %rax
push   0xa8(%rsp)
call   1100 <update_U@plt>
add    $0x30,%rsp
mov    0x78(%rsp),%r9
movsd  0x0(%r13),%xmm1
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    0x100(%rsp),%rcx
mov    %r15,%r8
movsd  0xa02(%rip),%xmm0
mov    0x158(%rsp),%eax
push   %rax
mov    0x140(%rsp),%eax
push   %rax
push   %rbx
mov    0x138(%rsp),%r13d
push   %r13
mov    0x148(%rsp),%eax
push   %rax
push   0x98(%rsp)
call   1030 <update_V@plt>
add    $0x28,%rsp
mov    %r12,%rdi
mov    %r14,%rsi
mov    0x108(%rsp),%rdx
mov    %rbp,%rcx
mov    %r15,%r8
mov    %r13d,%r9d
mov    0x160(%rsp),%eax
push   %rax
mov    0x148(%rsp),%r13d
lea    0x78(%rsp),%rax
push   %rax
push   %r13
push   %rbx
mov    0x150(%rsp),%eax
push   %rax
call   1130 <var_data@plt>
add    $0x30,%rsp
movsd  0x986(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x110(%rsp),%rax
movsd  %xmm1,(%rax)
mov    0x4c(%rsp),%ebx
cmp    0x148(%rsp),%ebx
mov    0x100(%rsp),%rdx
jl     1450 <lfmm_emcmc+0x1e0>
mov    0x8(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0x40(%rsp),%r9
movsd  0x68(%rsp),%xmm0
mov    %r15,%rdi
mov    %r14,%rsi
push   %r13
mov    0x138(%rsp),%eax
push   %rax
mov    0x138(%rsp),%eax
push   %rax
mov    0x138(%rsp),%eax
push   %rax
lea    0x20(%rsp),%rax
push   %rax
push   0x60(%rsp)
call   1180 <update_sums@plt>
add    $0x30,%rsp
jmp    1450 <lfmm_emcmc+0x1e0>
mov    0x168(%rsp),%r15
mov    0x160(%rsp),%r12
lea    0x920(%rip),%rdi
call   1050 <puts@plt>
lea    0x969(%rip),%rdi
call   1050 <puts@plt>
mov    0x8(%rsp),%rsi
mov    0x30(%rsp),%rdx
sub    0x148(%rsp),%ebp
mov    0xa0(%rsp),%r14
mov    %r14,%rdi
mov    0x128(%rsp),%ebx
mov    %ebx,%ecx
mov    %rbp,%r13
mov    %ebp,%r8d
call   10f0 <zscore_calc@plt>
mov    %r14,%rdi
mov    %ebx,%esi
xor    %edx,%edx
mov    $0x1,%ecx
call   1160 <check_mat@plt>
test   %rax,%rax
je     176e <lfmm_emcmc+0x4fe>
lea    0x8a3(%rip),%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1170 <print_error_global@plt>
mov    0x8(%rsp),%rsi
mov    0x40(%rsp),%rdx
mov    0x38(%rsp),%rcx
sub    $0x8,%rsp
lea    0x28(%rsp),%rax
lea    0x8(%rsp),%r9
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r8
mov    0x160(%rsp),%ebp
push   %rbp
mov    0x148(%rsp),%ebp
push   %rbp
mov    0x148(%rsp),%ebp
push   %rbp
mov    0x148(%rsp),%ebp
push   %rbp
mov    0x148(%rsp),%ebx
push   %rbx
push   %r13
push   %rax
call   10e0 <calc_dp_deviance@plt>
add    $0x40,%rsp
movsd  (%rsp),%xmm0
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
subsd  0x20(%rsp),%xmm1
lea    0x829(%rip),%rdi
mov    $0x2,%al
call   1090 <printf@plt>
mov    0x27ef(%rip),%rax
mov    (%rax),%edi
call   1120 <fflush@plt>
movsd  (%rsp),%xmm0
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
subsd  0x20(%rsp),%xmm1
cvttsd2si %xmm1,%esi
mov    %r15,%rdi
call   1070 <write_DIC@plt>
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r14,%rdx
call   1080 <write_zscore_double@plt>
lea    0x7fe(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <printf@plt>
mov    0x98(%rsp),%rdi
mov    0x90(%rsp),%rsi
mov    0x88(%rsp),%rdx
mov    0x80(%rsp),%rcx
mov    0x78(%rsp),%r8
mov    0x70(%rsp),%r9
sub    $0x8,%rsp
push   0x30(%rsp)
push   0xc8(%rsp)
push   0x20(%rsp)
push   0x50(%rsp)
push   0x60(%rsp)
push   0x70(%rsp)
push   0xf8(%rsp)
call   10a0 <free_all@plt>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [42 x i8] c"\09\09Start of the Gibbs Sampler algorithm.\0A\0A\00"
@.str.1 = [3 x i8] c"\0A\0A\00"
@.str.2 = [40 x i8] c"\09\09End of the Gibbs Sampler algorithm.\0A\0A\00"
@.str.3 = [4 x i8] c"nan\00"
@.str.4 = [29 x i8] c"\09ED:%10.10G\09 DIC: %10.10G \0A\0A\00"
@stdout = global i32 0
@.str.5 = [42 x i8] c"\09The zscores were registered in:\0A \09\09%s.\0A\0A\00"
define void @lfmm_emcmc(float* %0, i32* %1, double* %2, double* %3, double* %4, double* %5, double* %6, double* %7, double* %8, double* %9, i32 %10, i32 %11, i32 %12, i32 %13, double %14, i32 %15, i32 %16, i32 %17, i32 %18, i8* %19, i8* %20) {
%22 = alloca float*
%23 = alloca i32*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca double
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i8*
%42 = alloca i8*
%43 = alloca double*
%44 = alloca double*
%45 = alloca double*
%46 = alloca double*
%47 = alloca double*
%48 = alloca double*
%49 = alloca double*
%50 = alloca double*
%51 = alloca double*
%52 = alloca double*
%53 = alloca double*
%54 = alloca double*
%55 = alloca double*
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca double
%60 = alloca double
%61 = alloca double
store float* %0, float** %22
store i32* %1, i32** %23
store double* %2, double** %24
store double* %3, double** %25
store double* %4, double** %26
store double* %5, double** %27
store double* %6, double** %28
store double* %7, double** %29
store double* %8, double** %30
store double* %9, double** %31
store i32 %10, i32* %32
store i32 %11, i32* %33
store i32 %12, i32* %34
store i32 %13, i32* %35
store double %14, double* %36
store i32 %15, i32* %37
store i32 %16, i32* %38
store i32 %17, i32* %39
store i32 %18, i32* %40
store i8* %19, i8** %41
store i8* %20, i8** %42
store double 0.000000e+00, double* %59
store double 0.000000e+00, double* %60
%62 = load i32, i32* %32
%63 = load i32, i32* %33
%64 = load i32, i32* %34
%65 = load i32, i32* %35
%66 = call i32 @allocate_all(double** %43, double** %44, double** %45, double** %46, double** %47, double** %48, double** %49, double** %50, double** %51, double** %53, double** %52, double** %54, double** %55, i32 %62, i32 %63, i32 %64, i32 %65)
%67 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
%68 = load double*, double** %55
%69 = load double*, double** %24
%70 = load i32, i32* %35
%71 = load i32, i32* %32
%72 = call i32 @create_CCt(double* %68, double* %69, i32 %70, i32 %71)
%73 = load double*, double** %26
%74 = load i32, i32* %35
%75 = load i32, i32* %33
%76 = call i32 @rand_matrix_double(double* %73, i32 %74, i32 %75)
%77 = load double*, double** %27
%78 = load i32, i32* %34
%79 = load i32, i32* %32
%80 = call i32 @rand_matrix_double(double* %77, i32 %78, i32 %79)
%81 = load double*, double** %28
%82 = load i32, i32* %34
%83 = load i32, i32* %33
%84 = call i32 @rand_matrix_double(double* %81, i32 %82, i32 %83)
%85 = load float*, float** %22
%86 = load double*, double** %27
%87 = load double*, double** %28
%88 = load double*, double** %24
%89 = load double*, double** %26
%90 = load i32, i32* %32
%91 = load i32, i32* %33
%92 = load i32, i32* %34
%93 = load i32, i32* %35
%94 = load i32, i32* %40
%95 = call double @var_data(float* %85, double* %86, double* %87, double* %88, double* %89, i32 %90, i32 %91, i32 %92, i32 %93, double* %61, i32 %94)
%96 = fdiv double 1.000000e+00, %95
%97 = load double*, double** %30
store double %96, double* %97
%98 = call i32 @init_bar(i32* %56, i32* %57)
store i32 0, i32* %58
br label %99
99: ; preds = %214, %21
%100 = load i32, i32* %58
%101 = load i32, i32* %37
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %217
103: ; preds = %99
%104 = load i32, i32* %37
%105 = call i32 @print_bar(i32* %56, i32* %57, i32 %104)
%106 = load i32, i32* %39
%107 = icmp ne i32 %106, 0
br i1 %107, label %108, label %120
108: ; preds = %103
%109 = load float*, float** %22
%110 = load double*, double** %27
%111 = load double*, double** %28
%112 = load double*, double** %24
%113 = load double*, double** %26
%114 = load i32*, i32** %23
%115 = load i32, i32* %32
%116 = load i32, i32* %33
%117 = load i32, i32* %34
%118 = load i32, i32* %35
%119 = call i32 @inputation(float* %109, double* %110, double* %111, double* %112, double* %113, i32* %114, i32 %115, i32 %116, i32 %117, i32 %118)
br label %120
120: ; preds = %108, %103
%121 = load double*, double** %27
%122 = load double*, double** %31
%123 = load double, double* %36
%124 = load i32, i32* %34
%125 = load i32, i32* %32
%126 = call i32 @update_alpha_U(double* %121, double* %122, double %123, i32 %124, i32 %125)
%127 = load double*, double** %26
%128 = load double*, double** %29
%129 = load double, double* %36
%130 = load i32, i32* %35
%131 = load i32, i32* %33
%132 = call i32 @update_alpha_beta(double* %127, double* %128, double %129, i32 %130, i32 %131)
%133 = load double*, double** %24
%134 = load float*, float** %22
%135 = load double*, double** %27
%136 = load double*, double** %28
%137 = load double*, double** %26
%138 = load double*, double** %55
%139 = load double*, double** %43
%140 = load double*, double** %44
%141 = load double*, double** %29
%142 = load double*, double** %30
%143 = load double, double* %142
%144 = load i32, i32* %33
%145 = load i32, i32* %32
%146 = load i32, i32* %34
%147 = load i32, i32* %35
%148 = load i32, i32* %40
%149 = call i32 @update_beta(double* %133, float* %134, double* %135, double* %136, double* %137, double* %138, double* %139, double* %140, double* %141, double %143, i32 %144, i32 %145, i32 %146, i32 %147, i32 %148)
%150 = load double*, double** %24
%151 = load float*, float** %22
%152 = load double*, double** %27
%153 = load double*, double** %28
%154 = load double*, double** %26
%155 = load double*, double** %45
%156 = load double*, double** %46
%157 = load double*, double** %31
%158 = load double, double* %157
%159 = load double*, double** %30
%160 = load double, double* %159
%161 = load i32, i32* %33
%162 = load i32, i32* %32
%163 = load i32, i32* %34
%164 = load i32, i32* %35
%165 = load i32, i32* %40
%166 = call i32 @update_U(double* %150, float* %151, double* %152, double* %153, double* %154, double* %155, double* %156, double %158, double %160, i32 %161, i32 %162, i32 %163, i32 %164, i32 %165)
%167 = load double*, double** %24
%168 = load float*, float** %22
%169 = load double*, double** %27
%170 = load double*, double** %28
%171 = load double*, double** %26
%172 = load double*, double** %47
%173 = load double*, double** %48
%174 = load double*, double** %30
%175 = load double, double* %174
%176 = load i32, i32* %33
%177 = load i32, i32* %32
%178 = load i32, i32* %34
%179 = load i32, i32* %35
%180 = load i32, i32* %40
%181 = call i32 @update_V(double* %167, float* %168, double* %169, double* %170, double* %171, double* %172, double* %173, double 1.000000e+00, double %175, i32 %176, i32 %177, i32 %178, i32 %179, i32 %180)
%182 = load float*, float** %22
%183 = load double*, double** %27
%184 = load double*, double** %28
%185 = load double*, double** %24
%186 = load double*, double** %26
%187 = load i32, i32* %32
%188 = load i32, i32* %33
%189 = load i32, i32* %34
%190 = load i32, i32* %35
%191 = load i32, i32* %40
%192 = call double @var_data(float* %182, double* %183, double* %184, double* %185, double* %186, i32 %187, i32 %188, i32 %189, i32 %190, double* %61, i32 %191)
%193 = fdiv double 1.000000e+00, %192
%194 = load double*, double** %30
store double %193, double* %194
%195 = load i32, i32* %58
%196 = load i32, i32* %38
%197 = icmp sge i32 %195, %196
br i1 %197, label %198, label %214
198: ; preds = %120
%199 = load double*, double** %26
%200 = load double*, double** %27
%201 = load double*, double** %28
%202 = load double*, double** %52
%203 = load double*, double** %53
%204 = load double*, double** %50
%205 = load double*, double** %51
%206 = load double, double* %61
%207 = load i32, i32* %32
%208 = load i32, i32* %33
%209 = load i32, i32* %34
%210 = load i32, i32* %35
%211 = load double*, double** %30
%212 = load double, double* %211
%213 = call i32 @update_sums(double* %199, double* %200, double* %201, double* %202, double* %203, double* %204, double* %205, double* %59, double %206, i32 %207, i32 %208, i32 %209, i32 %210, double %212)
br label %214
214: ; preds = %198, %120
%215 = load i32, i32* %58
%216 = add nsw i32 %215, 1
store i32 %216, i32* %58
br label %99
217: ; preds = %99
%218 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%219 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.2, i64 0, i64 0))
%220 = load double*, double** %25
%221 = load double*, double** %52
%222 = load double*, double** %53
%223 = load i32, i32* %33
%224 = load i32, i32* %37
%225 = load i32, i32* %38
%226 = sub nsw i32 %224, %225
%227 = call i32 @zscore_calc(double* %220, double* %221, double* %222, i32 %223, i32 %226)
%228 = load double*, double** %25
%229 = load i32, i32* %33
%230 = call i64 @check_mat(double* %228, i32 %229, i32 0, i32 1)
%231 = icmp ne i64 %230, 0
br i1 %231, label %232, label %234
232: ; preds = %217
%233 = call i32 @print_error_global(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32* null, i32 0)
br label %234
234: ; preds = %232, %217
%235 = load float*, float** %22
%236 = load double*, double** %52
%237 = load double*, double** %50
%238 = load double*, double** %51
%239 = load double*, double** %24
%240 = load i32, i32* %37
%241 = load i32, i32* %38
%242 = sub nsw i32 %240, %241
%243 = load i32, i32* %32
%244 = load i32, i32* %33
%245 = load i32, i32* %34
%246 = load i32, i32* %35
%247 = load i32, i32* %40
%248 = call i32 @calc_dp_deviance(float* %235, double* %236, double* %237, double* %238, double* %239, double* %59, double* %60, i32 %242, i32 %243, i32 %244, i32 %245, i32 %246, i32 %247)
%249 = load double, double* %59
%250 = load double, double* %59
%251 = load double, double* %60
%252 = fneg double %251
%253 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %250, double %252)
%254 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0), double %249, double %253)
%255 = load i32, i32* @stdout
%256 = call i32 @fflush(i32 %255)
%257 = load i8*, i8** %42
%258 = load double, double* %59
%259 = load double, double* %59
%260 = load double, double* %60
%261 = fneg double %260
%262 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %259, double %261)
%263 = fptosi double %262 to i32
%264 = call i32 @write_DIC(i8* %257, double %258, i32 %263)
%265 = load i8*, i8** %41
%266 = load i32, i32* %33
%267 = load double*, double** %25
%268 = call i32 @write_zscore_double(i8* %265, i32 %266, double* %267)
%269 = load i8*, i8** %41
%270 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.5, i64 0, i64 0), i8* %269)
%271 = load double*, double** %43
%272 = load double*, double** %44
%273 = load double*, double** %45
%274 = load double*, double** %46
%275 = load double*, double** %47
%276 = load double*, double** %48
%277 = load double*, double** %49
%278 = load double*, double** %50
%279 = load double*, double** %51
%280 = load double*, double** %53
%281 = load double*, double** %52
%282 = load double*, double** %54
%283 = load double*, double** %55
%284 = call i32 @free_all(double* %271, double* %272, double* %273, double* %274, double* %275, double* %276, double* %277, double* %278, double* %279, double* %280, double* %281, double* %282, double* %283)
ret void
}

LLVM IR (-O2):
@.str.3 = [4 x i8] c"nan\00"
@.str.4 = [29 x i8] c"\09ED:%10.10G\09 DIC: %10.10G \0A\0A\00"
@stdout = global i32 0
@.str.5 = [42 x i8] c"\09The zscores were registered in:\0A \09\09%s.\0A\0A\00"
@str = [41 x i8] c"\09\09Start of the Gibbs Sampler algorithm.\0A\00"
@str.6 = [2 x i8] c"\0A\00"
@str.7 = [39 x i8] c"\09\09End of the Gibbs Sampler algorithm.\0A\00"
define void @lfmm_emcmc(float* %0, i32* %1, double* %2, double* %3, double* %4, double* %5, double* %6, double* %7, double* nocapture %8, double* %9, i32 %10, i32 %11, i32 %12, i32 %13, double %14, i32 %15, i32 %16, i32 %17, i32 %18, i8* %19, i8* %20) {
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca i32
%36 = alloca i32
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = bitcast double** %22 to i8*
%41 = bitcast double** %23 to i8*
%42 = bitcast double** %24 to i8*
%43 = bitcast double** %25 to i8*
%44 = bitcast double** %26 to i8*
%45 = bitcast double** %27 to i8*
%46 = bitcast double** %28 to i8*
%47 = bitcast double** %29 to i8*
%48 = bitcast double** %30 to i8*
%49 = bitcast double** %31 to i8*
%50 = bitcast double** %32 to i8*
%51 = bitcast double** %33 to i8*
%52 = bitcast double** %34 to i8*
%53 = bitcast i32* %35 to i8*
%54 = bitcast i32* %36 to i8*
%55 = bitcast double* %37 to i8*
store double 0.000000e+00, double* %37
%56 = bitcast double* %38 to i8*
store double 0.000000e+00, double* %38
%57 = bitcast double* %39 to i8*
%58 = call i32 @allocate_all(double** %22, double** %23, double** %24, double** %25, double** %26, double** %27, double** %28, double** %29, double** %30, double** %32, double** %31, double** %33, double** %34, i32 %10, i32 %11, i32 %12, i32 %13)
%59 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str, i64 0, i64 0))
%60 = load double*, double** %34
%61 = call i32 @create_CCt(double* %60, double* %2, i32 %13, i32 %10)
%62 = call i32 @rand_matrix_double(double* %4, i32 %13, i32 %11)
%63 = call i32 @rand_matrix_double(double* %5, i32 %12, i32 %10)
%64 = call i32 @rand_matrix_double(double* %6, i32 %12, i32 %11)
%65 = call double @var_data(float* %0, double* %5, double* %6, double* %2, double* %4, i32 %10, i32 %11, i32 %12, i32 %13, double* %39, i32 %18)
%66 = fdiv double 1.000000e+00, %65
store double %66, double* %8
%67 = call i32 @init_bar(i32* %35, i32* %36)
%68 = icmp sgt i32 %15, 0
br i1 %68, label %69, label %106
69: ; preds = %21
%70 = icmp eq i32 %17, 0
br label %71
71: ; preds = %69, %103
%72 = phi i32 [ 0, %69 ], [ %104, %103 ]
%73 = call i32 @print_bar(i32* %35, i32* %36, i32 %15)
br i1 %70, label %76, label %74
74: ; preds = %71
%75 = call i32 @inputation(float* %0, double* %5, double* %6, double* %2, double* %4, i32* %1, i32 %10, i32 %11, i32 %12, i32 %13)
br label %76
76: ; preds = %74, %71
%77 = call i32 @update_alpha_U(double* %5, double* %9, double %14, i32 %12, i32 %10)
%78 = call i32 @update_alpha_beta(double* %4, double* %7, double %14, i32 %13, i32 %11)
%79 = load double*, double** %34
%80 = load double*, double** %22
%81 = load double*, double** %23
%82 = load double, double* %8
%83 = call i32 @update_beta(double* %2, float* %0, double* %5, double* %6, double* %4, double* %79, double* %80, double* %81, double* %7, double %82, i32 %11, i32 %10, i32 %12, i32 %13, i32 %18)
%84 = load double*, double** %24
%85 = load double*, double** %25
%86 = load double, double* %9
%87 = load double, double* %8
%88 = call i32 @update_U(double* %2, float* %0, double* %5, double* %6, double* %4, double* %84, double* %85, double %86, double %87, i32 %11, i32 %10, i32 %12, i32 %13, i32 %18)
%89 = load double*, double** %26
%90 = load double*, double** %27
%91 = load double, double* %8
%92 = call i32 @update_V(double* %2, float* %0, double* %5, double* %6, double* %4, double* %89, double* %90, double 1.000000e+00, double %91, i32 %11, i32 %10, i32 %12, i32 %13, i32 %18)
%93 = call double @var_data(float* %0, double* %5, double* %6, double* %2, double* %4, i32 %10, i32 %11, i32 %12, i32 %13, double* %39, i32 %18)
%94 = fdiv double 1.000000e+00, %93
store double %94, double* %8
%95 = icmp slt i32 %72, %16
br i1 %95, label %103, label %96
96: ; preds = %76
%97 = load double*, double** %31
%98 = load double*, double** %32
%99 = load double*, double** %29
%100 = load double*, double** %30
%101 = load double, double* %39
%102 = call i32 @update_sums(double* %4, double* %5, double* %6, double* %97, double* %98, double* %99, double* %100, double* %37, double %101, i32 %10, i32 %11, i32 %12, i32 %13, double %94)
br label %103
103: ; preds = %96, %76
%104 = add nuw nsw i32 %72, 1
%105 = icmp eq i32 %104, %15
br i1 %105, label %106, label %71
106: ; preds = %103, %21
%107 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.6, i64 0, i64 0))
%108 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.7, i64 0, i64 0))
%109 = load double*, double** %31
%110 = load double*, double** %32
%111 = sub nsw i32 %15, %16
%112 = call i32 @zscore_calc(double* %3, double* %109, double* %110, i32 %11, i32 %111)
%113 = call i64 @check_mat(double* %3, i32 %11, i32 0, i32 1)
%114 = icmp eq i64 %113, 0
br i1 %114, label %117, label %115
115: ; preds = %106
%116 = call i32 @print_error_global(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32* null, i32 0)
br label %117
117: ; preds = %115, %106
%118 = load double*, double** %31
%119 = load double*, double** %29
%120 = load double*, double** %30
%121 = call i32 @calc_dp_deviance(float* %0, double* %118, double* %119, double* %120, double* %2, double* %37, double* %38, i32 %111, i32 %10, i32 %11, i32 %12, i32 %13, i32 %18)
%122 = load double, double* %37
%123 = load double, double* %38
%124 = fneg double %123
%125 = call double @llvm.fmuladd.f64(double %122, double 2.000000e+00, double %124)
%126 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0), double %122, double %125)
%127 = load i32, i32* @stdout
%128 = call i32 @fflush(i32 %127)
%129 = load double, double* %37
%130 = load double, double* %38
%131 = fneg double %130
%132 = call double @llvm.fmuladd.f64(double %129, double 2.000000e+00, double %131)
%133 = fptosi double %132 to i32
%134 = call i32 @write_DIC(i8* %20, double %129, i32 %133)
%135 = call i32 @write_zscore_double(i8* %19, i32 %11, double* %3)
%136 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.5, i64 0, i64 0), i8* %19)
%137 = load double*, double** %22
%138 = load double*, double** %23
%139 = load double*, double** %24
%140 = load double*, double** %25
%141 = load double*, double** %26
%142 = load double*, double** %27
%143 = load double*, double** %28
%144 = load double*, double** %29
%145 = load double*, double** %30
%146 = load double*, double** %32
%147 = load double*, double** %31
%148 = load double*, double** %33
%149 = load double*, double** %34
%150 = call i32 @free_all(double* %137, double* %138, double* %139, double* %140, double* %141, double* %142, double* %143, double* %144, double* %145, double* %146, double* %147, double* %148, double* %149)
ret void
}