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

```asm
<filevercmp>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x28,%rsp
  mov    %rdi,%rbx
  mov    %rsi,%rbp
  mov    %fs:0x28,%rax
  mov    %rax,0x18(%rsp)
  xor    %eax,%eax
  call   <strcmp@plt>
  mov    %eax,%r12d
  test   %eax,%eax
  je     L54
  movzbl (%rbx),%r13d
  test   %r13b,%r13b
  je     L16
  movzbl 0x0(%rbp),%r14d
  test   %r14b,%r14b
  je     L45
  mov    %rbx,%rsi
  lea    D4(%rip),%rdi
  call   <strcmp@plt>
  test   %eax,%eax
  je     L122
  mov    %rbp,%rsi
  lea    D4(%rip),%rdi
  call   <strcmp@plt>
  test   %eax,%eax
  je     L8
  mov    %rbx,%rsi
  lea    D8(%rip),%rdi
  call   <strcmp@plt>
  test   %eax,%eax
  je     L53
  mov    %rbp,%rsi
  lea    D8(%rip),%rdi
  call   <strcmp@plt>
  test   %eax,%eax
  je     L2
  cmp    $0x2e,%r13b
  sete   %al
  cmp    $0x2e,%r14b
  je     L212
  test   %al,%al
  jne    L246
L212:
  cmp    $0x2e,%r14b
  sete   %dl
  cmp    $0x2e,%r13b
  je     L28
  test   %dl,%dl
  jne    L33
L28:
  test   %al,%al
  je     L141
  test   %dl,%dl
  jne    L216
L141:
  mov    %rbx,0x8(%rsp)
  mov    %rbp,0x10(%rsp)
  lea    0x8(%rsp),%rdi
  call   <match_suffix@plt>
  mov    %rax,%r13
  lea    0x10(%rsp),%rdi
  call   <match_suffix@plt>
  test   %r13,%r13
  mov    %r13,%r14
  cmove  0x8(%rsp),%r14
  sub    %rbx,%r14
  test   %rax,%rax
  mov    %rax,%r15
  cmove  0x10(%rsp),%r15
  sub    %rbp,%r15
  or     %r13,%rax
  je     L64
  cmp    %r15,%r14
  je     L178
L64:
  mov    %r15,%rcx
  mov    %rbp,%rdx
  mov    %r14,%rsi
  mov    %rbx,%rdi
  call   <verrevcmp@plt>
  test   %eax,%eax
  cmovne %eax,%r12d
  jmp    L54
L216:
  add    $0x1,%rbx
  add    $0x1,%rbp
  jmp    L141
L178:
  mov    %r14,%rdx
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %rax,%rax
  jne    L64
  mov    0x8(%rsp),%r14
  sub    %rbx,%r14
  mov    0x10(%rsp),%r15
  sub    %rbp,%r15
  jmp    L64
L16:
  mov    $0xffffffff,%r12d
  jmp    L54
L45:
  mov    $0x1,%r12d
L54:
  mov    0x18(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L51
  mov    %r12d,%eax
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L122:
  mov    $0xffffffff,%r12d
  jmp    L54
L8:
  mov    $0x1,%r12d
  jmp    L54
L53:
  mov    $0xffffffff,%r12d
  jmp    L54
L2:
  mov    $0x1,%r12d
  jmp    L54
L246:
  mov    $0xffffffff,%r12d
  jmp    L54
L33:
  mov    $0x1,%r12d
  jmp    L54
L51:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: label: D4
type: string
name: unpack_data
arguments: label: D8
type: string

tool: D4: .

tool: D8: ..

assistant: ```c
int filevercmp(const char *s1, const char *s2) {
  const char *s1_pos;
  const char *s2_pos;
  const char *s1_suffix, *s2_suffix;
  size_t s1_len, s2_len;
  int result;
  int simple_cmp = strcmp(s1, s2);
  if (simple_cmp == 0)
    return 0;
  if (!*s1)
    return -1;
  if (!*s2)
    return 1;
  if (0 == strcmp(".", s1))
    return -1;
  if (0 == strcmp(".", s2))
    return 1;
  if (0 == strcmp("..", s1))
    return -1;
  if (0 == strcmp("..", s2))
    return 1;
  if (*s1 == '.' && *s2 != '.')
    return -1;
  if (*s1 != '.' && *s2 == '.')
    return 1;
  if (*s1 == '.' && *s2 == '.') {
    s1++;
    s2++;
  }
  s1_pos = s1;
  s2_pos = s2;
  s1_suffix = match_suffix(&s1_pos);
  s2_suffix = match_suffix(&s2_pos);
  s1_len = (s1_suffix ? s1_suffix : s1_pos) - s1;
  s2_len = (s2_suffix ? s2_suffix : s2_pos) - s2;
  if ((s1_suffix || s2_suffix) && (s1_len == s2_len) && 0 == strncmp(s1, s2, s1_len)) {
    s1_len = s1_pos - s1;
    s2_len = s2_pos - s2;
  }
  result = verrevcmp(s1, s1_len, s2, s2_len);
  return result == 0 ? simple_cmp : result;
}
```