user: 请从给定的汇编指令推导出C源代码:

```asm
<track1>:
  endbr64
  push   %r15
  lea    0x1(%rsi),%eax
  mov    %r8,%r15
  push   %r14
  push   %r13
  push   %r12
  mov    %edx,%r12d
  push   %rbp
  mov    %esi,%ebp
  mov    $0x4,%esi
  add    $0x1,%r12d
  push   %rbx
  sub    $0x68,%rsp
  mov    %rdi,0x18(%rsp)
  mov    %eax,%edi
  mov    0xb8(%rsp),%r13
  mov    %r9,0x8(%rsp)
  mov    0xc0(%rsp),%rbx
  mov    %edx,0x2c(%rsp)
  mov    %ecx,0x20(%rsp)
  mov    %eax,0x44(%rsp)
  call   <calloc@plt>
  mov    0x44(%rsp),%edi
  mov    %r12d,%esi
  mov    %rax,%r14
  call   <imatrix@plt>
  mov    0x20(%rsp),%r10d
  mov    0x8(%rsp),%r9
  mov    %rax,0x10(%rsp)
  movsd  D5(%rip),%xmm0
  test   %r10d,%r10d
  jle    L16
  mov    0xa8(%rsp),%r8
  lea    0x1(%r10),%edi
  mov    $0x1,%eax
L493:
  movswq -0x2(%r15,%rax,2),%rdx
  test   %dx,%dx
  jle    L321
  movswq -0x2(%r9,%rax,2),%rsi
  movl   $0x1,(%r14,%rdx,4)
  test   %si,%si
  jle    L321
  mov    0xa0(%rsp),%rcx
  pxor   %xmm1,%xmm1
  cvtss2sd -0x4(%rcx,%rax,4),%xmm1
  comisd %xmm1,%xmm0
  jbe    L321
  mov    %eax,%ecx
  sub    %r10d,%ecx
  sub    $0x1,%ecx
  movslq %ecx,%rcx
  movzbl (%r8,%rcx,1),%ecx
  cmp    %cl,-0x1(%r8,%rax,1)
  jne    L321
  mov    0x10(%rsp),%rcx
  mov    (%rcx,%rdx,8),%rdx
  movl   $0x1,(%rdx,%rsi,4)
L321:
  add    $0x1,%rax
  cmp    %rdi,%rax
  jne    L493
L16:
  mov    0x44(%rsp),%edi
  mov    $0x4,%esi
  call   <calloc@plt>
  mov    %rax,0x38(%rsp)
  test   %ebp,%ebp
  jle    L466
  mov    0x10(%rsp),%rax
  lea    -0x1(%rbp),%r8d
  mov    0x2c(%rsp),%r11d
  xor    %edi,%edi
  lea    0x8(,%r8,4),%r9
  mov    $0x4,%ecx
  xor    %r12d,%r12d
  lea    0x8(%rax),%r10
  mov    %r10,%rsi
L549:
  movslq 0x44(%rsp),%rax
  add    (%r14,%rcx,1),%edi
  mov    %edi,%r15d
  cmp    %r11d,%eax
  jg     L263
  mov    (%rsi),%rdx
  jmp    L589
L102:
  add    $0x1,%rax
  cmp    %eax,%r11d
  jl     L263
L589:
  cmpl   $0x1,(%rdx,%rax,4)
  jne    L102
  mov    0x18(%rsp),%rdx
  add    $0x1,%r12d
  mov    (%rdx),%rax
  add    %rcx,%rax
  addl   $0x1,(%rax)
  mov    0x38(%rsp),%rax
  movl   $0x1,(%rax,%rcx,1)
L263:
  add    $0x4,%rcx
  add    $0x8,%rsi
  cmp    %r9,%rcx
  jne    L549
  mov    %r14,%rdi
  mov    %r8,0x20(%rsp)
  sub    %r15d,%r12d
  mov    %r10,0x8(%rsp)
  call   <free@plt>
  mov    0x2c(%rsp),%eax
  cmp    %eax,0x44(%rsp)
  mov    %r12d,0x40(%rsp)
  mov    0x8(%rsp),%r10
  mov    0x20(%rsp),%r8
  mov    %eax,0x0(%r13)
  jg     L285
  mov    %eax,%r12d
  lea    0x3(%r8),%rax
  movq   $0x1,0x8(%rsp)
  mov    $0x2,%r15d
  mov    %rax,0x48(%rsp)
  movslq 0x44(%rsp),%rax
  mov    %rbx,0xc0(%rsp)
  mov    %rax,0x58(%rsp)
  mov    0xb0(%rsp),%rax
  lea    0x8(%rax),%r14
  mov    %rax,%r11
  mov    %r14,0x30(%rsp)
L568:
  lea    0x8(%r10),%rdi
  mov    (%r10),%rbx
  mov    0x44(%rsp),%esi
  mov    %r15d,0x50(%rsp)
  mov    0x8(%rsp),%rax
  mov    %rdi,0x20(%rsp)
  mov    %eax,0x54(%rsp)
  lea    0x0(,%rax,4),%r14
  mov    0x58(%rsp),%rax
  jmp    L533
L458:
  add    $0x1,%rax
  cmp    %r8d,%r12d
  je     L409
L533:
  mov    %esi,%r8d
  add    $0x1,%esi
  cmpl   $0x1,(%rbx,%rax,4)
  lea    0x0(,%rax,4),%rdi
  jne    L458
  cmp    %esi,%r12d
  jl     L479
  mov    %r12d,%ecx
  mov    0x30(%rsp),%r10
  movslq %esi,%rdx
  sub    %esi,%ecx
  lea    (%r11,%rdx,4),%rdx
  add    %rax,%rcx
  lea    (%r10,%rcx,4),%r9
  nopl   0x0(%rax)
L497:
  mov    (%rdx),%ecx
  cmp    (%r11,%rax,4),%ecx
  jle    L362
  sub    $0x1,%ecx
  mov    %ecx,(%rdx)
L362:
  add    $0x4,%rdx
  cmp    %rdx,%r9
  jne    L497
L479:
  mov    0x54(%rsp),%ecx
  mov    %r15,%rdx
  mov    %ecx,(%r11,%rax,4)
  mov    0x20(%rsp),%rcx
  cmp    %ebp,0x50(%rsp)
  jg     L470
  nopl   0x0(%rax)
L52:
  mov    (%rcx),%r10
  lea    (%r10,%rdi,1),%r9
  cmpl   $0x1,(%r9)
  jne    L276
  movl   $0x1,(%r10,%r14,1)
  movl   $0x1,(%rbx,%rdx,4)
  movl   $0x0,(%r9)
L276:
  add    $0x1,%rdx
  add    $0x8,%rcx
  cmp    %edx,%ebp
  jge    L52
L470:
  subl   $0x1,0x0(%r13)
  add    $0x1,%rax
  cmp    %r8d,%r12d
  jne    L533
L409:
  addq   $0x1,0x8(%rsp)
  mov    0x20(%rsp),%r10
  add    $0x1,%r15
  cmp    %r15,0x48(%rsp)
  jne    L568
  mov    0xc0(%rsp),%rbx
  mov    0x30(%rsp),%r14
L564:
  mov    0x0(%r13),%eax
  lea    0x1(%rax),%r12d
L30:
  mov    0x18(%rsp),%r15
  lea    0x0(,%r12,4),%esi
  mov    (%r15),%rdi
  call   <realloc@plt>
  mov    %rax,(%r15)
  mov    %rax,%r12
  mov    0x44(%rsp),%eax
  cmp    0x0(%r13),%eax
  jg     L467
  cltq
  lea    (%r12,%rax,4),%rdx
L271:
  movl   $0x1,(%rdx)
  add    $0x1,%eax
  add    $0x4,%rdx
  cmp    %eax,0x0(%r13)
  jge    L271
L467:
  mov    0x2c(%rsp),%eax
  mov    %ebp,(%rbx)
  sub    $0x1,%eax
  lea    (%r14,%rax,4),%r14
  mov    %r14,%rax
  mov    %r12,%r14
  mov    %rax,%r12
L258:
  cmp    $0x1,%ebp
  jle    L318
  mov    $0x1,%r10d
  xor    %eax,%eax
  mov    $0x1,%r15d
  nopl   0x0(%rax,%rax,1)
L507:
  mov    %r15d,0x20(%rsp)
  add    $0x1,%r15d
  cmp    %ebp,%r15d
  jg     L582
  mov    0x10(%rsp),%rsi
  mov    %r15d,0x30(%rsp)
  mov    %r15d,%ecx
  mov    (%rsi,%r10,8),%r11
  lea    0x0(,%r10,4),%rsi
  lea    (%rsi,%r14,1),%rdi
  mov    %rsi,0x18(%rsp)
  movslq %r15d,%rsi
  mov    %rdi,%r15
  jmp    L389
  nopl   0x0(%rax)
L154:
  add    $0x1,%rsi
  cmp    %ecx,%ebp
  jl     L163
L389:
  add    $0x1,%ecx
  cmpl   $0x1,(%r11,%rsi,4)
  jne    L154
  mov    0xb0(%rsp),%rax
  mov    0x2c(%rsp),%edx
  subl   $0x1,0x40(%rsp)
  mov    0x20(%rsp),%edi
  add    $0x4,%rax
  test   %edx,%edx
  jg     L182
  jmp    L473
  nopl   (%rax)
L78:
  jle    L317
  sub    $0x1,%edx
  mov    %edx,(%rax)
L317:
  add    $0x4,%rax
  cmp    %rax,%r12
  je     L473
L182:
  mov    (%rax),%edx
  cmp    %esi,%edx
  jne    L78
  mov    %edi,(%rax)
  add    $0x4,%rax
  cmp    %rax,%r12
  jne    L182
L473:
  mov    (%r15),%eax
  mov    (%r14,%rsi,4),%edx
  cmp    %edx,%eax
  cmovl  %edx,%eax
  mov    %eax,(%r15)
  cmp    %ecx,0x0(%r13)
  jl     L528
  movslq %ecx,%rax
  mov    %ecx,%edx
  lea    (%r14,%rax,4),%rax
  nopw   0x0(%rax,%rax,1)
L70:
  mov    (%rax),%edi
  add    $0x1,%edx
  add    $0x4,%rax
  mov    %edi,-0x8(%rax)
  cmp    %edx,0x0(%r13)
  jge    L70
L528:
  mov    (%rbx),%eax
  test   %eax,%eax
  jle    L167
  mov    0x10(%rsp),%rdi
  mov    $0x1,%edx
  lea    (%rdi,%rsi,8),%rbp
  add    $0x8,%rdi
  mov    %rdi,%r8
  nopl   0x0(%rax)
L415:
  cmp    %r10d,%edx
  je     L316
  cmp    %esi,%edx
  je     L316
  mov    0x0(%rbp),%r9
  cmpl   $0x1,(%r9,%rdx,4)
  jne    L316
  mov    (%r8),%rax
  mov    0x18(%rsp),%r9
  movl   $0x1,(%rax,%r9,1)
  movl   $0x1,(%r11,%rdx,4)
  mov    (%rbx),%eax
  cs nopw 0x0(%rax,%rax,1)
L316:
  add    $0x1,%rdx
  add    $0x8,%r8
  cmp    %edx,%eax
  jge    L415
  test   %eax,%eax
  jle    L167
  mov    $0x1,%r9d
  cmp    %ecx,%eax
  jl     L380
  nopw   0x0(%rax,%rax,1)
L457:
  mov    (%rdi),%r8
  movslq %ecx,%rdx
  cs nopw 0x0(%rax,%rax,1)
L180:
  mov    (%r8,%rdx,4),%eax
  mov    %eax,-0x4(%r8,%rdx,4)
  mov    (%rbx),%eax
  add    $0x1,%rdx
  cmp    %edx,%eax
  jge    L180
  add    $0x1,%r9d
  cmp    %eax,%r9d
  jg     L475
  add    $0x8,%rdi
  cmp    %ecx,%eax
  jge    L457
L380:
  add    $0x1,%r9d
  cmp    %eax,%r9d
  jg     L475
L167:
  sub    $0x1,%eax
  add    $0x1,%rsi
  mov    %eax,(%rbx)
  mov    $0x1,%eax
  subl   $0x1,0x0(%r13)
  mov    (%rbx),%ebp
  cmp    %ecx,%ebp
  jge    L389
L163:
  mov    0x30(%rsp),%r15d
L582:
  add    $0x1,%r10
  cmp    %ebp,%r15d
  jl     L507
  cmp    $0x1,%eax
  je     L258
L318:
  mov    0x38(%rsp),%rdi
  call   <free@plt>
  mov    0x44(%rsp),%esi
  mov    0x10(%rsp),%rdi
  call   <free_imatrix@plt>
  mov    0x40(%rsp),%eax
  add    $0x68,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L466:
  mov    %r14,%rdi
  call   <free@plt>
  mov    0x2c(%rsp),%eax
  movl   $0x0,0x40(%rsp)
  mov    %eax,0x0(%r13)
  mov    0xb0(%rsp),%rax
  lea    0x8(%rax),%r14
  jmp    L30
L285:
  mov    0xb0(%rsp),%rax
  lea    0x8(%rax),%r14
  jmp    L564
L475:
  cmp    %ecx,%eax
  jl     L167
  mov    0x38(%rsp),%rdi
  movslq %ecx,%rax
  mov    %ecx,%r9d
  lea    (%rdi,%rax,4),%r8
  mov    0x10(%rsp),%rdi
  lea    (%rdi,%rax,8),%rdi
  nopw   0x0(%rax,%rax,1)
L132:
  mov    (%rdi),%rbp
  mov    -0x8(%rdi),%rdx
  mov    %ecx,0x8(%rsp)
  mov    $0x1,%eax
  nopl   0x0(%rax,%rax,1)
L531:
  mov    0x0(%rbp,%rax,4),%ecx
  mov    %ecx,(%rdx,%rax,4)
  add    $0x1,%rax
  cmp    %eax,(%rbx)
  jg     L531
  mov    (%r8),%eax
  add    $0x1,%r9d
  mov    0x8(%rsp),%ecx
  add    $0x4,%r8
  add    $0x8,%rdi
  mov    %eax,-0x8(%r8)
  mov    (%rbx),%eax
  cmp    %r9d,%eax
  jge    L132
  jmp    L167
```

tool_calls: name: extract_symbolic_data
arguments: tag: D5
data_type: f64

tool: D5: 0.2

assistant: ```c
int track1(int **tracklen, int TR, int TR2, int imgsize, short *rmap1, short *rmap2, float *JT, unsigned char *rmap0, int *convert, int *TR1, int *newTR) {
  int **neigh, i, j, k, l, l1, m, TR4, *appear, Tappear, *tracked;
  appear = (int *)calloc(TR + 1, sizeof(int));
  neigh = (int **)imatrix(TR + 1, TR2 + 1);
  for (l = 0; l < imgsize; l++) {
    l1 = l - imgsize;
    if (rmap1[l] > 0) {
      appear[rmap1[l]] = 1;
      if (rmap2[l] > 0 && JT[l] < 0.2) {
        if (rmap0[l] == rmap0[l1])
          neigh[rmap1[l]][rmap2[l]] = 1;
      }
    }
  }
  tracked = (int *)calloc(TR + 1, sizeof(int));
  TR4 = 0;
  Tappear = 0;
  for (i = 1; i <= TR; i++) {
    Tappear += appear[i];
    for (j = TR + 1; j <= TR2; j++) {
      if (neigh[i][j] == 1) {
        (*tracklen)[i]++;
        TR4++;
        tracked[i] = 1;
        break;
      }
    }
  }
  free(appear);
  TR4 = TR4 - Tappear;
  *TR1 = TR2;
  for (i = 1; i <= TR; i++) {
    for (j = TR + 1; j <= TR2; j++) {
      if (neigh[i][j] == 1) {
        for (k = j + 1; k <= TR2; k++) {
          if (convert[k] > convert[j])
            convert[k]--;
        }
        convert[j] = i;
        for (k = i + 1; k <= TR; k++) {
          if (neigh[k][j] == 1) {
            neigh[i][k] = neigh[k][i] = 1;
            neigh[k][j] = 0;
          }
        }
        (*TR1)--;
      }
    }
  }
  *tracklen = (int *)realloc(*tracklen, ((*TR1) + 1) * sizeof(int));
  for (i = TR + 1; i <= (*TR1); i++)
    (*tracklen)[i] = 1;
  *newTR = TR;
  do {
    m = 0;
    for (i = 1; i < (*newTR); i++) {
      for (j = i + 1; j <= (*newTR); j++) {
        if (neigh[i][j] == 1) {
          TR4--;
          for (k = 1; k <= TR2; k++) {
            if (convert[k] == j)
              convert[k] = i;
            else if (convert[k] > j)
              convert[k]--;
          }
          (*tracklen)[i] = ((((*tracklen)[i]) > ((*tracklen)[j])) ? ((*tracklen)[i]) : ((*tracklen)[j]));
          for (k = j + 1; k <= (*TR1); k++)
            (*tracklen)[k - 1] = (*tracklen)[k];
          for (k = 1; k <= (*newTR); k++) {
            if (k != i && k != j) {
              if (neigh[j][k] == 1) {
                neigh[i][k] = neigh[k][i] = 1;
              }
            }
          }
          for (k = 1; k <= (*newTR); k++)
            for (l = j + 1; l <= (*newTR); l++)
              neigh[k][l - 1] = neigh[k][l];
          for (k = j + 1; k <= (*newTR); k++) {
            for (l = 1; l <= (*newTR) - 1; l++)
              neigh[k - 1][l] = neigh[k][l];
            tracked[k - 1] = tracked[k];
          }
          (*newTR)--;
          (*TR1)--;
          m = 1;
        }
      }
    }
  } while (m == 1);
  free(tracked);
  free_imatrix(neigh, TR + 1);
  return TR4;
}
```