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

```asm
<heap_relax_snode>:
  endbr64
  push   %r15
  mov    %r8,%r15
  push   %r14
  mov    %edx,%r14d
  push   %r13
  push   %r12
  mov    %rsi,%r12
  push   %rbp
  mov    %edi,%ebp
  lea    0x2(%rdi,%rdi,2),%edi
  push   %rbx
  mov    %rcx,%rbx
  sub    $0x138,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x128(%rsp)
  xor    %eax,%eax
  call   <intMalloc@plt>
  mov    %rax,(%rsp)
  test   %rax,%rax
  je     L191
L194:
  movslq %ebp,%rax
  mov    %r12,%rsi
  mov    %ebp,%edi
  lea    0x4(,%rax,4),%r9
  mov    (%rsp),%rax
  lea    (%rax,%r9,1),%r13
  add    %r13,%r9
  mov    %r9,0x8(%rsp)
  call   <TreePostorder@plt>
  mov    0x8(%rsp),%r9
  lea    0x1(%rbp),%esi
  mov    %rax,%r8
  mov    %rax,%rdx
  xor    %eax,%eax
  test   %ebp,%ebp
  js     L5
  nopl   0x0(%rax)
L15:
  movslq (%rdx),%rcx
  add    $0x4,%rdx
  mov    %eax,0x0(%r13,%rcx,4)
  add    $0x1,%eax
  cmp    %esi,%eax
  jne    L15
  test   %ebp,%ebp
  jle    L5
  mov    %ebp,%eax
  mov    %r13,0x10(%rsp)
  mov    %r12,%rdx
  mov    %r9,%rdi
  mov    (%rsp),%r13
  mov    %rax,0x8(%rsp)
  sub    %r8,%rdx
  sub    %r8,%rdi
  lea    0x0(,%rax,4),%r11
  mov    %r8,%rax
  lea    (%r8,%r11,1),%r10
  cs nopw 0x0(%rax,%rax,1)
L85:
  movslq (%rdx,%rax,1),%rcx
  mov    (%r8,%rcx,4),%esi
  movslq (%rax),%rcx
  mov    %esi,0x0(%r13,%rcx,4)
  mov    (%rdx,%rax,1),%ecx
  mov    %ecx,(%rdi,%rax,1)
  add    $0x4,%rax
  cmp    %rax,%r10
  jne    L85
  mov    (%rsp),%rdi
  mov    %r12,%rcx
  mov    0x10(%rsp),%r13
  add    %rdi,%r11
  mov    %rdi,%rax
  sub    %rdi,%rcx
  nopl   0x0(%rax)
L231:
  mov    (%rax),%edx
  mov    %edx,(%rcx,%rax,1)
  add    $0x4,%rax
  cmp    %rax,%r11
  jne    L231
  mov    $0xffffffff,%edx
  mov    %ebp,%esi
  mov    %r15,%rdi
  mov    %r9,0x18(%rsp)
  mov    %r8,0x10(%rsp)
  call   <ifill@plt>
  mov    0x8(%rsp),%rax
  xor    %esi,%esi
  mov    %rbx,%rdi
  lea    0x0(,%rax,4),%rdx
  call   <memset@plt>
  mov    0x10(%rsp),%r8
  mov    0x18(%rsp),%r9
  xor    %eax,%eax
  mov    0x8(%rsp),%rsi
  nopw   0x0(%rax,%rax,1)
L159:
  movslq (%r12,%rax,4),%rdx
  cmp    %edx,%ebp
  je     L197
  mov    (%rbx,%rax,4),%edi
  lea    0x1(%rdi),%ecx
  add    %ecx,(%rbx,%rdx,4)
L197:
  add    $0x1,%rax
  cmp    %rsi,%rax
  jne    L159
  xor    %ecx,%ecx
  nopl   0x0(%rax)
L44:
  movslq %ecx,%rsi
  mov    %ecx,%r10d
  mov    (%r12,%rsi,4),%eax
  lea    0x0(,%rsi,4),%rdi
  cmp    %eax,%ebp
  jne    L243
  jmp    L133
  nopl   0x0(%rax,%rax,1)
L232:
  movslq (%r12,%rdx,4),%rdx
  mov    %eax,%r10d
  cmp    %edx,%ebp
  je     L26
  mov    %edx,%eax
L243:
  movslq %eax,%rdx
  lea    0x0(,%rdx,4),%rdi
  cmp    %r14d,(%rbx,%rdx,4)
  jl     L232
  movslq %r10d,%rdi
  mov    %r10d,%eax
  movslq %ebp,%rdx
  shl    $0x2,%rdi
L26:
  mov    %eax,%r10d
  sub    %ecx,%r10d
  cmp    %ecx,%eax
  jl     L273
L173:
  mov    %rsi,%rcx
  nopl   0x0(%rax)
L260:
  movslq 0x0(%r13,%rcx,4),%r11
  cmp    %r11d,%edx
  cmovg  %r11,%rdx
  add    $0x1,%rcx
  cmp    %ecx,%eax
  jge    L260
  mov    0x0(%r13,%rdi,1),%ecx
  mov    %ecx,%edi
  sub    %edx,%edi
  cmp    %r10d,%edi
  jne    L111
L66:
  mov    %ecx,(%r15,%rdx,4)
L199:
  lea    0x1(%rax),%ecx
  movslq %ecx,%rdx
  mov    (%rbx,%rdx,4),%esi
  test   %esi,%esi
  je     L145
  cmp    %ecx,%ebp
  jle    L163
  add    $0x2,%eax
  cltq
L282:
  mov    (%rbx,%rax,4),%edx
  mov    %eax,%ecx
  test   %edx,%edx
  setne  %sil
  cmp    %eax,%ebp
  setg   %dl
  add    $0x1,%rax
  test   %dl,%sil
  jne    L282
L145:
  cmp    %ecx,%ebp
  jg     L44
L163:
  mov    0x8(%rsp),%rcx
  xor    %eax,%eax
  nopl   0x0(%rax,%rax,1)
L170:
  mov    (%r9,%rax,4),%edx
  mov    %edx,(%r12,%rax,4)
  add    $0x1,%rax
  cmp    %rcx,%rax
  jne    L170
L255:
  mov    %r8,%rdi
  call   <superlu_free@plt>
  mov    0x128(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L82
  mov    (%rsp),%rdi
  add    $0x138,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    1140 <superlu_free@plt>
  nopw   0x0(%rax,%rax,1)
L111:
  mov    (%rbx,%rsi,4),%edi
  test   %edi,%edi
  jne    L189
  movslq 0x0(%r13,%rsi,4),%rcx
  mov    %ecx,(%r15,%rcx,4)
L189:
  add    $0x1,%rsi
  cmp    %esi,%eax
  jge    L111
  jmp    L199
  nopl   (%rax)
L273:
  mov    0x0(%r13,%rdi,1),%ecx
  mov    %ecx,%esi
  sub    %edx,%esi
  cmp    %r10d,%esi
  je     L66
  jmp    L199
L133:
  movslq %ebp,%rdx
  mov    %ecx,%eax
  xor    %r10d,%r10d
  jmp    L173
L191:
  lea    0x20(%rsp),%r13
  lea    D13(%rip),%rcx
  mov    $0x100,%esi
  lea    D5(%rip),%rdx
  mov    %r13,%rdi
  call   <sprintf_s@plt>
  mov    %r13,%rdi
  call   <WriteSLUErrorMessage@plt>
  mov    %r13,%rdi
  call   <superlu_abort_and_exit@plt>
  jmp    L194
L5:
  mov    $0xffffffff,%edx
  mov    %ebp,%esi
  mov    %r15,%rdi
  mov    %r8,0x8(%rsp)
  call   <ifill@plt>
  mov    0x8(%rsp),%r8
  jmp    L255
L82:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: tag: D13
datatype: string
name: parse_data
arguments: tag: D5
datatype: string

tool: D13: SUPERLU_MALLOC fails for iwork[]

tool: D5: Error: %s

assistant: ```c
void heap_relax_snode(const int n, int *et, const int relax_columns, int *descendants, int *relax_end) {
  register int i, j, k, l, parent;
  register int snode_start;
  int *et_save, *post, *inv_post, *iwork;
  int nsuper_et = 0, nsuper_et_post = 0;
  iwork = (int *)intMalloc(3 * n + 2);
  if (!iwork) {
    char msg[256];
    sprintf_s(msg, 256, "Error: %s", "SUPERLU_MALLOC fails for iwork[]");
    WriteSLUErrorMessage(msg);
    superlu_abort_and_exit(msg);
  };
  inv_post = iwork + n + 1;
  et_save = inv_post + n + 1;
  post = (int *)TreePostorder(n, et);
  for (i = 0; i < n + 1; ++i)
    inv_post[post[i]] = i;
  for (i = 0; i < n; ++i) {
    iwork[post[i]] = post[et[i]];
    et_save[i] = et[i];
  }
  for (i = 0; i < n; ++i)
    et[i] = iwork[i];
  ifill(relax_end, n, (-1));
  for (j = 0; j < n; j++)
    descendants[j] = 0;
  for (j = 0; j < n; j++) {
    parent = et[j];
    if (parent != n)
      descendants[parent] += descendants[j] + 1;
  }
  for (j = 0; j < n;) {
    parent = et[j];
    snode_start = j;
    while (parent != n && descendants[parent] < relax_columns) {
      j = parent;
      parent = et[j];
    }
    ++nsuper_et_post;
    k = n;
    for (i = snode_start; i <= j; ++i)
      k = ((k) < (inv_post[i]) ? (k) : (inv_post[i]));
    l = inv_post[j];
    if ((l - k) == (j - snode_start)) {
      relax_end[k] = l;
      ++nsuper_et;
    } else {
      for (i = snode_start; i <= j; ++i) {
        l = inv_post[i];
        if (descendants[i] == 0)
          relax_end[l] = l;
      }
    }
    j++;
    while (descendants[j] != 0 && j < n)
      j++;
  }
  for (i = 0; i < n; ++i)
    et[i] = et_save[i];
  superlu_free(post);
  superlu_free(iwork);
}
```