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

```asm
<rad_int_lambda>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  push   %r14
  push   %r13
  push   %r12
  push   %rbx
  sub    $0x30,%rsp
  mov    %edi,-0x34(%rbp)
  mov    %esi,-0x38(%rbp)
  mov    %edx,-0x3c(%rbp)
  mov    %ecx,-0x40(%rbp)
  mov    %r8d,-0x44(%rbp)
  cmpl   $0x6,-0x44(%rbp)
  jle    L19
  lea    D2(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x44(%rbp),%eax
  mov    %eax,%esi
  lea    D109(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
L19:
  mov    -0x38(%rbp),%edx
  mov    -0x44(%rbp),%eax
  add    %edx,%eax
  cmp    %eax,-0x40(%rbp)
  jg     L44
  mov    -0x38(%rbp),%eax
  sub    -0x44(%rbp),%eax
  mov    %eax,%edx
  neg    %edx
  cmovns %edx,%eax
  cmp    %eax,-0x40(%rbp)
  jge    L71
L44:
  lea    D2(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D77(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x38(%rbp),%edi
  mov    -0x34(%rbp),%esi
  mov    -0x44(%rbp),%ecx
  mov    -0x40(%rbp),%edx
  mov    -0x3c(%rbp),%eax
  mov    %edi,%r9d
  mov    %esi,%r8d
  mov    %eax,%esi
  lea    D65(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
L71:
  mov    -0x34(%rbp),%eax
  lea    (%rax,%rax,1),%r12d
  mov    -0x3c(%rbp),%eax
  lea    (%rax,%rax,1),%ebx
  mov    %r12d,%edx
  sub    -0x40(%rbp),%edx
  mov    -0x38(%rbp),%eax
  add    %eax,%edx
  mov    %ebx,%ecx
  sub    -0x38(%rbp),%ecx
  mov    -0x40(%rbp),%eax
  add    %ecx,%eax
  cmp    %eax,%edx
  jle    L21
  mov    %r12d,%edx
  sub    -0x40(%rbp),%edx
  mov    -0x38(%rbp),%eax
  add    %edx,%eax
  sub    -0x44(%rbp),%eax
  test   %eax,%eax
  setg   %al
  jmp    L101
L21:
  mov    %ebx,%edx
  sub    -0x38(%rbp),%edx
  mov    -0x40(%rbp),%eax
  add    %edx,%eax
  sub    -0x44(%rbp),%eax
  test   %eax,%eax
  setg   %al
L101:
  test   %al,%al
  je     L38
  mov    %r12d,%edx
  sub    -0x40(%rbp),%edx
  mov    -0x38(%rbp),%eax
  add    %eax,%edx
  mov    %ebx,%ecx
  sub    -0x38(%rbp),%ecx
  mov    -0x40(%rbp),%eax
  add    %ecx,%eax
  cmp    %eax,%edx
  jle    L82
  mov    %r12d,%edx
  sub    -0x40(%rbp),%edx
  mov    -0x38(%rbp),%eax
  add    %edx,%eax
  sub    -0x44(%rbp),%eax
  jmp    L83
L82:
  mov    %ebx,%edx
  sub    -0x38(%rbp),%edx
  mov    -0x40(%rbp),%eax
  add    %edx,%eax
  sub    -0x44(%rbp),%eax
  jmp    L83
L38:
  mov    $0x0,%eax
L83:
  mov    %eax,%r13d
  cmp    %r12d,%ebx
  mov    %r12d,%r14d
  cmovle %ebx,%r14d
  pxor   %xmm0,%xmm0
  movsd  %xmm0,-0x28(%rbp)
  jmp    L43
L15:
  mov    -0x38(%rbp),%edx
  mov    -0x40(%rbp),%eax
  add    %eax,%edx
  mov    -0x44(%rbp),%eax
  add    %edx,%eax
  add    $0x3,%eax
  add    %r13d,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm0
  lea    0x2(%r13),%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm2
  lea    0x2(%r12),%eax
  sub    %r13d,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm1
  mulsd  %xmm1,%xmm2
  lea    0x2(%rbx),%eax
  sub    %r13d,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm1
  mulsd  %xmm1,%xmm2
  mov    -0x40(%rbp),%eax
  sub    -0x38(%rbp),%eax
  mov    %eax,%edx
  mov    -0x44(%rbp),%eax
  add    %edx,%eax
  add    $0x2,%eax
  sub    %r12d,%eax
  add    %r13d,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm1
  mulsd  %xmm1,%xmm2
  mov    -0x38(%rbp),%eax
  sub    -0x40(%rbp),%eax
  mov    %eax,%edx
  mov    -0x44(%rbp),%eax
  add    %edx,%eax
  add    $0x2,%eax
  sub    %ebx,%eax
  add    %r13d,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm1
  mulsd  %xmm2,%xmm1
  divsd  %xmm1,%xmm0
  movsd  -0x28(%rbp),%xmm1
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x28(%rbp)
  add    $0x2,%r13d
L43:
  cmp    %r14d,%r13d
  jle    L15
  lea    0x2(%r12),%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm1
  lea    0x2(%rbx),%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm0
  mulsd  %xmm1,%xmm0
  lea    0x3(%r12),%edx
  mov    -0x38(%rbp),%eax
  add    %eax,%eax
  add    %edx,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm2
  lea    0x3(%rbx),%edx
  mov    -0x40(%rbp),%eax
  add    %eax,%eax
  add    %edx,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm1
  mulsd  %xmm2,%xmm1
  divsd  %xmm1,%xmm0
  movq   %xmm0,%rax
  movq   %rax,%xmm0
  call   <sqrt@plt>
  mov    -0x40(%rbp),%eax
  sub    -0x38(%rbp),%eax
  mov    %eax,%edx
  mov    -0x44(%rbp),%eax
  add    %edx,%eax
  add    $0x2,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm1
  mulsd  %xmm0,%xmm1
  mov    -0x38(%rbp),%eax
  sub    -0x40(%rbp),%eax
  mov    %eax,%edx
  mov    -0x44(%rbp),%eax
  add    %edx,%eax
  add    $0x2,%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D149(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm0
  mulsd  %xmm0,%xmm1
  mov    -0x44(%rbp),%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  lea    D15(%rip),%rax
  movsd  (%rdx,%rax,1),%xmm0
  mulsd  %xmm1,%xmm0
  movsd  -0x28(%rbp),%xmm1
  mulsd  %xmm1,%xmm0
  movsd  %xmm0,-0x28(%rbp)
  movsd  -0x28(%rbp),%xmm0
  movq   %xmm0,%rax
  movq   %rax,%xmm0
  add    $0x30,%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %rbp
  ret
```

tool_calls: name: disassemble_data
arguments: data_tag: D2
type_guessed: string
name: disassemble_data
arguments: data_tag: D109
type_guessed: string
name: disassemble_data
arguments: data_tag: D77
type_guessed: string
name: disassemble_data
arguments: data_tag: D65
type_guessed: string

tool: D2: 

Error in function rad_int_lambda():

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


tool: D77:  Not allowed angular momentum relation

tool: D65: 
<n_2 = %d, l_2 = %d | r**%d | n_1 = %d, l_1 = %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;
}
```