#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 *);
scalar_t__ malloc(int);
double obj_func_ar_ls(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;
  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;
  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++) {
        r = cans[i * dim2 + j] - ar[j];
        error += r * r;
        for (k = 0; k < n_coef; k++) {
          if (k == 0) {
            grad[k * dim2 + j] -= 2.0 * r;
          } else {
            grad[k * dim2 + j] -= 2.0 * r * 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++) {
        r = cans[i * dim2 + j] - ar[j];
        error += r * r;
        for (k = 0; k < n_coef; k++) {
          grad[k * dim2 + j] -= 2.0 * r * cans[(i - k - 1) * dim2 + j];
        }
      }
    }
  }
  free(ar);
  return error;
}


x86 assembly (clang, -O0):
<obj_func_ar_ls>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%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    1199 <obj_func_ar_ls+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    116f <obj_func_ar_ls+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,-0x50(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x1,0x10(%rbp)
jne    11cf <obj_func_ar_ls+0x8f>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x1,0x10(%rbp)
jne    1352 <obj_func_ar_ls+0x212>
mov    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    134d <obj_func_ar_ls+0x20d>
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    -0x50(%rbp),%r9
call   1050 <ar_bias@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    133a <obj_func_ar_ls+0x1fa>
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    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1327 <obj_func_ar_ls+0x1e7>
cmpl   $0x0,-0x30(%rbp)
jne    12b4 <obj_func_ar_ls+0x174>
movsd  -0x48(%rbp),%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
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1314 <obj_func_ar_ls+0x1d4>
movsd  0xd44(%rip),%xmm0
mulsd  -0x48(%rbp),%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    1319 <obj_func_ar_ls+0x1d9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1271 <obj_func_ar_ls+0x131>
jmp    132c <obj_func_ar_ls+0x1ec>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    121a <obj_func_ar_ls+0xda>
jmp    133f <obj_func_ar_ls+0x1ff>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e7 <obj_func_ar_ls+0xa7>
jmp    148a <obj_func_ar_ls+0x34a>
mov    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1485 <obj_func_ar_ls+0x345>
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    -0x50(%rbp),%r9
call   1040 <ar_unbias@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1472 <obj_func_ar_ls+0x332>
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    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    145f <obj_func_ar_ls+0x31f>
movsd  0xc0a(%rip),%xmm0
mulsd  -0x48(%rbp),%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    13e2 <obj_func_ar_ls+0x2a2>
jmp    1464 <obj_func_ar_ls+0x324>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    138b <obj_func_ar_ls+0x24b>
jmp    1477 <obj_func_ar_ls+0x337>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1358 <obj_func_ar_ls+0x218>
jmp    148a <obj_func_ar_ls+0x34a>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<obj_func_ar_ls>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9d,%r15d
mov    %r8,0x30(%rsp)
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %rdi,0x48(%rsp)
mov    0xc0(%rsp),%eax
mov    0xb8(%rsp),%rdi
mov    0xb0(%rsp),%ebx
test   %eax,%eax
jle    1197 <obj_func_ar_ls+0x47>
mov    %eax,%edx
shl    $0x3,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    %ebp,%eax
cltd
idiv   %r15d
mov    %eax,%ebp
lea    0x0(,%r15,8),%edi
call   1070 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%r8d
mov    %eax,%ecx
cmp    $0x1,%ebx
cmove  %r8d,%ecx
mov    %ecx,0x10(%rsp)
mov    %ebp,0x14(%rsp)
xorpd  %xmm3,%xmm3
jne    1401 <obj_func_ar_ls+0x2b1>
cmp    %eax,%ebp
mov    0xb8(%rsp),%rcx
jl     1547 <obj_func_ar_ls+0x3f7>
movslq %r15d,%rdx
movslq %r8d,%rbx
mov    %r15d,%esi
mov    %rsi,0x20(%rsp)
mov    %eax,%r12d
add    $0xffffffffffffffff,%r12
lea    (%rcx,%rdx,8),%rax
mov    %rax,0x60(%rsp)
mov    %rdx,%r13
shl    $0x4,%r13
lea    -0x1(%rbx),%rax
imul   %rdx,%rax
lea    (%r14,%rax,8),%rbp
lea    0x0(,%rdx,8),%rax
mov    %rax,0x68(%rsp)
lea    (%rcx,%r13,1),%rax
mov    %rax,0x58(%rsp)
lea    -0x2(%rbx),%rax
mov    %rdx,0x50(%rsp)
imul   %rdx,%rax
lea    (%r14,%rax,8),%rax
mov    %rax,0x40(%rsp)
mov    %r12,0x38(%rsp)
and    $0xfffffffffffffffe,%r12
neg    %r12
xorpd  %xmm3,%xmm3
jmp    128a <obj_func_ar_ls+0x13a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsp),%xmm3
mov    0x18(%rsp),%rbx
add    $0x1,%rbx
mov    0x70(%rsp),%rbp
mov    0x68(%rsp),%rax
add    %rax,%rbp
add    %rax,0x40(%rsp)
cmp    %ebx,0x14(%rsp)
je     1547 <obj_func_ar_ls+0x3f7>
movsd  %xmm3,(%rsp)
mov    %rbx,%r8
imul   0x50(%rsp),%r8
mov    0x48(%rsp),%rdi
mov    %r14,%rsi
mov    0x10(%rsp),%edx
mov    %r15d,%ecx
mov    %r8,0x28(%rsp)
mov    0x8(%rsp),%r9
call   1060 <ar_bias@plt>
test   %r15d,%r15d
mov    %rbx,0x18(%rsp)
mov    %rbp,0x70(%rsp)
jle    1260 <obj_func_ar_ls+0x110>
mov    0x40(%rsp),%r9
mov    0x58(%rsp),%rcx
mov    %rbp,%rdx
mov    0x60(%rsp),%rsi
xor    %r8d,%r8d
mov    0x30(%rsp),%r10
mov    0xb8(%rsp),%r11
movsd  (%rsp),%xmm3
mov    0x20(%rsp),%rbx
movsd  0xd07(%rip),%xmm4
jmp    1325 <obj_func_ar_ls+0x1d5>
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%r8
add    $0x8,%rsi
add    $0x8,%rdx
add    $0x8,%rcx
add    $0x8,%r9
cmp    %rbx,%r8
je     1265 <obj_func_ar_ls+0x115>
mov    0x28(%rsp),%rax
lea    (%r8,%rax,1),%rdi
movsd  (%r14,%rdi,8),%xmm0
mov    0x8(%rsp),%rax
subsd  (%rax,%r8,8),%xmm0
test   %r10d,%r10d
jle    1300 <obj_func_ar_ls+0x1b0>
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  (%r11,%r8,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r11,%r8,8)
cmp    $0x1,%r10d
je     1300 <obj_func_ar_ls+0x1b0>
mov    $0x1,%ebp
cmp    $0x2,%r10d
je     13bf <obj_func_ar_ls+0x26f>
mov    $0x1,%ebp
xor    %ebx,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rdi,1),%xmm2
movsd  %xmm2,(%rsi,%rdi,1)
movsd  (%r9,%rbx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rdi,1),%xmm2
movsd  %xmm2,(%rcx,%rdi,1)
add    %r13,%rdi
sub    %r13,%rbx
lea    (%r12,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbp
cmp    $0x1,%rax
jne    1380 <obj_func_ar_ls+0x230>
testb  $0x1,0x38(%rsp)
mov    0x20(%rsp),%rbx
je     1300 <obj_func_ar_ls+0x1b0>
mov    0x18(%rsp),%rax
sub    %rbp,%rax
mov    0x50(%rsp),%rdi
imul   %rdi,%rax
add    %r8,%rax
imul   %rdi,%rbp
mulsd  (%r14,%rax,8),%xmm1
add    %r8,%rbp
addsd  (%r11,%rbp,8),%xmm1
movsd  %xmm1,(%r11,%rbp,8)
jmp    1300 <obj_func_ar_ls+0x1b0>
cmp    %eax,%ebp
jle    1547 <obj_func_ar_ls+0x3f7>
movslq %r15d,%rcx
movslq %eax,%r9
mov    %r15d,%r10d
mov    %eax,%r11d
imul   %r15d,%r8d
mov    %rcx,0x20(%rsp)
lea    0x0(,%rcx,8),%r12
xorpd  %xmm3,%xmm3
mov    %r10,0x38(%rsp)
mov    %r11,0x18(%rsp)
mov    0x30(%rsp),%rbp
jmp    145f <obj_func_ar_ls+0x30f>
nopl   0x0(%rax,%rax,1)
movsd  (%rsp),%xmm3
mov    %ebx,%r8d
mov    0x28(%rsp),%r9
add    $0x1,%r9
add    %r15d,%r8d
cmp    %r9d,0x14(%rsp)
je     1547 <obj_func_ar_ls+0x3f7>
mov    %r8d,%ebx
movsd  %xmm3,(%rsp)
mov    %r9,0x28(%rsp)
mov    %r9,%r13
imul   0x20(%rsp),%r13
mov    0x48(%rsp),%rdi
mov    %r14,%rsi
mov    0x10(%rsp),%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
mov    0x8(%rsp),%r9
call   1050 <ar_unbias@plt>
test   %r15d,%r15d
jle    1440 <obj_func_ar_ls+0x2f0>
mov    0xb8(%rsp),%rax
xor    %ecx,%ecx
movsd  (%rsp),%xmm3
mov    %ebx,%r8d
mov    0x28(%rsp),%r9
mov    0x38(%rsp),%r10
mov    0x18(%rsp),%r11
movsd  0xb41(%rip),%xmm4
jmp    14e9 <obj_func_ar_ls+0x399>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r10,%rcx
je     144d <obj_func_ar_ls+0x2fd>
lea    (%rcx,%r13,1),%rdx
movsd  (%r14,%rdx,8),%xmm0
mov    0x8(%rsp),%rdx
subsd  (%rdx,%rcx,8),%xmm0
test   %ebp,%ebp
jle    14d0 <obj_func_ar_ls+0x380>
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
mov    %r11,%rdx
mov    %rax,%rsi
mov    %r8d,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %edi,%rdi
lea    (%rcx,%rdi,1),%rbx
movsd  (%r14,%rbx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi),%xmm2
movsd  %xmm2,(%rsi)
sub    %r15d,%edi
add    %r12,%rsi
add    $0xffffffffffffffff,%rdx
jne    1520 <obj_func_ar_ls+0x3d0>
jmp    14d0 <obj_func_ar_ls+0x380>
movsd  %xmm3,(%rsp)
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
movsd  (%rsp),%xmm0
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @obj_func_ar_ls(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
br i1 %20, label %32, label %23
23: ; preds = %15
%24 = icmp sgt i32 %16, %4
br i1 %24, label %25, label %160
25: ; preds = %23
%26 = icmp sgt i32 %5, 0
%27 = icmp sgt i32 %4, 0
%28 = sext i32 %5 to i64
%29 = sext i32 %4 to i64
%30 = zext i32 %5 to i64
%31 = zext i32 %4 to i64
br label %115
32: ; preds = %15
%33 = icmp slt i32 %16, %4
br i1 %33, label %160, label %34
34: ; preds = %32
%35 = icmp sgt i32 %5, 0
%36 = icmp sgt i32 %4, 0
%37 = sext i32 %5 to i64
%38 = sext i32 %21 to i64
%39 = zext i32 %5 to i64
%40 = zext i32 %4 to i64
%41 = add nsw i64 %40, -1
%42 = and i64 %41, 1
%43 = icmp eq i32 %4, 2
%44 = and i64 %41, -2
%45 = icmp eq i64 %42, 0
br label %46
46: ; preds = %34, %110
%47 = phi i64 [ %38, %34 ], [ %112, %110 ]
%48 = phi double [ 0.000000e+00, %34 ], [ %111, %110 ]
%49 = mul nsw i64 %47, %37
%50 = trunc i64 %49 to i32
%51 = tail call i32 @ar_bias(double* %0, double* %2, i32 %22, i32 %5, i32 %50, double* %19)
br i1 %35, label %52, label %110
52: ; preds = %46, %107
%53 = phi i64 [ %108, %107 ], [ 0, %46 ]
%54 = phi double [ %61, %107 ], [ %48, %46 ]
%55 = add nsw i64 %53, %49
%56 = getelementptr inbounds double, double* %2, i64 %55
%57 = load double, double* %56
%58 = getelementptr inbounds double, double* %19, i64 %53
%59 = load double, double* %58
%60 = fsub double %57, %59
%61 = tail call double @llvm.fmuladd.f64(double %60, double %60, double %54)
br i1 %36, label %62, label %107
62: ; preds = %52
%63 = fmul double %60, -2.000000e+00
%64 = getelementptr inbounds double, double* %7, i64 %53
%65 = load double, double* %64
%66 = tail call double @llvm.fmuladd.f64(double %60, double -2.000000e+00, double %65)
store double %66, double* %64
switch i32 %4, label %67 [
i32 1, label %107
i32 2, label %94
]
67: ; preds = %62, %67
%68 = phi i64 [ %91, %67 ], [ 1, %62 ]
%69 = phi i64 [ %92, %67 ], [ 0, %62 ]
%70 = sub nsw i64 %47, %68
%71 = mul nsw i64 %70, %37
%72 = add nsw i64 %71, %53
%73 = getelementptr inbounds double, double* %2, i64 %72
%74 = load double, double* %73
%75 = mul nsw i64 %68, %37
%76 = add nsw i64 %75, %53
%77 = getelementptr inbounds double, double* %7, i64 %76
%78 = load double, double* %77
%79 = tail call double @llvm.fmuladd.f64(double %63, double %74, double %78)
store double %79, double* %77
%80 = add nuw nsw i64 %68, 1
%81 = sub nsw i64 %47, %80
%82 = mul nsw i64 %81, %37
%83 = add nsw i64 %82, %53
%84 = getelementptr inbounds double, double* %2, i64 %83
%85 = load double, double* %84
%86 = mul nsw i64 %80, %37
%87 = add nsw i64 %86, %53
%88 = getelementptr inbounds double, double* %7, i64 %87
%89 = load double, double* %88
%90 = tail call double @llvm.fmuladd.f64(double %63, double %85, double %89)
store double %90, double* %88
%91 = add nuw nsw i64 %68, 2
%92 = add i64 %69, 2
%93 = icmp eq i64 %92, %44
br i1 %93, label %94, label %67
94: ; preds = %67, %62
%95 = phi i64 [ 1, %62 ], [ %91, %67 ]
br i1 %45, label %107, label %96
96: ; preds = %94
%97 = sub nsw i64 %47, %95
%98 = mul nsw i64 %97, %37
%99 = add nsw i64 %98, %53
%100 = getelementptr inbounds double, double* %2, i64 %99
%101 = load double, double* %100
%102 = mul nsw i64 %95, %37
%103 = add nsw i64 %102, %53
%104 = getelementptr inbounds double, double* %7, i64 %103
%105 = load double, double* %104
%106 = tail call double @llvm.fmuladd.f64(double %63, double %101, double %105)
store double %106, double* %104
br label %107
107: ; preds = %96, %94, %62, %52
%108 = add nuw nsw i64 %53, 1
%109 = icmp eq i64 %108, %39
br i1 %109, label %110, label %52
110: ; preds = %107, %46
%111 = phi double [ %48, %46 ], [ %61, %107 ]
%112 = add nsw i64 %47, 1
%113 = trunc i64 %112 to i32
%114 = icmp eq i32 %16, %113
br i1 %114, label %160, label %46
115: ; preds = %25, %155
%116 = phi i64 [ %29, %25 ], [ %157, %155 ]
%117 = phi double [ 0.000000e+00, %25 ], [ %156, %155 ]
%118 = mul nsw i64 %116, %28
%119 = trunc i64 %118 to i32
%120 = tail call i32 @ar_unbias(double* %0, double* %2, i32 %22, i32 %5, i32 %119, double* %19)
br i1 %26, label %121, label %155
121: ; preds = %115
%122 = trunc i64 %116 to i32
br label %123
123: ; preds = %121, %152
%124 = phi i64 [ 0, %121 ], [ %153, %152 ]
%125 = phi double [ %117, %121 ], [ %132, %152 ]
%126 = add nsw i64 %124, %118
%127 = getelementptr inbounds double, double* %2, i64 %126
%128 = load double, double* %127
%129 = getelementptr inbounds double, double* %19, i64 %124
%130 = load double, double* %129
%131 = fsub double %128, %130
%132 = tail call double @llvm.fmuladd.f64(double %131, double %131, double %125)
br i1 %27, label %133, label %152
133: ; preds = %123
%134 = fmul double %131, -2.000000e+00
br label %135
135: ; preds = %133, %135
%136 = phi i64 [ 0, %133 ], [ %150, %135 ]
%137 = trunc i64 %136 to i32
%138 = xor i32 %137, -1
%139 = add i32 %122, %138
%140 = mul nsw i32 %139, %5
%141 = sext i32 %140 to i64
%142 = add nsw i64 %124, %141
%143 = getelementptr inbounds double, double* %2, i64 %142
%144 = load double, double* %143
%145 = mul nsw i64 %136, %28
%146 = add nsw i64 %145, %124
%147 = getelementptr inbounds double, double* %7, i64 %146
%148 = load double, double* %147
%149 = tail call double @llvm.fmuladd.f64(double %134, double %144, double %148)
store double %149, double* %147
%150 = add nuw nsw i64 %136, 1
%151 = icmp eq i64 %150, %31
br i1 %151, label %152, label %135
152: ; preds = %135, %123
%153 = add nuw nsw i64 %124, 1
%154 = icmp eq i64 %153, %30
br i1 %154, label %155, label %123
155: ; preds = %152, %115
%156 = phi double [ %117, %115 ], [ %132, %152 ]
%157 = add nsw i64 %116, 1
%158 = trunc i64 %157 to i32
%159 = icmp eq i32 %16, %158
br i1 %159, label %160, label %115
160: ; preds = %155, %110, %23, %32
%161 = phi double [ 0.000000e+00, %32 ], [ 0.000000e+00, %23 ], [ %111, %110 ], [ %156, %155 ]
%162 = tail call i32 @free(double* %19)
ret double %161
}