#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 */
double bessi0_spd(double);
double bessi1_spd(double);
double cos(double);
double marginal_j_concentration(int, int, double *, double *, double *,
                                double *);
double marginal_j_mean(int, int, double *, double *, double *, double *);
double sin(double);
double vm_loglikelihood_kappa_partial_naive(int n, int p, int R, double *mu,
                                            double *kappa, double *lambda,
                                            double *theta) {
  double k_rest, m_rest;
  double acum = 0., acum_scnd;
  int i, l;
  for (i = 0; i < n; i++) {
    k_rest = marginal_j_concentration(p, R, mu, kappa, lambda, theta + i * p);
    m_rest = marginal_j_mean(p, R, mu, kappa, lambda, theta + i * p);
    acum += (cos(theta[i * p + R] - m_rest) -
             (bessi1_spd(k_rest) / bessi0_spd(k_rest))) /
            k_rest;
    acum_scnd = 0.;
    for (l = 0; l < p; l++) {
      if (l != R) {
        acum_scnd += lambda[R * p + l] * sin(theta[i * p + l] - mu[l]);
      }
    }
    acum += (sin(theta[i * p + R] - m_rest) * acum_scnd) / k_rest;
  }
  return -acum * kappa[R];
}


x86 assembly (clang, -O0):
<vm_loglikelihood_kappa_partial_naive>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1337 <vm_loglikelihood_kappa_partial_naive+0x1d7>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    0x10(%rbp),%r9
mov    -0x4c(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%r9
call   1030 <marginal_j_concentration@plt>
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    0x10(%rbp),%r9
mov    -0x4c(%rbp),%eax
imul   -0x8(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%r9
call   1050 <marginal_j_mean@plt>
movsd  %xmm0,-0x38(%rbp)
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x38(%rbp),%xmm0
call   1070 <cos@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x30(%rbp),%xmm0
call   1080 <bessi1_spd@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x30(%rbp),%xmm0
call   1060 <bessi0_spd@plt>
movsd  -0x60(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x58(%rbp),%xmm0
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
divsd  -0x30(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12f5 <vm_loglikelihood_kappa_partial_naive+0x195>
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
je     12e2 <vm_loglikelihood_kappa_partial_naive+0x182>
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm2
movsd  -0x68(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    12e7 <vm_loglikelihood_kappa_partial_naive+0x187>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    126d <vm_loglikelihood_kappa_partial_naive+0x10d>
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x38(%rbp),%xmm0
call   1040 <sin@plt>
mulsd  -0x48(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1190 <vm_loglikelihood_kappa_partial_naive+0x30>
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vm_loglikelihood_kappa_partial_naive>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r8,0x48(%rsp)
mov    %rcx,0xa0(%rsp)
mov    %edx,%r8d
test   %edi,%edi
jle    151c <vm_loglikelihood_kappa_partial_naive+0x3bc>
mov    %r9,%r12
mov    0x110(%rsp),%rbp
mov    %r8d,%eax
imul   %esi,%eax
movslq %eax,%rcx
mov    %r8d,%r14d
mov    %esi,0x28(%rsp)
movslq %esi,%rdx
movslq %r8d,%rax
mov    %rax,0x40(%rsp)
mov    %edi,%eax
mov    %rax,0x98(%rsp)
mov    %edx,%eax
mov    %rax,0x80(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x70(%rsp)
mov    %rcx,0x68(%rsp)
lea    (%r9,%rcx,8),%rax
add    $0x8,%rax
mov    %rax,0x60(%rsp)
lea    0x8(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    %rdx,0x58(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x90(%rsp)
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
mov    %r8d,0x2c(%rsp)
mov    %r9,0x50(%rsp)
mov    %r14,0x88(%rsp)
mov    0xa0(%rsp),%r15
jmp    12bc <vm_loglikelihood_kappa_partial_naive+0x15c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,0x8(%rsp)
movsd  0xb8(%rsp),%xmm2
divsd  0xb0(%rsp),%xmm2
movsd  0xc0(%rsp),%xmm1
subsd  %xmm2,%xmm1
divsd  0x18(%rsp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x0(%rbp,%rbx,8),%xmm0
subsd  0xc8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x8(%rsp),%xmm0
divsd  0x18(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
mov    0xd0(%rsp),%r13
add    $0x1,%r13
mov    0x90(%rsp),%rax
add    %rax,0x20(%rsp)
cmp    0x98(%rsp),%r13
mov    0x50(%rsp),%r12
mov    0x2c(%rsp),%r8d
je     1515 <vm_loglikelihood_kappa_partial_naive+0x3b5>
movapd %xmm0,0x30(%rsp)
mov    %r13,0xd0(%rsp)
mov    0x58(%rsp),%rbx
imul   %rbx,%r13
lea    0x0(,%r13,8),%r9
add    %rbp,%r9
mov    %r9,0x8(%rsp)
mov    %ebx,%edi
mov    %r8d,%esi
mov    %r15,%rdx
mov    0x48(%rsp),%rbp
mov    %rbp,%rcx
mov    %r8d,%r14d
mov    %r12,%r8
call   1030 <marginal_j_concentration@plt>
movsd  %xmm0,0x18(%rsp)
mov    %ebx,%edi
mov    %r14d,%esi
mov    0x88(%rsp),%r14
mov    %r15,%rdx
mov    %rbp,%rcx
mov    %r12,%r8
mov    0x8(%rsp),%r9
call   1050 <marginal_j_mean@plt>
movapd %xmm0,%xmm1
mov    0x40(%rsp),%rax
mov    %r13,0xa8(%rsp)
lea    (%rax,%r13,1),%rbx
mov    0x110(%rsp),%rax
mov    %rax,%rbp
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm1,0xc8(%rsp)
subsd  %xmm1,%xmm0
call   1070 <cos@plt>
movsd  %xmm0,0xc0(%rsp)
movsd  0x18(%rsp),%xmm0
call   1080 <bessi1_spd@plt>
movsd  %xmm0,0xb8(%rsp)
movsd  0x18(%rsp),%xmm0
call   1060 <bessi0_spd@plt>
movsd  %xmm0,0xb0(%rsp)
movapd 0x30(%rsp),%xmm0
xorpd  %xmm1,%xmm1
cmpl   $0x0,0x58(%rsp)
jle    1230 <vm_loglikelihood_kappa_partial_naive+0xd0>
cmpl   $0x1,0x28(%rsp)
jne    13d0 <vm_loglikelihood_kappa_partial_naive+0x270>
xorpd  %xmm1,%xmm1
xor    %r13d,%r13d
testb  $0x1,0x80(%rsp)
01
je     1230 <vm_loglikelihood_kappa_partial_naive+0xd0>
jmp    14b7 <vm_loglikelihood_kappa_partial_naive+0x357>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,0x78(%rsp)
xorpd  %xmm1,%xmm1
xor    %r12d,%r12d
mov    0x70(%rsp),%rbx
jmp    1403 <vm_loglikelihood_kappa_partial_naive+0x2a3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd 0x30(%rsp),%xmm0
add    $0x1,%r12
cmp    %rbx,%r12
je     14a0 <vm_loglikelihood_kappa_partial_naive+0x340>
mov    %r12,%r13
cmp    %r12,%r14
je     144a <vm_loglikelihood_kappa_partial_naive+0x2ea>
mov    0x60(%rsp),%rax
movsd  -0x8(%rax,%r13,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x20(%rsp),%rax
movsd  -0x8(%rax,%r13,8),%xmm0
subsd  (%r15,%r13,8),%xmm0
movsd  %xmm1,0x8(%rsp)
call   1040 <sin@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm0,%xmm1
lea    0x1(%r13),%r12
cmp    %r14,%r12
je     13f0 <vm_loglikelihood_kappa_partial_naive+0x290>
mov    0x60(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x20(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
subsd  0x8(%r15,%r13,8),%xmm0
movsd  %xmm1,0x8(%rsp)
call   1040 <sin@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm0,%xmm1
jmp    13f0 <vm_loglikelihood_kappa_partial_naive+0x290>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%r13
mov    0x78(%rsp),%rbx
testb  $0x1,0x80(%rsp)
01
je     1230 <vm_loglikelihood_kappa_partial_naive+0xd0>
cmp    %r14,%r13
je     1230 <vm_loglikelihood_kappa_partial_naive+0xd0>
mov    0x68(%rsp),%rax
add    %r13,%rax
mov    0x50(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0xa8(%rsp),%rax
add    %r13,%rax
movsd  0x0(%rbp,%rax,8),%xmm0
subsd  (%r15,%r13,8),%xmm0
movsd  %xmm1,0x8(%rsp)
call   1040 <sin@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm0,%xmm1
movapd 0x30(%rsp),%xmm0
jmp    1230 <vm_loglikelihood_kappa_partial_naive+0xd0>
mov    0x40(%rsp),%rcx
jmp    1523 <vm_loglikelihood_kappa_partial_naive+0x3c3>
movslq %r8d,%rcx
xorpd  %xmm0,%xmm0
xorpd  0xad5(%rip),%xmm0
mov    0x48(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm0
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @vm_loglikelihood_kappa_partial_naive(i32 %0, i32 %1, i32 %2, double* %3, double* %4, double* %5, double* %6) {
%8 = icmp sgt i32 %0, 0
br i1 %8, label %11, label %9
9: ; preds = %7
%10 = sext i32 %2 to i64
br label %109
11: ; preds = %7
%12 = icmp sgt i32 %1, 0
%13 = mul nsw i32 %2, %1
%14 = sext i32 %13 to i64
%15 = zext i32 %2 to i64
%16 = sext i32 %1 to i64
%17 = sext i32 %2 to i64
%18 = zext i32 %0 to i64
%19 = zext i32 %1 to i64
%20 = and i64 %19, 1
%21 = icmp eq i32 %1, 1
%22 = and i64 %19, 4294967294
%23 = icmp eq i64 %20, 0
br label %24
24: ; preds = %11, %99
%25 = phi i64 [ 0, %11 ], [ %107, %99 ]
%26 = phi double [ 0.000000e+00, %11 ], [ %106, %99 ]
%27 = mul nsw i64 %25, %16
%28 = getelementptr inbounds double, double* %6, i64 %27
%29 = tail call double @marginal_j_concentration(i32 %1, i32 %2, double* %3, double* %4, double* %5, double* %28)
%30 = tail call double @marginal_j_mean(i32 %1, i32 %2, double* %3, double* %4, double* %5, double* %28)
%31 = add nsw i64 %27, %17
%32 = getelementptr inbounds double, double* %6, i64 %31
%33 = load double, double* %32
%34 = fsub double %33, %30
%35 = tail call double @cos(double %34)
%36 = tail call double @bessi1_spd(double %29)
%37 = tail call double @bessi0_spd(double %29)
%38 = fdiv double %36, %37
%39 = fsub double %35, %38
%40 = fdiv double %39, %29
%41 = fadd double %26, %40
br i1 %12, label %42, label %99
42: ; preds = %24
br i1 %21, label %81, label %43
43: ; preds = %42, %76
%44 = phi i64 [ %78, %76 ], [ 0, %42 ]
%45 = phi double [ %77, %76 ], [ 0.000000e+00, %42 ]
%46 = phi i64 [ %79, %76 ], [ 0, %42 ]
%47 = icmp eq i64 %44, %15
br i1 %47, label %60, label %48
48: ; preds = %43
%49 = add nsw i64 %44, %14
%50 = getelementptr inbounds double, double* %5, i64 %49
%51 = load double, double* %50
%52 = add nsw i64 %44, %27
%53 = getelementptr inbounds double, double* %6, i64 %52
%54 = load double, double* %53
%55 = getelementptr inbounds double, double* %3, i64 %44
%56 = load double, double* %55
%57 = fsub double %54, %56
%58 = tail call double @sin(double %57)
%59 = tail call double @llvm.fmuladd.f64(double %51, double %58, double %45)
br label %60
60: ; preds = %43, %48
%61 = phi double [ %59, %48 ], [ %45, %43 ]
%62 = or i64 %44, 1
%63 = icmp eq i64 %62, %15
br i1 %63, label %76, label %64
64: ; preds = %60
%65 = add nsw i64 %62, %14
%66 = getelementptr inbounds double, double* %5, i64 %65
%67 = load double, double* %66
%68 = add nsw i64 %62, %27
%69 = getelementptr inbounds double, double* %6, i64 %68
%70 = load double, double* %69
%71 = getelementptr inbounds double, double* %3, i64 %62
%72 = load double, double* %71
%73 = fsub double %70, %72
%74 = tail call double @sin(double %73)
%75 = tail call double @llvm.fmuladd.f64(double %67, double %74, double %61)
br label %76
76: ; preds = %64, %60
%77 = phi double [ %75, %64 ], [ %61, %60 ]
%78 = add nuw nsw i64 %44, 2
%79 = add i64 %46, 2
%80 = icmp eq i64 %79, %22
br i1 %80, label %81, label %43
81: ; preds = %76, %42
%82 = phi double [ undef, %42 ], [ %77, %76 ]
%83 = phi i64 [ 0, %42 ], [ %78, %76 ]
%84 = phi double [ 0.000000e+00, %42 ], [ %77, %76 ]
br i1 %23, label %99, label %85
85: ; preds = %81
%86 = icmp eq i64 %83, %15
br i1 %86, label %99, label %87
87: ; preds = %85
%88 = add nsw i64 %83, %14
%89 = getelementptr inbounds double, double* %5, i64 %88
%90 = load double, double* %89
%91 = add nsw i64 %83, %27
%92 = getelementptr inbounds double, double* %6, i64 %91
%93 = load double, double* %92
%94 = getelementptr inbounds double, double* %3, i64 %83
%95 = load double, double* %94
%96 = fsub double %93, %95
%97 = tail call double @sin(double %96)
%98 = tail call double @llvm.fmuladd.f64(double %90, double %97, double %84)
br label %99
99: ; preds = %81, %87, %85, %24
%100 = phi double [ 0.000000e+00, %24 ], [ %82, %81 ], [ %98, %87 ], [ %84, %85 ]
%101 = load double, double* %32
%102 = fsub double %101, %30
%103 = tail call double @sin(double %102)
%104 = fmul double %100, %103
%105 = fdiv double %104, %29
%106 = fadd double %41, %105
%107 = add nuw nsw i64 %25, 1
%108 = icmp eq i64 %107, %18
br i1 %108, label %109, label %24
109: ; preds = %99, %9
%110 = phi i64 [ %10, %9 ], [ %17, %99 ]
%111 = phi double [ 0.000000e+00, %9 ], [ %106, %99 ]
%112 = fneg double %111
%113 = getelementptr inbounds double, double* %4, i64 %110
%114 = load double, double* %113
%115 = fmul double %114, %112
ret double %115
}