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

```asm
<heap_relax_snode>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  mov    %edx,%r13d
  push   %r12
  mov    %rsi,%r12
  push   %rbp
  mov    %edi,%ebp
  lea    0x2(%rdi,%rdi,2),%edi
  push   %rbx
  mov    %rcx,%rbx
  sub    $0x158,%rsp
  mov    %r8,0x8(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x148(%rsp)
  xor    %eax,%eax
  call   <intMalloc@plt>
  mov    %rax,%r14
  test   %rax,%rax
  je     L334
L320:
  movslq %ebp,%rax
  mov    %r12,%rsi
  mov    %ebp,%edi
  mov    %rax,0x10(%rsp)
  lea    0x4(,%rax,4),%rax
  lea    (%r14,%rax,1),%r15
  add    %r15,%rax
  mov    %rax,0x38(%rsp)
  call   <TreePostorder@plt>
  lea    0x1(%rbp),%esi
  mov    %rax,0x28(%rsp)
  mov    %rax,%rdx
  xor    %eax,%eax
  test   %ebp,%ebp
  js     L43
  nopl   0x0(%rax,%rax,1)
L442:
  movslq (%rdx),%rcx
  add    $0x4,%rdx
  mov    %eax,(%r15,%rcx,4)
  add    $0x1,%eax
  cmp    %esi,%eax
  jne    L442
  test   %ebp,%ebp
  jle    L43
  mov    0x28(%rsp),%rsi
  mov    %ebp,%eax
  mov    0x38(%rsp),%rdi
  mov    %r12,%rdx
  lea    0x0(,%rax,4),%r9
  mov    %rax,0x30(%rsp)
  lea    -0x1(%rbp),%r10d
  lea    (%rsi,%r9,1),%r8
  mov    %rsi,%rax
  sub    %rsi,%rdx
  sub    %rsi,%rdi
  nopw   0x0(%rax,%rax,1)
L261:
  movslq (%rdx,%rax,1),%rcx
  mov    (%rsi,%rcx,4),%r11d
  movslq (%rax),%rcx
  mov    %r11d,(%r14,%rcx,4)
  mov    (%rdx,%rax,1),%ecx
  mov    %ecx,(%rdi,%rax,1)
  add    $0x4,%rax
  cmp    %r8,%rax
  jne    L261
  cmp    $0x2,%r10d
  lea    0x4(%r14),%rdx
  mov    %r12,%rax
  seta   0x27(%rsp)
  sub    %rdx,%rax
  movzbl 0x27(%rsp),%edi
  cmp    $0x8,%rax
  jbe    L153
  test   %dil,%dil
  je     L153
  mov    %ebp,%edx
  mov    %r12,%rcx
  mov    %r14,%rax
  shr    $0x2,%edx
  sub    %r14,%rcx
  shl    $0x4,%rdx
  add    %r14,%rdx
  xchg   %ax,%ax
L58:
  movdqu (%rax),%xmm5
  movups %xmm5,(%rcx,%rax,1)
  add    $0x10,%rax
  cmp    %rdx,%rax
  jne    L58
  mov    %ebp,%eax
  and    $0xfffffffc,%eax
  test   $0x3,%bpl
  je     L131
  mov    %eax,%ecx
  mov    (%r14,%rcx,4),%esi
  lea    0x0(,%rcx,4),%rdx
  mov    %esi,(%r12,%rcx,4)
  lea    0x1(%rax),%ecx
  cmp    %ecx,%ebp
  jle    L131
  mov    0x4(%r14,%rdx,1),%ecx
  add    $0x2,%eax
  mov    %ecx,0x4(%r12,%rdx,1)
  cmp    %eax,%ebp
  jle    L131
  mov    0x8(%r14,%rdx,1),%eax
  mov    %eax,0x8(%r12,%rdx,1)
L131:
  mov    0x8(%rsp),%rdi
  mov    $0xffffffff,%edx
  mov    %ebp,%esi
  call   <ifill@plt>
  mov    0x30(%rsp),%rax
  xor    %esi,%esi
  mov    %rbx,%rdi
  lea    0x0(,%rax,4),%rdx
  call   <memset@plt>
  mov    0x30(%rsp),%rsi
  xor    %eax,%eax
  nop
L204:
  movslq (%r12,%rax,4),%rdx
  cmp    %edx,%ebp
  je     L433
  mov    (%rbx,%rax,4),%edi
  lea    0x1(%rdi),%ecx
  add    %ecx,(%rbx,%rdx,4)
L433:
  add    $0x1,%rax
  cmp    %rsi,%rax
  jne    L204
  mov    %r14,0x18(%rsp)
  mov    0x8(%rsp),%r10
  xor    %ecx,%ecx
  cs nopw 0x0(%rax,%rax,1)
L388:
  movslq %ecx,%r8
  mov    %ecx,%r9d
  mov    (%r12,%r8,4),%eax
  mov    %r8,%rsi
  lea    0x0(,%r8,4),%rdi
  cmp    %eax,%ebp
  jne    L109
  jmp    L370
  xchg   %ax,%ax
L386:
  mov    (%r12,%rdx,4),%edx
  mov    %eax,%r9d
  cmp    %edx,%ebp
  je     L157
  mov    %edx,%eax
L109:
  movslq %eax,%rdx
  lea    0x0(,%rdx,4),%rdi
  cmp    %r13d,(%rbx,%rdx,4)
  jl     L386
  movslq %r9d,%rdi
  mov    %r9d,%eax
  mov    %ebp,%edx
  shl    $0x2,%rdi
L157:
  mov    %eax,%r11d
  sub    %ecx,%r11d
  cmp    %ecx,%eax
  jl     L231
L53:
  mov    %eax,%r14d
  sub    %ecx,%r14d
  cmp    %eax,%ecx
  mov    %r14d,0x8(%rsp)
  lea    0x1(%r14),%r9d
  mov    $0x1,%r14d
  cmovg  %r14d,%r9d
  cmpl   $0x2,0x8(%rsp)
  jbe    L287
  cmp    %eax,%ecx
  jg     L287
  movd   %edx,%xmm4
  mov    0x18(%rsp),%rdx
  add    0x10(%rsp),%r8
  pshufd $0x0,%xmm4,%xmm0
  lea    (%rdx,%r8,4),%r14
  mov    %r9d,%r8d
  shr    $0x2,%r8d
  lea    0x4(%r14),%rdx
  sub    $0x1,%r8d
  shl    $0x4,%r8
  lea    0x14(%r14,%r8,1),%r8
  nopl   (%rax)
L154:
  movdqu (%rdx),%xmm1
  movdqu (%rdx),%xmm3
  add    $0x10,%rdx
  pcmpgtd %xmm0,%xmm1
  pand   %xmm1,%xmm0
  pandn  %xmm3,%xmm1
  por    %xmm1,%xmm0
  cmp    %r8,%rdx
  jne    L154
  movdqa %xmm0,%xmm2
  mov    %r9d,%r8d
  psrldq $0x8,%xmm2
  and    $0xfffffffc,%r8d
  movdqa %xmm2,%xmm1
  add    %r8d,%ecx
  pcmpgtd %xmm0,%xmm1
  pand   %xmm1,%xmm0
  pandn  %xmm2,%xmm1
  por    %xmm1,%xmm0
  movdqa %xmm0,%xmm2
  psrldq $0x4,%xmm2
  movdqa %xmm2,%xmm1
  pcmpgtd %xmm0,%xmm1
  pand   %xmm1,%xmm0
  pandn  %xmm2,%xmm1
  por    %xmm0,%xmm1
  movd   %xmm1,%edx
  cmp    %r9d,%r8d
  je     L449
  movslq %ecx,%r8
L287:
  lea    0x0(,%r8,4),%r9
  mov    (%r15,%r8,4),%r8d
  cmp    %r8d,%edx
  cmovg  %r8d,%edx
  lea    0x1(%rcx),%r8d
  cmp    %r8d,%eax
  jl     L449
  mov    0x4(%r15,%r9,1),%r8d
  cmp    %r8d,%edx
  cmovg  %r8d,%edx
  add    $0x2,%ecx
  cmp    %ecx,%eax
  jl     L449
  mov    0x8(%r15,%r9,1),%ecx
  cmp    %ecx,%edx
  cmovg  %ecx,%edx
L449:
  mov    (%r15,%rdi,1),%ecx
  mov    %ecx,%edi
  sub    %edx,%edi
  cmp    %r11d,%edi
  jne    L86
L106:
  movslq %edx,%rdx
  mov    %ecx,(%r10,%rdx,4)
L104:
  lea    0x1(%rax),%ecx
  movslq %ecx,%rdx
  mov    (%rbx,%rdx,4),%esi
  test   %esi,%esi
  je     L360
  cmp    %ecx,%ebp
  jle    L470
  add    $0x2,%eax
  cltq
L289:
  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    L289
L360:
  cmp    %ecx,%ebp
  jg     L388
L470:
  mov    0x10(%rsp),%rax
  mov    0x18(%rsp),%r14
  lea    (%r14,%rax,8),%rsi
  mov    %r12,%rax
  lea    0xc(%rsi),%rdx
  sub    %rdx,%rax
  cmp    $0x8,%rax
  jbe    L145
  cmpb   $0x0,0x27(%rsp)
  je     L145
  mov    %ebp,%edx
  lea    0x8(%rsi),%rax
  shr    $0x2,%edx
  sub    $0x1,%edx
  shl    $0x4,%rdx
  lea    0x18(%rsi,%rdx,1),%rcx
  mov    %r12,%rdx
  sub    %rsi,%rdx
  nopl   0x0(%rax)
L284:
  movdqu (%rax),%xmm6
  movups %xmm6,-0x8(%rdx,%rax,1)
  add    $0x10,%rax
  cmp    %rcx,%rax
  jne    L284
  mov    %ebp,%eax
  and    $0xfffffffc,%eax
  test   $0x3,%bpl
  je     L343
  mov    0x38(%rsp),%rdi
  mov    %eax,%ecx
  lea    0x0(,%rcx,4),%rdx
  mov    (%rdi,%rcx,4),%esi
  mov    %esi,(%r12,%rcx,4)
  lea    0x1(%rax),%ecx
  cmp    %ecx,%ebp
  jle    L343
  mov    0x4(%rdi,%rdx,1),%ecx
  add    $0x2,%eax
  mov    %ecx,0x4(%r12,%rdx,1)
  cmp    %eax,%ebp
  jle    L343
  mov    0x8(%rdi,%rdx,1),%eax
  mov    %eax,0x8(%r12,%rdx,1)
L343:
  mov    0x28(%rsp),%rdi
  call   <superlu_free@plt>
  mov    0x148(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L228
  add    $0x158,%rsp
  mov    %r14,%rdi
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    1140 <superlu_free@plt>
  nopl   (%rax)
L86:
  mov    (%rbx,%rsi,4),%edi
  test   %edi,%edi
  jne    L316
  movslq (%r15,%rsi,4),%rcx
  mov    %ecx,(%r10,%rcx,4)
L316:
  add    $0x1,%rsi
  cmp    %esi,%eax
  jge    L86
  jmp    L104
  nopl   0x0(%rax)
L231:
  mov    (%r15,%rdi,1),%ecx
  mov    %ecx,%esi
  sub    %edx,%esi
  cmp    %r11d,%esi
  je     L106
  jmp    L104
L370:
  mov    %ebp,%edx
  mov    %ecx,%eax
  xor    %r11d,%r11d
  jmp    L53
L334:
  lea    0x40(%rsp),%r15
  lea    D15(%rip),%rcx
  mov    $0x100,%esi
  lea    D13(%rip),%rdx
  mov    %r15,%rdi
  call   <sprintf_s@plt>
  mov    %r15,%rdi
  call   <WriteSLUErrorMessage@plt>
  mov    %r15,%rdi
  call   <superlu_abort_and_exit@plt>
  jmp    L320
L145:
  mov    0x38(%rsp),%rcx
  mov    0x30(%rsp),%rsi
  xor    %eax,%eax
  nopl   0x0(%rax,%rax,1)
L304:
  mov    (%rcx,%rax,4),%edx
  mov    %edx,(%r12,%rax,4)
  add    $0x1,%rax
  cmp    %rsi,%rax
  jne    L304
  jmp    L343
L153:
  mov    %r12,%rcx
  add    %r14,%r9
  mov    %r14,%rax
  sub    %r14,%rcx
  nopl   0x0(%rax)
L344:
  mov    (%rax),%edx
  mov    %edx,(%rcx,%rax,1)
  add    $0x4,%rax
  cmp    %rax,%r9
  jne    L344
  jmp    L131
L43:
  mov    0x8(%rsp),%rdi
  mov    $0xffffffff,%edx
  mov    %ebp,%esi
  call   <ifill@plt>
  jmp    L343
L228:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: data_label: D15
type_guessed: string
name: parse_data
arguments: data_label: D13
type_guessed: string

tool: D15: SUPERLU_MALLOC fails for iwork[]

tool: D13: 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);
}
```