user: Converte this assembly snippet into its equivalent C code:

```asm
<lp_base_case>:
  endbr64
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x28,%rsp
  mov    %rdx,%rbx
  mov    %rcx,%rbp
  mov    %r8,%r12
  mov    %r9,%rdx
  mov    %fs:0x28,%rax
  mov    %rax,0x20(%rsp)
  xor    %eax,%eax
  lea    0xc(%rsp),%rax
  push   %rax
  lea    0x20(%rsp),%r9
  lea    0x18(%rsp),%r8
  mov    0x50(%rsp),%rcx
  call   <wedge@plt>
  add    $0x10,%rsp
  test   %eax,%eax
  je     L2
  cmp    $0x2,%eax
  je     L77
  movss  (%rbx),%xmm2
  movss  0x4(%rbp),%xmm4
  movss  0x4(%rbx),%xmm3
  movss  0x0(%rbp),%xmm1
  movaps %xmm2,%xmm0
  mulss  %xmm4,%xmm0
  movaps %xmm3,%xmm5
  mulss  %xmm1,%xmm5
  subss  %xmm5,%xmm0
  comiss D13(%rip),%xmm0
  jbe    L113
L47:
  cvtss2sd %xmm0,%xmm0
  movsd  D33(%rip),%xmm5
  comisd %xmm0,%xmm5
  jbe    L88
  movaps %xmm3,%xmm5
  mulss  %xmm3,%xmm5
  movaps %xmm2,%xmm0
  mulss  %xmm2,%xmm0
  addss  %xmm5,%xmm0
  cvtss2sd %xmm0,%xmm0
  movsd  D33(%rip),%xmm5
  comisd %xmm0,%xmm5
  ja     L111
  mulss  %xmm1,%xmm1
  mulss  %xmm4,%xmm4
  addss  %xmm4,%xmm1
  cvtss2sd %xmm1,%xmm1
  comisd %xmm5,%xmm1
  ja     L111
  cmpl   $0x0,0x4(%rsp)
  jne    L60
  movaps %xmm3,%xmm0
  mulss  0x8(%rsp),%xmm0
  movaps %xmm2,%xmm1
  mulss  0xc(%rsp),%xmm1
  subss  %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  comiss %xmm0,%xmm1
  jae    L55
L60:
  movss  0x8(%rsp),%xmm4
  movss  0xc(%rsp),%xmm1
  movss  0x10(%rsp),%xmm6
  movss  0x14(%rsp),%xmm5
  movaps %xmm2,%xmm0
  mulss  %xmm4,%xmm0
  movaps %xmm3,%xmm7
  mulss  %xmm1,%xmm7
  addss  %xmm7,%xmm0
  mulss  %xmm6,%xmm2
  mulss  %xmm5,%xmm3
  addss  %xmm3,%xmm2
  comiss %xmm2,%xmm0
  jbe    L109
  movss  %xmm6,(%r12)
  movss  %xmm5,0x4(%r12)
  mov    $0x1,%eax
  jmp    L2
L77:
  mov    %r12,%rcx
  mov    %rbp,%rdx
  mov    %rbx,%rsi
  mov    $0x1,%edi
  call   <lp_no_constraints@plt>
  jmp    L2
L113:
  xorps  D36(%rip),%xmm0
  jmp    L47
L111:
  movss  0x8(%rsp),%xmm0
  movss  %xmm0,(%r12)
  movss  0xc(%rsp),%xmm0
  movss  %xmm0,0x4(%r12)
  mov    $0x3,%eax
L2:
  mov    0x18(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L76
  add    $0x20,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
L55:
  movaps %xmm2,%xmm0
  mulss  0x14(%rsp),%xmm0
  movaps %xmm3,%xmm1
  mulss  0x10(%rsp),%xmm1
  subss  %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  comiss %xmm0,%xmm1
  jb     L60
  movss  D36(%rip),%xmm1
  xorps  %xmm1,%xmm2
  movss  %xmm2,(%r12)
  movss  0x4(%rbx),%xmm0
  xorps  %xmm1,%xmm0
  movss  %xmm0,0x4(%r12)
  mov    $0x1,%eax
  jmp    L2
L109:
  movss  %xmm4,(%r12)
  movss  %xmm1,0x4(%r12)
  mov    $0x1,%eax
  jmp    L2
L88:
  lea    0x10(%rsp),%rdx
  lea    0x8(%rsp),%rsi
  mov    %r12,%r9
  mov    %rbp,%r8
  mov    %rbx,%rcx
  mov    0x4(%rsp),%edi
  call   <lp_min_lin_rat@plt>
  mov    $0x1,%eax
  jmp    L2
L76:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: data_label: D13
type_guessed: f64
name: extract_symbolic_data
arguments: data_label: D33
type_guessed: byte[8]
name: extract_symbolic_data
arguments: data_label: D36
type_guessed: byte[16]

tool: D13: 0

tool: {"D33": [0x9a,0x2b,0xa1,0x86,0x9b,0x84,0x16,0x3d]}

tool: {"D36": [0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]}

assistant: ```c
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);
}
```