user: 请显示与下面列出的汇编代码相匹配的C语言实现：

```asm
<touch>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x78,%rsp
  mov    %edi,%ebx
  mov    %edi,0x5c(%rsp)
  mov    %rsi,0x10(%rsp)
  mov    %rdx,%r13
  mov    %rcx,0x8(%rsp)
  mov    %r9,(%rsp)
  mov    0xb0(%rsp),%rax
  mov    %rax,0x28(%rsp)
  mov    0xb8(%rsp),%r10
  mov    %r10,0x18(%rsp)
  mov    0xc0(%rsp),%rcx
  mov    %rcx,0x20(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x68(%rsp)
  xor    %eax,%eax
  movslq %edi,%rdx
  lea    0x0(,%rdx,4),%r11
  mov    %r11,0x50(%rsp)
  movl   $0x1,(%r9,%rdx,4)
  mov    %rcx,%rdi
  mov    (%rcx),%eax
  lea    0x1(%rax),%ecx
  mov    %ecx,(%rdi)
  cltq
  mov    %ebx,(%r10,%rax,4)
  mov    (%rsi,%rdx,4),%ebp
  lea    0x4(%rsi,%r11,1),%r15
  cmp    (%r15),%ebp
  jge    L9
  mov    %r8,%r12
  movslq %ebp,%rbp
  lea    0x64(%rsp),%rax
  mov    %rax,0x40(%rsp)
  jmp    L4
L179:
  mov    0x28(%rsp),%rcx
  mov    (%rcx),%ecx
  cmp    %ecx,%edx
  cmovle %edx,%ecx
  sub    %ecx,%edx
  mov    %edx,(%rsi)
  mov    %rdi,%rdx
  mov    0x50(%rsp),%rdi
  sub    %ecx,(%rdx,%rdi,1)
  mov    0x10(%rsp),%rdi
  mov    (%rdi,%rax,1),%edx
  mov    0x4(%rdi,%rax,1),%esi
  cmp    %esi,%edx
  jge    L123
  movslq %edx,%rax
  lea    0x0(%r13,%rax,4),%rax
  mov    0x5c(%rsp),%edi
L135:
  cmp    %edi,(%rax)
  je     L123
  add    $0x1,%edx
  add    $0x4,%rax
  cmp    %esi,%edx
  jne    L135
  mov    %esi,%edx
L123:
  movslq %edx,%rdx
  add    %ecx,(%r12,%rdx,4)
  jmp    L147
L85:
  add    $0x1,%rbx
  cmp    %ebx,(%r14)
  jle    L3
L1:
  lea    0x0(,%rbx,4),%rbp
  lea    (%r12,%rbp,1),%r15
  mov    (%r12,%rbx,4),%eax
  test   %eax,%eax
  je     L85
  add    %r13,%rbp
  mov    0x0(%r13,%rbx,4),%edi
  movslq %edi,%rdx
  mov    (%rsp),%rsi
  cmpl   $0x0,(%rsi,%rdx,4)
  jne    L85
  mov    0x28(%rsp),%rsi
  mov    (%rsi),%edx
  cmp    %eax,%edx
  cmovg  %eax,%edx
  mov    %edx,0x64(%rsp)
  sub    $0x8,%rsp
  push   0x28(%rsp)
  push   0x28(%rsp)
  push   0x58(%rsp)
  mov    0x20(%rsp),%r9
  mov    %r12,%r8
  mov    0x28(%rsp),%rcx
  mov    %r13,%rdx
  mov    0x30(%rsp),%rsi
  call   <touch>
  mov    0x84(%rsp),%ecx
  add    $0x20,%rsp
  test   %ecx,%ecx
  je     L85
  movslq 0x0(%rbp),%rax
  mov    0x8(%rsp),%rdi
  add    %ecx,(%rdi,%rax,4)
  mov    0x50(%rsp),%rdx
  sub    %ecx,(%rdi,%rdx,1)
  sub    %ecx,(%r15)
  mov    0x48(%rsp),%rax
  mov    (%rax),%eax
  mov    (%r14),%esi
  cmp    %esi,%eax
  jge    L134
  movslq %eax,%rdx
  lea    0x0(%r13,%rdx,4),%rdx
  mov    0x5c(%rsp),%edi
L94:
  cmp    %edi,(%rdx)
  je     L134
  add    $0x1,%eax
  add    $0x4,%rdx
  cmp    %esi,%eax
  jne    L94
  mov    %esi,%eax
L134:
  cltq
  add    %ecx,(%r12,%rax,4)
L147:
  mov    0x28(%rsp),%rax
  mov    %ecx,(%rax)
  jmp    L25
L3:
  mov    0x30(%rsp),%r15
  mov    0x38(%rsp),%rbp
L178:
  add    $0x1,%rbp
  cmp    %ebp,(%r15)
  jle    L9
L4:
  mov    0x0(%r13,%rbp,4),%edx
  movslq %edx,%rax
  shl    $0x2,%rax
  mov    (%rsp),%rsi
  lea    (%rsi,%rax,1),%rcx
  cmpl   $0x0,(%rcx)
  jne    L178
  movl   $0x1,(%rcx)
  mov    0x20(%rsp),%rdi
  mov    (%rdi),%ecx
  lea    0x1(%rcx),%esi
  mov    %esi,(%rdi)
  movslq %ecx,%rcx
  mov    0x18(%rsp),%rdi
  mov    %edx,(%rdi,%rcx,4)
  mov    0x8(%rsp),%rdi
  lea    (%rdi,%rax,1),%rsi
  mov    (%rsi),%edx
  test   %edx,%edx
  jne    L179
  mov    0x10(%rsp),%rcx
  lea    (%rcx,%rax,1),%rdi
  mov    %rdi,0x48(%rsp)
  mov    (%rdi),%ebx
  lea    0x4(%rcx,%rax,1),%r14
  cmp    (%r14),%ebx
  jge    L178
  movslq %ebx,%rbx
  mov    %r15,0x30(%rsp)
  mov    %rbp,0x38(%rsp)
  jmp    L1
L9:
  mov    0x28(%rsp),%rax
  movl   $0x0,(%rax)
L25:
  mov    0x68(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L97
  add    $0x78,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L97:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void touch(int node, int *pointers, int *indices, int *resid, int *flow, int *touched, int *flow1, int *seen, int *nseen) {
  int flow2;
  int neighbor;
  int i, j, k;
  touched[node] = 1;
  seen[(*nseen)++] = node;
  for (i = pointers[node]; i < pointers[node + 1]; i++) {
    neighbor = indices[i];
    if (!touched[neighbor]) {
      touched[neighbor] = 1;
      seen[(*nseen)++] = neighbor;
      if (resid[neighbor]) {
        flow2 = ((*flow1) < (resid[neighbor]) ? (*flow1) : (resid[neighbor]));
        resid[neighbor] -= flow2;
        resid[node] -= flow2;
        for (k = pointers[neighbor]; k < pointers[neighbor + 1] && indices[k] != node; k++) {
          ;
        }
        flow[k] += flow2;
        *flow1 = flow2;
        return;
      }
      for (j = pointers[neighbor]; j < pointers[neighbor + 1]; j++) {
        if (flow[j] && !touched[indices[j]]) {
          flow2 = ((*flow1) < (flow[j]) ? (*flow1) : (flow[j]));
          touch(indices[j], pointers, indices, resid, flow, touched, &flow2, seen, nseen);
          if (flow2) {
            resid[indices[j]] += flow2;
            resid[node] -= flow2;
            flow[j] -= flow2;
            for (k = pointers[neighbor]; k < pointers[neighbor + 1] && indices[k] != node; k++) {
              ;
            }
            flow[k] += flow2;
            *flow1 = flow2;
            return;
          }
        }
      }
    }
  }
  *flow1 = 0;
}
```