#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 size_t V;

/* Variables and functions */
int sample_Mult_smooth(double, double *, int, int);
void resample_w(int D, int **M, int *N, double eta, double **post_beta,
                int ***w, int ***z, int V) {
  int d_11;
  int n_17;
  int m_23;
  for (d_11 = 1; d_11 <= D; d_11++) {
    for (n_17 = 1; n_17 <= N[d_11 - 1]; n_17++) {
      for (m_23 = 1; m_23 <= M[d_11 - 1][n_17 - 1]; m_23++) {
        post_beta[z[d_11 - 1][n_17 - 1][m_23 - 1] - 1][(V) + (1) - 1] +=
            (0.0) - ((1.0) * ((((z[d_11 - 1][n_17 - 1][m_23 - 1]) ==
                                (z[d_11 - 1][n_17 - 1][m_23 - 1]))
                                   ? 1
                                   : 0)));
        post_beta[z[d_11 - 1][n_17 - 1][m_23 - 1] - 1]
                 [w[d_11 - 1][n_17 - 1][m_23 - 1] - 1] +=
            (0.0) - ((1.0) * ((((z[d_11 - 1][n_17 - 1][m_23 - 1]) ==
                                (z[d_11 - 1][n_17 - 1][m_23 - 1]))
                                   ? 1
                                   : 0)));
        w[d_11 - 1][n_17 - 1][m_23 - 1] = sample_Mult_smooth(
            eta, post_beta[z[d_11 - 1][n_17 - 1][m_23 - 1] - 1], 1, V);
        post_beta[z[d_11 - 1][n_17 - 1][m_23 - 1] - 1][(V) + (1) - 1] +=
            (1.0) * ((((z[d_11 - 1][n_17 - 1][m_23 - 1]) ==
                       (z[d_11 - 1][n_17 - 1][m_23 - 1]))
                          ? 1
                          : 0));
        post_beta[z[d_11 - 1][n_17 - 1][m_23 - 1] - 1]
                 [w[d_11 - 1][n_17 - 1][m_23 - 1] - 1] +=
            (1.0) * ((((z[d_11 - 1][n_17 - 1][m_23 - 1]) ==
                       (z[d_11 - 1][n_17 - 1][m_23 - 1]))
                          ? 1
                          : 0));
      }
    }
  }
}


x86 assembly (clang, -O0):
<resample_w>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1567 <resample_w+0x457>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1554 <resample_w+0x444>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1541 <resample_w+0x431>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x10(%rbp),%edx
mov    $0x1,%esi
call   1030 <sample_Mult_smooth@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1171 <resample_w+0x61>
jmp    1546 <resample_w+0x436>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1151 <resample_w+0x41>
jmp    1559 <resample_w+0x449>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    113e <resample_w+0x2e>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<resample_w>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,0x8(%rsp)
mov    %rdi,(%rsp)
test   %edi,%edi
jle    12a8 <resample_w+0x198>
mov    %r9,%r15
mov    %rcx,%r12
mov    %rsi,%r14
mov    0x60(%rsp),%eax
movslq %eax,%r11
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
mov    $0x1,%ebp
movsd  0xea9(%rip),%xmm2
movsd  %xmm0,0x18(%rsp)
mov    %r11,0x10(%rsp)
jmp    117e <resample_w+0x6e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    (%rsp),%rbp
je     12a8 <resample_w+0x198>
mov    0x8(%rsp),%rax
mov    -0x4(%rax,%rbp,4),%ebx
test   %ebx,%ebx
jle    1170 <resample_w+0x60>
mov    -0x8(%r14,%rbp,8),%rax
mov    $0x1,%edi
jmp    11af <resample_w+0x9f>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdi),%rdx
movslq %ebx,%rsi
cmp    %rsi,%rdi
mov    %rdx,%rdi
jge    1170 <resample_w+0x60>
cmpl   $0x0,-0x4(%rax,%rdi,4)
jle    11a0 <resample_w+0x90>
mov    -0x8(%r15,%rbp,8),%rax
mov    -0x8(%rax,%rdi,8),%rdx
mov    -0x8(%r8,%rbp,8),%rax
mov    -0x8(%rax,%rdi,8),%rbx
xor    %r13d,%r13d
mov    %rdi,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rdx,%r13,4),%rax
mov    -0x8(%r12,%rax,8),%rdi
movsd  (%rdi,%r11,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r11,8)
movslq (%rbx,%r13,4),%rax
movsd  -0x8(%rdi,%rax,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,-0x8(%rdi,%rax,8)
mov    $0x1,%esi
mov    %r11d,%edx
mov    %r8,%rbx
call   1030 <sample_Mult_smooth@plt>
movsd  0xde3(%rip),%xmm3
movsd  0xdd3(%rip),%xmm2
mov    0x10(%rsp),%r11
mov    0x20(%rsp),%rdi
movsd  0x18(%rsp),%xmm0
mov    %rbx,%r8
mov    -0x8(%rbx,%rbp,8),%rdx
mov    -0x8(%rdx,%rdi,8),%rbx
mov    %eax,(%rbx,%r13,4)
mov    -0x8(%r15,%rbp,8),%rdx
mov    -0x8(%rdx,%rdi,8),%rdx
movslq (%rdx,%r13,4),%rsi
mov    -0x8(%r12,%rsi,8),%rsi
movsd  (%rsi,%r11,8),%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%r11,8)
cltq
movsd  -0x8(%rsi,%rax,8),%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,-0x8(%rsi,%rax,8)
mov    -0x8(%r14,%rbp,8),%rax
movslq -0x4(%rax,%rdi,4),%rsi
add    $0x1,%r13
cmp    %rsi,%r13
jl     11e0 <resample_w+0xd0>
mov    0x8(%rsp),%rdx
mov    -0x4(%rdx,%rbp,4),%ebx
jmp    11a0 <resample_w+0x90>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @resample_w(i32 %0, i32** %1, i32* %2, double %3, double** %4, i32*** %5, i32*** %6, i32 %7) {
%9 = alloca i32
%10 = alloca i32**
%11 = alloca i32*
%12 = alloca double
%13 = alloca double**
%14 = alloca i32***
%15 = alloca i32***
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 %0, i32* %9
store i32** %1, i32*** %10
store i32* %2, i32** %11
store double %3, double* %12
store double** %4, double*** %13
store i32*** %5, i32**** %14
store i32*** %6, i32**** %15
store i32 %7, i32* %16
store i32 1, i32* %17
br label %20
20: ; preds = %383, %8
%21 = load i32, i32* %17
%22 = load i32, i32* %9
%23 = icmp sle i32 %21, %22
br i1 %23, label %24, label %386
24: ; preds = %20
store i32 1, i32* %18
br label %25
25: ; preds = %379, %24
%26 = load i32, i32* %18
%27 = load i32*, i32** %11
%28 = load i32, i32* %17
%29 = sub nsw i32 %28, 1
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32, i32* %27, i64 %30
%32 = load i32, i32* %31
%33 = icmp sle i32 %26, %32
br i1 %33, label %34, label %382
34: ; preds = %25
store i32 1, i32* %19
br label %35
35: ; preds = %375, %34
%36 = load i32, i32* %19
%37 = load i32**, i32*** %10
%38 = load i32, i32* %17
%39 = sub nsw i32 %38, 1
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i32*, i32** %37, i64 %40
%42 = load i32*, i32** %41
%43 = load i32, i32* %18
%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 %36, %47
br i1 %48, label %49, label %378
49: ; preds = %35
%50 = load i32***, i32**** %15
%51 = load i32, i32* %17
%52 = sub nsw i32 %51, 1
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32**, i32*** %50, i64 %53
%55 = load i32**, i32*** %54
%56 = load i32, i32* %18
%57 = sub nsw i32 %56, 1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32*, i32** %55, i64 %58
%60 = load i32*, i32** %59
%61 = load i32, i32* %19
%62 = sub nsw i32 %61, 1
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %60, i64 %63
%65 = load i32, i32* %64
%66 = load i32***, i32**** %15
%67 = load i32, i32* %17
%68 = sub nsw i32 %67, 1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32**, i32*** %66, i64 %69
%71 = load i32**, i32*** %70
%72 = load i32, i32* %18
%73 = sub nsw i32 %72, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i32*, i32** %71, i64 %74
%76 = load i32*, i32** %75
%77 = load i32, i32* %19
%78 = sub nsw i32 %77, 1
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %76, i64 %79
%81 = load i32, i32* %80
%82 = icmp eq i32 %65, %81
%83 = zext i1 %82 to i64
%84 = select i1 %82, i32 1, i32 0
%85 = sitofp i32 %84 to double
%86 = call double @llvm.fmuladd.f64(double -1.000000e+00, double %85, double 0.000000e+00)
%87 = load double**, double*** %13
%88 = load i32***, i32**** %15
%89 = load i32, i32* %17
%90 = sub nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32**, i32*** %88, i64 %91
%93 = load i32**, i32*** %92
%94 = load i32, i32* %18
%95 = sub nsw i32 %94, 1
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32*, i32** %93, i64 %96
%98 = load i32*, i32** %97
%99 = load i32, i32* %19
%100 = sub nsw i32 %99, 1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %98, i64 %101
%103 = load i32, i32* %102
%104 = sub nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double*, double** %87, i64 %105
%107 = load double*, double** %106
%108 = load i32, i32* %16
%109 = add nsw i32 %108, 1
%110 = sub nsw i32 %109, 1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %107, i64 %111
%113 = load double, double* %112
%114 = fadd double %113, %86
store double %114, double* %112
%115 = load i32***, i32**** %15
%116 = load i32, i32* %17
%117 = sub nsw i32 %116, 1
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32**, i32*** %115, i64 %118
%120 = load i32**, i32*** %119
%121 = load i32, i32* %18
%122 = sub nsw i32 %121, 1
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32*, i32** %120, i64 %123
%125 = load i32*, i32** %124
%126 = load i32, i32* %19
%127 = sub nsw i32 %126, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %125, i64 %128
%130 = load i32, i32* %129
%131 = load i32***, i32**** %15
%132 = load i32, i32* %17
%133 = sub nsw i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32**, i32*** %131, i64 %134
%136 = load i32**, i32*** %135
%137 = load i32, i32* %18
%138 = sub nsw i32 %137, 1
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32*, i32** %136, i64 %139
%141 = load i32*, i32** %140
%142 = load i32, i32* %19
%143 = sub nsw i32 %142, 1
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %141, i64 %144
%146 = load i32, i32* %145
%147 = icmp eq i32 %130, %146
%148 = zext i1 %147 to i64
%149 = select i1 %147, i32 1, i32 0
%150 = sitofp i32 %149 to double
%151 = call double @llvm.fmuladd.f64(double -1.000000e+00, double %150, double 0.000000e+00)
%152 = load double**, double*** %13
%153 = load i32***, i32**** %15
%154 = load i32, i32* %17
%155 = sub nsw i32 %154, 1
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i32**, i32*** %153, i64 %156
%158 = load i32**, i32*** %157
%159 = load i32, i32* %18
%160 = sub nsw i32 %159, 1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32*, i32** %158, i64 %161
%163 = load i32*, i32** %162
%164 = load i32, i32* %19
%165 = sub nsw i32 %164, 1
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i32, i32* %163, i64 %166
%168 = load i32, i32* %167
%169 = sub nsw i32 %168, 1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double*, double** %152, i64 %170
%172 = load double*, double** %171
%173 = load i32***, i32**** %14
%174 = load i32, i32* %17
%175 = sub nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32**, i32*** %173, i64 %176
%178 = load i32**, i32*** %177
%179 = load i32, i32* %18
%180 = sub nsw i32 %179, 1
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32*, i32** %178, i64 %181
%183 = load i32*, i32** %182
%184 = load i32, i32* %19
%185 = sub nsw i32 %184, 1
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32, i32* %183, i64 %186
%188 = load i32, i32* %187
%189 = sub nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %172, i64 %190
%192 = load double, double* %191
%193 = fadd double %192, %151
store double %193, double* %191
%194 = load double, double* %12
%195 = load double**, double*** %13
%196 = load i32***, i32**** %15
%197 = load i32, i32* %17
%198 = sub nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32**, i32*** %196, i64 %199
%201 = load i32**, i32*** %200
%202 = load i32, i32* %18
%203 = sub nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32*, i32** %201, i64 %204
%206 = load i32*, i32** %205
%207 = load i32, i32* %19
%208 = sub nsw i32 %207, 1
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i32, i32* %206, i64 %209
%211 = load i32, i32* %210
%212 = sub nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double*, double** %195, i64 %213
%215 = load double*, double** %214
%216 = load i32, i32* %16
%217 = call i32 @sample_Mult_smooth(double %194, double* %215, i32 1, i32 %216)
%218 = load i32***, i32**** %14
%219 = load i32, i32* %17
%220 = sub nsw i32 %219, 1
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32**, i32*** %218, i64 %221
%223 = load i32**, i32*** %222
%224 = load i32, i32* %18
%225 = sub nsw i32 %224, 1
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i32*, i32** %223, i64 %226
%228 = load i32*, i32** %227
%229 = load i32, i32* %19
%230 = sub nsw i32 %229, 1
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i32, i32* %228, i64 %231
store i32 %217, i32* %232
%233 = load i32***, i32**** %15
%234 = load i32, i32* %17
%235 = sub nsw i32 %234, 1
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i32**, i32*** %233, i64 %236
%238 = load i32**, i32*** %237
%239 = load i32, i32* %18
%240 = sub nsw i32 %239, 1
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32*, i32** %238, i64 %241
%243 = load i32*, i32** %242
%244 = load i32, i32* %19
%245 = sub nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i32, i32* %243, i64 %246
%248 = load i32, i32* %247
%249 = load i32***, i32**** %15
%250 = load i32, i32* %17
%251 = sub nsw i32 %250, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i32**, i32*** %249, i64 %252
%254 = load i32**, i32*** %253
%255 = load i32, i32* %18
%256 = sub nsw i32 %255, 1
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i32*, i32** %254, i64 %257
%259 = load i32*, i32** %258
%260 = load i32, i32* %19
%261 = sub nsw i32 %260, 1
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i32, i32* %259, i64 %262
%264 = load i32, i32* %263
%265 = icmp eq i32 %248, %264
%266 = zext i1 %265 to i64
%267 = select i1 %265, i32 1, i32 0
%268 = sitofp i32 %267 to double
%269 = load double**, double*** %13
%270 = load i32***, i32**** %15
%271 = load i32, i32* %17
%272 = sub nsw i32 %271, 1
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i32**, i32*** %270, i64 %273
%275 = load i32**, i32*** %274
%276 = load i32, i32* %18
%277 = sub nsw i32 %276, 1
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32*, i32** %275, i64 %278
%280 = load i32*, i32** %279
%281 = load i32, i32* %19
%282 = sub nsw i32 %281, 1
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i32, i32* %280, i64 %283
%285 = load i32, i32* %284
%286 = sub nsw i32 %285, 1
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds double*, double** %269, i64 %287
%289 = load double*, double** %288
%290 = load i32, i32* %16
%291 = add nsw i32 %290, 1
%292 = sub nsw i32 %291, 1
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %289, i64 %293
%295 = load double, double* %294
%296 = call double @llvm.fmuladd.f64(double 1.000000e+00, double %268, double %295)
store double %296, double* %294
%297 = load i32***, i32**** %15
%298 = load i32, i32* %17
%299 = sub nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32**, i32*** %297, i64 %300
%302 = load i32**, i32*** %301
%303 = load i32, i32* %18
%304 = sub nsw i32 %303, 1
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i32*, i32** %302, i64 %305
%307 = load i32*, i32** %306
%308 = load i32, i32* %19
%309 = sub nsw i32 %308, 1
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i32, i32* %307, i64 %310
%312 = load i32, i32* %311
%313 = load i32***, i32**** %15
%314 = load i32, i32* %17
%315 = sub nsw i32 %314, 1
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i32**, i32*** %313, i64 %316
%318 = load i32**, i32*** %317
%319 = load i32, i32* %18
%320 = sub nsw i32 %319, 1
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds i32*, i32** %318, i64 %321
%323 = load i32*, i32** %322
%324 = load i32, i32* %19
%325 = sub nsw i32 %324, 1
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %323, i64 %326
%328 = load i32, i32* %327
%329 = icmp eq i32 %312, %328
%330 = zext i1 %329 to i64
%331 = select i1 %329, i32 1, i32 0
%332 = sitofp i32 %331 to double
%333 = load double**, double*** %13
%334 = load i32***, i32**** %15
%335 = load i32, i32* %17
%336 = sub nsw i32 %335, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i32**, i32*** %334, i64 %337
%339 = load i32**, i32*** %338
%340 = load i32, i32* %18
%341 = sub nsw i32 %340, 1
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i32*, i32** %339, i64 %342
%344 = load i32*, i32** %343
%345 = load i32, i32* %19
%346 = sub nsw i32 %345, 1
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i32, i32* %344, i64 %347
%349 = load i32, i32* %348
%350 = sub nsw i32 %349, 1
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double*, double** %333, i64 %351
%353 = load double*, double** %352
%354 = load i32***, i32**** %14
%355 = load i32, i32* %17
%356 = sub nsw i32 %355, 1
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i32**, i32*** %354, i64 %357
%359 = load i32**, i32*** %358
%360 = load i32, i32* %18
%361 = sub nsw i32 %360, 1
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds i32*, i32** %359, i64 %362
%364 = load i32*, i32** %363
%365 = load i32, i32* %19
%366 = sub nsw i32 %365, 1
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i32, i32* %364, i64 %367
%369 = load i32, i32* %368
%370 = sub nsw i32 %369, 1
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %353, i64 %371
%373 = load double, double* %372
%374 = call double @llvm.fmuladd.f64(double 1.000000e+00, double %332, double %373)
store double %374, double* %372
br label %375
375: ; preds = %49
%376 = load i32, i32* %19
%377 = add nsw i32 %376, 1
store i32 %377, i32* %19
br label %35
378: ; preds = %35
br label %379
379: ; preds = %378
%380 = load i32, i32* %18
%381 = add nsw i32 %380, 1
store i32 %381, i32* %18
br label %25
382: ; preds = %25
br label %383
383: ; preds = %382
%384 = load i32, i32* %17
%385 = add nsw i32 %384, 1
store i32 %385, i32* %17
br label %20
386: ; preds = %20
ret void
}

LLVM IR (-O2):
define void @resample_w(i32 %0, i32** nocapture %1, i32* nocapture %2, double %3, double** nocapture %4, i32*** nocapture %5, i32*** nocapture %6, i32 %7) {
%9 = icmp slt i32 %0, 1
br i1 %9, label %100, label %10
10: ; preds = %8
%11 = sext i32 %7 to i64
%12 = add nuw i32 %0, 1
%13 = zext i32 %12 to i64
br label %14
14: ; preds = %10, %97
%15 = phi i64 [ 1, %10 ], [ %98, %97 ]
%16 = add nsw i64 %15, -1
%17 = getelementptr inbounds i32, i32* %2, i64 %16
%18 = load i32, i32* %17
%19 = icmp slt i32 %18, 1
br i1 %19, label %97, label %20
20: ; preds = %14
%21 = getelementptr inbounds i32*, i32** %1, i64 %16
%22 = getelementptr inbounds i32**, i32*** %6, i64 %16
%23 = getelementptr inbounds i32**, i32*** %5, i64 %16
%24 = load i32*, i32** %21
br label %25
25: ; preds = %20, %91
%26 = phi i32 [ %18, %20 ], [ %92, %91 ]
%27 = phi i32* [ %24, %20 ], [ %93, %91 ]
%28 = phi i64 [ 1, %20 ], [ %94, %91 ]
%29 = add nsw i64 %28, -1
%30 = getelementptr inbounds i32, i32* %27, i64 %29
%31 = load i32, i32* %30
%32 = icmp slt i32 %31, 1
br i1 %32, label %91, label %33
33: ; preds = %25
%34 = load i32**, i32*** %22
%35 = getelementptr inbounds i32*, i32** %34, i64 %29
%36 = load i32*, i32** %35
%37 = load i32**, i32*** %23
%38 = getelementptr inbounds i32*, i32** %37, i64 %29
%39 = load i32*, i32** %38
br label %40
40: ; preds = %33, %40
%41 = phi i32* [ %39, %33 ], [ %64, %40 ]
%42 = phi i32* [ %36, %33 ], [ %68, %40 ]
%43 = phi i64 [ 1, %33 ], [ %83, %40 ]
%44 = add nsw i64 %43, -1
%45 = getelementptr inbounds i32, i32* %42, i64 %44
%46 = load i32, i32* %45
%47 = add nsw i32 %46, -1
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds double*, double** %4, i64 %48
%50 = load double*, double** %49
%51 = getelementptr inbounds double, double* %50, i64 %11
%52 = load double, double* %51
%53 = fadd double %52, -1.000000e+00
store double %53, double* %51
%54 = getelementptr inbounds i32, i32* %41, i64 %44
%55 = load i32, i32* %54
%56 = add nsw i32 %55, -1
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %50, i64 %57
%59 = load double, double* %58
%60 = fadd double %59, -1.000000e+00
store double %60, double* %58
%61 = tail call i32 @sample_Mult_smooth(double %3, double* %50, i32 1, i32 %7)
%62 = load i32**, i32*** %23
%63 = getelementptr inbounds i32*, i32** %62, i64 %29
%64 = load i32*, i32** %63
%65 = getelementptr inbounds i32, i32* %64, i64 %44
store i32 %61, i32* %65
%66 = load i32**, i32*** %22
%67 = getelementptr inbounds i32*, i32** %66, i64 %29
%68 = load i32*, i32** %67
%69 = getelementptr inbounds i32, i32* %68, i64 %44
%70 = load i32, i32* %69
%71 = add nsw i32 %70, -1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double*, double** %4, i64 %72
%74 = load double*, double** %73
%75 = getelementptr inbounds double, double* %74, i64 %11
%76 = load double, double* %75
%77 = fadd double %76, 1.000000e+00
store double %77, double* %75
%78 = add nsw i32 %61, -1
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %74, i64 %79
%81 = load double, double* %80
%82 = fadd double %81, 1.000000e+00
store double %82, double* %80
%83 = add nuw nsw i64 %43, 1
%84 = load i32*, i32** %21
%85 = getelementptr inbounds i32, i32* %84, i64 %29
%86 = load i32, i32* %85
%87 = sext i32 %86 to i64
%88 = icmp slt i64 %43, %87
br i1 %88, label %40, label %89
89: ; preds = %40
%90 = load i32, i32* %17
br label %91
91: ; preds = %89, %25
%92 = phi i32 [ %90, %89 ], [ %26, %25 ]
%93 = phi i32* [ %84, %89 ], [ %27, %25 ]
%94 = add nuw nsw i64 %28, 1
%95 = sext i32 %92 to i64
%96 = icmp slt i64 %28, %95
br i1 %96, label %25, label %97
97: ; preds = %91, %14
%98 = add nuw nsw i64 %15, 1
%99 = icmp eq i64 %98, %13
br i1 %99, label %100, label %14
100: ; preds = %97, %8
ret void
}