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

```asm
<rad_int_lambda>:
  endbr64
  push   %r15
  push   %r14
  mov    %edi,%r14d
  push   %r13
  mov    %edx,%r13d
  push   %r12
  mov    %esi,%r12d
  push   %rbp
  mov    %ecx,%ebp
  push   %rbx
  movslq %r8d,%rbx
  sub    $0x28,%rsp
  cmp    $0x6,%ebx
  jg     L57
L99:
  lea    (%rbx,%r12,1),%eax
  cmp    %ebp,%eax
  jl     L16
  mov    %r12d,%edx
  sub    %ebx,%edx
  mov    %edx,%eax
  neg    %eax
  cmovs  %edx,%eax
  cmp    %ebp,%eax
  jg     L16
L84:
  lea    (%r14,%r14,1),%r8d
  lea    0x0(%r13,%r13,1),%edi
  mov    %r8d,%eax
  mov    %edi,%ecx
  sub    %ebp,%eax
  sub    %r12d,%ecx
  add    %r12d,%eax
  add    %ebp,%ecx
  cmp    %ecx,%eax
  jle    L53
  sub    %ebx,%eax
  mov    %eax,%ecx
  mov    $0x0,%eax
  cmovs  %eax,%ecx
L51:
  lea    0x2(%rdi),%eax
  cmp    %edi,%r8d
  mov    %edi,%esi
  mov    %eax,0x8(%rsp)
  mov    %ebp,%eax
  cmovle %r8d,%esi
  lea    0x2(%r8),%edx
  sub    %r12d,%eax
  mov    %edx,0x14(%rsp)
  lea    0x2(%rbx,%rax,1),%r15d
  mov    %r12d,%eax
  sub    %ebp,%eax
  mov    %r15d,0x18(%rsp)
  lea    0x2(%rbx,%rax,1),%r9d
  mov    %r9d,0x1c(%rsp)
  cmp    %esi,%ecx
  jg     L83
  sub    %rcx,%rsi
  movslq %ecx,%r13
  lea    D68(%rip),%r14
  sub    %r8d,%r15d
  lea    (%r12,%rbp,1),%eax
  and    $0xfffffffe,%esi
  sub    %ecx,%edx
  movslq %r15d,%r10
  add    %r13,%rsi
  lea    0x3(%rbx,%rax,1),%r11d
  lea    (%r14,%r13,8),%rax
  movslq %edx,%r15
  lea    0x10(%r14),%r13
  sub    %edi,%r9d
  pxor   %xmm3,%xmm3
  movslq %r11d,%r11
  lea    0x0(%r13,%rsi,8),%r13
  mov    0x8(%rsp),%esi
  lea    (%r14,%r15,8),%rdx
  movslq %r9d,%r9
  movapd %xmm3,%xmm2
  sub    %ecx,%esi
  movslq %esi,%rsi
  sub    %r15,%rsi
  nopl   0x0(%rax,%rax,1)
L58:
  movsd  0x10(%rax),%xmm0
  mulsd  (%rdx),%xmm0
  mulsd  (%rdx,%rsi,8),%xmm0
  movsd  (%rax,%r11,8),%xmm1
  sub    $0x10,%rdx
  mulsd  (%rax,%r10,8),%xmm0
  mulsd  (%rax,%r9,8),%xmm0
  add    $0x10,%rax
  divsd  %xmm0,%xmm1
  addsd  %xmm1,%xmm2
  cmp    %rax,%r13
  jne    L58
L106:
  movslq 0x14(%rsp),%rdx
  movslq 0x8(%rsp),%rax
  movsd  (%r14,%rdx,8),%xmm0
  lea    0x3(%r8,%r12,2),%edx
  mulsd  (%r14,%rax,8),%xmm0
  lea    0x3(%rdi,%rbp,2),%eax
  movslq %edx,%rdx
  cltq
  movsd  (%r14,%rdx,8),%xmm1
  mulsd  (%r14,%rax,8),%xmm1
  divsd  %xmm1,%xmm0
  ucomisd %xmm0,%xmm3
  ja     L50
  sqrtsd %xmm0,%xmm0
L73:
  movslq 0x18(%rsp),%rax
  mulsd  (%r14,%rax,8),%xmm0
  movslq 0x1c(%rsp),%rax
  mulsd  (%r14,%rax,8),%xmm0
  lea    D66(%rip),%rax
  mulsd  (%rax,%rbx,8),%xmm0
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  mulsd  %xmm2,%xmm0
  ret
  nopl   0x0(%rax)
L16:
  lea    D51(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D2(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %r12d,%r9d
  mov    %r14d,%r8d
  mov    %ebx,%ecx
  mov    %ebp,%edx
  mov    %r13d,%esi
  lea    D5(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L84
  cs nopw 0x0(%rax,%rax,1)
L53:
  sub    %ebx,%ecx
  mov    $0x0,%eax
  cmovs  %eax,%ecx
  jmp    L51
  nop
L57:
  lea    D51(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %ebx,%esi
  lea    D37(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L99
  nopl   (%rax)
L83:
  pxor   %xmm3,%xmm3
  lea    D68(%rip),%r14
  movapd %xmm3,%xmm2
  jmp    L106
L50:
  movsd  %xmm2,0x8(%rsp)
  call   <sqrt@plt>
  movsd  0x8(%rsp),%xmm2
  jmp    L73
```

tool_calls: name: disassemble_data
arguments: label: D68
data_type: f64
name: disassemble_data
arguments: label: D66
data_type: f64
name: disassemble_data
arguments: label: D51
data_type: string
name: disassemble_data
arguments: label: D2
data_type: string
name: disassemble_data
arguments: label: D5
data_type: string
name: disassemble_data
arguments: label: D37
data_type: string

tool: D68: 0

tool: D66: 1

tool: D51: 

Error in function rad_int_lambda():

tool: D2:  Not allowed angular momentum relation

tool: D5: 
<n_2 = %d, l_2 = %d | r**%d | n_1 = %d, l_1 = %d >


tool: D37:   Not allowed lambda-value!!! lambda  = %d


assistant: ```c
double rad_int_lambda(int n_1, int l_1, int n_2, int l_2, int lambda) {
  register int nn_1, nn_2, sigma, low, high;
  double sum;
  static double factor[7] = {1.0, 3.16227766, 10.0, 31.62277660, 100.0, 316.22776602, 1000.0};
  static double fct[51] = {0.0, 5.60499122, 1.0, 2.80249561e-1, 1.0e-1, 4.20374341e-2, 2.0e-2, 1.05093585e-2, 6.0e-3, 3.67827549e-3, 2.40e-3, 1.65522397e-3, 1.20e-3, 9.10373183e-4, 7.2e-4, 5.91742569e-4, 5.04e-4, 4.43806927e-4, 4.032e-4, 3.77235888e-4, 3.6288e-4, 3.58374093e-4, 3.6288e-4, 3.76292798e-4, 3.99168e-4, 4.32736718e-4, 4.790016e-4, 5.40920897e-4, 6.2270208e-4, 7.30243211e-4, 8.71782912e-4, 1.05885266e-3, 1.30767437e-3, 1.64122162e-3, 2.09227899e-3, 2.70801567e-3, 3.55687428e-3, 4.73902742e-3, 6.40237371e-3, 8.76720072e-3, 1.21645100e-2, 1.70960414e-2, 2.43290201e-2, 3.50468849e-2, 5.10909422e-2, 7.53508025e-2, 1.12400073e-1, 1.69539306e-1, 2.58520167e-1, 3.98417368e-1, 6.20448402e-1};
  if (lambda > 6) {
    printf("\n\nError in function rad_int_lambda():");
    printf("  Not allowed lambda-value!!! lambda  = %d\n", lambda);
    exit(1);
  }
  if ((l_2 > (l_1 + lambda)) || (l_2 < abs(l_1 - lambda))) {
    printf("\n\nError in function rad_int_lambda():");
    printf(" Not allowed angular momentum relation");
    printf("\n<n_2 = %d, l_2 = %d | r**%d | n_1 = %d, l_1 = %d >\n", n_2, l_2, lambda, n_1, l_1);
    exit(1);
  }
  nn_1 = 2 * n_1;
  nn_2 = 2 * n_2;
  low = ((((((nn_1 - l_2 + l_1 - lambda) > (nn_2 - l_1 + l_2 - lambda)) ? (nn_1 - l_2 + l_1 - lambda) : (nn_2 - l_1 + l_2 - lambda))) > (0)) ? ((((nn_1 - l_2 + l_1 - lambda) > (nn_2 - l_1 + l_2 - lambda)) ? (nn_1 - l_2 + l_1 - lambda) : (nn_2 - l_1 + l_2 - lambda))) : (0));
  high = (((nn_1) < (nn_2)) ? (nn_1) : (nn_2));
  for (sum = 0.0, sigma = low; sigma <= high; sigma += 2) {
    sum += fct[l_1 + l_2 + lambda + 3 + sigma] / (fct[2 + sigma] * fct[nn_1 + 2 - sigma] * fct[nn_2 + 2 - sigma] * fct[l_2 - l_1 + lambda + 2 - nn_1 + sigma] * fct[l_1 - l_2 + lambda + 2 - nn_2 + sigma]);
  }
  sum *= sqrt((fct[nn_1 + 2] * fct[nn_2 + 2]) / (fct[nn_1 + 3 + 2 * l_1] * fct[nn_2 + 3 + 2 * l_2])) * fct[l_2 - l_1 + lambda + 2] * fct[l_1 - l_2 + lambda + 2] * factor[lambda];
  return sum;
}
```