#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 soft_threshold_update(int, double *, double *, double, double);
double elasticnet_coord_descent(double *beta, double lambda, double alpha,
                                int N, int p, double rsqr, double **c,
                                double *g) {
  int j, k;
  double v, max_delta, delta;
  do {
    max_delta = 0;
    for (j = 0; j < p; ++j) {
      if ((v = soft_threshold_update(j, beta, g, lambda, alpha)) == beta[j])
        continue;
      delta = v - beta[j];
      beta[j] = v;
      rsqr += delta * (2.0 * g[j] - delta);
      for (k = 0; k < p; ++k)
        g[k] -= c[j][k] * delta;
      delta = delta * delta;
      if (delta > max_delta)
        max_delta = delta;
    }
  } while (max_delta > 1e-7);
  return rsqr;
}


x86 assembly (clang, -O0):
<elasticnet_coord_descent>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12aa <elasticnet_coord_descent+0x19a>
mov    -0x3c(%rbp),%edi
mov    -0x8(%rbp),%rsi
mov    -0x38(%rbp),%rdx
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
call   1030 <soft_threshold_update@plt>
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1191 <elasticnet_coord_descent+0x81>
jp     1191 <elasticnet_coord_descent+0x81>
jmp    129c <elasticnet_coord_descent+0x18c>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    126e <elasticnet_coord_descent+0x15e>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1209 <elasticnet_coord_descent+0xf9>
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1297 <elasticnet_coord_descent+0x187>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    129c <elasticnet_coord_descent+0x18c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1148 <elasticnet_coord_descent+0x38>
jmp    12af <elasticnet_coord_descent+0x19f>
movsd  -0x50(%rbp),%xmm0
movsd  0xd44(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1139 <elasticnet_coord_descent+0x29>
movsd  -0x28(%rbp),%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<elasticnet_coord_descent>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8,%rbx
mov    %rcx,%r14
movsd  %xmm2,0x10(%rsp)
mov    %edx,%r15d
movsd  %xmm1,0x50(%rsp)
movsd  %xmm0,0x48(%rsp)
mov    %rdi,%r12
mov    %edx,%r13d
lea    (%r8,%r13,8),%rax
mov    %rax,0x38(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x30(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x40(%rsp)
jmp    11a4 <elasticnet_coord_descent+0x94>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x8(%rsp),%xmm0
ucomisd 0xe62(%rip),%xmm0
jbe    13c6 <elasticnet_coord_descent+0x2b6>
test   %r15d,%r15d
jle    13c6 <elasticnet_coord_descent+0x2b6>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
jmp    11c9 <elasticnet_coord_descent+0xb9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %r13,%rbp
je     1190 <elasticnet_coord_descent+0x80>
mov    %ebp,%edi
mov    %r12,%rsi
mov    %rbx,%rdx
movsd  0x48(%rsp),%xmm0
movsd  0x50(%rsp),%xmm1
call   1030 <soft_threshold_update@plt>
movsd  (%r12,%rbp,8),%xmm1
ucomisd %xmm1,%xmm0
jne    11f0 <elasticnet_coord_descent+0xe0>
jnp    11c0 <elasticnet_coord_descent+0xb0>
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm0
movsd  %xmm2,(%r12,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm1
mov    (%r14,%rbp,8),%rax
cmp    $0x4,%r15d
jb     1225 <elasticnet_coord_descent+0x115>
lea    (%rax,%r13,8),%rcx
cmp    %rbx,%rcx
jbe    129f <elasticnet_coord_descent+0x18f>
cmp    0x38(%rsp),%rax
jae    129f <elasticnet_coord_descent+0x18f>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r13b
je     124e <elasticnet_coord_descent+0x13e>
movsd  (%rbx,%rdx,8),%xmm2
movsd  (%rax,%rdx,8),%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rbx,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x40(%rsp),%rdx
je     1380 <elasticnet_coord_descent+0x270>
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rbx,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x8(%rbx,%rcx,8),%xmm2
movsd  %xmm3,(%rbx,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1260 <elasticnet_coord_descent+0x150>
jmp    1380 <elasticnet_coord_descent+0x270>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
cmpq   $0x0,0x28(%rsp)
je     13b7 <elasticnet_coord_descent+0x2a7>
mov    0x18(%rsp),%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%rax,%rcx,8),%xmm3
movupd 0x10(%rax,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
movupd (%rbx,%rcx,8),%xmm5
subpd  %xmm3,%xmm5
movupd 0x10(%rbx,%rcx,8),%xmm3
movupd 0x20(%rbx,%rcx,8),%xmm6
movupd 0x30(%rbx,%rcx,8),%xmm7
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm3
movupd %xmm5,(%rbx,%rcx,8)
movupd %xmm3,0x10(%rbx,%rcx,8)
movupd 0x20(%rax,%rcx,8),%xmm3
movupd 0x30(%rax,%rcx,8),%xmm4
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm6
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm7
movupd %xmm6,0x20(%rbx,%rcx,8)
movupd %xmm7,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    12c0 <elasticnet_coord_descent+0x1b0>
testb  $0x1,0x20(%rsp)
je     1367 <elasticnet_coord_descent+0x257>
movupd (%rax,%rcx,8),%xmm3
movupd 0x10(%rax,%rcx,8),%xmm4
movupd (%rbx,%rcx,8),%xmm5
movupd 0x10(%rbx,%rcx,8),%xmm6
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm6
movupd %xmm5,(%rbx,%rcx,8)
movupd %xmm6,0x10(%rbx,%rcx,8)
mov    0x30(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r13,%rcx
jne    1227 <elasticnet_coord_descent+0x117>
nopl   0x0(%rax,%rax,1)
addsd  %xmm1,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x10(%rsp),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsp)
mulsd  %xmm0,%xmm0
ucomisd 0x8(%rsp),%xmm0
jbe    11c0 <elasticnet_coord_descent+0xb0>
movsd  %xmm0,0x8(%rsp)
jmp    11c0 <elasticnet_coord_descent+0xb0>
xor    %ecx,%ecx
testb  $0x1,0x20(%rsp)
jne    1336 <elasticnet_coord_descent+0x226>
jmp    1367 <elasticnet_coord_descent+0x257>
movsd  0x10(%rsp),%xmm0
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @elasticnet_coord_descent(double* %0, double %1, double %2, i32 %3, i32 %4, double %5, double** %6, double* %7) {
%9 = alloca double*
%10 = alloca double
%11 = alloca double
%12 = alloca i32
%13 = alloca i32
%14 = alloca double
%15 = alloca double**
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca double
%20 = alloca double
%21 = alloca double
store double* %0, double** %9
store double %1, double* %10
store double %2, double* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store double %5, double* %14
store double** %6, double*** %15
store double* %7, double** %16
br label %22
22: ; preds = %104, %8
store double 0.000000e+00, double* %20
store i32 0, i32* %17
br label %23
23: ; preds = %100, %22
%24 = load i32, i32* %17
%25 = load i32, i32* %13
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %103
27: ; preds = %23
%28 = load i32, i32* %17
%29 = load double*, double** %9
%30 = load double*, double** %16
%31 = load double, double* %10
%32 = load double, double* %11
%33 = call double @soft_threshold_update(i32 %28, double* %29, double* %30, double %31, double %32)
store double %33, double* %19
%34 = load double*, double** %9
%35 = load i32, i32* %17
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %34, i64 %36
%38 = load double, double* %37
%39 = fcmp oeq double %33, %38
br i1 %39, label %40, label %41
40: ; preds = %27
br label %100
41: ; preds = %27
%42 = load double, double* %19
%43 = load double*, double** %9
%44 = load i32, i32* %17
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %43, i64 %45
%47 = load double, double* %46
%48 = fsub double %42, %47
store double %48, double* %21
%49 = load double, double* %19
%50 = load double*, double** %9
%51 = load i32, i32* %17
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
store double %49, double* %53
%54 = load double, double* %21
%55 = load double*, double** %16
%56 = load i32, i32* %17
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
%59 = load double, double* %58
%60 = load double, double* %21
%61 = fneg double %60
%62 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %59, double %61)
%63 = load double, double* %14
%64 = call double @llvm.fmuladd.f64(double %54, double %62, double %63)
store double %64, double* %14
store i32 0, i32* %18
br label %65
65: ; preds = %87, %41
%66 = load i32, i32* %18
%67 = load i32, i32* %13
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %90
69: ; preds = %65
%70 = load double**, double*** %15
%71 = load i32, i32* %17
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double*, double** %70, i64 %72
%74 = load double*, double** %73
%75 = load i32, i32* %18
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
%78 = load double, double* %77
%79 = load double, double* %21
%80 = load double*, double** %16
%81 = load i32, i32* %18
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %80, i64 %82
%84 = load double, double* %83
%85 = fneg double %78
%86 = call double @llvm.fmuladd.f64(double %85, double %79, double %84)
store double %86, double* %83
br label %87
87: ; preds = %69
%88 = load i32, i32* %18
%89 = add nsw i32 %88, 1
store i32 %89, i32* %18
br label %65
90: ; preds = %65
%91 = load double, double* %21
%92 = load double, double* %21
%93 = fmul double %91, %92
store double %93, double* %21
%94 = load double, double* %21
%95 = load double, double* %20
%96 = fcmp ogt double %94, %95
br i1 %96, label %97, label %99
97: ; preds = %90
%98 = load double, double* %21
store double %98, double* %20
br label %99
99: ; preds = %97, %90
br label %100
100: ; preds = %99, %40
%101 = load i32, i32* %17
%102 = add nsw i32 %101, 1
store i32 %102, i32* %17
br label %23
103: ; preds = %23
br label %104
104: ; preds = %103
%105 = load double, double* %20
%106 = fcmp ogt double %105, 0x3E7AD7F29ABCAF48
br i1 %106, label %22, label %107
107: ; preds = %104
%108 = load double, double* %14
ret double %108
}

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