#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 */
struct rpc {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ decompose_vector_basis(double *, double *, double *,
                                          double *);
int /*<<< orphan*/ eval_nrpci(double *, struct rpc *, double, double, double);
int l2_squared_dist(double *, double *);
void eval_nrpc_iterative(double *result, struct rpc *p, double x, double y,
                         double z) {
  double a[2];
  double x0[2];
  double x1[2];
  double x2[2];
  double xf[2] = {x, y};
  double lon = -1, lat = -1, eps = 2;
  eval_nrpci(x0, p, lon, lat, z);
  eval_nrpci(x1, p, lon + eps, lat, z);
  eval_nrpci(x2, p, lon, lat + eps, z);
  while (l2_squared_dist(x0, xf) > 1e-18) {
    double u[2] = {xf[0] - x0[0], xf[1] - x0[1]};
    double e1[2] = {x1[0] - x0[0], x1[1] - x0[1]};
    double e2[2] = {x2[0] - x0[0], x2[1] - x0[1]};
    decompose_vector_basis(a, u, e1, e2);
    lon += a[0] * eps;
    lat += a[1] * eps;
    eps = 0.1;
    eval_nrpci(x0, p, lon, lat, z);
    eval_nrpci(x1, p, lon + eps, lat, z);
    eval_nrpci(x2, p, lon, lat + eps, z);
  }
  result[0] = lon;
  result[1] = lat;
}


x86 assembly (clang, -O0):
<eval_nrpc_iterative>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xe9a(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xe8a(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xe72(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
lea    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
call   1040 <eval_nrpci@plt>
lea    -0x60(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
call   1040 <eval_nrpci@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
addsd  -0x98(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
call   1040 <eval_nrpci@plt>
lea    -0x50(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1030 <l2_squared_dist@plt>
cvtsi2sd %eax,%xmm0
movsd  0xdeb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    138e <eval_nrpc_iterative+0x25e>
movsd  -0x80(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
lea    -0x40(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
lea    -0xd0(%rbp),%rcx
call   1050 <decompose_vector_basis@plt>
movsd  -0x40(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xd0d(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
lea    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
call   1040 <eval_nrpci@plt>
lea    -0x60(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
call   1040 <eval_nrpci@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
addsd  -0x98(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
call   1040 <eval_nrpci@plt>
jmp    120c <eval_nrpc_iterative+0xdc>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eval_nrpc_iterative>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
movsd  %xmm2,0x8(%rsp)
mov    %rsi,%rbx
mov    %rdi,%rbp
movsd  %xmm0,0x20(%rsp)
movsd  %xmm1,0x28(%rsp)
lea    0x60(%rsp),%r14
movsd  0xe9a(%rip),%xmm0
mov    %r14,%rdi
movaps %xmm0,%xmm1
call   1040 <eval_nrpci@plt>
lea    0x50(%rsp),%rdi
movsd  0xe8a(%rip),%xmm0
mov    %rbx,%rsi
movsd  0xe77(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
lea    0x40(%rsp),%rdi
mov    %rbx,%rsi
movsd  0xe5c(%rip),%xmm0
movsd  0xe5c(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
lea    0x20(%rsp),%rsi
mov    %r14,%rdi
call   1030 <l2_squared_dist@plt>
test   %eax,%eax
mov    %rbp,0xb0(%rsp)
jle    13ed <eval_nrpc_iterative+0x2bd>
movapd 0x20(%rsp),%xmm0
movapd 0x60(%rsp),%xmm1
subpd  %xmm1,%xmm0
movapd %xmm0,0x90(%rsp)
movapd 0x50(%rsp),%xmm0
subpd  %xmm1,%xmm0
movapd %xmm0,0x80(%rsp)
movapd 0x40(%rsp),%xmm0
subpd  %xmm1,%xmm0
movapd %xmm0,0x70(%rsp)
lea    0xa0(%rsp),%rdi
lea    0x90(%rsp),%rsi
lea    0x80(%rsp),%rdx
lea    0x70(%rsp),%rcx
call   1050 <decompose_vector_basis@plt>
movapd 0xa0(%rsp),%xmm0
addpd  %xmm0,%xmm0
addpd  0xdd9(%rip),%xmm0
movapd %xmm0,0x10(%rsp)
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
movapd %xmm1,0x30(%rsp)
lea    0x60(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
movapd 0x10(%rsp),%xmm0
addsd  0xd91(%rip),%xmm0
lea    0x50(%rsp),%rdi
mov    %rbx,%rsi
movaps 0x30(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
movapd 0x30(%rsp),%xmm1
addsd  0xd6b(%rip),%xmm1
lea    0x40(%rsp),%rdi
mov    %rbx,%rsi
movaps 0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
lea    0x20(%rsp),%rsi
mov    %rbp,%rdi
call   1030 <l2_squared_dist@plt>
test   %eax,%eax
jle    13f9 <eval_nrpc_iterative+0x2c9>
lea    0x70(%rsp),%rbp
lea    0x60(%rsp),%r14
lea    0x50(%rsp),%r15
lea    0x40(%rsp),%r12
lea    0x20(%rsp),%r13
nopl   0x0(%rax,%rax,1)
movapd 0x20(%rsp),%xmm0
movapd 0x60(%rsp),%xmm1
subpd  %xmm1,%xmm0
movapd %xmm0,0x90(%rsp)
movapd 0x50(%rsp),%xmm0
subpd  %xmm1,%xmm0
movapd %xmm0,0x80(%rsp)
movapd 0x40(%rsp),%xmm0
subpd  %xmm1,%xmm0
movapd %xmm0,0x70(%rsp)
lea    0xa0(%rsp),%rdi
lea    0x90(%rsp),%rsi
lea    0x80(%rsp),%rdx
mov    %rbp,%rcx
call   1050 <decompose_vector_basis@plt>
movapd 0xa0(%rsp),%xmm1
mulpd  0xcd3(%rip),%xmm1
movapd 0x10(%rsp),%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,0x10(%rsp)
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
movapd %xmm1,0x30(%rsp)
mov    %r14,%rdi
mov    %rbx,%rsi
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
movapd 0x10(%rsp),%xmm0
movsd  0xc76(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    %r15,%rdi
mov    %rbx,%rsi
movaps 0x30(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
movapd 0x30(%rsp),%xmm1
addsd  0xc4e(%rip),%xmm1
mov    %r12,%rdi
mov    %rbx,%rsi
movaps 0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm2
call   1040 <eval_nrpci@plt>
mov    %r14,%rdi
mov    %r13,%rsi
call   1030 <l2_squared_dist@plt>
test   %eax,%eax
jg     12f0 <eval_nrpc_iterative+0x1c0>
jmp    13f9 <eval_nrpc_iterative+0x2c9>
movaps 0xc2c(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
mov    0xb0(%rsp),%rax
movaps 0x10(%rsp),%xmm0
movups %xmm0,(%rax)
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.rpc = type { i32 }
define void @eval_nrpc_iterative(double* nocapture writeonly %0, %struct.rpc* %1, double %2, double %3, double %4) {
%6 = alloca <2 x double>
%7 = alloca <2 x double>
%8 = alloca <2 x double>
%9 = alloca <2 x double>
%10 = alloca <2 x double>
%11 = alloca <2 x double>
%12 = alloca <2 x double>
%13 = alloca <2 x double>
%14 = bitcast <2 x double>* %6 to i8*
%15 = bitcast <2 x double>* %7 to i8*
%16 = bitcast <2 x double>* %8 to i8*
%17 = bitcast <2 x double>* %9 to i8*
%18 = bitcast <2 x double>* %10 to i8*
%19 = getelementptr inbounds <2 x double>, <2 x double>* %10, i64 0, i64 0
store double %2, double* %19
%20 = getelementptr inbounds <2 x double>, <2 x double>* %10, i64 0, i64 1
store double %3, double* %20
%21 = getelementptr inbounds <2 x double>, <2 x double>* %7, i64 0, i64 0
%22 = call i32 @eval_nrpci(double* %21, %struct.rpc* %1, double -1.000000e+00, double -1.000000e+00, double %4)
%23 = getelementptr inbounds <2 x double>, <2 x double>* %8, i64 0, i64 0
%24 = call i32 @eval_nrpci(double* %23, %struct.rpc* %1, double 1.000000e+00, double -1.000000e+00, double %4)
%25 = getelementptr inbounds <2 x double>, <2 x double>* %9, i64 0, i64 0
%26 = call i32 @eval_nrpci(double* %25, %struct.rpc* %1, double -1.000000e+00, double 1.000000e+00, double %4)
%27 = call i32 @l2_squared_dist(double* %21, double* %19)
%28 = icmp sgt i32 %27, 0
br i1 %28, label %29, label %78
29: ; preds = %5
%30 = bitcast <2 x double>* %11 to i8*
%31 = getelementptr inbounds <2 x double>, <2 x double>* %11, i64 0, i64 0
%32 = bitcast <2 x double>* %12 to i8*
%33 = getelementptr inbounds <2 x double>, <2 x double>* %12, i64 0, i64 0
%34 = bitcast <2 x double>* %13 to i8*
%35 = getelementptr inbounds <2 x double>, <2 x double>* %13, i64 0, i64 0
%36 = getelementptr inbounds <2 x double>, <2 x double>* %6, i64 0, i64 0
%37 = load <2 x double>, <2 x double>* %10
%38 = load <2 x double>, <2 x double>* %7
%39 = fsub <2 x double> %37, %38
store <2 x double> %39, <2 x double>* %11
%40 = load <2 x double>, <2 x double>* %8
%41 = fsub <2 x double> %40, %38
store <2 x double> %41, <2 x double>* %12
%42 = load <2 x double>, <2 x double>* %9
%43 = fsub <2 x double> %42, %38
store <2 x double> %43, <2 x double>* %13
%44 = call i32 @decompose_vector_basis(double* %36, double* %31, double* %33, double* %35)
%45 = load <2 x double>, <2 x double>* %6
%46 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %45, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> <double -1.000000e+00, double -1.000000e+00>)
%47 = extractelement <2 x double> %46, i64 0
%48 = extractelement <2 x double> %46, i64 1
%49 = call i32 @eval_nrpci(double* %21, %struct.rpc* %1, double %47, double %48, double %4)
%50 = fadd double %47, 1.000000e-01
%51 = call i32 @eval_nrpci(double* %23, %struct.rpc* %1, double %50, double %48, double %4)
%52 = fadd double %48, 1.000000e-01
%53 = call i32 @eval_nrpci(double* %25, %struct.rpc* %1, double %47, double %52, double %4)
%54 = call i32 @l2_squared_dist(double* %21, double* %19)
%55 = icmp sgt i32 %54, 0
br i1 %55, label %56, label %78
56: ; preds = %29, %56
%57 = phi <2 x double> [ %67, %56 ], [ %46, %29 ]
%58 = load <2 x double>, <2 x double>* %10
%59 = load <2 x double>, <2 x double>* %7
%60 = fsub <2 x double> %58, %59
store <2 x double> %60, <2 x double>* %11
%61 = load <2 x double>, <2 x double>* %8
%62 = fsub <2 x double> %61, %59
store <2 x double> %62, <2 x double>* %12
%63 = load <2 x double>, <2 x double>* %9
%64 = fsub <2 x double> %63, %59
store <2 x double> %64, <2 x double>* %13
%65 = call i32 @decompose_vector_basis(double* %36, double* %31, double* %33, double* %35)
%66 = load <2 x double>, <2 x double>* %6
%67 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> <double 1.000000e-01, double 1.000000e-01>, <2 x double> %57)
%68 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> <double 1.000000e-01, double 1.000000e-01>, <2 x double> %57)
%69 = extractelement <2 x double> %68, i64 0
%70 = extractelement <2 x double> %68, i64 1
%71 = call i32 @eval_nrpci(double* %21, %struct.rpc* %1, double %69, double %70, double %4)
%72 = fadd double %69, 1.000000e-01
%73 = call i32 @eval_nrpci(double* %23, %struct.rpc* %1, double %72, double %70, double %4)
%74 = fadd double %70, 1.000000e-01
%75 = call i32 @eval_nrpci(double* %25, %struct.rpc* %1, double %69, double %74, double %4)
%76 = call i32 @l2_squared_dist(double* %21, double* %19)
%77 = icmp sgt i32 %76, 0
br i1 %77, label %56, label %78
78: ; preds = %56, %29, %5
%79 = phi <2 x double> [ <double -1.000000e+00, double -1.000000e+00>, %5 ], [ %46, %29 ], [ %68, %56 ]
%80 = bitcast double* %0 to <2 x double>*
store <2 x double> %79, <2 x double>* %80
ret void
}