user: What would the C source look like for the assembly code provided here?

```asm
<fourSum>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  mov    %esi,0xc(%rsp)
  mov    $0x0,%r15d
  cmp    $0x3,%esi
  jle    L9
  mov    %rdi,%rbx
  mov    %edx,%ebp
  mov    %rcx,%r13
  mov    $0x200,%edi
  call   <malloc@plt>
  mov    %rax,%r15
  mov    %rax,%r12
  lea    0x200(%rax),%r14
L119:
  mov    $0x10,%edi
  call   <malloc@plt>
  mov    %rax,(%r12)
  add    $0x8,%r12
  cmp    %r14,%r12
  jne    L119
  mov    0xc(%rsp),%r14d
  lea    -0x1(%r14),%eax
  mov    %eax,0x28(%rsp)
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    %rbx,%rdi
  call   <quick_sort@plt>
  lea    0x4(%rbx),%r12
  lea    -0x2(%r14),%eax
  mov    %rax,0x20(%rsp)
  movq   $0x1,0x18(%rsp)
  lea    -0x2(%r14),%eax
  mov    %eax,0x2c(%rsp)
  lea    -0x1(%r14),%eax
  mov    %eax,0x14(%rsp)
  mov    %r15,%r14
  jmp    L11
L89:
  jle    L116
  sub    $0x1,%ecx
L47:
  cmp    %ecx,%eax
  jge    L142
L247:
  mov    -0x4(%r12),%r11d
  movslq %eax,%rdi
  lea    0x0(,%rdi,4),%r8
  lea    (%rbx,%r8,1),%r10
  movslq %ecx,%rdx
  lea    (%rbx,%rdx,4),%r9
  mov    %r11d,%edx
  add    (%rsi),%edx
  add    (%r10),%edx
  add    (%r9),%edx
  cmp    %ebp,%edx
  jge    L89
  add    $0x1,%eax
  jmp    L47
L116:
  movslq 0x0(%r13),%rdx
  mov    (%r14,%rdx,8),%rdx
  mov    %r11d,(%rdx)
  movslq 0x0(%r13),%rdx
  mov    (%r14,%rdx,8),%rdx
  mov    (%rsi),%r11d
  mov    %r11d,0x4(%rdx)
  movslq 0x0(%r13),%rdx
  mov    (%r14,%rdx,8),%rdx
  mov    (%r10),%r10d
  mov    %r10d,0x8(%rdx)
  movslq 0x0(%r13),%rdx
  mov    (%r14,%rdx,8),%rdx
  mov    (%r9),%r9d
  mov    %r9d,0xc(%rdx)
  addl   $0x1,0x0(%r13)
  lea    0x1(%rax),%edx
  mov    (%rbx,%rdi,4),%edi
  cmp    %edi,0x4(%rbx,%r8,1)
  jne    L183
  cmp    %ecx,%edx
  jge    L183
  add    $0x2,%eax
  movslq %eax,%rdx
L241:
  mov    %edx,%eax
  mov    -0x4(%rbx,%rdx,4),%edi
  cmp    %edi,(%rbx,%rdx,4)
  sete   %r8b
  cmp    %edx,%ecx
  setg   %dil
  add    $0x1,%rdx
  test   %dil,%r8b
  jne    L241
  jmp    L47
L183:
  mov    %edx,%eax
  jmp    L47
L142:
  mov    0xc(%rsp),%r15d
L20:
  add    $0x1,%r15d
  add    $0x4,%rsi
  cmp    0x14(%rsp),%r15d
  je     L5
L22:
  lea    -0x1(%r15),%eax
  cmp    0x10(%rsp),%eax
  jle    L179
  mov    0x0(%r13),%eax
  test   %eax,%eax
  jle    L179
  cltq
  mov    -0x8(%r14,%rax,8),%rax
  mov    (%rax),%ecx
  cmp    %ecx,-0x4(%r12)
  jne    L179
  mov    0x4(%rax),%eax
  cmp    %eax,(%rsi)
  je     L20
L179:
  mov    %r15d,%eax
  mov    0x28(%rsp),%ecx
  cmp    %r15d,%ecx
  jle    L20
  mov    %r15d,0xc(%rsp)
  jmp    L247
L5:
  addq   $0x1,0x18(%rsp)
  mov    0x18(%rsp),%rax
  add    $0x4,%r12
  cmp    0x20(%rsp),%rax
  je     L118
L11:
  mov    0x18(%rsp),%rax
  mov    %eax,%r15d
  sub    $0x1,%eax
  test   %eax,%eax
  jle    L158
  mov    0x0(%r13),%eax
  test   %eax,%eax
  jle    L158
  cltq
  mov    -0x8(%r14,%rax,8),%rax
  mov    (%rax),%eax
  cmp    %eax,-0x4(%r12)
  je     L5
L158:
  mov    0x18(%rsp),%rax
  mov    %eax,0x10(%rsp)
  cmp    %eax,0x2c(%rsp)
  jle    L5
  add    $0x1,%r15d
  mov    %r12,%rsi
  jmp    L22
L118:
  mov    %r14,%r15
L9:
  mov    %r15,%rax
  add    $0x38,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

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;
}
```