user: 请从给定的汇编指令推导出C源代码：

```asm
<solve_quartic_2>:
  endbr64
  movaps %xmm0,%xmm6
  push   %rbp
  movaps %xmm0,%xmm4
  movaps %xmm1,%xmm7
  mulss  %xmm0,%xmm6
  push   %rbx
  movaps %xmm4,%xmm8
  cvtss2sd %xmm3,%xmm3
  mulss  %xmm1,%xmm8
  mov    %rdi,%rbx
  sub    $0x48,%rsp
  movss  D2(%rip),%xmm0
  movss  D141(%rip),%xmm5
  mulss  D127(%rip),%xmm8
  mov    %fs:0x28,%rax
  mov    %rax,0x38(%rsp)
  xor    %eax,%eax
  mulss  %xmm6,%xmm0
  mulss  %xmm5,%xmm0
  subss  %xmm0,%xmm7
  movaps %xmm6,%xmm0
  mulss  %xmm4,%xmm0
  mulss  %xmm1,%xmm6
  pxor   %xmm1,%xmm1
  mulss  D100(%rip),%xmm6
  mulss  %xmm0,%xmm5
  mulss  %xmm4,%xmm0
  cvtss2sd %xmm6,%xmm6
  subss  %xmm8,%xmm5
  cvtss2sd %xmm0,%xmm0
  mulsd  D139(%rip),%xmm0
  addss  %xmm2,%xmm5
  mulss  %xmm4,%xmm2
  mulss  D90(%rip),%xmm2
  addsd  %xmm6,%xmm0
  cvtss2sd %xmm2,%xmm2
  subsd  %xmm2,%xmm0
  addsd  %xmm3,%xmm0
  pxor   %xmm3,%xmm3
  ucomiss %xmm3,%xmm5
  cvtsd2ss %xmm0,%xmm1
  jp     L59
  jne    L59
  lea    0x20(%rsp),%rsi
  movaps %xmm7,%xmm0
  mov    $0x1,%edi
  movss  %xmm4,(%rsp)
  call   <solve_quadratic_2@plt>
  test   %eax,%eax
  jne    L36
L64:
  mov    0x38(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L69
  add    $0x48,%rsp
  pop    %rbx
  pop    %rbp
  ret
  nopl   0x0(%rax)
L59:
  movaps %xmm7,%xmm0
  movss  D119(%rip),%xmm3
  movaps %xmm5,%xmm2
  movss  %xmm4,0xc(%rsp)
  mulss  %xmm7,%xmm0
  xorps  %xmm3,%xmm2
  lea    0x20(%rsp),%rsi
  movss  %xmm7,0x8(%rsp)
  mulss  D25(%rip),%xmm1
  movss  %xmm2,0x4(%rsp)
  mulss  %xmm2,%xmm5
  subss  %xmm1,%xmm0
  movaps %xmm7,%xmm1
  addss  %xmm7,%xmm1
  cvttss2si %xmm1,%edi
  movaps %xmm5,%xmm1
  call   <solve_cubic@plt>
  movss  0x20(%rsp),%xmm1
  movaps %xmm1,%xmm0
  movss  %xmm1,(%rsp)
  call   <sqrt@plt>
  movss  0x4(%rsp),%xmm2
  movss  (%rsp),%xmm1
  movabs $0xbf800000bf800000,%rax
  movss  0x8(%rsp),%xmm7
  lea    0x10(%rsp),%rsi
  mov    $0x1,%edi
  movss  %xmm0,(%rsp)
  divss  %xmm0,%xmm2
  mov    %rax,0x10(%rsp)
  addss  %xmm1,%xmm7
  mov    %rax,0x18(%rsp)
  movaps %xmm7,%xmm1
  movss  %xmm7,0x8(%rsp)
  addss  %xmm2,%xmm1
  mulss  D127(%rip),%xmm1
  movss  %xmm2,0x4(%rsp)
  call   <solve_quadratic_2@plt>
  movss  0x4(%rsp),%xmm2
  movss  0x8(%rsp),%xmm7
  movss  D119(%rip),%xmm3
  movss  D127(%rip),%xmm1
  movss  (%rsp),%xmm0
  lea    0x18(%rsp),%rsi
  mov    %eax,%ebp
  subss  %xmm2,%xmm7
  mov    $0x1,%edi
  xorps  %xmm3,%xmm0
  mulss  %xmm7,%xmm1
  call   <solve_quadratic_2@plt>
  movss  0xc(%rsp),%xmm4
  mulss  D90(%rip),%xmm4
  movss  0x10(%rsp),%xmm0
  mov    %eax,%r8d
  movslq %ebp,%rax
  subss  %xmm4,%xmm0
  movss  %xmm0,(%rbx)
  movss  0x14(%rsp),%xmm0
  subss  %xmm4,%xmm0
  movss  %xmm0,0x4(%rbx)
  movss  0x18(%rsp),%xmm0
  subss  %xmm4,%xmm0
  movss  %xmm0,(%rbx,%rax,4)
  movss  0x1c(%rsp),%xmm0
  subss  %xmm4,%xmm0
  movss  %xmm0,0x4(%rbx,%rax,4)
  lea    0x0(%rbp,%r8,1),%eax
  jmp    L64
  nopl   (%rax)
L36:
  xor    %edi,%edi
  cmp    $0x2,%eax
  sete   %dil
  call   <assert@plt>
  pxor   %xmm3,%xmm3
  xor    %eax,%eax
  movss  (%rsp),%xmm4
  movss  0x20(%rsp),%xmm0
  comiss %xmm3,%xmm0
  jb     L31
  call   <sqrt@plt>
  movss  (%rsp),%xmm4
  mov    $0x2,%eax
  movss  D90(%rip),%xmm1
  movaps %xmm0,%xmm2
  xorps  D119(%rip),%xmm0
  mulss  %xmm4,%xmm1
  subss  %xmm1,%xmm2
  subss  %xmm1,%xmm0
  movss  %xmm2,(%rbx)
  movss  %xmm0,0x4(%rbx)
L31:
  movss  0x24(%rsp),%xmm0
  pxor   %xmm3,%xmm3
  movss  %xmm4,(%rsp)
  comiss %xmm3,%xmm0
  jb     L64
  mov    %eax,0x4(%rsp)
  call   <sqrt@plt>
  movss  (%rsp),%xmm4
  movslq 0x4(%rsp),%rdx
  mulss  D90(%rip),%xmm4
  movaps %xmm0,%xmm1
  xorps  D119(%rip),%xmm0
  mov    %rdx,%rax
  add    $0x2,%eax
  subss  %xmm4,%xmm1
  subss  %xmm4,%xmm0
  movss  %xmm1,(%rbx,%rdx,4)
  movss  %xmm0,0x4(%rbx,%rdx,4)
  jmp    L64
L69:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: tag: D2
type: f32
name: parse_data
arguments: tag: D141
type: byte[4]
name: parse_data
arguments: tag: D127
type: byte[4]
name: parse_data
arguments: tag: D100
type: byte[4]
name: parse_data
arguments: tag: D139
type: f32[2]
name: parse_data
arguments: tag: D90
type: byte[4]
name: parse_data
arguments: tag: D119
type: byte[16]
name: parse_data
arguments: tag: D25
type: f32

tool: D2: 3

tool: {"D141": [0x00,0x00,0x00,0x3e]}

tool: {"D127": [0x00,0x00,0x00,0x3f]}

tool: {"D100": [0x00,0x00,0x80,0x3d]}

tool: {"D139": [0.0,-1.0625]}

tool: {"D90": [0x00,0x00,0x80,0x3e]}

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

tool: D25: 4

assistant: ```c
int solve_quartic_2(float p, float q, float r, float s, float t[4]) {
  float a = q - p * p * 3 / 8;
  float b = p * p * p / 8 - p * q / 2 + r;
  float c = p * p * p * p * (-3.0 / 256.0) + p * p * q / 16 - p * r / 4 + s;
  if (b == 0.0) {
    float z[2];
    int count = solve_quadratic_2(1, a, c, z);
    if (count == 0)
      return 0;
    assert(count == 2);
    int solutions = 0;
    if (z[0] >= 0) {
      float x1 = sqrt(z[0]);
      float x2 = -x1;
      t[0] = x1 - p / 4;
      t[1] = x2 - p / 4;
      solutions += 2;
    }
    if (z[1] >= 0) {
      float x1 = sqrt(z[1]);
      float x2 = -x1;
      t[solutions + 0] = x1 - p / 4;
      t[solutions + 1] = x2 - p / 4;
      solutions += 2;
    }
    return solutions;
  }
  float t3[4];
  solve_cubic(2 * a, a * a - 4 * c, -b * b, t3);
  float z = t3[0];
  float alpha = sqrt(z);
  float rho = -b / alpha;
  float beta = (a + z + rho) / 2;
  float delta = (a + z - rho) / 2;
  float t1[2] = {-1, -1}, t2[2] = {-1, -1};
  int n1 = solve_quadratic_2(1, alpha, beta, t1);
  int n2 = solve_quadratic_2(1, -alpha, delta, t2);
  t[0] = t1[0] - p / 4;
  t[1] = t1[1] - p / 4;
  t[n1 + 0] = t2[0] - p / 4;
  t[n1 + 1] = t2[1] - p / 4;
  return n1 + n2;
}
```