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

```asm
<eigen>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  sub    $0xc8,%rsp
  mov    %rdi,0x8(%rsp)
  mov    %esi,%r12d
  mov    %rdx,%r15
  mov    %rcx,0x98(%rsp)
  mov    %r8,0xa8(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x10b8(%rsp)
  xor    %eax,%eax
  test   %esi,%esi
  jle    L419
  movslq %esi,%r9
  lea    0x8(,%r9,8),%rdi
  mov    %rcx,%rsi
  shl    $0x3,%r9
  lea    -0x1(%r12),%eax
  lea    0x8(%rcx,%rax,8),%rdx
  mov    $0x0,%ecx
  mov    %r12d,%r8d
  neg    %r8
  shl    $0x3,%r8
  movsd  D59(%rip),%xmm0
L168:
  lea    (%r8,%rdx,1),%rax
L462:
  movq   $0x0,(%rax)
  add    $0x8,%rax
  cmp    %rdx,%rax
  jne    L462
  movsd  %xmm0,(%rsi)
  lea    0x1(%rcx),%eax
  add    %rdi,%rsi
  add    %r9,%rdx
  cmp    %eax,%r12d
  je     L420
  mov    %eax,%ecx
  jmp    L168
L420:
  mov    0x8(%rsp),%rdx
  mov    %ecx,%ecx
  mov    $0x0,%eax
L283:
  movsd  (%rdx),%xmm0
  movsd  %xmm0,0xb0(%rsp,%rax,8)
  movsd  %xmm0,(%r15,%rax,8)
  movq   $0x0,0x8b0(%rsp,%rax,8)
  mov    %rax,%rsi
  add    $0x1,%rax
  add    %rdi,%rdx
  cmp    %rcx,%rsi
  jne    L283
L419:
  mov    %r12d,%eax
  imul   %r12d,%eax
  mov    %eax,0xa4(%rsp)
  movslq %r12d,%rax
  shl    $0x3,%rax
  mov    %rax,(%rsp)
  movl   $0x1,0x58(%rsp)
  movl   $0x0,0x84(%rsp)
  mov    %r12d,%r14d
  jmp    L163
L248:
  mulsd  D168(%rip),%xmm1
  pxor   %xmm0,%xmm0
  cvtsi2sdl 0xa4(%rsp),%xmm0
  divsd  %xmm0,%xmm1
  movsd  %xmm1,0x38(%rsp)
  jmp    L290
L329:
  comisd 0x38(%rsp),%xmm2
  ja     L10
L112:
  add    $0x1,%rbp
  add    $0x1,%rbx
  add    %r15d,0x1c(%rsp)
  addq   $0x8,0x20(%rsp)
  add    $0x1,%r14
  cmp    0x30(%rsp),%rbp
  je     L324
L98:
  mov    %ebp,0x2c(%rsp)
  lea    -0x1(%rbp),%eax
  mov    %eax,0x28(%rsp)
  mov    0x8(%rsp),%rax
  movsd  (%rax,%r14,8),%xmm6
  movsd  %xmm6,0x10(%rsp)
  movapd %xmm6,%xmm2
  andpd  D13(%rip),%xmm2
  movapd %xmm2,%xmm1
  mulsd  D0(%rip),%xmm1
  cmpl   $0x6,0x58(%rsp)
  jle    L329
  movsd  0x0(%r13,%r12,8),%xmm0
  andpd  D13(%rip),%xmm0
  movapd %xmm0,%xmm3
  addsd  %xmm1,%xmm3
  ucomisd %xmm3,%xmm0
  jp     L329
  jne    L329
  movsd  -0x8(%r13,%rbp,8),%xmm0
  andpd  D13(%rip),%xmm0
  movapd %xmm0,%xmm3
  addsd  %xmm1,%xmm3
  ucomisd %xmm3,%xmm0
  jp     L329
  jne    L329
  movq   $0x0,(%rax,%r14,8)
  jmp    L112
L10:
  movsd  0x0(%r13,%r12,8),%xmm7
  movsd  %xmm7,0x50(%rsp)
  movsd  -0x8(%r13,%rbp,8),%xmm0
  subsd  %xmm7,%xmm0
  movapd %xmm0,%xmm2
  andpd  D13(%rip),%xmm2
  addsd  %xmm2,%xmm1
  ucomisd %xmm1,%xmm2
  jp     L86
  jne    L86
  movsd  0x10(%rsp),%xmm6
  divsd  %xmm0,%xmm6
  movsd  %xmm6,0x40(%rsp)
L452:
  movsd  0x40(%rsp),%xmm7
  movapd %xmm7,%xmm0
  mulsd  %xmm7,%xmm0
  addsd  D59(%rip),%xmm0
  pxor   %xmm1,%xmm1
  ucomisd %xmm0,%xmm1
  ja     L184
  sqrtsd %xmm0,%xmm0
L441:
  movsd  D59(%rip),%xmm3
  movapd %xmm3,%xmm2
  divsd  %xmm0,%xmm2
  movsd  0x40(%rsp),%xmm7
  movapd %xmm7,%xmm1
  mulsd  %xmm2,%xmm1
  addsd  %xmm3,%xmm2
  movapd %xmm2,%xmm0
  movapd %xmm1,%xmm2
  divsd  %xmm0,%xmm2
  movsd  0x10(%rsp),%xmm0
  mulsd  %xmm7,%xmm0
  lea    0x8b0(%rsp),%rax
  movsd  (%rax,%r12,8),%xmm3
  subsd  %xmm0,%xmm3
  movsd  %xmm3,(%rax,%r12,8)
  movapd %xmm0,%xmm3
  addsd  0x8a8(%rsp,%rbp,8),%xmm3
  movsd  %xmm3,0x8a8(%rsp,%rbp,8)
  movsd  0x50(%rsp),%xmm3
  subsd  %xmm0,%xmm3
  movsd  %xmm3,0x0(%r13,%r12,8)
  addsd  -0x8(%r13,%rbp,8),%xmm0
  movsd  %xmm0,-0x8(%r13,%rbp,8)
  mov    0x8(%rsp),%rax
  movq   $0x0,(%rax,%r14,8)
  mov    %r12d,%ecx
  test   %r12d,%r12d
  jle    L258
  mov    0x70(%rsp),%rax
  mov    $0x0,%edx
L384:
  movsd  (%rax),%xmm0
  movsd  (%rax,%rbx,8),%xmm4
  movapd %xmm2,%xmm3
  mulsd  %xmm0,%xmm3
  addsd  %xmm4,%xmm3
  mulsd  %xmm1,%xmm3
  movapd %xmm0,%xmm5
  subsd  %xmm3,%xmm5
  movsd  %xmm5,(%rax)
  movapd %xmm2,%xmm3
  mulsd  %xmm4,%xmm3
  subsd  %xmm3,%xmm0
  mulsd  %xmm1,%xmm0
  addsd  %xmm4,%xmm0
  movsd  %xmm0,(%rax,%rbx,8)
  add    $0x1,%edx
  add    (%rsp),%rax
  cmp    %ecx,%edx
  jne    L384
L258:
  mov    0x5c(%rsp),%esi
  cmp    %esi,0x28(%rsp)
  jle    L287
  mov    0x48(%rsp),%rax
  add    %r12,%rax
  lea    -0x2(%rbx),%edx
  add    %rdx,%rax
  mov    0x8(%rsp),%rsi
  lea    0x10(%rsi,%rax,8),%rcx
  mov    0x20(%rsp),%rdx
  mov    0x60(%rsp),%rax
L379:
  movsd  (%rax),%xmm0
  movsd  (%rdx),%xmm4
  movapd %xmm2,%xmm3
  mulsd  %xmm0,%xmm3
  addsd  %xmm4,%xmm3
  mulsd  %xmm1,%xmm3
  movapd %xmm0,%xmm5
  subsd  %xmm3,%xmm5
  movsd  %xmm5,(%rax)
  movapd %xmm2,%xmm3
  mulsd  %xmm4,%xmm3
  subsd  %xmm3,%xmm0
  mulsd  %xmm1,%xmm0
  addsd  %xmm4,%xmm0
  movsd  %xmm0,(%rdx)
  add    $0x8,%rax
  add    (%rsp),%rdx
  cmp    %rcx,%rax
  jne    L379
L287:
  cmp    %ebp,%r15d
  jle    L48
  movslq %ebp,%rax
  mov    0x48(%rsp),%rdi
  add    %rdi,%rax
  mov    0x8(%rsp),%rsi
  lea    (%rsi,%rax,8),%rax
  lea    -0x1(%r15),%edx
  sub    0x2c(%rsp),%edx
  add    %r14,%rdx
  lea    0x10(%rsi,%rdx,8),%rcx
  movslq 0x1c(%rsp),%rdx
  sub    %rdi,%rdx
L406:
  movsd  (%rax),%xmm0
  movsd  (%rax,%rdx,8),%xmm4
  movapd %xmm2,%xmm3
  mulsd  %xmm0,%xmm3
  addsd  %xmm4,%xmm3
  mulsd  %xmm1,%xmm3
  movapd %xmm0,%xmm5
  subsd  %xmm3,%xmm5
  movsd  %xmm5,(%rax)
  movapd %xmm2,%xmm3
  mulsd  %xmm4,%xmm3
  subsd  %xmm3,%xmm0
  mulsd  %xmm1,%xmm0
  addsd  %xmm4,%xmm0
  movsd  %xmm0,(%rax,%rdx,8)
  add    $0x8,%rax
  cmp    %rcx,%rax
  jne    L406
L48:
  test   %r15d,%r15d
  jle    L66
  mov    0x68(%rsp),%rax
  mov    $0x0,%edx
L7:
  movsd  (%rax),%xmm0
  movsd  (%rax,%rbx,8),%xmm4
  movapd %xmm2,%xmm3
  mulsd  %xmm0,%xmm3
  addsd  %xmm4,%xmm3
  mulsd  %xmm1,%xmm3
  movapd %xmm0,%xmm5
  subsd  %xmm3,%xmm5
  movsd  %xmm5,(%rax)
  movapd %xmm2,%xmm3
  mulsd  %xmm4,%xmm3
  subsd  %xmm3,%xmm0
  mulsd  %xmm1,%xmm0
  addsd  %xmm4,%xmm0
  movsd  %xmm0,(%rax,%rbx,8)
  add    $0x1,%edx
  add    (%rsp),%rax
  cmp    %edx,%r15d
  jne    L7
L66:
  addl   $0x1,0x84(%rsp)
  jmp    L112
L86:
  mulsd  D5(%rip),%xmm0
  divsd  0x10(%rsp),%xmm0
  movsd  %xmm0,0x88(%rsp)
  movapd %xmm0,%xmm6
  andpd  D13(%rip),%xmm6
  movsd  %xmm6,0x40(%rsp)
  mulsd  %xmm0,%xmm0
  addsd  D59(%rip),%xmm0
  pxor   %xmm1,%xmm1
  ucomisd %xmm0,%xmm1
  ja     L157
  sqrtsd %xmm0,%xmm0
L72:
  addsd  0x40(%rsp),%xmm0
  movsd  D59(%rip),%xmm1
  movapd %xmm1,%xmm7
  divsd  %xmm0,%xmm7
  movsd  %xmm7,0x40(%rsp)
  pxor   %xmm0,%xmm0
  comisd 0x88(%rsp),%xmm0
  jbe    L452
  xorpd  D79(%rip),%xmm7
  movsd  %xmm7,0x40(%rsp)
  jmp    L452
L157:
  call   <sqrt@plt>
  jmp    L72
L184:
  call   <sqrt@plt>
  jmp    L441
L324:
  lea    0x1(%r12),%rax
  addq   $0x1,0x78(%rsp)
  add    %r15d,0x80(%rsp)
  cmp    0x90(%rsp),%r12
  je     L387
  mov    %rax,%r12
L5:
  mov    0x78(%rsp),%rsi
  mov    %esi,0x5c(%rsp)
  cmp    %esi,%r15d
  jle    L324
  lea    0x2(%r12),%ebp
  movslq %ebp,%rbp
  mov    0x80(%rsp),%edi
  movslq %edi,%rax
  add    %rsi,%rax
  mov    0x8(%rsp),%rcx
  lea    (%rcx,%rax,8),%rax
  mov    %rax,0x20(%rsp)
  mov    %edi,%eax
  sub    %r15d,%eax
  cltq
  mov    %rax,0x48(%rsp)
  mov    %rax,%r14
  add    %rsi,%r14
  mov    0xa0(%rsp),%eax
  sub    %r12d,%eax
  lea    0x3(%r12,%rax,1),%rax
  mov    %rax,0x30(%rsp)
  lea    0x0(,%r12,8),%rax
  lea    (%rcx,%rax,1),%rsi
  mov    %rsi,0x70(%rsp)
  lea    (%rcx,%r14,8),%rsi
  mov    %rsi,0x60(%rsp)
  add    0x98(%rsp),%rax
  mov    %rax,0x68(%rsp)
  mov    %edi,0x1c(%rsp)
  mov    $0x1,%ebx
  jmp    L98
L387:
  mov    %r15d,%r14d
  mov    %r13,%r15
  test   %r14d,%r14d
  jle    L166
  mov    %r14d,%esi
  mov    $0x0,%eax
  lea    0x8b0(%rsp),%rcx
L277:
  lea    0xb0(%rsp),%rdx
  movsd  (%rdx,%rax,8),%xmm0
  addsd  (%rcx,%rax,8),%xmm0
  movsd  %xmm0,(%rdx,%rax,8)
  movsd  %xmm0,(%r15,%rax,8)
  movq   $0x0,(%rcx,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%rsi
  jne    L277
L166:
  addl   $0x1,0x58(%rsp)
  mov    0x58(%rsp),%eax
  cmp    $0x32,%eax
  je     L6
L163:
  cmp    $0x1,%r14d
  jle    L78
  lea    -0x2(%r14),%eax
  mov    %eax,0xa0(%rsp)
  mov    %eax,%eax
  mov    %rax,0x90(%rsp)
  lea    0x2(%rax),%rdi
  mov    $0x1,%ecx
  mov    $0x0,%esi
  pxor   %xmm1,%xmm1
  lea    -0x1(%r14),%r9d
  mov    0x8(%rsp),%r11
  lea    0x10(%r11),%r8
L20:
  cmp    %ecx,%r14d
  jle    L380
  movslq %esi,%rdx
  lea    (%rdx,%rcx,1),%rax
  lea    (%r11,%rax,8),%rax
  lea    -0x1(%rdx,%rcx,1),%rdx
  mov    %r9d,%r10d
  sub    %ecx,%r10d
  add    %r10,%rdx
  lea    (%r8,%rdx,8),%rdx
L55:
  movsd  (%rax),%xmm0
  andpd  D13(%rip),%xmm0
  addsd  %xmm0,%xmm1
  add    $0x8,%rax
  cmp    %rdx,%rax
  jne    L55
L380:
  add    %r14d,%esi
  add    $0x1,%rcx
  cmp    %rdi,%rcx
  jne    L20
  ucomisd D155(%rip),%xmm1
  jp     L475
  je     L82
L475:
  pxor   %xmm7,%xmm7
  movsd  %xmm7,0x38(%rsp)
  cmpl   $0x5,0x58(%rsp)
  jle    L248
L290:
  mov    %r14d,0x80(%rsp)
  movq   $0x1,0x78(%rsp)
  mov    $0x0,%r12d
  mov    %r15,%r13
  mov    %r14d,%r15d
  jmp    L5
L78:
  mov    $0x0,%eax
L136:
  mov    0xa8(%rsp),%rdi
  mov    0x84(%rsp),%esi
  mov    %esi,(%rdi)
  mov    0x10b8(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L255
  add    $0x10c8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L6:
  lea    D30(%rip),%rdi
  call   <puts@plt>
  mov    $0xffffffff,%eax
  jmp    L136
L82:
  mov    $0x0,%eax
  jmp    L136
L255:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: tag: D59
data_type: f64
name: extract_symbolic_data
arguments: tag: D168
data_type: f64
name: extract_symbolic_data
arguments: tag: D13
data_type: qword[2]
name: extract_symbolic_data
arguments: tag: D0
data_type: f64
name: extract_symbolic_data
arguments: tag: D5
data_type: f64
name: extract_symbolic_data
arguments: tag: D79
data_type: f32[4]
name: extract_symbolic_data
arguments: tag: D155
data_type: f32[2]
name: extract_symbolic_data
arguments: tag: D30
data_type: string

tool: D59: 1

tool: D168: 0.2

tool: {"D13": [0x7fffffffffffffff,0x0000000000000000]}

tool: D0: 100

tool: D5: 0.5

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

tool: {"D155": [0.0,0.0]}

tool: D30: routine JACOBI: 50 iterations should not happen

assistant: ```c
int eigen(a, n, d, v, nr)
double *a;
int n;
double *d;
double *v;
int *nr;
{
  int nrot;
  int j, iq, ip, i;
  double tresh, theta, tau, t, sm, s, h, g, c;
  double b[256], z[256];
  for (ip = 0; ip < n; ip++) {
    for (iq = 0; iq < n; iq++) {
      v[ip * n + iq] = 0.0;
    }
    v[ip * n + ip] = 1.0;
  }
  for (ip = 0; ip < n; ip++) {
    b[ip] = a[ip * n + ip];
    d[ip] = b[ip];
    z[ip] = 0.0;
  }
  nrot = 0;
  for (i = 1; i < 50; i++) {
    sm = 0.0;
    for (ip = 0; ip < n - 1; ip++) {
      for (iq = ip + 1; iq < n; iq++) {
        sm += fabs(a[ip * n + iq]);
      }
    }
    if (sm == 0.0) {
      *nr = nrot;
      return 0;
    }
    if (i < 6) {
      tresh = (double)0.2 * sm / (double)(n * n);
    } else {
      tresh = 0.0;
    }
    for (ip = 0; ip < n - 1; ip++) {
      for (iq = ip + 1; iq < n; iq++) {
        g = 100.0 * fabs(a[ip * n + iq]);
        if ((i > 6) && ((fabs(d[ip]) + g) == fabs(d[ip])) && ((fabs(d[iq]) + g) == fabs(d[iq]))) {
          a[ip * n + iq] = 0.0;
        } else if (fabs(a[ip * n + iq]) > tresh) {
          h = d[iq] - d[ip];
          if ((fabs(h) + g) == fabs(h)) {
            t = a[ip * n + iq] / h;
          } else {
            theta = 0.5 * h / a[ip * n + iq];
            t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
            if (theta < 0.0)
              t = -t;
          }
          c = 1.0 / sqrt(1 + t * t);
          s = t * c;
          tau = s / (1.0 + c);
          h = t * a[ip * n + iq];
          z[ip] = z[ip] - h;
          z[iq] = z[iq] + h;
          d[ip] = d[ip] - h;
          d[iq] = d[iq] + h;
          a[ip * n + iq] = 0.0;
          for (j = 0; j <= ip - 1; j++) {
            g = a[j * n + ip];
            h = a[j * n + iq];
            a[j * n + ip] = g - s * (h + g * tau);
            a[j * n + iq] = h + s * (g - h * tau);
          }
          for (j = ip + 1; j <= iq - 1; j++) {
            g = a[ip * n + j];
            h = a[j * n + iq];
            a[ip * n + j] = g - s * (h + g * tau);
            a[j * n + iq] = h + s * (g - h * tau);
          }
          for (j = iq + 1; j < n; j++) {
            g = a[ip * n + j];
            h = a[iq * n + j];
            a[ip * n + j] = g - s * (h + g * tau);
            a[iq * n + j] = h + s * (g - h * tau);
          }
          for (j = 0; j < n; j++) {
            g = v[j * n + ip];
            h = v[j * n + iq];
            v[j * n + ip] = g - s * (h + g * tau);
            v[j * n + iq] = h + s * (g - h * tau);
          }
          nrot++;
        }
      }
    }
    for (ip = 0; ip < n; ip++) {
      b[ip] = b[ip] + z[ip];
      d[ip] = b[ip];
      z[ip] = 0.0;
    }
  }
  printf("routine JACOBI: 50 iterations should not happen\n");
  *nr = nrot;
  return -1;
}
```