user: Please show me the C implementation that matches the assembly code listed below:

```asm
<Mutation_DoubleSkeletalChange>:
  endbr64
  push   %r15
  push   %r14
  mov    %r8d,%r14d
  push   %r13
  push   %r12
  mov    %rcx,%r12
  push   %rbp
  mov    %rdi,%rbp
  push   %rbx
  mov    %rdx,%rbx
  sub    $0x88,%rsp
  mov    0xc0(%rsp),%rax
  mov    %rsi,0x18(%rsp)
  lea    0x70(%rsp),%rdi
  mov    0xd0(%rsp),%rsi
  mov    %rdx,0x48(%rsp)
  mov    %rax,0x40(%rsp)
  mov    0xc8(%rsp),%rax
  mov    %r9,0x38(%rsp)
  mov    0xd8(%rsp),%edx
  mov    %rax,0x50(%rsp)
  mov    0xe0(%rsp),%rax
  mov    %rsi,0x58(%rsp)
  mov    %rax,0x68(%rsp)
  mov    0xe8(%rsp),%rax
  movsd  %xmm0,0x60(%rsp)
  movsd  (%rbx),%xmm0
  lea    -0x1(%r14),%ebx
  mov    %rax,0x8(%rsp)
  mov    0xf0(%rsp),%rax
  mov    %rax,(%rsp)
  mov    0xf8(%rsp),%rax
  mov    %rax,0x10(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x78(%rsp)
  xor    %eax,%eax
  call   <self_adj_index_search@plt>
  test   %r14d,%r14d
  jle    L100
  mov    %r14d,%r15d
  mov    %r14d,%eax
  lea    0x1(%r14),%r8d
  mov    $0x1,%esi
  and    $0xfffffffc,%r15d
  shr    $0x2,%eax
  lea    0x2(%r15),%r10d
  lea    -0x1(%rax),%edi
  mov    %r10,%r13
  lea    0x3(%r15),%r11d
  shl    $0x4,%rdi
  lea    0x1(%r15),%r9d
  mov    %r13d,0x20(%rsp)
  shl    $0x2,%r9
  add    $0x14,%rdi
  shl    $0x2,%r10
  mov    0x18(%rsp),%r13
  mov    %r11d,0x2c(%rsp)
  shl    $0x2,%r11
  nopl   (%rax)
L69:
  mov    0x0(%rbp,%rsi,4),%eax
  mov    0x8(%rsp),%rcx
  movsd  (%r12,%rsi,8),%xmm0
  mov    0x0(%r13,%rsi,8),%rdx
  mov    %eax,(%rcx,%rsi,4)
  mov    0x10(%rsp),%rax
  movsd  %xmm0,(%rax,%rsi,8)
  mov    (%rsp),%rax
  mov    (%rax,%rsi,8),%rcx
  mov    %rcx,%rax
  sub    %rdx,%rax
  sub    $0x4,%rax
  cmp    $0x8,%rax
  jbe    L242
  cmp    $0x2,%ebx
  jbe    L242
  mov    $0x4,%eax
  nopl   0x0(%rax,%rax,1)
L281:
  movdqu (%rdx,%rax,1),%xmm3
  movups %xmm3,(%rcx,%rax,1)
  add    $0x10,%rax
  cmp    %rax,%rdi
  jne    L281
  cmp    %r14d,%r15d
  je     L296
  mov    (%rdx,%r9,1),%eax
  mov    %eax,(%rcx,%r9,1)
  cmp    0x20(%rsp),%r14d
  jl     L296
  mov    (%rdx,%r10,1),%eax
  mov    %eax,(%rcx,%r10,1)
  cmp    0x2c(%rsp),%r14d
  jl     L296
  mov    (%rdx,%r11,1),%eax
  mov    %eax,(%rcx,%r11,1)
L296:
  add    $0x1,%rsi
  cmp    %rsi,%r8
  jne    L69
L100:
  mov    %rbp,0x20(%rsp)
  jmp    L211
  nopl   0x0(%rax)
L86:
  cmp    %ebp,%r15d
  jne    L8
L211:
  mov    %r14d,%esi
  mov    $0x1,%edi
  call   <integerrng@plt>
  mov    %ebx,%esi
  mov    $0x1,%edi
  mov    %eax,%ebp
  call   <integerrng@plt>
  mov    %eax,%r13d
  cmp    %eax,%ebp
  jg     L201
  add    $0x1,%r13d
  cmp    %r13d,%ebp
  jg     L201
  mov    %r13d,%eax
  mov    %ebp,%r13d
  mov    %eax,%ebp
L201:
  mov    %r14d,%esi
  mov    $0x1,%edi
  call   <integerrng@plt>
  mov    %ebx,%esi
  mov    $0x1,%edi
  mov    %eax,%r15d
  call   <integerrng@plt>
  cmp    %eax,%r15d
  jg     L123
  add    $0x1,%eax
  cmp    %eax,%r15d
  jg     L123
  mov    %eax,%ecx
  mov    %r15d,%eax
  mov    %ecx,%r15d
L123:
  cmp    %r13d,%eax
  je     L86
L8:
  mov    (%rsp),%rcx
  movslq %r13d,%rdx
  movslq %ebp,%rsi
  cltq
  movd   %esi,%xmm0
  mov    %rsi,%r13
  movd   %r15d,%xmm6
  mov    0x20(%rsp),%rbp
  mov    (%rcx,%rdx,8),%rdx
  punpckldq %xmm6,%xmm0
  lea    (%rdx,%rsi,4),%rsi
  mov    $0x1,%edx
  mov    %edx,%edi
  sub    (%rsi),%edi
  mov    %edi,(%rsi)
  mov    (%rcx,%rax,8),%rdi
  movslq %r15d,%rsi
  lea    (%rdi,%rsi,4),%rax
  sub    (%rax),%edx
  mov    %edx,(%rax)
  mov    0x38(%rsp),%rax
  cmp    %r13d,%r15d
  je     L138
  movl   $0x2,(%rax)
  mov    0x40(%rsp),%rax
  mov    %rcx,%rsi
  movq   %xmm0,0x4(%rax)
  mov    %rax,%r8
L189:
  mov    0x38(%rsp),%rax
  mov    0x10(%rsp),%rcx
  mov    %r14d,%edx
  mov    0x8(%rsp),%rdi
  mov    (%rax),%r9d
  call   <cost@plt>
  mov    0x58(%rsp),%rsi
  lea    0x74(%rsp),%rdi
  mov    0xd8(%rsp),%edx
  movsd  %xmm0,0x20(%rsp)
  call   <self_adj_index_search@plt>
  movsd  0x20(%rsp),%xmm1
  movsd  0x60(%rsp),%xmm5
  mov    0x50(%rsp),%rdx
  movslq 0x74(%rsp),%rax
  movapd %xmm1,%xmm2
  mov    0x48(%rsp),%r13
  divsd  %xmm5,%xmm2
  movsd  (%rdx,%rax,8),%xmm0
  movslq 0x70(%rsp),%rax
  xorpd  D1(%rip),%xmm0
  subsd  %xmm2,%xmm0
  movsd  0x0(%r13),%xmm2
  addsd  (%rdx,%rax,8),%xmm0
  divsd  %xmm5,%xmm2
  addsd  %xmm2,%xmm0
  pxor   %xmm2,%xmm2
  minsd  %xmm0,%xmm2
  movapd %xmm2,%xmm0
  call   <exp@plt>
  mov    0x68(%rsp),%r15
  xor    %eax,%eax
  movsd  %xmm0,(%r15)
  call   <uniformrng@plt>
  movsd  (%r15),%xmm2
  comisd %xmm0,%xmm2
  jbe    L210
  movsd  0x20(%rsp),%xmm1
  movsd  %xmm1,0x0(%r13)
  test   %r14d,%r14d
  jle    L210
  mov    %r14d,%eax
  mov    0x8(%rsp),%r13
  mov    0x10(%rsp),%r15
  lea    0x1(%r14),%r8d
  shr    $0x2,%eax
  mov    $0x1,%esi
  lea    -0x1(%rax),%edi
  mov    %r14d,%eax
  and    $0xfffffffc,%eax
  shl    $0x4,%rdi
  mov    %eax,0x20(%rsp)
  lea    0x2(%rax),%r10d
  lea    0x3(%rax),%r11d
  add    $0x14,%rdi
  lea    0x1(%rax),%r9d
  mov    %r10d,0x2c(%rsp)
  shl    $0x2,%r10
  mov    %r11d,0x30(%rsp)
  shl    $0x2,%r9
  shl    $0x2,%r11
  nopl   (%rax)
L254:
  mov    0x0(%r13,%rsi,4),%eax
  movsd  (%r15,%rsi,8),%xmm0
  mov    %eax,0x0(%rbp,%rsi,4)
  mov    (%rsp),%rax
  movsd  %xmm0,(%r12,%rsi,8)
  mov    (%rax,%rsi,8),%rdx
  mov    0x18(%rsp),%rax
  mov    (%rax,%rsi,8),%rcx
  mov    %rcx,%rax
  sub    %rdx,%rax
  sub    $0x4,%rax
  cmp    $0x8,%rax
  jbe    L67
  cmp    $0x2,%ebx
  jbe    L67
  mov    $0x4,%eax
L60:
  movdqu (%rdx,%rax,1),%xmm4
  movups %xmm4,(%rcx,%rax,1)
  add    $0x10,%rax
  cmp    %rax,%rdi
  jne    L60
  cmp    %r14d,0x20(%rsp)
  je     L108
  mov    (%rdx,%r9,1),%eax
  mov    %eax,(%rcx,%r9,1)
  cmp    0x2c(%rsp),%r14d
  jl     L108
  mov    (%rdx,%r10,1),%eax
  mov    %eax,(%rcx,%r10,1)
  cmp    0x30(%rsp),%r14d
  jl     L108
  mov    (%rdx,%r11,1),%eax
  mov    %eax,(%rcx,%r11,1)
L108:
  add    $0x1,%rsi
  cmp    %rsi,%r8
  jne    L254
L210:
  mov    0x78(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L268
  add    $0x88,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopw   0x0(%rax,%rax,1)
L242:
  mov    %rsi,0x30(%rsp)
  mov    $0x1,%eax
  nopw   0x0(%rax,%rax,1)
L159:
  mov    (%rdx,%rax,4),%esi
  mov    %esi,(%rcx,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%r8
  jne    L159
  mov    0x30(%rsp),%rsi
  jmp    L296
  nopl   0x0(%rax)
L67:
  mov    %rsi,0x8(%rsp)
  mov    $0x1,%eax
  nopw   0x0(%rax,%rax,1)
L78:
  mov    (%rdx,%rax,4),%esi
  mov    %esi,(%rcx,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%r8
  jne    L78
  mov    0x8(%rsp),%rsi
  jmp    L108
L138:
  movl   $0x1,(%rax)
  mov    0x40(%rsp),%rax
  mov    %rcx,%rsi
  mov    %r15d,0x4(%rax)
  mov    %rax,%r8
  jmp    L189
L268:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: data_label: D1
type: f32[4]

tool: {"D1": [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];
    }
  }
}
```