user: 这段汇编代码用C语言表示是什么样的:

```asm
<Mutation_DoubleSkeletalChange>:
  endbr64
  push   %r15
  push   %r14
  mov    %rdx,%r14
  push   %r13
  mov    %rcx,%r13
  push   %r12
  mov    %rdi,%r12
  push   %rbp
  push   %rbx
  mov    %r8d,%ebx
  sub    $0x78,%rsp
  mov    0xb0(%rsp),%rax
  mov    %rsi,0x20(%rsp)
  lea    0x60(%rsp),%rdi
  mov    0xc0(%rsp),%rsi
  mov    %rdx,0x28(%rsp)
  mov    %rax,0x18(%rsp)
  mov    0xb8(%rsp),%rax
  mov    %r9,0x10(%rsp)
  mov    0xc8(%rsp),%edx
  mov    %rax,0x30(%rsp)
  mov    0xd0(%rsp),%rax
  mov    %rsi,0x38(%rsp)
  mov    0xe8(%rsp),%r15
  mov    %rax,0x48(%rsp)
  mov    0xd8(%rsp),%rax
  movsd  %xmm0,0x40(%rsp)
  movsd  (%r14),%xmm0
  mov    %rax,0x8(%rsp)
  mov    0xe0(%rsp),%rax
  mov    %rax,(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x68(%rsp)
  xor    %eax,%eax
  call   <self_adj_index_search@plt>
  test   %ebx,%ebx
  jle    L27
  mov    0x20(%rsp),%r9
  mov    0x8(%rsp),%r10
  lea    0x1(%rbx),%ecx
  mov    $0x1,%esi
  mov    (%rsp),%r11
  nopl   0x0(%rax,%rax,1)
L7:
  mov    (%r12,%rsi,4),%eax
  movsd  0x0(%r13,%rsi,8),%xmm0
  mov    (%r9,%rsi,8),%r8
  mov    (%r11,%rsi,8),%rdi
  mov    %eax,(%r10,%rsi,4)
  mov    $0x1,%eax
  movsd  %xmm0,(%r15,%rsi,8)
  nopw   0x0(%rax,%rax,1)
L21:
  mov    (%r8,%rax,4),%edx
  mov    %edx,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%rcx
  jne    L21
  add    $0x1,%rsi
  cmp    %rsi,%rcx
  jne    L7
L27:
  mov    %r12,0x50(%rsp)
  lea    -0x1(%rbx),%ebp
  mov    %r13,0x58(%rsp)
  jmp    L68
L28:
  cmp    %r13d,%r12d
  jne    L92
L68:
  mov    %ebx,%esi
  mov    $0x1,%edi
  call   <integerrng@plt>
  mov    %ebp,%esi
  mov    $0x1,%edi
  mov    %eax,%r13d
  call   <integerrng@plt>
  mov    %eax,%r14d
  cmp    %eax,%r13d
  jg     L52
  add    $0x1,%r14d
  cmp    %r14d,%r13d
  jg     L52
  mov    %r14d,%eax
  mov    %r13d,%r14d
  mov    %eax,%r13d
L52:
  mov    %ebx,%esi
  mov    $0x1,%edi
  call   <integerrng@plt>
  mov    %ebp,%esi
  mov    $0x1,%edi
  mov    %eax,%r12d
  call   <integerrng@plt>
  cmp    %eax,%r12d
  jg     L6
  add    $0x1,%eax
  cmp    %eax,%r12d
  jg     L6
  mov    %eax,%esi
  mov    %r12d,%eax
  mov    %esi,%r12d
L6:
  cmp    %r14d,%eax
  je     L28
L92:
  mov    (%rsp),%r10
  movslq %r14d,%rdx
  movslq %r13d,%rsi
  cltq
  mov    %rsi,%r14
  mov    %r12d,%ecx
  mov    0x58(%rsp),%r13
  mov    0x50(%rsp),%r12
  mov    (%r10,%rdx,8),%rdi
  mov    $0x1,%edx
  lea    (%rdi,%rsi,4),%rsi
  mov    %edx,%edi
  sub    (%rsi),%edi
  mov    %edi,(%rsi)
  mov    (%r10,%rax,8),%rdi
  movslq %ecx,%rsi
  lea    (%rdi,%rsi,4),%rax
  sub    (%rax),%edx
  mov    %edx,(%rax)
  mov    0x10(%rsp),%rax
  cmp    %r14d,%ecx
  je     L2
  movl   $0x2,(%rax)
  mov    0x18(%rsp),%rax
  mov    %r14d,0x4(%rax)
  mov    %ecx,0x8(%rax)
L9:
  mov    0x10(%rsp),%rax
  mov    0x18(%rsp),%r8
  mov    %r15,%rcx
  mov    %ebx,%edx
  mov    (%rsp),%rsi
  mov    0x8(%rsp),%rdi
  mov    (%rax),%r9d
  call   <cost@plt>
  mov    0x38(%rsp),%rsi
  lea    0x64(%rsp),%rdi
  mov    0xc8(%rsp),%edx
  movsd  %xmm0,0x10(%rsp)
  call   <self_adj_index_search@plt>
  movsd  0x10(%rsp),%xmm1
  movsd  0x40(%rsp),%xmm3
  mov    0x30(%rsp),%rcx
  movslq 0x64(%rsp),%rax
  movapd %xmm1,%xmm2
  mov    0x28(%rsp),%rbp
  divsd  %xmm3,%xmm2
  movsd  (%rcx,%rax,8),%xmm0
  movslq 0x60(%rsp),%rax
  xorpd  D2(%rip),%xmm0
  subsd  %xmm2,%xmm0
  movsd  0x0(%rbp),%xmm2
  addsd  (%rcx,%rax,8),%xmm0
  divsd  %xmm3,%xmm2
  addsd  %xmm2,%xmm0
  pxor   %xmm2,%xmm2
  minsd  %xmm0,%xmm2
  movapd %xmm2,%xmm0
  call   <exp@plt>
  mov    0x48(%rsp),%r14
  xor    %eax,%eax
  movsd  %xmm0,(%r14)
  call   <uniformrng@plt>
  movsd  (%r14),%xmm2
  comisd %xmm0,%xmm2
  jbe    L152
  movsd  0x10(%rsp),%xmm1
  movsd  %xmm1,0x0(%rbp)
  test   %ebx,%ebx
  jle    L152
  mov    0x20(%rsp),%r9
  mov    0x8(%rsp),%r10
  lea    0x1(%rbx),%ecx
  mov    $0x1,%esi
  mov    (%rsp),%r11
  cs nopw 0x0(%rax,%rax,1)
L45:
  mov    (%r10,%rsi,4),%eax
  movsd  (%r15,%rsi,8),%xmm0
  mov    (%r11,%rsi,8),%r8
  mov    (%r9,%rsi,8),%rdi
  mov    %eax,(%r12,%rsi,4)
  mov    $0x1,%eax
  movsd  %xmm0,0x0(%r13,%rsi,8)
  nopw   0x0(%rax,%rax,1)
L35:
  mov    (%r8,%rax,4),%edx
  mov    %edx,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%rcx
  jne    L35
  add    $0x1,%rsi
  cmp    %rsi,%rcx
  jne    L45
L152:
  mov    0x68(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L64
  add    $0x78,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L2:
  movl   $0x1,(%rax)
  mov    0x18(%rsp),%rax
  mov    %ecx,0x4(%rax)
  jmp    L9
L64:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: tag: D2
data_type: f32[4]

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

assistant: ```c
void Mutation_DoubleSkeletalChange(int *z, int **zmat, double *fz, double *fz_cond, int N_node, int *changelength, int *changelist, double *theta, double *grid_points, int grid_size, double temp, double *accpr_pop, int *z_new, int **zmat_new, double *fz_cond_new) {
  int k_old;
  int k_new;
  int j;
  int i;
  int nodeA1;
  int nodeA2;
  int nodeB1;
  int nodeB2;
  double fz_new;
  double rat;
  double un;
  self_adj_index_search(&k_old, *fz, grid_points, grid_size);
  for (i = 1; i <= N_node; i++) {
    z_new[i] = z[i];
    fz_cond_new[i] = fz_cond[i];
    for (j = 1; j <= N_node; j++)
      zmat_new[i][j] = zmat[i][j];
  }
  nodeA1 = 0;
  nodeA2 = 0;
  nodeB1 = 0;
  nodeB2 = 0;
  while (nodeA1 == nodeB1 && nodeA2 == nodeB2) {
    nodeA1 = integerrng(1, N_node);
    nodeA2 = integerrng(1, N_node - 1);
    if (nodeA2 >= nodeA1)
      nodeA2++;
    if (nodeA1 > nodeA2) {
      i = nodeA1;
      nodeA1 = nodeA2;
      nodeA2 = i;
    }
    nodeB1 = integerrng(1, N_node);
    nodeB2 = integerrng(1, N_node - 1);
    if (nodeB2 >= nodeB1)
      nodeB2++;
    if (nodeB1 > nodeB2) {
      i = nodeB1;
      nodeB1 = nodeB2;
      nodeB2 = i;
    }
  }
  zmat_new[nodeA1][nodeA2] = 1 - zmat_new[nodeA1][nodeA2];
  zmat_new[nodeB1][nodeB2] = 1 - zmat_new[nodeB1][nodeB2];
  if (nodeA2 == nodeB2) {
    *changelength = 1;
    changelist[1] = nodeA2;
  } else {
    *changelength = 2;
    changelist[1] = nodeA2;
    changelist[2] = nodeB2;
  }
  fz_new = cost(z_new, zmat_new, N_node, fz_cond_new, changelist, *changelength);
  self_adj_index_search(&k_new, fz_new, grid_points, grid_size);
  rat = -theta[k_new] - fz_new / temp + theta[k_old] + *fz / temp;
  *accpr_pop = exp((((0.0) < (rat)) ? (0.0) : (rat)));
  un = uniformrng();
  if (*accpr_pop > un) {
    *fz = fz_new;
    for (i = 1; i <= N_node; i++) {
      z[i] = z_new[i];
      fz_cond[i] = fz_cond_new[i];
      for (j = 1; j <= N_node; j++)
        zmat[i][j] = zmat_new[i][j];
    }
  }
}
```