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

```asm
<typeI_migration>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  mov    %rsi,%r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x98,%rsp
  cmpl   $0x1,(%rdi)
  mov    %rcx,0x78(%rsp)
  mov    0x118(%rsp),%r10
  mov    0x120(%rsp),%rsi
  mov    0x130(%rsp),%r12
  jle    L48
  mov    %r13,%r15
  mov    $0x1,%ebp
  mov    %r12,%r13
  mov    %rdi,%r14
  mov    0x128(%rsp),%r12
  mov    %r9,%rcx
  jmp    L129
  nopl   0x0(%rax)
L117:
  add    $0x1,%rbp
  cmp    %ebp,(%r14)
  jle    L48
L129:
  cmpl   $0x1,(%r15,%rbp,4)
  ja     L117
  mov    0xd0(%rsp),%rax
  cmpl   $0x1,(%r10)
  movsd  (%rax,%rbp,8),%xmm3
  jle    L7
  movsd  D130(%rip),%xmm6
  mov    %r14,0x80(%rsp)
  mov    %rbp,%rdx
  xor    %ebx,%ebx
  mov    %r15,0x88(%rsp)
  mov    %r13,%r14
  mov    %rcx,%r15
  mov    %rsi,%rbp
  movsd  %xmm6,(%rsp)
  mov    %r10,%r13
  jmp    L38
  nopl   0x0(%rax,%rax,1)
L104:
  mov    0x0(%r13),%eax
  add    $0x1,%rbx
  sub    $0x1,%eax
  cmp    %ebx,%eax
  jle    L53
L38:
  movsd  0x0(%rbp,%rbx,8),%xmm1
  comisd %xmm1,%xmm3
  jbe    L104
  movsd  0x8(%rbp,%rbx,8),%xmm5
  comisd %xmm3,%xmm5
  jbe    L104
  movsd  0x8(%r14,%rbx,8),%xmm0
  mov    %rdx,0x70(%rsp)
  movsd  %xmm3,0x30(%rsp)
  movsd  %xmm1,0x8(%rsp)
  movsd  %xmm5,0x18(%rsp)
  call   <log@plt>
  movsd  (%r14,%rbx,8),%xmm4
  movsd  %xmm0,0x68(%rsp)
  movapd %xmm4,%xmm0
  movsd  %xmm4,0x60(%rsp)
  call   <log@plt>
  movsd  0x18(%rsp),%xmm5
  movsd  %xmm0,0x10(%rsp)
  movapd %xmm5,%xmm0
  movsd  %xmm5,0x28(%rsp)
  call   <log@plt>
  movsd  0x8(%rsp),%xmm1
  movsd  %xmm0,0x58(%rsp)
  movapd %xmm1,%xmm0
  call   <log@plt>
  movsd  %xmm0,0x18(%rsp)
  movsd  0x8(%r12,%rbx,8),%xmm0
  call   <log@plt>
  movsd  (%r12,%rbx,8),%xmm9
  add    $0x1,%rbx
  movsd  %xmm0,0x50(%rsp)
  movapd %xmm9,%xmm0
  movsd  %xmm9,0x48(%rsp)
  call   <log@plt>
  movsd  0x28(%rsp),%xmm5
  movsd  %xmm0,0x20(%rsp)
  movapd %xmm5,%xmm0
  call   <log@plt>
  movsd  0x8(%rsp),%xmm1
  movsd  %xmm0,0x40(%rsp)
  movapd %xmm1,%xmm0
  call   <log@plt>
  movsd  0x30(%rsp),%xmm3
  movsd  D178(%rip),%xmm7
  mov    0xd8(%rsp),%rax
  movsd  %xmm0,0x28(%rsp)
  mulsd  %xmm3,%xmm7
  movsd  %xmm3,0x38(%rsp)
  movsd  (%rax),%xmm6
  mov    D46(%rip),%rax
  movq   %rax,%xmm1
  movsd  %xmm6,0x8(%rsp)
  movapd %xmm7,%xmm0
  call   <pow@plt>
  movsd  D18(%rip),%xmm7
  mulsd  0x8(%rsp),%xmm7
  movapd %xmm0,%xmm1
  movapd %xmm7,%xmm0
  divsd  %xmm1,%xmm0
  movsd  (%rsp),%xmm1
  call   <pow@plt>
  movsd  (%rsp),%xmm1
  movsd  0x48(%rsp),%xmm9
  divsd  D24(%rip),%xmm9
  movsd  %xmm0,0x30(%rsp)
  movapd %xmm9,%xmm0
  call   <pow@plt>
  movsd  0x30(%rsp),%xmm5
  movsd  0x38(%rsp),%xmm3
  movsd  0x50(%rsp),%xmm6
  mulsd  D93(%rip),%xmm0
  movapd %xmm5,%xmm1
  movsd  0x40(%rsp),%xmm8
  subsd  0x28(%rsp),%xmm8
  divsd  D178(%rip),%xmm0
  mulsd  %xmm3,%xmm1
  movapd %xmm6,%xmm7
  mov    0x78(%rsp),%rax
  subsd  0x20(%rsp),%xmm7
  movsd  0x68(%rsp),%xmm2
  subsd  0x10(%rsp),%xmm2
  movsd  0x60(%rsp),%xmm4
  mulsd  D178(%rip),%xmm4
  mulsd  D178(%rip),%xmm4
  mov    0x70(%rsp),%rdx
  movsd  0x8(%rsp),%xmm6
  divsd  %xmm0,%xmm1
  movapd %xmm7,%xmm0
  movsd  0x58(%rsp),%xmm7
  subsd  0x18(%rsp),%xmm7
  mulsd  %xmm3,%xmm4
  mulsd  %xmm3,%xmm4
  divsd  %xmm8,%xmm0
  mulsd  %xmm1,%xmm1
  divsd  %xmm7,%xmm2
  mulsd  D16(%rip),%xmm0
  divsd  %xmm6,%xmm4
  addsd  %xmm2,%xmm0
  movsd  D115(%rip),%xmm2
  mulsd  (%rax),%xmm2
  subsd  D65(%rip),%xmm0
  mov    0x0(%r13),%eax
  sub    $0x1,%eax
  mulsd  %xmm2,%xmm0
  movsd  (%r15,%rdx,8),%xmm2
  divsd  %xmm6,%xmm2
  mulsd  %xmm2,%xmm0
  mulsd  %xmm4,%xmm0
  mulsd  %xmm1,%xmm0
  mulsd  %xmm3,%xmm0
  movapd %xmm0,%xmm2
  mulsd  %xmm5,%xmm2
  cmp    %ebx,%eax
  jg     L38
  nopw   0x0(%rax,%rax,1)
L53:
  mov    %r15,%rcx
  mov    %r13,%r10
  mov    %r14,%r13
  mov    %rbp,%rsi
  mov    0x88(%rsp),%r15
  mov    0x80(%rsp),%r14
  mov    %rdx,%rbp
L143:
  mov    0xe0(%rsp),%rax
  movsd  D29(%rip),%xmm0
  movsd  (%rsp),%xmm1
  mulsd  (%rax),%xmm0
  mov    0xd0(%rsp),%rax
  mulsd  %xmm2,%xmm0
  addsd  %xmm3,%xmm0
  movsd  D17(%rip),%xmm3
  movsd  %xmm0,(%rax,%rbp,8)
  mov    0xe8(%rsp),%rax
  movsd  (%rax,%rbp,8),%xmm4
  mulsd  %xmm4,%xmm1
  comisd %xmm0,%xmm1
  jbe    L40
  mov    0xf8(%rsp),%rax
  mov    D17(%rip),%rdi
  mov    (%rax,%rbp,4),%eax
  movq   %rdi,%xmm3
  cmp    $0x4,%eax
  jle    L42
L40:
  comisd %xmm0,%xmm3
  jbe    L117
  mov    0xd0(%rsp),%rax
  movq   $0x0,(%rax,%rbp,8)
  movl   $0x4,(%r15,%rbp,4)
  add    $0x1,%rbp
  cmp    %ebp,(%r14)
  jg     L129
L48:
  add    $0x98,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L42:
  movslq (%r14),%rdx
  pxor   %xmm1,%xmm1
  movapd %xmm3,%xmm0
  mov    %rcx,(%rsp)
  mov    0xd0(%rsp),%rdi
  cvtsi2sd %eax,%xmm1
  subsd  D31(%rip),%xmm1
  mov    %rsi,0x120(%rsp)
  mov    %r10,0x118(%rsp)
  movsd  %xmm4,(%rdi,%rdx,8)
  mov    0xe8(%rsp),%rdi
  movsd  %xmm2,0x10(%rsp)
  movsd  %xmm4,(%rdi,%rdx,8)
  movsd  %xmm3,0x8(%rsp)
  call   <pow@plt>
  mulsd  D110(%rip),%xmm0
  movslq (%r14),%rax
  mov    0xf0(%rsp),%r11
  mov    0x100(%rsp),%rdi
  lea    0x0(,%rax,8),%rdx
  mov    (%rsp),%rcx
  mov    0x120(%rsp),%rsi
  add    %rdx,%r11
  add    0x108(%rsp),%rdx
  mov    0x118(%rsp),%r10
  movsd  0x10(%rsp),%xmm2
  movsd  0x8(%rsp),%xmm3
  movsd  %xmm0,(%r11)
  pxor   %xmm0,%xmm0
  movq   $0x0,(%rdi,%rax,8)
  mov    0x110(%rsp),%rdi
  movq   $0x0,(%rdx)
  addsd  (%r11),%xmm0
  movsd  %xmm0,(%rdi,%rax,8)
  addsd  (%rdx),%xmm0
  mov    0xf8(%rsp),%rdi
  movsd  %xmm0,(%rcx,%rax,8)
  movl   $0x0,(%r15,%rax,4)
  mov    0xf8(%rsp),%rax
  movslq (%r14),%rdx
  mov    (%rax,%rbp,4),%eax
  mov    %eax,(%rsp)
  add    $0x1,%eax
  mov    %eax,(%rdi,%rdx,4)
  mov    0xe8(%rsp),%rax
  addl   $0x1,(%r14)
  movq   $0x0,(%rax,%rbp,8)
  mov    0xd0(%rsp),%rax
  movsd  (%rax,%rbp,8),%xmm0
  jmp    L40
  nopl   0x0(%rax)
L7:
  movsd  D130(%rip),%xmm6
  movsd  %xmm6,(%rsp)
  jmp    L143
```

tool_calls: name: read_data
arguments: data_label: D130
type_infered: f64
name: read_data
arguments: data_label: D178
type_infered: f64
name: read_data
arguments: data_label: D46
type_infered: f64
name: read_data
arguments: data_label: D18
type_infered: byte[8]
name: read_data
arguments: data_label: D24
type_infered: f64
name: read_data
arguments: data_label: D93
type_infered: f64
name: read_data
arguments: data_label: D16
type_infered: f64
name: read_data
arguments: data_label: D115
type_infered: f64
name: read_data
arguments: data_label: D65
type_infered: f64
name: read_data
arguments: data_label: D29
type_infered: f64
name: read_data
arguments: data_label: D17
type_infered: f64
name: read_data
arguments: data_label: D31
type_infered: f64
name: read_data
arguments: data_label: D110
type_infered: f64

tool: D130: 0.5

tool: D178: 14959787070000

tool: D46: 3

tool: {"D18": [0x23,0xc6,0xa8,0xc1,0x3b,0xea,0x71,0x3e]}

tool: D24: 300

tool: D93: 100000

tool: D16: 0.8

tool: D115: 1.08

tool: D65: 2.52

tool: D29: 31556926

tool: D17: 0.01

tool: D31: 1

tool: D110: 1e+20

assistant: ```c
void typeI_migration(int *n, int type[], double *qg, double *C1, double *fg, double Mp[], double a[], double *M, double *dt, double a_0[], double Mr[], int gene[], double Mi[], double Mg[], double Mc[], int *nd, double r[], double T[], double Sigg[], double *L) {
  int i, j;
  double tau_mig;
  double dr, p, q, Omega, Cs;
  for (i = 1; i < *n; i++) {
    if (type[i] == 0 || type[i] == 1) {
      for (j = 0; j < *nd - 1; j++) {
        if (a[i] > r[j] && a[i] < r[j + 1]) {
          p = (log(Sigg[j + 1]) - log(Sigg[j])) / (log(r[j + 1]) - log(r[j]));
          q = (log(T[j + 1]) - log(T[j])) / (log(r[j + 1]) - log(r[j]));
          Omega = pow(6.6738480e-8 * (*M) / pow(a[i] * 1.495978707e13, 3.0), 0.5);
          Cs = 1.0e5 * pow(T[j] / 3.0e2, 0.5) / 1.495978707e13;
          dr = *C1 * 1.08 * (p + 0.80 * q - 2.52) * (Mp[i] / (*M)) * (Sigg[j] * 1.495978707e13 * 1.495978707e13 * a[i] * a[i] / (*M)) * pow(a[i] * Omega / Cs, 2.0) * a[i] * Omega;
        }
      }
      a[i] += (*dt * 3.1556926e7) * dr;
      if (a[i] < 0.5 * a_0[i] && gene[i] < 5) {
        a[*n] = a_0[i];
        a_0[*n] = a_0[i];
        Mr[*n] = 1.0e20 * pow(0.01, (double)gene[i] - 1.0);
        Mi[*n] = 0.0;
        Mg[*n] = 0.0;
        Mc[*n] = Mr[*n] + Mi[*n];
        Mp[*n] = Mc[*n] + Mg[*n];
        type[*n] = 0;
        gene[*n] = gene[i] + 1;
        (*n)++;
        a_0[i] = 0.0;
      }
      if (a[i] < 0.01) {
        a[i] = 0.0;
        type[i] = 4;
      }
    }
  }
}
```