#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*/ assert(int);
double fabs(double);
void approximate_intersection_pt(int *L, double *c, double *pt) {
  double a;
  double z0, z1, z2, z3;
  double b1, b2;
  double x1, y1;
  double x2, y2;
  double z;
  assert(L[0] != L[2]);
  assert(L[1] != L[3]);
  z0 = c[3 * L[0] + 2];
  z1 = c[3 * L[1] + 2];
  z2 = c[3 * L[2] + 2];
  z3 = c[3 * L[3] + 2];
  if (fabs((z1 - z0) - (z3 - z2)) > 0.0) {
    a = (z2 - z0) / ((z1 - z0) - (z3 - z2));
  } else {
    a = 0;
  }
  z = z0 * (1.0 - a) + z1 * a;
  b1 = (z2 - z) / (z2 - z0);
  b2 = (z - z0) / (z2 - z0);
  x1 = c[3 * L[0] + 0] * b1 + c[3 * L[2] + 0] * b2;
  y1 = c[3 * L[0] + 1] * b1 + c[3 * L[2] + 1] * b2;
  b1 = (z - z3) / (z1 - z3);
  b2 = (z1 - z) / (z1 - z3);
  x2 = c[3 * L[1] + 0] * b1 + c[3 * L[3] + 0] * b2;
  y2 = c[3 * L[1] + 1] * b1 + c[3 * L[3] + 1] * b2;
  pt[0] = x1 * (1.0 - a) + x2 * a;
  pt[1] = y1 * (1.0 - a) + y2 * a;
  pt[2] = z;
}


x86 assembly (clang, -O0):
<approximate_intersection_pt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
cmp    0x8(%rcx),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x8(%rbp),%rcx
cmp    0xc(%rcx),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0x8(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0xc(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
subsd  %xmm1,%xmm0
movaps 0xe16(%rip),%xmm1
pand   %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    122b <approximate_intersection_pt+0x11b>
movsd  -0x38(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
subsd  -0x38(%rbp),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    1233 <approximate_intersection_pt+0x123>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  0xdd0(%rip),%xmm2
subsd  -0x20(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x38(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0x8(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0x8(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x30(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0x4(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0xc(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,0xc(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xc21(%rip),%xmm2
subsd  -0x20(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
movsd  0xbf5(%rip),%xmm2
subsd  -0x20(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<approximate_intersection_pt>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
mov    (%rdi),%eax
xor    %edi,%edi
cmp    0x8(%rbx),%eax
setne  %dil
call   1030 <assert@plt>
mov    0x4(%rbx),%eax
xor    %edi,%edi
cmp    0xc(%rbx),%eax
setne  %dil
call   1030 <assert@plt>
movslq (%rbx),%rax
lea    (%rax,%rax,2),%rdx
movsd  0x10(%r15,%rdx,8),%xmm6
movslq 0x4(%rbx),%rax
lea    (%rax,%rax,2),%rax
movsd  0x10(%r15,%rax,8),%xmm5
movslq 0x8(%rbx),%rcx
lea    (%rcx,%rcx,2),%rsi
movsd  0x10(%r15,%rsi,8),%xmm0
movslq 0xc(%rbx),%rcx
lea    (%rcx,%rcx,2),%rcx
movsd  0x10(%r15,%rcx,8),%xmm8
movapd %xmm5,%xmm3
subsd  %xmm6,%xmm3
movapd %xmm8,%xmm1
subsd  %xmm0,%xmm1
subsd  %xmm1,%xmm3
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm3
movapd %xmm0,%xmm7
subsd  %xmm6,%xmm7
je     11a9 <approximate_intersection_pt+0x99>
movapd %xmm7,%xmm1
divsd  %xmm3,%xmm1
movsd  0xe4f(%rip),%xmm3
subsd  %xmm1,%xmm3
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm6,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm2,%xmm4
subsd  %xmm4,%xmm0
divsd  %xmm7,%xmm0
movapd %xmm4,%xmm2
subsd  %xmm6,%xmm2
divsd  %xmm7,%xmm2
movslq %edx,%rdx
movslq %esi,%rsi
movupd (%r15,%rsi,8),%xmm6
unpcklpd %xmm2,%xmm2
mulpd  %xmm6,%xmm2
movupd (%r15,%rdx,8),%xmm6
unpcklpd %xmm0,%xmm0
mulpd  %xmm6,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm4,%xmm2
subsd  %xmm8,%xmm2
movapd %xmm5,%xmm6
subsd  %xmm8,%xmm6
divsd  %xmm6,%xmm2
subsd  %xmm4,%xmm5
divsd  %xmm6,%xmm5
cltq
movslq %ecx,%rcx
unpcklpd %xmm5,%xmm5
movupd (%r15,%rcx,8),%xmm6
mulpd  %xmm5,%xmm6
movupd (%r15,%rax,8),%xmm5
unpcklpd %xmm2,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm6,%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
unpcklpd %xmm3,%xmm3
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,(%r14)
movsd  %xmm4,0x10(%r14)
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @approximate_intersection_pt(i32* nocapture %0, double* nocapture %1, double* nocapture writeonly %2) {
%4 = load i32, i32* %0
%5 = getelementptr inbounds i32, i32* %0, i64 2
%6 = load i32, i32* %5
%7 = icmp ne i32 %4, %6
%8 = zext i1 %7 to i32
%9 = tail call i32 @assert(i32 %8)
%10 = getelementptr inbounds i32, i32* %0, i64 1
%11 = load i32, i32* %10
%12 = getelementptr inbounds i32, i32* %0, i64 3
%13 = load i32, i32* %12
%14 = icmp ne i32 %11, %13
%15 = zext i1 %14 to i32
%16 = tail call i32 @assert(i32 %15)
%17 = load i32, i32* %0
%18 = mul nsw i32 %17, 3
%19 = add nsw i32 %18, 2
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds double, double* %1, i64 %20
%22 = load double, double* %21
%23 = load i32, i32* %10
%24 = mul nsw i32 %23, 3
%25 = add nsw i32 %24, 2
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds double, double* %1, i64 %26
%28 = load double, double* %27
%29 = load i32, i32* %5
%30 = mul nsw i32 %29, 3
%31 = add nsw i32 %30, 2
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds double, double* %1, i64 %32
%34 = load double, double* %33
%35 = load i32, i32* %12
%36 = mul nsw i32 %35, 3
%37 = add nsw i32 %36, 2
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %1, i64 %38
%40 = load double, double* %39
%41 = fsub double %28, %22
%42 = fsub double %40, %34
%43 = fsub double %41, %42
%44 = fcmp ueq double %43, 0.000000e+00
%45 = fsub double %34, %22
%46 = fdiv double %45, %43
%47 = select i1 %44, double 0.000000e+00, double %46
%48 = fsub double 1.000000e+00, %47
%49 = fmul double %28, %47
%50 = tail call double @llvm.fmuladd.f64(double %22, double %48, double %49)
%51 = fsub double %34, %50
%52 = fdiv double %51, %45
%53 = fsub double %50, %22
%54 = fdiv double %53, %45
%55 = sext i32 %18 to i64
%56 = getelementptr inbounds double, double* %1, i64 %55
%57 = load double, double* %56
%58 = sext i32 %30 to i64
%59 = getelementptr inbounds double, double* %1, i64 %58
%60 = load double, double* %59
%61 = add nsw i32 %18, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %1, i64 %62
%64 = load double, double* %63
%65 = add nsw i32 %30, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %1, i64 %66
%68 = load double, double* %67
%69 = insertelement <2 x double> poison, double %60, i64 0
%70 = insertelement <2 x double> %69, double %68, i64 1
%71 = insertelement <2 x double> poison, double %54, i64 0
%72 = shufflevector <2 x double> %71, <2 x double> poison, <2 x i32> zeroinitializer
%73 = fmul <2 x double> %70, %72
%74 = insertelement <2 x double> poison, double %57, i64 0
%75 = insertelement <2 x double> %74, double %64, i64 1
%76 = insertelement <2 x double> poison, double %52, i64 0
%77 = shufflevector <2 x double> %76, <2 x double> poison, <2 x i32> zeroinitializer
%78 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %75, <2 x double> %77, <2 x double> %73)
%79 = fsub double %50, %40
%80 = fsub double %28, %40
%81 = fdiv double %79, %80
%82 = fsub double %28, %50
%83 = fdiv double %82, %80
%84 = sext i32 %24 to i64
%85 = getelementptr inbounds double, double* %1, i64 %84
%86 = load double, double* %85
%87 = sext i32 %36 to i64
%88 = getelementptr inbounds double, double* %1, i64 %87
%89 = load double, double* %88
%90 = add nsw i32 %24, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %1, i64 %91
%93 = load double, double* %92
%94 = add nsw i32 %36, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %1, i64 %95
%97 = load double, double* %96
%98 = insertelement <2 x double> poison, double %83, i64 0
%99 = shufflevector <2 x double> %98, <2 x double> poison, <2 x i32> zeroinitializer
%100 = insertelement <2 x double> poison, double %89, i64 0
%101 = insertelement <2 x double> %100, double %97, i64 1
%102 = fmul <2 x double> %99, %101
%103 = insertelement <2 x double> poison, double %86, i64 0
%104 = insertelement <2 x double> %103, double %93, i64 1
%105 = insertelement <2 x double> poison, double %81, i64 0
%106 = shufflevector <2 x double> %105, <2 x double> poison, <2 x i32> zeroinitializer
%107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %104, <2 x double> %106, <2 x double> %102)
%108 = insertelement <2 x double> poison, double %47, i64 0
%109 = shufflevector <2 x double> %108, <2 x double> poison, <2 x i32> zeroinitializer
%110 = fmul <2 x double> %109, %107
%111 = insertelement <2 x double> poison, double %48, i64 0
%112 = shufflevector <2 x double> %111, <2 x double> poison, <2 x i32> zeroinitializer
%113 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %78, <2 x double> %112, <2 x double> %110)
%114 = bitcast double* %2 to <2 x double>*
store <2 x double> %113, <2 x double>* %114
%115 = getelementptr inbounds double, double* %2, i64 2
store double %50, double* %115
ret void
}