user: 下面的汇编指令对应的C源代码是什么：

```asm
<rad_int_lambda>:
  endbr64
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x10,%rsp
  mov    %edi,%r14d
  mov    %esi,%ebp
  mov    %edx,%r13d
  mov    %ecx,%r12d
  mov    %r8d,%ebx
  cmp    $0x6,%r8d
  jg     L64
L60:
  lea    (%rbx,%rbp,1),%eax
  cmp    %r12d,%eax
  jl     L90
  mov    %ebp,%edx
  sub    %ebx,%edx
  mov    %edx,%eax
  neg    %eax
  cmovs  %edx,%eax
  cmp    %r12d,%eax
  jle    L66
L90:
  lea    D8(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D56(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %ebp,%r9d
  mov    %r14d,%r8d
  mov    %ebx,%ecx
  mov    %r12d,%edx
  mov    %r13d,%esi
  lea    D59(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
L66:
  lea    (%r14,%r14,1),%r8d
  lea    0x0(%r13,%r13,1),%edi
  mov    %r8d,%esi
  sub    %r12d,%esi
  add    %ebp,%esi
  mov    %edi,%eax
  sub    %ebp,%eax
  add    %r12d,%eax
  cmp    %eax,%esi
  jle    L13
  sub    %ebx,%esi
  mov    $0x0,%eax
  cmovs  %eax,%esi
L0:
  cmp    %edi,%r8d
  mov    %edi,%ecx
  cmovle %r8d,%ecx
  cmp    %ecx,%esi
  jg     L56
  movslq %esi,%r9
  lea    D66(%rip),%rdx
  lea    (%rdx,%r9,8),%rax
  lea    0x2(%r8),%r11d
  sub    %esi,%r11d
  movslq %r11d,%r11
  lea    (%rdx,%r11,8),%rdx
  sub    %esi,%ecx
  shr    %ecx
  mov    %ecx,%ecx
  lea    (%r9,%rcx,2),%r9
  lea    D28(%rip),%rcx
  lea    (%rcx,%r9,8),%r10
  pxor   %xmm4,%xmm4
  movsd  %xmm4,0x8(%rsp)
  lea    0x0(%rbp,%r12,1),%ecx
  lea    0x3(%rbx,%rcx,1),%r9d
  movslq %r9d,%r9
  lea    0x2(%rdi),%ecx
  sub    %esi,%ecx
  movslq %ecx,%rcx
  sub    %r11,%rcx
  mov    %r12d,%esi
  sub    %ebp,%esi
  lea    0x2(%rbx,%rsi,1),%r11d
  sub    %r8d,%r11d
  movslq %r11d,%r11
  mov    %ebp,%esi
  sub    %r12d,%esi
  lea    0x2(%rbx,%rsi,1),%esi
  sub    %edi,%esi
  movslq %esi,%rsi
L57:
  movsd  0x10(%rax),%xmm0
  mulsd  (%rdx),%xmm0
  mulsd  (%rdx,%rcx,8),%xmm0
  mulsd  (%rax,%r11,8),%xmm0
  mulsd  (%rax,%rsi,8),%xmm0
  movsd  (%rax,%r9,8),%xmm1
  divsd  %xmm0,%xmm1
  addsd  0x8(%rsp),%xmm1
  movsd  %xmm1,0x8(%rsp)
  add    $0x10,%rax
  sub    $0x10,%rdx
  cmp    %r10,%rax
  jne    L57
L68:
  lea    D66(%rip),%rax
  lea    0x2(%r8),%ecx
  movslq %ecx,%rcx
  lea    0x2(%rdi),%edx
  movslq %edx,%rdx
  movsd  (%rax,%rcx,8),%xmm0
  mulsd  (%rax,%rdx,8),%xmm0
  lea    0x3(%r8,%rbp,2),%ecx
  movslq %ecx,%rcx
  lea    0x3(%rdi,%r12,2),%edx
  movslq %edx,%rdx
  movsd  (%rax,%rcx,8),%xmm1
  mulsd  (%rax,%rdx,8),%xmm1
  divsd  %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  ucomisd %xmm0,%xmm1
  ja     L9
  sqrtsd %xmm0,%xmm0
L27:
  lea    D66(%rip),%rdx
  mov    %r12d,%eax
  sub    %ebp,%eax
  lea    0x2(%rbx,%rax,1),%eax
  cltq
  mulsd  (%rdx,%rax,8),%xmm0
  sub    %r12d,%ebp
  lea    0x2(%rbx,%rbp,1),%eax
  cltq
  mulsd  (%rdx,%rax,8),%xmm0
  movslq %ebx,%rbx
  lea    D98(%rip),%rax
  mulsd  (%rax,%rbx,8),%xmm0
  mulsd  0x8(%rsp),%xmm0
  add    $0x10,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
L64:
  lea    D8(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %ebx,%esi
  lea    D4(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L60
L13:
  mov    %eax,%esi
  sub    %ebx,%esi
  cmp    %ebx,%eax
  mov    $0x0,%eax
  cmovle %eax,%esi
  jmp    L0
L56:
  pxor   %xmm5,%xmm5
  movsd  %xmm5,0x8(%rsp)
  jmp    L68
L9:
  call   <sqrt@plt>
  jmp    L27
```

tool_calls: name: extract_symbolic_data
arguments: data_tag: D8
data_type: string
name: extract_symbolic_data
arguments: data_tag: D56
data_type: string
name: extract_symbolic_data
arguments: data_tag: D59
data_type: string
name: extract_symbolic_data
arguments: data_tag: D66
data_type: f64
name: extract_symbolic_data
arguments: data_tag: D28
data_type: f64
name: extract_symbolic_data
arguments: data_tag: D98
data_type: f64
name: extract_symbolic_data
arguments: data_tag: D4
data_type: string

tool: D8: 

Error in function rad_int_lambda():

tool: D56:  Not allowed angular momentum relation

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


tool: D66: 0

tool: D28: 1

tool: D98: 1

tool: D4:   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;
}
```