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

```asm
<groundwaterTransportCoefficientsEvaluate>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x68,%rsp
  mov    %edi,%eax
  movsd  %xmm0,0x28(%rsp)
  movsd  %xmm1,0x40(%rsp)
  movsd  %xmm2,0x50(%rsp)
  movsd  %xmm3,0x58(%rsp)
  mov    0xa0(%rsp),%r13
  mov    0xa8(%rsp),%r14
  mov    %esi,%edi
  imul   %esi,%edi
  mov    %edi,0x34(%rsp)
  test   %eax,%eax
  jle    L62
  mov    %esi,%ebx
  mov    %rdx,%r12
  mov    %rcx,0x8(%rsp)
  mov    %r8,0x18(%rsp)
  mov    %r9,0x20(%rsp)
  lea    -0x1(%rax),%eax
  lea    0x8(%rcx,%rax,8),%rax
  mov    %rax,0x38(%rsp)
  movslq %esi,%rax
  mov    %rax,0x48(%rsp)
  lea    0x8(,%rax,8),%rdi
  mov    %rdi,(%rsp)
  lea    0x0(,%rax,8),%rbp
  neg    %rax
  mov    %rax,%r15
  shl    $0x3,%r15
  movl   $0x0,0x30(%rsp)
  movl   $0x0,0x14(%rsp)
  jmp    L18
L22:
  pxor   %xmm1,%xmm1
  jmp    L17
L7:
  movapd %xmm1,%xmm0
  call   <sqrt@plt>
  movapd %xmm0,%xmm1
  comisd D12(%rip),%xmm0
  ja     L60
L78:
  test   %ebx,%ebx
  jle    L102
  movsd  0x28(%rsp),%xmm0
  mulsd  0x40(%rsp),%xmm0
  movslq 0x30(%rsp),%rax
  mov    0xb0(%rsp),%rdi
  lea    (%rdi,%rax,8),%rdx
  mov    $0x0,%eax
L98:
  movsd  %xmm0,(%rdx)
  add    $0x1,%eax
  add    (%rsp),%rdx
  cmp    %eax,%ebx
  jne    L98
L102:
  addq   $0x8,0x8(%rsp)
  mov    0x8(%rsp),%rax
  addq   $0x8,0x18(%rsp)
  addq   $0x8,0x20(%rsp)
  add    %ebx,0x14(%rsp)
  mov    0x34(%rsp),%edi
  add    %edi,0x30(%rsp)
  cmp    0x38(%rsp),%rax
  je     L62
L18:
  mov    0x8(%rsp),%rax
  mov    %rax,%rcx
  movsd  0x28(%rsp),%xmm5
  movapd %xmm5,%xmm0
  mulsd  (%rax),%xmm0
  mov    0x18(%rsp),%rax
  movsd  %xmm0,(%rax)
  mov    0x20(%rsp),%rax
  movsd  %xmm5,(%rax)
  test   %ebx,%ebx
  jle    L22
  movslq 0x14(%rsp),%rsi
  lea    0x0(,%rsi,8),%rax
  mov    %ebx,%edx
  add    %rsi,%rdx
  shl    $0x3,%rdx
  pxor   %xmm1,%xmm1
L143:
  movsd  (%r12,%rax,1),%xmm0
  mulsd  (%rcx),%xmm0
  movsd  %xmm0,0x0(%r13,%rax,1)
  movsd  (%r12,%rax,1),%xmm0
  movsd  %xmm0,(%r14,%rax,1)
  mulsd  %xmm0,%xmm0
  addsd  %xmm0,%xmm1
  add    $0x8,%rax
  cmp    %rdx,%rax
  jne    L143
  pxor   %xmm7,%xmm7
  ucomisd %xmm1,%xmm7
  ja     L7
L17:
  sqrtsd %xmm1,%xmm1
  comisd D12(%rip),%xmm1
  jbe    L78
  test   %ebx,%ebx
  jle    L102
L60:
  movsd  0x58(%rsp),%xmm6
  movapd %xmm6,%xmm0
  mulsd  %xmm1,%xmm0
  movsd  0x28(%rsp),%xmm4
  mulsd  0x40(%rsp),%xmm4
  addsd  %xmm0,%xmm4
  movslq 0x14(%rsp),%rax
  lea    (%r12,%rax,8),%rdi
  mov    %rdi,%r8
  movslq 0x30(%rsp),%rax
  mov    0x48(%rsp),%rsi
  lea    (%rax,%rsi,1),%rdx
  mov    0xb0(%rsp),%rsi
  lea    (%rsi,%rdx,8),%r10
  lea    (%rsi,%rax,8),%rcx
  mov    %ebx,%r11d
  mov    $0x1,%r9d
  movsd  0x50(%rsp),%xmm2
  subsd  %xmm6,%xmm2
L34:
  mov    %r8,%rsi
  movsd  (%r8),%xmm3
  movapd %xmm2,%xmm0
  mulsd  %xmm3,%xmm0
  mulsd  %xmm3,%xmm0
  divsd  %xmm1,%xmm0
  addsd  %xmm4,%xmm0
  movsd  %xmm0,(%r10,%r15,1)
  cmp    %r11,%r9
  je     L102
  mov    %r10,%rdx
  mov    %r9,%rax
L55:
  movapd %xmm2,%xmm0
  mulsd  (%rsi),%xmm0
  mulsd  (%rdi,%rax,8),%xmm0
  divsd  %xmm1,%xmm0
  movsd  %xmm0,(%rcx,%rax,8)
  movsd  %xmm0,(%rdx)
  add    $0x1,%rax
  add    %rbp,%rdx
  cmp    %eax,%ebx
  jg     L55
  add    $0x1,%r9
  add    $0x8,%r8
  add    (%rsp),%r10
  add    %rbp,%rcx
  jmp    L34
L62:
  add    $0x68,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

tool_calls: name: disassemble_data
arguments: data_label: D12
type: f64

tool: D12: 0

assistant: ```c
void groundwaterTransportCoefficientsEvaluate(const int nPoints, const int nSpace, const double omega, const double d, const double alpha_L, const double alpha_T, const double *v, const double *u, double *m, double *dm, double *f, double *df, double *a) {
  int k, I, J;
  const int nSpace2 = nSpace * nSpace;
  double norm_v;
  for (k = 0; k < nPoints; k++) {
    m[k] = omega * u[k];
    dm[k] = omega;
    norm_v = 0.0;
    for (I = 0; I < nSpace; I++) {
      f[k * nSpace + I] = v[k * nSpace + I] * u[k];
      df[k * nSpace + I] = v[k * nSpace + I];
      norm_v += v[k * nSpace + I] * v[k * nSpace + I];
    }
    norm_v = sqrt(norm_v);
    if (norm_v > 0.0) {
      for (I = 0; I < nSpace; I++) {
        a[k * nSpace2 + I * nSpace + I] = omega * d + alpha_T * norm_v + (alpha_L - alpha_T) * v[k * nSpace + I] * v[k * nSpace + I] / norm_v;
        for (J = I + 1; J < nSpace; J++) {
          a[k * nSpace2 + I * nSpace + J] = (alpha_L - alpha_T) * v[k * nSpace + I] * v[k * nSpace + J] / norm_v;
          a[k * nSpace2 + J * nSpace + I] = a[k * nSpace2 + I * nSpace + J];
        }
      }
    } else
      for (I = 0; I < nSpace; I++)
        a[k * nSpace2 + I * nSpace + I] = omega * d;
  }
}
```