user: Please show me the C implementation that matches the assembly code listed below:

```asm
<adaptiveSimpsonsAux>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0xb0,%rsp
  mov    %rdi,-0x58(%rbp)
  mov    %rsi,-0x60(%rbp)
  movsd  %xmm0,-0x68(%rbp)
  movsd  %xmm1,-0x70(%rbp)
  movsd  %xmm2,-0x78(%rbp)
  movsd  %xmm3,-0x80(%rbp)
  movsd  %xmm4,-0x88(%rbp)
  movsd  %xmm5,-0x90(%rbp)
  movsd  %xmm6,-0x98(%rbp)
  mov    %edx,-0x9c(%rbp)
  movsd  -0x68(%rbp),%xmm0
  addsd  -0x70(%rbp),%xmm0
  movsd  D27(%rip),%xmm1
  divsd  %xmm1,%xmm0
  movsd  %xmm0,-0x48(%rbp)
  movsd  -0x70(%rbp),%xmm0
  subsd  -0x68(%rbp),%xmm0
  movsd  %xmm0,-0x40(%rbp)
  movsd  -0x68(%rbp),%xmm0
  addsd  -0x48(%rbp),%xmm0
  movsd  D27(%rip),%xmm1
  divsd  %xmm1,%xmm0
  movsd  %xmm0,-0x38(%rbp)
  movsd  -0x48(%rbp),%xmm0
  addsd  -0x70(%rbp),%xmm0
  movsd  D27(%rip),%xmm1
  divsd  %xmm1,%xmm0
  movsd  %xmm0,-0x30(%rbp)
  mov    -0x60(%rbp),%rdx
  mov    -0x38(%rbp),%rax
  mov    -0x58(%rbp),%rcx
  mov    %rdx,%rdi
  movq   %rax,%xmm0
  call   *%rcx
  movq   %xmm0,%rax
  mov    %rax,-0x28(%rbp)
  mov    -0x60(%rbp),%rdx
  mov    -0x30(%rbp),%rax
  mov    -0x58(%rbp),%rcx
  mov    %rdx,%rdi
  movq   %rax,%xmm0
  call   *%rcx
  movq   %xmm0,%rax
  mov    %rax,-0x20(%rbp)
  movsd  -0x40(%rbp),%xmm0
  movsd  D50(%rip),%xmm2
  movapd %xmm0,%xmm1
  divsd  %xmm2,%xmm1
  movsd  -0x28(%rbp),%xmm2
  movsd  D40(%rip),%xmm0
  mulsd  %xmm2,%xmm0
  addsd  -0x88(%rbp),%xmm0
  addsd  -0x98(%rbp),%xmm0
  mulsd  %xmm1,%xmm0
  movsd  %xmm0,-0x18(%rbp)
  movsd  -0x40(%rbp),%xmm0
  movsd  D50(%rip),%xmm2
  movapd %xmm0,%xmm1
  divsd  %xmm2,%xmm1
  movsd  -0x20(%rbp),%xmm2
  movsd  D40(%rip),%xmm0
  mulsd  %xmm2,%xmm0
  addsd  -0x98(%rbp),%xmm0
  addsd  -0x90(%rbp),%xmm0
  mulsd  %xmm1,%xmm0
  movsd  %xmm0,-0x10(%rbp)
  movsd  -0x18(%rbp),%xmm0
  addsd  -0x10(%rbp),%xmm0
  movsd  %xmm0,-0x8(%rbp)
  cmpl   $0x0,-0x9c(%rbp)
  jle    L24
  movsd  -0x8(%rbp),%xmm0
  subsd  -0x80(%rbp),%xmm0
  movq   %xmm0,%rax
  movq   %rax,%xmm0
  call   <fabs@plt>
  pxor   %xmm1,%xmm1
  cvtsi2sd %eax,%xmm1
  movsd  -0x78(%rbp),%xmm2
  movsd  D20(%rip),%xmm0
  mulsd  %xmm2,%xmm0
  comisd %xmm1,%xmm0
  jb     L15
L24:
  movsd  -0x8(%rbp),%xmm0
  subsd  -0x80(%rbp),%xmm0
  movsd  D20(%rip),%xmm1
  divsd  %xmm1,%xmm0
  addsd  -0x8(%rbp),%xmm0
  jmp    L4
L15:
  mov    -0x9c(%rbp),%eax
  lea    -0x1(%rax),%edx
  movsd  -0x78(%rbp),%xmm0
  movsd  D27(%rip),%xmm1
  movapd %xmm0,%xmm2
  divsd  %xmm1,%xmm2
  movsd  -0x28(%rbp),%xmm5
  movsd  -0x98(%rbp),%xmm4
  movsd  -0x88(%rbp),%xmm3
  movsd  -0x18(%rbp),%xmm1
  movsd  -0x48(%rbp),%xmm0
  mov    -0x68(%rbp),%rsi
  mov    -0x60(%rbp),%rcx
  mov    -0x58(%rbp),%rax
  movapd %xmm5,%xmm6
  movapd %xmm4,%xmm5
  movapd %xmm3,%xmm4
  movapd %xmm1,%xmm3
  movapd %xmm0,%xmm1
  movq   %rsi,%xmm0
  mov    %rcx,%rsi
  mov    %rax,%rdi
  call   <adaptiveSimpsonsAux>
  movsd  %xmm0,-0xa8(%rbp)
  mov    -0x9c(%rbp),%eax
  lea    -0x1(%rax),%edx
  movsd  -0x78(%rbp),%xmm0
  movsd  D27(%rip),%xmm1
  movapd %xmm0,%xmm2
  divsd  %xmm1,%xmm2
  movsd  -0x20(%rbp),%xmm5
  movsd  -0x90(%rbp),%xmm4
  movsd  -0x98(%rbp),%xmm3
  movsd  -0x10(%rbp),%xmm1
  movsd  -0x70(%rbp),%xmm0
  mov    -0x48(%rbp),%rsi
  mov    -0x60(%rbp),%rcx
  mov    -0x58(%rbp),%rax
  movapd %xmm5,%xmm6
  movapd %xmm4,%xmm5
  movapd %xmm3,%xmm4
  movapd %xmm1,%xmm3
  movapd %xmm0,%xmm1
  movq   %rsi,%xmm0
  mov    %rcx,%rsi
  mov    %rax,%rdi
  call   <adaptiveSimpsonsAux>
  addsd  -0xa8(%rbp),%xmm0
L4:
  movq   %xmm0,%rax
  movq   %rax,%xmm0
  leave
  ret
```

tool_calls: name: parse_data
arguments: tag: D27
type_guessed: f64
name: parse_data
arguments: tag: D50
type_guessed: f64
name: parse_data
arguments: tag: D40
type_guessed: f64
name: parse_data
arguments: tag: D20
type_guessed: byte[8]

tool: D27: 2

tool: D50: 12

tool: D40: 4

tool: {"D20": [0x00,0x00,0x00,0x00,0x00,0x00,0x2e,0x40]}

assistant: ```c
double adaptiveSimpsonsAux(double (*f)(double, void *), void *extra_data, double a, double b, double epsilon, double S, double fa, double fb, double fc, int bottom) {
  double c = (a + b) / 2, h = b - a;
  double d = (a + c) / 2, e = (c + b) / 2;
  double fd = f(d, extra_data), fe = f(e, extra_data);
  double Sleft = (h / 12) * (fa + 4 * fd + fc);
  double Sright = (h / 12) * (fc + 4 * fe + fb);
  double S2 = Sleft + Sright;
  if (bottom <= 0 || fabs(S2 - S) <= 15 * epsilon)
    return S2 + (S2 - S) / 15;
  return adaptiveSimpsonsAux(f, extra_data, a, c, epsilon / 2, Sleft, fa, fc, fd, bottom - 1) + adaptiveSimpsonsAux(f, extra_data, c, b, epsilon / 2, Sright, fc, fb, fe, bottom - 1);
}
```