user: 请显示与下面列出的汇编代码相匹配的C语言实现:

```asm
<hessian_edmiston>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  mov    %rdx,%rbp
  lea    -0x1(%rdi),%edx
  push   %rbx
  imul   %edi,%edx
  mov    %rcx,-0x10(%rsp)
  mov    %edx,%ecx
  shr    $0x1f,%ecx
  add    %edx,%ecx
  sar    %ecx
  mov    %ecx,-0x4(%rsp)
  cmp    $0x1,%edx
  jle    L48
  mov    %edi,%r8d
  lea    0x1(%rdi),%edx
  lea    -0x1(%rcx),%ebx
  mov    %edi,%eax
  imul   %edi,%r8d
  mov    %ebx,-0x8(%rsp)
  pxor   %xmm4,%xmm4
  mov    %rsi,%r14
  imul   %edi,%edx
  movl   $0x0,-0x20(%rsp)
  movq   D9(%rip),%xmm3
  movq   $0x0,-0x18(%rsp)
  movsd  D15(%rip),%xmm2
  imul   %edi,%r8d
  movslq %edx,%rdx
  lea    0x8(,%rdx,8),%r9
  movslq %r8d,%r8
  shl    $0x3,%r8
  cs nopw 0x0(%rax,%rax,1)
L26:
  mov    -0x8(%rsp),%esi
  mov    $0x2,%ecx
  test   %esi,%esi
  jle    L35
  nopl   (%rax)
L127:
  mov    %ecx,%edx
  add    $0x1,%ecx
  imul   %ecx,%edx
  sar    %edx
  cmp    %esi,%edx
  jle    L127
L35:
  mov    %eax,%ebx
  mov    %eax,%r10d
  sub    %ecx,%ebx
  lea    0x1(%rbx),%esi
  lea    0x2(%rbx),%edx
  imul   %esi,%edx
  imul   %ebx,%r10d
  mov    %edx,%edi
  shr    $0x1f,%edi
  mov    %r10d,-0x1c(%rsp)
  add    %edx,%edi
  mov    -0x20(%rsp),%edx
  sar    %edi
  sub    %r10d,%edx
  add    %edx,%edi
  cmp    %eax,%esi
  jge    L59
  mov    %eax,%edx
  movslq %esi,%rcx
  add    %eax,%r10d
  movslq %ebx,%r11
  imul   %edi,%edx
  movapd %xmm4,%xmm1
  add    %esi,%edx
  imul   %eax,%edx
  add    %esi,%edx
  imul   %eax,%edx
  movslq %edx,%rdx
  add    %rcx,%rdx
  lea    (%r14,%rdx,8),%rsi
  lea    (%rbx,%r10,1),%edx
  add    %edi,%r10d
  imul   %eax,%edx
  imul   %eax,%r10d
  add    %edi,%edx
  imul   %eax,%edx
  movslq %edx,%rdx
  add    %r11,%rdx
  lea    (%r14,%rdx,8),%r13
  lea    (%rbx,%r10,1),%edx
  add    %edi,%r10d
  imul   %eax,%edx
  imul   %eax,%r10d
  movslq %edx,%rdx
  add    %r11,%rdx
  movslq %r10d,%r10
  lea    (%r14,%rdx,8),%r12
  movslq %edi,%rdx
  add    %rdx,%r10
  neg    %rdx
  lea    (%r14,%r10,8),%r11
  mov    -0x18(%rsp),%r10
  lea    (%r10,%rdx,8),%r10
  xor    %edx,%edx
  add    %rbp,%r10
  nopw   0x0(%rax,%rax,1)
L66:
  movsd  0x0(%r13,%rdx,1),%xmm0
  movsd  (%r12,%rdx,1),%xmm5
  mulsd  %xmm2,%xmm0
  addsd  %xmm5,%xmm5
  addsd  %xmm5,%xmm0
  subsd  (%r11,%rdx,1),%xmm0
  add    %r8,%rdx
  subsd  (%rsi),%xmm0
  add    %r9,%rsi
  addsd  %xmm0,%xmm0
  mulsd  (%r10,%rcx,8),%xmm0
  add    $0x1,%rcx
  addsd  %xmm0,%xmm1
  cmp    %ecx,%eax
  jg     L66
L80:
  test   %edi,%edi
  jle    L30
  mov    -0x1c(%rsp),%r15d
  mov    %eax,%edx
  movslq %edi,%rcx
  imul   %edi,%edx
  mov    %r15d,%r10d
  lea    (%r15,%rbx,1),%r12d
  lea    (%r15,%rdi,1),%r13d
  movslq %ebx,%r15
  imul   %eax,%r10d
  imul   %eax,%r12d
  add    %ebx,%edx
  imul   %eax,%edx
  imul   %eax,%r10d
  imul   %eax,%r13d
  movslq %r12d,%r12
  movslq %edx,%rdx
  add    %r15,%r12
  lea    (%rcx,%rdx,1),%rsi
  movslq %r10d,%r10
  sub    %rcx,%r12
  xor    %ecx,%ecx
  movslq %r13d,%r13
  lea    (%r14,%r10,8),%r11
  lea    (%r14,%rsi,8),%rsi
  mov    %edi,%r10d
  sub    %rdx,%r13
  sub    %rdx,%r12
L18:
  mov    %ecx,%edx
  movsd  (%rsi),%xmm0
  add    $0x1,%ecx
  movsd  (%rsi,%r13,8),%xmm5
  add    $0x2,%edx
  imul   %ecx,%edx
  mulsd  %xmm2,%xmm0
  addsd  %xmm5,%xmm5
  mov    %edx,%r15d
  shr    $0x1f,%r15d
  add    %r15d,%edx
  addsd  %xmm5,%xmm0
  subsd  (%rsi,%r12,8),%xmm0
  mov    %r10d,%r15d
  subsd  (%r11),%xmm0
  sar    %edx
  add    %r8,%rsi
  add    %r9,%r11
  sub    %edx,%r15d
  add    %eax,%r10d
  movslq %r15d,%r15
  addsd  %xmm0,%xmm0
  mulsd  0x0(%rbp,%r15,8),%xmm0
  addsd  %xmm0,%xmm1
  cmp    %edi,%ecx
  jne    L18
L30:
  lea    0x1(%rdi),%r13d
  cmp    %r13d,%eax
  jle    L51
  mov    %eax,%r12d
  movslq %edi,%r15
  mov    -0x1c(%rsp),%ecx
  movslq %r13d,%rdx
  imul   %edi,%r12d
  add    %r13d,%ecx
  imul   %eax,%ecx
  lea    (%r12,%rax,1),%esi
  movslq %r12d,%r12
  lea    (%rdi,%rsi,1),%r10d
  add    %ebx,%esi
  imul   %eax,%r10d
  add    %r13d,%ecx
  imul   %eax,%esi
  imul   %eax,%ecx
  add    %ebx,%r10d
  imul   %eax,%r10d
  movslq %ecx,%rcx
  add    %rdx,%rcx
  movslq %r10d,%r10
  lea    (%r14,%rcx,8),%rcx
  add    %r15,%r10
  lea    (%r14,%r10,8),%r11
  lea    (%rdi,%rsi,1),%r10d
  add    %ebx,%esi
  imul   %eax,%r10d
  imul   %eax,%esi
  movslq %r10d,%r10
  add    %r15,%r10
  movslq %esi,%rsi
  movslq %ebx,%r15
  add    %r15,%rsi
  lea    (%r14,%r10,8),%r10
  lea    (%r14,%rsi,8),%r15
  lea    0x2(%rdi),%esi
  imul   %esi,%r13d
  mov    %r13d,%esi
  shr    $0x1f,%esi
  add    %r13d,%esi
  sar    %esi
  neg    %esi
  movslq %esi,%rsi
  add    %r12,%rsi
  lea    0x0(%rbp,%rsi,8),%r12
  xor    %esi,%esi
  nopl   0x0(%rax,%rax,1)
L128:
  movsd  (%r11,%rsi,1),%xmm0
  movsd  (%r10,%rsi,1),%xmm5
  mulsd  %xmm2,%xmm0
  addsd  %xmm5,%xmm5
  addsd  %xmm5,%xmm0
  subsd  (%r15,%rsi,1),%xmm0
  add    %r8,%rsi
  subsd  (%rcx),%xmm0
  add    %r9,%rcx
  addsd  %xmm0,%xmm0
  mulsd  (%r12,%rdx,8),%xmm0
  add    $0x1,%rdx
  subsd  %xmm0,%xmm1
  cmp    %edx,%eax
  jg     L128
L51:
  test   %ebx,%ebx
  jle    L68
  mov    %eax,%ecx
  mov    -0x1c(%rsp),%edx
  movslq %ebx,%r13
  imul   %edi,%ecx
  add    %edi,%edx
  imul   %eax,%edx
  mov    %ecx,%r10d
  lea    (%rcx,%rbx,1),%r12d
  add    %edi,%ecx
  movslq %edi,%rdi
  imul   %eax,%r10d
  sub    %r13,%rdi
  imul   %eax,%ecx
  movslq %edx,%rdx
  imul   %eax,%r12d
  lea    0x0(%r13,%rdx,1),%rsi
  imul   %eax,%r10d
  lea    (%r14,%rsi,8),%rsi
  movslq %ecx,%rcx
  add    %rcx,%rdi
  movslq %r12d,%r12
  xor    %ecx,%ecx
  movslq %r10d,%r10
  sub    %rdx,%r12
  sub    %rdx,%rdi
  lea    (%r14,%r10,8),%r11
  mov    %ebx,%r10d
  nopl   0x0(%rax)
L23:
  mov    %ecx,%edx
  movsd  (%rsi),%xmm0
  add    $0x1,%ecx
  movsd  (%rsi,%r12,8),%xmm5
  add    $0x2,%edx
  imul   %ecx,%edx
  mulsd  %xmm2,%xmm0
  addsd  %xmm5,%xmm5
  mov    %edx,%r13d
  shr    $0x1f,%r13d
  add    %r13d,%edx
  addsd  %xmm5,%xmm0
  subsd  (%rsi,%rdi,8),%xmm0
  mov    %r10d,%r13d
  subsd  (%r11),%xmm0
  sar    %edx
  add    %r8,%rsi
  add    %r9,%r11
  sub    %edx,%r13d
  add    %eax,%r10d
  movslq %r13d,%rdx
  addsd  %xmm0,%xmm0
  mulsd  0x0(%rbp,%rdx,8),%xmm0
  subsd  %xmm0,%xmm1
  cmp    %ebx,%ecx
  jne    L23
L68:
  mov    -0x18(%rsp),%rbx
  mov    -0x10(%rsp),%rdi
  xorpd  %xmm3,%xmm1
  addl   $0x1,-0x20(%rsp)
  movsd  %xmm1,(%rdi,%rbx,1)
  add    $0x8,%rbx
  mov    -0x20(%rsp),%edi
  subl   $0x1,-0x8(%rsp)
  mov    %rbx,-0x18(%rsp)
  cmp    %edi,-0x4(%rsp)
  jg     L26
L48:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopw   0x0(%rax,%rax,1)
L59:
  movapd %xmm4,%xmm1
  jmp    L80
```

tool_calls: name: extract_symbolic_data
arguments: label: D9
type_infered: f32[2]
name: extract_symbolic_data
arguments: label: D15
type_infered: f32[2]

tool: {"D9": [0.0,-0.0]}

tool: {"D15": [0.0,2.25]}

assistant: ```c
void hessian_edmiston(const int Norbs, double *eri, double *vector_in, double *vector_out) {
  int rowindex, p, q, r, s;
  const int num_vars = (Norbs * (Norbs - 1)) / 2;
#pragma omp parallel for schedule(static)
  for (rowindex = 0; rowindex < num_vars; rowindex++) {
    s = num_vars - 1 - rowindex;
    r = 2;
    while ((r * (r - 1)) / 2 <= s) {
      r++;
    }
    p = Norbs - r;
    q = rowindex - p * Norbs + ((p + 1) * (p + 2)) / 2;
    double value = 0.0;
    for (s = p + 1; s < Norbs; s++) {
      const int pqps = p + Norbs * (q + Norbs * (p + Norbs * s));
      const int ppqs = p + Norbs * (p + Norbs * (q + Norbs * s));
      const int qqqs = q + Norbs * (q + Norbs * (q + Norbs * s));
      const int sssq = s + Norbs * (s + Norbs * (s + Norbs * q));
      const double prefactor = 2 * (4 * eri[pqps] + 2 * eri[ppqs] - eri[qqqs] - eri[sssq]);
      const int colindex = rowindex + s - q;
      value += prefactor * vector_in[colindex];
    }
    for (r = 0; r < q; r++) {
      const int qpqr = q + Norbs * (p + Norbs * (q + Norbs * r));
      const int qqpr = q + Norbs * (q + Norbs * (p + Norbs * r));
      const int pppr = p + Norbs * (p + Norbs * (p + Norbs * r));
      const int rrrp = r + Norbs * (r + Norbs * (r + Norbs * p));
      const double prefactor = 2 * (4 * eri[qpqr] + 2 * eri[qqpr] - eri[pppr] - eri[rrrp]);
      const int colindex = q + r * Norbs - ((r + 1) * (r + 2)) / 2;
      value += prefactor * vector_in[colindex];
    }
    for (s = q + 1; s < Norbs; s++) {
      const int qpqs = q + Norbs * (p + Norbs * (q + Norbs * s));
      const int qqps = q + Norbs * (q + Norbs * (p + Norbs * s));
      const int ppps = p + Norbs * (p + Norbs * (p + Norbs * s));
      const int sssp = s + Norbs * (s + Norbs * (s + Norbs * p));
      const double prefactor = 2 * (4 * eri[qpqs] + 2 * eri[qqps] - eri[ppps] - eri[sssp]);
      const int colindex = s + q * Norbs - ((q + 1) * (q + 2)) / 2;
      value -= prefactor * vector_in[colindex];
    }
    for (r = 0; r < p; r++) {
      const int pqpr = p + Norbs * (q + Norbs * (p + Norbs * r));
      const int ppqr = p + Norbs * (p + Norbs * (q + Norbs * r));
      const int qqqr = q + Norbs * (q + Norbs * (q + Norbs * r));
      const int rrrq = r + Norbs * (r + Norbs * (r + Norbs * q));
      const double prefactor = 2 * (4 * eri[pqpr] + 2 * eri[ppqr] - eri[qqqr] - eri[rrrq]);
      const int colindex = p + r * Norbs - ((r + 1) * (r + 2)) / 2;
      value -= prefactor * vector_in[colindex];
    }
    vector_out[rowindex] = -value;
  }
}
```