user: 这段汇编代码用C语言表示是什么样的：

```asm
<fourSum>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  xor    %r13d,%r13d
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x18,%rsp
  mov    %esi,(%rsp)
  cmp    $0x3,%esi
  jle    L122
  mov    %rdi,%rbx
  mov    $0x200,%edi
  mov    %edx,%ebp
  mov    %rcx,%r12
  call   <malloc@plt>
  mov    %rax,%r13
  mov    %rax,%r14
  lea    0x200(%rax),%r15
L37:
  mov    $0x10,%edi
  add    $0x8,%r14
  call   <malloc@plt>
  mov    %rax,-0x8(%r14)
  cmp    %r14,%r15
  jne    L37
  mov    (%rsp),%r15d
  xor    %esi,%esi
  mov    %rbx,%rdi
  lea    -0x1(%r15),%eax
  mov    %eax,%edx
  mov    %eax,0xc(%rsp)
  call   <quick_sort@plt>
  mov    %r15d,%eax
  lea    -0x3(%r15),%esi
  lea    0x4(%rbx),%r11
  sub    $0x2,%eax
  mov    %esi,0x8(%rsp)
  xor    %r15d,%r15d
  mov    %eax,0x4(%rsp)
  nopl   0x0(%rax,%rax,1)
L58:
  add    $0x1,%r15d
  cmp    $0x1,%r15d
  je     L227
  movslq (%r12),%rax
  test   %eax,%eax
  jle    L22
  mov    -0x8(%r13,%rax,8),%rax
  mov    (%rax),%eax
  cmp    %eax,-0x4(%r11)
  je     L101
L22:
  cmp    %r15d,0x4(%rsp)
  jle    L101
L227:
  mov    %r15d,(%rsp)
  mov    %r15d,%r14d
  mov    0xc(%rsp),%r15d
  mov    %r11,%r10
  nopl   (%rax)
L216:
  mov    %r14d,%eax
  add    $0x1,%r14d
  cmp    (%rsp),%eax
  jle    L184
  movslq (%r12),%rax
  test   %eax,%eax
  jle    L184
  mov    -0x8(%r13,%rax,8),%rax
  mov    (%rax),%esi
  cmp    %esi,-0x4(%r11)
  jne    L184
  mov    0x4(%rax),%eax
  cmp    %eax,(%r10)
  je     L105
L184:
  cmp    %r14d,%r15d
  jle    L105
  mov    %r15d,%esi
  mov    %r14d,%eax
  jmp    L134
  cs nopw 0x0(%rax,%rax,1)
L108:
  add    $0x1,%eax
L102:
  cmp    %eax,%esi
  jle    L105
L134:
  movslq %esi,%rdx
  movslq %eax,%rcx
  mov    -0x4(%r11),%r9d
  lea    (%rbx,%rdx,4),%r8
  shl    $0x2,%rcx
  mov    (%r10),%edx
  lea    (%rbx,%rcx,1),%rdi
  add    %r9d,%edx
  add    (%rdi),%edx
  add    (%r8),%edx
  cmp    %ebp,%edx
  jl     L108
  jle    L46
  sub    $0x1,%esi
  cmp    %eax,%esi
  jg     L134
L105:
  add    $0x4,%r10
  cmp    %r14d,0x4(%rsp)
  jg     L216
  mov    (%rsp),%r15d
L101:
  add    $0x4,%r11
  cmp    %r15d,0x8(%rsp)
  jne    L58
L122:
  add    $0x18,%rsp
  mov    %r13,%rax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   (%rax)
L46:
  movslq (%r12),%rdx
  mov    0x0(%r13,%rdx,8),%rdx
  mov    %r9d,(%rdx)
  movslq (%r12),%rdx
  mov    (%r10),%r9d
  mov    0x0(%r13,%rdx,8),%rdx
  mov    %r9d,0x4(%rdx)
  movslq (%r12),%rdx
  mov    (%rdi),%r9d
  mov    0x0(%r13,%rdx,8),%rdx
  mov    %r9d,0x8(%rdx)
  movslq (%r12),%rdx
  mov    (%r8),%r8d
  mov    0x0(%r13,%rdx,8),%rdx
  mov    %r8d,0xc(%rdx)
  lea    0x1(%rax),%edx
  addl   $0x1,(%r12)
  mov    (%rdi),%edi
  cmp    %edi,0x4(%rbx,%rcx,1)
  jne    L205
  cmp    %esi,%edx
  jge    L205
  lea    0x2(%rax),%edx
  movslq %edx,%rdx
  xchg   %ax,%ax
L6:
  mov    -0x4(%rbx,%rdx,4),%edi
  cmp    %edi,(%rbx,%rdx,4)
  mov    %edx,%eax
  sete   %dil
  cmp    %edx,%esi
  setg   %cl
  add    $0x1,%rdx
  test   %cl,%dil
  jne    L6
  jmp    L102
L205:
  mov    %edx,%eax
  jmp    L102
```

assistant: ```c
int **fourSum(int *nums, int numsSize, int target, int *returnSize) {
  int left = 0;
  int right = 0;
  int **ret = NULL;
  if (numsSize < 4) {
    return NULL;
  }
  ret = (int **)malloc(sizeof(int *) * 64);
  for (int i = 0; i < 64; i++) {
    ret[i] = (int *)malloc(sizeof(int) * 4);
  }
  quick_sort(nums, 0, numsSize - 1);
  for (int i = 0; i < numsSize - 3; i++) {
    if (i > 0 && (*returnSize) > 0 && nums[i] == ret[(*returnSize) - 1][0])
      continue;
    for (int j = i + 1; j < numsSize - 2; j++) {
      if (j > i + 1 && (*returnSize) > 0 && nums[i] == ret[(*returnSize) - 1][0] && nums[j] == ret[(*returnSize) - 1][1])
        continue;
      left = j + 1;
      right = numsSize - 1;
      while (left < right) {
        if (nums[i] + nums[j] + nums[left] + nums[right] < target) {
          left++;
        } else if (nums[i] + nums[j] + nums[left] + nums[right] > target) {
          right--;
        } else {
          ret[*returnSize][0] = nums[i];
          ret[*returnSize][1] = nums[j];
          ret[*returnSize][2] = nums[left];
          ret[*returnSize][3] = nums[right];
          (*returnSize)++;
          left++;
          while (nums[left] == nums[left - 1] && left < right)
            left++;
        }
      }
    }
  }
  return ret;
}
```