#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*/ lp_min_lin_rat(int, float *, float *, float *, float *,
                                  float *);
int lp_no_constraints(int, float *, float *, float *);
int wedge(float **, int, int *, int *, float *, float *, int *);
int lp_base_case(float halves[][2], int m, float n_vec[2], float d_vec[2],
                 float opt[2], int next[], int prev[]) {
  float cw_vec[2], ccw_vec[2];
  int status, degen;
  float ab;
  status = wedge(halves, m, next, prev, cw_vec, ccw_vec, &degen);
  if (status == 0)
    return (status);
  if (status == 2) {
    return (lp_no_constraints(1, n_vec, d_vec, opt));
  }
  ab = ((((n_vec)[0] * (d_vec)[1] - (n_vec)[1] * (d_vec)[0])) > 0.0
            ? (((n_vec)[0] * (d_vec)[1] - (n_vec)[1] * (d_vec)[0]))
            : -(((n_vec)[0] * (d_vec)[1] - (n_vec)[1] * (d_vec)[0])));
  if (ab < 2 * 1.0e-7 * 1.0e-7) {
    if (((n_vec)[0] * (n_vec)[0] + (n_vec)[1] * (n_vec)[1]) <
            2 * 1.0e-7 * 1.0e-7 ||
        ((d_vec)[0] * (d_vec)[0] + (d_vec)[1] * (d_vec)[1]) >
            2 * 1.0e-7 * 1.0e-7) {
      opt[0] = cw_vec[0];
      opt[1] = cw_vec[1];
      status = 3;
    } else {
      if (!degen &&
          ((cw_vec)[0] * (n_vec)[1] - (cw_vec)[1] * (n_vec)[0]) <= 0.0 &&
          ((n_vec)[0] * (ccw_vec)[1] - (n_vec)[1] * (ccw_vec)[0]) <= 0.0) {
        opt[0] = -n_vec[0];
        opt[1] = -n_vec[1];
      } else if (((n_vec)[0] * (cw_vec)[0] + (n_vec)[1] * (cw_vec)[1]) >
                 ((n_vec)[0] * (ccw_vec)[0] + (n_vec)[1] * (ccw_vec)[1])) {
        opt[0] = ccw_vec[0];
        opt[1] = ccw_vec[1];
      } else {
        opt[0] = cw_vec[0];
        opt[1] = cw_vec[1];
      }
      status = 1;
    }
  } else {
    lp_min_lin_rat(degen, cw_vec, ccw_vec, n_vec, d_vec, opt);
    status = 1;
  }
  return (status);
}


x86 assembly (clang, -O0):
<lp_base_case>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x38(%rbp),%rdx
mov    0x10(%rbp),%rcx
lea    -0x40(%rbp),%r8
lea    -0x48(%rbp),%r9
lea    -0x50(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wedge@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    118f <lp_base_case+0x5f>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    14e6 <lp_base_case+0x3b6>
cmpl   $0x2,-0x4c(%rbp)
jne    11b7 <lp_base_case+0x87>
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    $0x1,%edi
call   1050 <lp_no_constraints@plt>
mov    %eax,-0x4(%rbp)
jmp    14e6 <lp_base_case+0x3b6>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1240 <lp_base_case+0x110>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1289 <lp_base_case+0x159>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd5c(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    14bd <lp_base_case+0x38d>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd1c(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     132e <lp_base_case+0x1fe>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcdc(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1355 <lp_base_case+0x225>
movss  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x3,-0x4c(%rbp)
jmp    14b8 <lp_base_case+0x388>
cmpl   $0x0,-0x50(%rbp)
jne    1422 <lp_base_case+0x2f2>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1422 <lp_base_case+0x2f2>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1422 <lp_base_case+0x2f2>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    14b1 <lp_base_case+0x381>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x40(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x48(%rbp),%xmm3
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  -0x44(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    1491 <lp_base_case+0x361>
movss  -0x48(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    14ac <lp_base_case+0x37c>
movss  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    14b1 <lp_base_case+0x381>
movl   $0x1,-0x4c(%rbp)
jmp    14e0 <lp_base_case+0x3b0>
mov    -0x50(%rbp),%edi
lea    -0x40(%rbp),%rsi
lea    -0x48(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
call   1040 <lp_min_lin_rat@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lp_base_case>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %r9,%rax
mov    %r8,%r14
mov    %rcx,%rbx
mov    %rdx,%r15
mov    0x40(%rsp),%rcx
lea    0xc(%rsp),%rdx
mov    %rdx,(%rsp)
lea    0x18(%rsp),%r8
lea    0x10(%rsp),%r9
mov    %rax,%rdx
call   1030 <wedge@plt>
test   %eax,%eax
je     125b <lp_base_case+0x12b>
cmp    $0x2,%eax
jne    118a <lp_base_case+0x5a>
mov    $0x1,%edi
mov    %r15,%rsi
mov    %rbx,%rdx
mov    %r14,%rcx
call   1050 <lp_no_constraints@plt>
jmp    125b <lp_base_case+0x12b>
movss  (%r15),%xmm0
movss  0x4(%r15),%xmm1
movss  (%rbx),%xmm3
movss  0x4(%rbx),%xmm4
movaps 0xe5b(%rip),%xmm2
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
movaps %xmm0,%xmm6
mulss  %xmm4,%xmm6
subss  %xmm5,%xmm6
movaps %xmm6,%xmm5
xorps  %xmm2,%xmm5
xorps  %xmm7,%xmm7
cmpltss %xmm6,%xmm7
andps  %xmm7,%xmm6
andnps %xmm5,%xmm7
orps   %xmm6,%xmm7
xorps  %xmm6,%xmm6
cvtss2sd %xmm7,%xmm6
movsd  0xe33(%rip),%xmm5
ucomisd %xmm6,%xmm5
jbe    123a <lp_base_case+0x10a>
movaps %xmm1,%xmm6
mulss  %xmm1,%xmm6
movaps %xmm0,%xmm7
mulss  %xmm0,%xmm7
addss  %xmm6,%xmm7
xorps  %xmm6,%xmm6
cvtss2sd %xmm7,%xmm6
ucomisd %xmm6,%xmm5
ja     121c <lp_base_case+0xec>
mulss  %xmm4,%xmm4
mulss  %xmm3,%xmm3
addss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
ucomisd 0xdf6(%rip),%xmm3
jbe    1265 <lp_base_case+0x135>
movss  0x18(%rsp),%xmm0
movss  %xmm0,(%r14)
movss  0x1c(%rsp),%xmm0
movss  %xmm0,0x4(%r14)
mov    $0x3,%eax
jmp    125b <lp_base_case+0x12b>
mov    0xc(%rsp),%edi
lea    0x18(%rsp),%rsi
lea    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %rbx,%r8
mov    %r14,%r9
call   1040 <lp_min_lin_rat@plt>
mov    $0x1,%eax
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret
cmpl   $0x0,0xc(%rsp)
movss  0x18(%rsp),%xmm3
movss  0x1c(%rsp),%xmm4
jne    12b1 <lp_base_case+0x181>
movaps %xmm0,%xmm5
mulss  %xmm4,%xmm5
movaps %xmm3,%xmm6
mulss  %xmm1,%xmm6
subss  %xmm5,%xmm6
xorps  %xmm5,%xmm5
ucomiss %xmm6,%xmm5
jb     12b1 <lp_base_case+0x181>
movaps %xmm1,%xmm6
xorps  %xmm2,%xmm6
mulss  0x10(%rsp),%xmm6
movss  0x14(%rsp),%xmm7
mulss  %xmm0,%xmm7
addss  %xmm6,%xmm7
ucomiss %xmm7,%xmm5
jae    1306 <lp_base_case+0x1d6>
movss  0x10(%rsp),%xmm2
movss  0x14(%rsp),%xmm5
shufps $0x0,%xmm1,%xmm1
movaps %xmm4,%xmm6
unpcklps %xmm5,%xmm6
mulps  %xmm1,%xmm6
shufps $0x0,%xmm0,%xmm0
movaps %xmm3,%xmm1
unpcklps %xmm2,%xmm1
mulps  %xmm0,%xmm1
addps  %xmm6,%xmm1
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
ucomiss %xmm0,%xmm1
jbe    12f6 <lp_base_case+0x1c6>
movss  %xmm2,(%r14)
movss  %xmm5,0x4(%r14)
jmp    1256 <lp_base_case+0x126>
movss  %xmm3,(%r14)
movss  %xmm4,0x4(%r14)
jmp    1256 <lp_base_case+0x126>
xorps  %xmm2,%xmm0
movss  %xmm0,(%r14)
movss  0x4(%r15),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,0x4(%r14)
jmp    1256 <lp_base_case+0x126>

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

LLVM IR (-O2):
define i32 @lp_base_case([2 x float]* %0, i32 %1, float* %2, float* %3, float* %4, i32* %5, i32* %6) {
%8 = alloca [2 x float]
%9 = alloca [2 x float]
%10 = alloca i32
%11 = bitcast [2 x float]* %8 to i8*
%12 = bitcast [2 x float]* %9 to i8*
%13 = bitcast i32* %10 to i8*
%14 = bitcast [2 x float]* %0 to float**
%15 = getelementptr inbounds [2 x float], [2 x float]* %8, i64 0, i64 0
%16 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 0, i64 0
%17 = call i32 @wedge(float** %14, i32 %1, i32* %5, i32* %6, float* %15, float* %16, i32* %10)
switch i32 %17, label %20 [
i32 0, label %97
i32 2, label %18
]
18: ; preds = %7
%19 = call i32 @lp_no_constraints(i32 1, float* %2, float* %3, float* %4)
br label %97
20: ; preds = %7
%21 = load float, float* %2
%22 = getelementptr inbounds float, float* %3, i64 1
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %2, i64 1
%25 = load float, float* %24
%26 = load float, float* %3
%27 = fneg float %25
%28 = fmul float %26, %27
%29 = call float @llvm.fmuladd.f32(float %21, float %23, float %28)
%30 = fcmp ogt float %29, 0.000000e+00
%31 = fneg float %29
%32 = select i1 %30, float %29, float %31
%33 = fpext float %32 to double
%34 = fcmp olt double %33, 0x3D16849B86A12B9A
br i1 %34, label %35, label %94
35: ; preds = %20
%36 = fmul float %25, %25
%37 = call float @llvm.fmuladd.f32(float %21, float %21, float %36)
%38 = fpext float %37 to double
%39 = fcmp olt double %38, 0x3D16849B86A12B9A
br i1 %39, label %45, label %40
40: ; preds = %35
%41 = fmul float %23, %23
%42 = call float @llvm.fmuladd.f32(float %26, float %26, float %41)
%43 = fpext float %42 to double
%44 = fcmp ogt double %43, 0x3D16849B86A12B9A
br i1 %44, label %45, label %50
45: ; preds = %40, %35
%46 = load float, float* %15
store float %46, float* %4
%47 = getelementptr inbounds [2 x float], [2 x float]* %8, i64 0, i64 1
%48 = load float, float* %47
%49 = getelementptr inbounds float, float* %4, i64 1
store float %48, float* %49
br label %97
50: ; preds = %40
%51 = load i32, i32* %10
%52 = icmp eq i32 %51, 0
%53 = load float, float* %15
%54 = getelementptr inbounds [2 x float], [2 x float]* %8, i64 0, i64 1
%55 = load float, float* %54
br i1 %52, label %56, label %73
56: ; preds = %50
%57 = fneg float %55
%58 = fmul float %21, %57
%59 = call float @llvm.fmuladd.f32(float %53, float %25, float %58)
%60 = fcmp ugt float %59, 0.000000e+00
br i1 %60, label %73, label %61
61: ; preds = %56
%62 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 0, i64 1
%63 = load float, float* %62
%64 = load float, float* %16
%65 = fmul float %64, %27
%66 = call float @llvm.fmuladd.f32(float %21, float %63, float %65)
%67 = fcmp ugt float %66, 0.000000e+00
br i1 %67, label %73, label %68
68: ; preds = %61
%69 = fneg float %21
store float %69, float* %4
%70 = load float, float* %24
%71 = fneg float %70
%72 = getelementptr inbounds float, float* %4, i64 1
store float %71, float* %72
br label %97
73: ; preds = %50, %61, %56
%74 = load float, float* %16
%75 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 0, i64 1
%76 = load float, float* %75
%77 = insertelement <2 x float> poison, float %25, i64 0
%78 = shufflevector <2 x float> %77, <2 x float> poison, <2 x i32> zeroinitializer
%79 = insertelement <2 x float> poison, float %55, i64 0
%80 = insertelement <2 x float> %79, float %76, i64 1
%81 = fmul <2 x float> %78, %80
%82 = insertelement <2 x float> poison, float %21, i64 0
%83 = shufflevector <2 x float> %82, <2 x float> poison, <2 x i32> zeroinitializer
%84 = insertelement <2 x float> poison, float %53, i64 0
%85 = insertelement <2 x float> %84, float %74, i64 1
%86 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %83, <2 x float> %85, <2 x float> %81)
%87 = extractelement <2 x float> %86, i64 0
%88 = extractelement <2 x float> %86, i64 1
%89 = fcmp ogt float %87, %88
br i1 %89, label %90, label %92
90: ; preds = %73
store float %74, float* %4
%91 = getelementptr inbounds float, float* %4, i64 1
store float %76, float* %91
br label %97
92: ; preds = %73
store float %53, float* %4
%93 = getelementptr inbounds float, float* %4, i64 1
store float %55, float* %93
br label %97
94: ; preds = %20
%95 = load i32, i32* %10
%96 = call i32 @lp_min_lin_rat(i32 %95, float* %15, float* %16, float* %2, float* %3, float* %4)
br label %97
97: ; preds = %94, %45, %90, %92, %68, %7, %18
%98 = phi i32 [ %19, %18 ], [ %17, %7 ], [ 3, %45 ], [ 1, %94 ], [ 1, %90 ], [ 1, %92 ], [ 1, %68 ]
ret i32 %98
}