#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*/ ar_bias(double *, double *, int, int, int, double *);
int /*<<< orphan*/ ar_unbias(double *, double *, int, int, int, double *);
int /*<<< orphan*/ free(double *);
double log(double);
scalar_t__ malloc(int);
double obj_func_ar_cml(double *p, int np, double *cans, int nc, int n_coef,
                       int dim2, int intercept, double *grad, int ng) {
  int i, j, k, order, n_cans;
  double error, r, ps;
  double *ar;
  for (j = 0; j < ng; j++)
    grad[j] = 0.0;
  n_cans = (int)(nc / dim2);
  ar = (double *)malloc(dim2 * sizeof(double));
  order = n_coef;
  if (intercept == 1)
    order = n_coef - 1;
  error = 0.0;
  for (i = 0; i < dim2; i++) {
    ps = p[n_coef * dim2 + i];
    error += 0.5 * (n_cans - order) * log(ps * ps);
    grad[n_coef * dim2 + i] = (n_cans - order) / ps;
  }
  if (intercept == 1) {
    for (i = order; i < n_cans; i++) {
      ar_bias(p, cans, order, dim2, i * dim2, ar);
      for (j = 0; j < dim2; j++) {
        ps = p[n_coef * dim2 + j];
        r = cans[i * dim2 + j] - ar[j];
        error += (r * r) / (2.0 * ps * ps);
        grad[n_coef * dim2 + j] -= (r * r) / (ps * ps * ps);
        for (k = 0; k < n_coef; k++) {
          if (k == 0) {
            grad[k * dim2 + j] -= r / (ps * ps);
          } else {
            grad[k * dim2 + j] -= (r / (ps * ps)) * cans[(i - k) * dim2 + j];
          }
        }
      }
    }
  } else {
    for (i = order; i < n_cans; i++) {
      ar_unbias(p, cans, order, dim2, i * dim2, ar);
      for (j = 0; j < dim2; j++) {
        ps = p[n_coef * dim2 + j];
        r = cans[i * dim2 + j] - ar[j];
        error += (r * r) / (2.0 * ps * ps);
        grad[n_coef * dim2 + j] -= (r * r) / (ps * ps * ps);
        for (k = 0; k < n_coef; k++) {
          grad[k * dim2 + j] -= (r / (ps * ps)) * cans[(i - k - 1) * dim2 + j];
        }
      }
    }
  }
  free(ar);
  return error;
}


x86 assembly (clang, -O0):
<obj_func_ar_cml>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    11a9 <obj_func_ar_cml+0x59>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117f <obj_func_ar_cml+0x2f>
mov    -0x1c(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %eax,-0x38(%rbp)
movslq -0x24(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x1,0x10(%rbp)
jne    11df <obj_func_ar_cml+0x8f>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    128c <obj_func_ar_cml+0x13c>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
cvtsi2sd %eax,%xmm1
movsd  0xde1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1070 <log@plt>
movaps %xmm0,%xmm2
movsd  -0x60(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
cvtsi2sd %eax,%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ee <obj_func_ar_cml+0x9e>
cmpl   $0x1,0x10(%rbp)
jne    147c <obj_func_ar_cml+0x32c>
mov    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1477 <obj_func_ar_cml+0x327>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x34(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%r8d
imul   -0x24(%rbp),%r8d
mov    -0x58(%rbp),%r9
call   1050 <ar_bias@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1464 <obj_func_ar_cml+0x314>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  0xcd0(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
divsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1451 <obj_func_ar_cml+0x301>
cmpl   $0x0,-0x30(%rbp)
jne    13d8 <obj_func_ar_cml+0x288>
movsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
divsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    143e <obj_func_ar_cml+0x2ee>
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x30(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1443 <obj_func_ar_cml+0x2f3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    138b <obj_func_ar_cml+0x23b>
jmp    1456 <obj_func_ar_cml+0x306>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12cf <obj_func_ar_cml+0x17f>
jmp    1469 <obj_func_ar_cml+0x319>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    129c <obj_func_ar_cml+0x14c>
jmp    161f <obj_func_ar_cml+0x4cf>
mov    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    161a <obj_func_ar_cml+0x4ca>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x34(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%r8d
imul   -0x24(%rbp),%r8d
mov    -0x58(%rbp),%r9
call   1040 <ar_unbias@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1607 <obj_func_ar_cml+0x4b7>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  0xaea(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
divsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    15f4 <obj_func_ar_cml+0x4a4>
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1571 <obj_func_ar_cml+0x421>
jmp    15f9 <obj_func_ar_cml+0x4a9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14b5 <obj_func_ar_cml+0x365>
jmp    160c <obj_func_ar_cml+0x4bc>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1482 <obj_func_ar_cml+0x332>
jmp    161f <obj_func_ar_cml+0x4cf>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<obj_func_ar_cml>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9d,%r15d
mov    %r8,0x20(%rsp)
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %rdi,0x10(%rsp)
mov    0xd0(%rsp),%eax
mov    0xc8(%rsp),%rdi
test   %eax,%eax
jle    11a3 <obj_func_ar_cml+0x43>
mov    %eax,%edx
shl    $0x3,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    %ebp,%eax
cltd
idiv   %r15d
mov    %eax,%ebx
lea    0x0(,%r15,8),%edi
call   1070 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%rcx
lea    -0x1(%rcx),%eax
cmpl   $0x1,0xc0(%rsp)
01
mov    %ecx,%edx
mov    %eax,0x18(%rsp)
cmove  %eax,%edx
test   %r15d,%r15d
mov    %ebx,0xc(%rsp)
mov    %edx,0x4c(%rsp)
jle    1277 <obj_func_ar_cml+0x117>
mov    %r15d,%eax
imul   %ecx,%eax
sub    %edx,%ebx
cvtsi2sd %ebx,%xmm0
movsd  0xe05(%rip),%xmm1
movsd  %xmm0,0x30(%rsp)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
cltq
mov    %r15d,%r13d
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
xorpd  %xmm1,%xmm1
xor    %r12d,%r12d
nopl   0x0(%rax)
movsd  %xmm1,(%rsp)
movsd  0x0(%rbp,%r12,8),%xmm0
movsd  %xmm0,0x38(%rsp)
mulsd  %xmm0,%xmm0
call   1080 <log@plt>
movsd  (%rsp),%xmm1
mulsd  0x28(%rsp),%xmm0
addsd  %xmm0,%xmm1
movsd  0x30(%rsp),%xmm0
divsd  0x38(%rsp),%xmm0
movsd  %xmm0,(%rbx,%r12,8)
add    $0x1,%r12
cmp    %r12,%r13
jne    1230 <obj_func_ar_cml+0xd0>
jmp    127b <obj_func_ar_cml+0x11b>
xorpd  %xmm1,%xmm1
cmpl   $0x1,0xc0(%rsp)
01
movsd  %xmm1,(%rsp)
jne    1533 <obj_func_ar_cml+0x3d3>
mov    0x20(%rsp),%rcx
cmp    %ecx,0xc(%rsp)
mov    0x18(%rsp),%esi
jl     16ca <obj_func_ar_cml+0x56a>
mov    %r15d,%eax
imul   %ecx,%eax
movslq %r15d,%rdx
cltq
mov    %rax,0x30(%rsp)
movslq %esi,%rbx
mov    %r15d,%eax
mov    %rax,0x28(%rsp)
mov    %ecx,%r13d
add    $0xffffffffffffffff,%r13
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rdx,8),%rax
mov    %rax,0x70(%rsp)
mov    %rdx,%r12
shl    $0x4,%r12
lea    -0x1(%rbx),%rax
imul   %rdx,%rax
lea    (%r14,%rax,8),%rbp
lea    0x0(,%rdx,8),%rax
mov    %rax,0x78(%rsp)
lea    (%rcx,%r12,1),%rax
mov    %rax,0x68(%rsp)
lea    -0x2(%rbx),%rax
mov    %rdx,0x58(%rsp)
imul   %rdx,%rax
lea    (%r14,%rax,8),%rax
mov    %rax,0x50(%rsp)
mov    %r13,0x18(%rsp)
and    $0xfffffffffffffffe,%r13
neg    %r13
mov    0x10(%rsp),%rdi
jmp    1367 <obj_func_ar_cml+0x207>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdi
movsd  (%rsp),%xmm6
movsd  %xmm6,(%rsp)
mov    0x60(%rsp),%rbx
add    $0x1,%rbx
mov    0x80(%rsp),%rbp
mov    0x78(%rsp),%rax
add    %rax,%rbp
add    %rax,0x50(%rsp)
cmp    %ebx,0xc(%rsp)
je     16ca <obj_func_ar_cml+0x56a>
mov    %rbx,%r8
imul   0x58(%rsp),%r8
mov    %r14,%rsi
mov    0x4c(%rsp),%edx
mov    %r15d,%ecx
mov    %r8,0x38(%rsp)
mov    0x40(%rsp),%r9
call   1060 <ar_bias@plt>
test   %r15d,%r15d
mov    %rbx,0x60(%rsp)
mov    %rbp,0x80(%rsp)
jle    1330 <obj_func_ar_cml+0x1d0>
mov    0x50(%rsp),%r9
mov    0x68(%rsp),%rcx
mov    %rbp,%r11
mov    0x70(%rsp),%rsi
xor    %r8d,%r8d
mov    0x20(%rsp),%r10
mov    0x10(%rsp),%rdi
movsd  (%rsp),%xmm6
movapd 0xc49(%rip),%xmm7
jmp    1403 <obj_func_ar_cml+0x2a3>
nopl   0x0(%rax)
movapd %xmm0,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm6
add    $0x1,%r8
add    $0x8,%rsi
add    $0x8,%r11
add    $0x8,%rcx
add    $0x8,%r9
cmp    0x28(%rsp),%r8
je     133a <obj_func_ar_cml+0x1da>
mov    0x30(%rsp),%rax
add    %r8,%rax
mov    0x38(%rsp),%rdx
lea    (%r8,%rdx,1),%rbp
movsd  (%rdi,%rax,8),%xmm0
movsd  (%r14,%rbp,8),%xmm2
mov    0x40(%rsp),%rdx
subsd  (%rdx,%r8,8),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm0,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm1,%xmm5
divsd  %xmm4,%xmm5
mov    0xc8(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm4
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rdx,%rax,8)
test   %r10d,%r10d
jle    13d0 <obj_func_ar_cml+0x270>
movapd %xmm2,%xmm4
divsd  %xmm3,%xmm4
mov    0xc8(%rsp),%rax
movsd  (%rax,%r8,8),%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,(%rax,%r8,8)
cmp    $0x1,%r10d
je     13d0 <obj_func_ar_cml+0x270>
xorpd  %xmm7,%xmm2
divsd  %xmm3,%xmm2
mov    $0x1,%ebx
cmp    $0x2,%r10d
je     14f0 <obj_func_ar_cml+0x390>
mov    $0x1,%ebx
xor    %ebp,%ebp
xor    %edx,%edx
nop
movsd  (%r11,%rbp,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rsi,%rdx,1),%xmm3
movsd  %xmm3,(%rsi,%rdx,1)
movsd  (%r9,%rbp,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rdx,1),%xmm3
movsd  %xmm3,(%rcx,%rdx,1)
add    %r12,%rdx
sub    %r12,%rbp
lea    (%rbx,%r13,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
jne    14b0 <obj_func_ar_cml+0x350>
testb  $0x1,0x18(%rsp)
je     13d0 <obj_func_ar_cml+0x270>
mov    0x60(%rsp),%rax
sub    %rbx,%rax
mov    0x58(%rsp),%rdx
imul   %rdx,%rax
add    %r8,%rax
imul   %rdx,%rbx
mulsd  (%r14,%rax,8),%xmm2
add    %r8,%rbx
mov    0xc8(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm2
movsd  %xmm2,(%rax,%rbx,8)
jmp    13d0 <obj_func_ar_cml+0x270>
mov    0x20(%rsp),%rcx
cmp    %ecx,0xc(%rsp)
mov    0x18(%rsp),%r10d
jle    16ca <obj_func_ar_cml+0x56a>
mov    %r15d,%eax
imul   %ecx,%eax
movslq %r15d,%rdx
movslq %eax,%r11
movslq %ecx,%r12
mov    %r15d,%eax
mov    %rax,0x38(%rsp)
mov    %ecx,%eax
mov    %rax,0x30(%rsp)
imul   %r15d,%r10d
mov    %rdx,0x18(%rsp)
lea    0x0(,%rdx,8),%r13
mov    0x10(%rsp),%rdi
jmp    15ac <obj_func_ar_cml+0x44c>
nopl   (%rax)
mov    0x10(%rsp),%rdi
movsd  (%rsp),%xmm6
mov    %ebx,%r10d
mov    %rbp,%r11
movsd  %xmm6,(%rsp)
mov    0x28(%rsp),%r12
add    $0x1,%r12
add    %r15d,%r10d
cmp    %r12d,0xc(%rsp)
je     16ca <obj_func_ar_cml+0x56a>
mov    %r11,%rbp
mov    %r10d,%ebx
mov    %r12,0x28(%rsp)
imul   0x18(%rsp),%r12
mov    %r14,%rsi
mov    0x4c(%rsp),%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
mov    0x40(%rsp),%r9
call   1050 <ar_unbias@plt>
test   %r15d,%r15d
jle    1580 <obj_func_ar_cml+0x420>
mov    0xc8(%rsp),%r9
mov    %r9,%rax
xor    %ecx,%ecx
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%rdi
movsd  (%rsp),%xmm6
mov    %ebx,%r10d
mov    %rbp,%r11
movapd 0xa0d(%rip),%xmm7
jmp    1637 <obj_func_ar_cml+0x4d7>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm0,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm6
add    $0x1,%rcx
add    $0x8,%rax
cmp    0x38(%rsp),%rcx
je     1590 <obj_func_ar_cml+0x430>
lea    (%rcx,%r11,1),%rdx
lea    (%rcx,%r12,1),%rsi
movsd  (%rdi,%rdx,8),%xmm0
movsd  (%r14,%rsi,8),%xmm2
mov    0x40(%rsp),%rsi
subsd  (%rsi,%rcx,8),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm0,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm1,%xmm5
divsd  %xmm4,%xmm5
movsd  (%r9,%rdx,8),%xmm4
subsd  %xmm5,%xmm4
movsd  %xmm4,(%r9,%rdx,8)
test   %r8d,%r8d
jle    1610 <obj_func_ar_cml+0x4b0>
xorpd  %xmm7,%xmm2
divsd  %xmm3,%xmm2
mov    0x30(%rsp),%rdx
mov    %rax,%rsi
mov    %r10d,%ebp
nopl   0x0(%rax)
movslq %ebp,%rbp
lea    (%rcx,%rbp,1),%rbx
movsd  (%r14,%rbx,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rsi),%xmm3
movsd  %xmm3,(%rsi)
sub    %r15d,%ebp
add    %r13,%rsi
add    $0xffffffffffffffff,%rdx
jne    16a0 <obj_func_ar_cml+0x540>
jmp    1610 <obj_func_ar_cml+0x4b0>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
movsd  (%rsp),%xmm0
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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