LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sIsTTY
bool sIsTTY(FILE *stream)
{
  const int descriptor = fileno(stream);
  if(descriptor == -1)
  {
    dieErrno("failed to get file descriptor from stream");
  }

  const int old_errno = errno;
  const int is_tty = isatty(descriptor);
  errno = old_errno;

  return is_tty == 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2280
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0xd2bc
leaq 0x17b03(%rip), %rdi     # 0x24db8
movb $0x0, %al
callq 0x4760
callq 0x2050
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x2090
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x2050
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x1, -0x14(%rbp)
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sStringToSize
size_t sStringToSize(StringView string)
{
  const int old_errno = errno;
  errno = 0;

  const char *raw_string = nullTerminate(string);
  char *endptr;
  const long long int value = strtoll(raw_string, &endptr, 10);

  if(endptr == raw_string)
  {
    die("unable to convert to size: \"%s\"", raw_string);
  }
  else if(value < 0)
  {
    die("unable to convert negative value to size: \"%s\"", raw_string);
  }
  else if((value == LLONG_MAX && errno == ERANGE) ||
          (unsigned long long int)value > SIZE_MAX)
  {
    die("value too large to convert to size: \"%s\"", raw_string);
  }

  errno = old_errno;
  return (size_t)value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2050
movl (%rax), %eax
movl %eax, -0x4(%rbp)
callq 0x2050
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl $0x0, (%rcx)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xbc50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0x2220
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xd370
movq -0x10(%rbp), %rsi
leaq 0x17a79(%rip), %rdi     # 0x24de2
movb $0x0, %al
callq 0x4680
cmpq $0x0, -0x20(%rbp)
jge 0xd389
movq -0x10(%rbp), %rsi
leaq 0x17a80(%rip), %rdi     # 0x24e02
movb $0x0, %al
callq 0x4680
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
jne 0xd3a3
callq 0x2050
cmpl $0x22, (%rax)
je 0xd3aa
cmpq $-0x1, -0x20(%rbp)
jbe 0xd3bc
movq -0x10(%rbp), %rsi
leaq 0x17a7c(%rip), %rdi     # 0x24e31
movb $0x0, %al
callq 0x4680
jmp 0xd3be
jmp 0xd3c0
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x2050
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sTime
time_t sTime(void)
{
  const time_t current_time = time(NULL);

  if(current_time == (time_t)-1)
  {
    die("failed to determine current time");
  }

  return current_time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x2270
movq %rax, -0x8(%rbp)
cmpq $-0x1, -0x8(%rbp)
jne 0xd40a
leaq 0x17a57(%rip), %rdi     # 0x24e5a
movb $0x0, %al
callq 0x4680
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sTimeMilliseconds
uint64_t sTimeMilliseconds(void)
{
  struct timespec timespec;
  if(clock_gettime(CLOCK_REALTIME, &timespec) == -1)
  {
    dieErrno("failed to determine current time");
  }

  return sUint64Add(sUint64Mul(timespec.tv_sec, 1000),
                    timespec.tv_nsec / 1000000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
leaq -0x10(%rbp), %rsi
callq 0x20c0
cmpl $-0x1, %eax
jne 0xd446
leaq 0x17a1b(%rip), %rdi     # 0x24e5a
movb $0x0, %al
callq 0x4760
movq -0x10(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0xb9d0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %rsi
callq 0xb990
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sRand
int sRand(void)
{
  static bool already_seeded = false;

  if(!already_seeded)
  {
    srand((sTime() << 9) + getpid());
    already_seeded = true;
  }

  return rand();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x1be21(%rip)     # 0x292b0
jne 0xd4bd
callq 0xd3e0
shlq $0x9, %rax
movq %rax, -0x8(%rbp)
callq 0x20d0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, %edi
callq 0x21f0
movb $0x1, 0x1bdf3(%rip)     # 0x292b0
callq 0x23b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sGetFilesContent
FileContent sGetFilesContent(CR_Region *region, StringView path)
{
  const struct stat file_stats = sStat(path);
  if(!S_ISREG(file_stats.st_mode))
  {
    die("\"" PRI_STR "\" is not a regular file", STR_FMT(path));
  }

  /* On 32-bit systems off_t is often larger than size_t. */
  if((uint64_t)file_stats.st_size > SIZE_MAX)
  {
    die("unable to load file into mem due to its size: \"" PRI_STR "\"",
        STR_FMT(path));
  }

  if(file_stats.st_size > 0)
  {
    FileStream *stream = sFopenRead(path);
    char *content = CR_RegionAllocUnaligned(region, file_stats.st_size);
    sFread(content, file_stats.st_size, stream);
    const bool stream_not_at_end = sFbytesLeft(stream);
    sFclose(stream);

    if(stream_not_at_end)
    {
      die("file changed while reading: \"" PRI_STR "\"", STR_FMT(path));
    }

    return (FileContent){ .content = content, .size = file_stats.st_size };
  }

  char *content = CR_RegionAllocUnaligned(region, 1);
  content[0] = '\0';

  return (FileContent){ .content = content, .size = 0 };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xc5a0
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
je 0xd53f
movq -0xd0(%rbp), %rax
movq 0x8(%rax), %rcx
movl %ecx, %esi
movq (%rax), %rdx
leaq 0x17943(%rip), %rdi     # 0x24e7b
movb $0x0, %al
callq 0x4680
cmpq $-0x1, -0x78(%rbp)
jbe 0xd564
movq -0xd0(%rbp), %rax
movq 0x8(%rax), %rcx
movl %ecx, %esi
movq (%rax), %rdx
leaq 0x1793b(%rip), %rdi     # 0x24e98
movb $0x0, %al
callq 0x4680
cmpq $0x0, -0x78(%rbp)
jle 0xd622
movq -0xd0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xbad0
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x23170
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0xbdc0
movq -0xb0(%rbp), %rdi
callq 0xc410
andb $0x1, %al
movb %al, -0xb9(%rbp)
movq -0xb0(%rbp), %rdi
callq 0xc020
testb $0x1, -0xb9(%rbp)
je 0xd60d
movq -0xd0(%rbp), %rax
movq 0x8(%rax), %rcx
movl %ecx, %esi
movq (%rax), %rdx
leaq 0x178c7(%rip), %rdi     # 0x24ecd
movb $0x0, %al
callq 0x4680
movq -0xb8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd654
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x23170
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movb $0x0, (%rax)
movq -0xc8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sRegexCompile
const regex_t *sRegexCompile(CR_Region *r, StringView expression,
                             StringView file_name, const size_t line_nr)
{
  regex_t *regex = CR_RegionAlloc(r, sizeof *regex);
  const int error =
    regcomp(regex, nullTerminate(expression), REG_EXTENDED | REG_NOSUB);

  if(error != 0)
  {
    const size_t error_length = regerror(error, regex, NULL, 0);
    char *error_str = allocate(getTemporaryBuffer(false), error_length);
    regerror(error, regex, error_str, error_length);
    die(PRI_STR ": line %zu: %s: \"" PRI_STR "\"", STR_FMT(file_name),
        line_nr, error_str, STR_FMT(expression));
  }
  CR_RegionAttach(r, releaseRegex, regex);

  return regex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x230e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xbc50
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl $0x9, %edx
callq 0x21c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xd760
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x2260
movq %rax, -0x28(%rbp)
xorl %edi, %edi
callq 0xd020
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x24c0
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2260
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq 0x8(%rcx), %rdx
movl %edx, %esi
movq (%rcx), %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x8(%rax), %rdi
movl %edi, %r9d
movq (%rax), %rax
leaq 0x1779b(%rip), %rdi     # 0x24ef0
movq %rax, (%rsp)
movb $0x0, %al
callq 0x4680
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x11(%rip), %rsi        # 0xd780
callq 0x232e0
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search-tree.c
// Function: getLine
static StringView getLine(StringView config, const size_t start)
{
  /* Find the index of the line ending. */
  size_t end = start;
  while(end < config.length && config.content[end] != '\n')
    end++;

  return strUnterminated(&config.content[start], end - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x29(%rbp)
jae 0xe17f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xe188
jmp 0xe196
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe154
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
subq -0x8(%rbp), %rdx
callq 0xf140
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search-tree.c
// Function: inheritPolicyToSubnodes
static void inheritPolicyToSubnodes(SearchNode *parent_node)
{
  for(SearchNode *node = parent_node->subnodes; node != NULL;
      node = node->next)
  {
    if(node->policy == BPOL_none || node->policy_inherited)
    {
      node->policy = parent_node->policy;
      node->policy_inherited = true;
      node->policy_line_nr = parent_node->policy_line_nr;
      inheritPolicyToSubnodes(node);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe552
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0xe513
movq -0x10(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0xe542
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0xe4e0
jmp 0xe544
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xe4f8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search-tree.c
// Function: searchTreeLoad
SearchNode *searchTreeLoad(CR_Region *r, StringView path_to_config)
{
  CR_Region *disposable_r = CR_RegionNew();
  const FileContent content =
    sGetFilesContent(disposable_r, path_to_config);
  StringView config = strUnterminated(content.content, content.size);

  SearchNode *root_node = searchTreeParse(r, config);
  CR_RegionRelease(disposable_r);

  return root_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x22f30
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xd4d0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xf140
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xd800
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23370
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: searchNew
SearchIterator *searchNew(SearchNode *root_node)
{
  CR_Region *r = CR_RegionNew();

  SearchIterator *iterator = CR_RegionAlloc(r, sizeof *iterator);
  iterator->r = r;

  iterator->current_path_buffer = allocatorWrapOneSingleGrowableBuffer(r);
  strSet(&iterator->current_path,
         strCopy(str("/"), iterator->current_path_buffer));
  iterator->tmp_buffer = allocatorWrapOneSingleGrowableBuffer(r);

  recursionStepRaw(iterator, root_node, root_node->policy);

  /* Prevent found paths from starting with two slashes. */
  iterator->state.path_length = 0;

  /* Store reference to ignore expression list. */
  iterator->ignore_expressions = *root_node->ignore_expressions;

  /* Initialise the state stack. */
  iterator->state_stack.used = 0;
  iterator->state_stack.capacity = 4;

  Allocator *state_array_buffer = allocatorWrapOneSingleGrowableBuffer(r);
  iterator->state_stack.state_array_buffer = state_array_buffer;
  iterator->state_stack.state_array =
    allocate(state_array_buffer,
             sSizeMul(sizeof *iterator->state_stack.state_array,
                      iterator->state_stack.capacity));

  return iterator;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
callq 0x22f30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x80, %esi
callq 0x230e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x25e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq 0x15d9e(%rip), %rsi     # 0x243fe
callq 0xf100
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf270
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf240
movq -0x10(%rbp), %rdi
callq 0x25e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %edx
callq 0xe770
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x18(%rbp), %rax
movq $0x4, 0x70(%rax)
movq -0x10(%rbp), %rdi
callq 0x25e0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rsi
movl $0x28, %edi
callq 0xb930
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x24c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: recursionStepRaw
static void recursionStepRaw(SearchIterator *iterator, SearchNode *node,
                             const BackupPolicy policy)
{
  /* Store the directories path length before recursing into it. */
  iterator->state.path_length = iterator->current_path.length;

  if(node != NULL && node->policy == BPOL_none &&
     !node->subnodes_contain_regex)
  {
    iterator->state.is_dir_search = false;
    iterator->state.access.current_node = node->subnodes;
  }
  else
  {
    iterator->state.is_dir_search = true;
    iterator->state.access.search.dir = sDirOpen(iterator->current_path);
    iterator->state.access.search.subnodes = node ? node->subnodes : NULL;
    iterator->state.access.search.fallback_policy = policy;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xe7c8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0xe7c8
movq -0x10(%rbp), %rax
testb $0x1, 0x48(%rax)
jne 0xe7c8
movq -0x8(%rbp), %rax
movb $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0xe834
movq -0x8(%rbp), %rax
movb $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xc0f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xe816
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe81e
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0xe81e
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: finishCurrentNode
static SearchResult finishCurrentNode(SearchIterator *iterator)
{
  if(iterator->state.access.current_node == NULL)
  {
    return finishDirectory(iterator);
  }

  SearchNode *node = iterator->state.access.current_node;
  iterator->state.access.current_node = node->next;

  replaceCurrentFilename(iterator, node->name);

  if(sPathExists(iterator->current_path))
  {
    return finishNodeStep(iterator, node, node->policy);
  }

  return finishCurrentNode(iterator);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xeb61
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xec00
jmp 0xebf6
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xecb0
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xc4d0
testb $0x1, %al
jne 0xebcf
jmp 0xebe9
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
callq 0xee40
jmp 0xebf6
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xeb30
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: finishDirectory
static SearchResult finishDirectory(SearchIterator *iterator)
{
  if(iterator->state_stack.used > 0)
  {
    iterator->state_stack.used--;
    iterator->state =
      iterator->state_stack.state_array[iterator->state_stack.used];

    return (SearchResult){ .type = SRT_end_of_directory };
  }

  CR_RegionRelease(iterator->r);

  return (SearchResult){ .type = SRT_end_of_search };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jbe 0xec71
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x8(%rbp), %rax
imulq $0x28, 0x78(%rax), %rax
addq %rax, %rsi
movl $0x28, %edx
callq 0x2250
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x2170
movq -0x18(%rbp), %rax
movl $0x10, (%rax)
jmp 0xec97
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x23370
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x2170
movq -0x18(%rbp), %rax
movl $0x20, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: replaceCurrentFilename
static void replaceCurrentFilename(SearchIterator *iterator,
                                   StringView filename)
{
  StringView path_head =
    strCopy(strUnterminated(iterator->current_path.content,
                            iterator->state.path_length),
            iterator->tmp_buffer);
  strSet(
    &iterator->current_path,
    strAppendPath(path_head, filename, iterator->current_path_buffer));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
leaq -0x38(%rbp), %rdi
callq 0xf140
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf270
movq -0x60(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq %rcx, -0x58(%rbp)
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0xf750
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf240
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: finishNodeStep
static SearchResult finishNodeStep(SearchIterator *iterator,
                                   SearchNode *node,
                                   const BackupPolicy policy)
{
  SearchResult found_file = buildSearchResult(iterator, node, policy);

  if(node != NULL)
  {
    node->search_match |= found_file.type;
  }

  if(found_file.type == SRT_directory)
  {
    recursionStep(iterator, node, policy);
  }

  return found_file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0xeeb0
cmpq $0x0, -0x10(%rbp)
je 0xee85
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
orl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xee9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xf010
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: buildSearchResult
static SearchResult buildSearchResult(const SearchIterator *iterator,
                                      const SearchNode *node,
                                      const BackupPolicy policy)
{
  const struct stat stats = node != NULL && node->subnodes != NULL
    ? sStat(iterator->current_path)
    : sLStat(iterator->current_path);

  return (SearchResult){
    .type = S_ISREG(stats.st_mode) ? SRT_regular_file
      : S_ISLNK(stats.st_mode)     ? SRT_symlink
      : S_ISDIR(stats.st_mode)     ? SRT_directory
                                   : SRT_other,

    .path = iterator->current_path,

    .node = node,
    .policy = policy,
    .stats = stats,
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xef15
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xef15
movq -0x8(%rbp), %rax
addq $0x8, %rax
leaq -0xa8(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xc5a0
jmp 0xef42
movq -0x8(%rbp), %rax
addq $0x8, %rax
leaq -0xa8(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xc670
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0xef61
movl $0x1, %eax
movl %eax, -0xbc(%rbp)
jmp 0xefb1
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
jne 0xef80
movl $0x2, %eax
movl %eax, -0xc0(%rbp)
jmp 0xefa5
movl -0x90(%rbp), %edx
andl $0xf000, %edx           # imm = 0xF000
movl $0x8, %eax
movl $0x4, %ecx
cmpl $0x4000, %edx           # imm = 0x4000
cmovel %ecx, %eax
movl %eax, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
movl %eax, -0xbc(%rbp)
movq -0xb8(%rbp), %rdi
movl -0xbc(%rbp), %eax
movl %eax, (%rdi)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x20(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x28(%rdi)
addq $0x30, %rdi
leaq -0xa8(%rbp), %rsi
movl $0x90, %edx
callq 0x2250
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/search.c
// Function: pushCurrentState
static void pushCurrentState(SearchIterator *iterator)
{
  /* Grow state array if needed. */
  if(iterator->state_stack.used == iterator->state_stack.capacity)
  {
    iterator->state_stack.capacity =
      sSizeMul(iterator->state_stack.capacity, 2);
    iterator->state_stack.state_array =
      allocate(iterator->state_stack.state_array_buffer,
               sSizeMul(sizeof *iterator->state_stack.state_array,
                        iterator->state_stack.capacity));
  }

  iterator->state_stack.state_array[iterator->state_stack.used] =
    iterator->state;
  iterator->state_stack.used++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jne 0xf0c0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movl $0x2, %esi
callq 0xb930
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rsi
movl $0x28, %edi
callq 0xb930
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x24c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x28, 0x78(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movl $0x28, %edx
callq 0x2250
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x78(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: str
StringView str(const char *string)
{
  return (StringView){
    .content = string,
    .length = strlen(string),
    .is_terminated = true,
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, (%rdi)
movq -0x8(%rbp), %rdi
callq 0x2110
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: strUnterminated
StringView strUnterminated(const char *string, const size_t length)
{
  return (StringView){
    .content = string,
    .length = length,
    .is_terminated = false,
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: strCopyRaw
char *strCopyRaw(StringView string, Allocator *a)
{
  char *raw_string = allocate(a, sSizeAdd(string.length, 1));
  memcpy(raw_string, string.content, string.length);
  raw_string[string.length] = '\0';
  return raw_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0xb8f0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x24c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x2250
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: strCopy
StringView strCopy(StringView string, Allocator *a)
{
  return (StringView){
    .content = strCopyRaw(string, a),
    .length = string.length,
    .is_terminated = true,
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf1d0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, (%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: strStripTrailingSlashes
StringView strStripTrailingSlashes(StringView string)
{
  size_t new_length = string.length;
  while(new_length > 0 && string.content[new_length - 1] == '/')
  {
    new_length--;
  }

  return (StringView){
    .content = string.content,
    .length = new_length,
    .is_terminated = new_length == string.length && string.is_terminated,
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x21(%rbp)
jbe 0xf324
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xf32d
jmp 0xf33b
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf2fc
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rdx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x22(%rbp)
jne 0xf372
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
movb %al, -0x22(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb -0x22(%rbp), %dl
andb $0x1, %dl
movb %dl, (%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: strSplitPath
PathSplit strSplitPath(StringView path)
{
  size_t last_slash = path.length;
  while(last_slash > 0 && path.content[last_slash - 1] != '/')
  {
    last_slash--;
  }

  /* If the last slash is preceded by other slashes, get its position
     instead. */
  while(last_slash > 1 && path.content[last_slash - 2] == '/')
  {
    last_slash--;
  }

  return (PathSplit){
    (StringView){
      .content = path.content,
      .length = last_slash > 0 ? last_slash - 1 : 0,
      .is_terminated = false,
    },
    (StringView){
      .content = &path.content[last_slash],
      .length = path.length - last_slash,
      .is_terminated = path.is_terminated,
    },
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x21(%rbp)
jbe 0xf3d4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xf3dd
jmp 0xf3eb
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf3ac
jmp 0xf3ed
xorl %eax, %eax
cmpq $0x1, -0x8(%rbp)
movb %al, -0x22(%rbp)
jbe 0xf415
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0xf41e
jmp 0xf42c
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf3ed
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
jbe 0xf457
movq -0x8(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xf45f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xf45f
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq %rdi, (%rsi)
movb $0x0, 0x10(%rcx)
movq (%rdx), %rsi
addq -0x8(%rbp), %rsi
movq %rsi, 0x18(%rcx)
movq 0x8(%rdx), %rsi
subq -0x8(%rbp), %rsi
movq %rsi, 0x20(%rcx)
movb 0x10(%rdx), %dl
andb $0x1, %dl
movb %dl, 0x28(%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: strIsWhitespaceOnly
bool strIsWhitespaceOnly(StringView string)
{
  for(size_t index = 0; index < string.length; index++)
  {
    if(string.content[index] != ' ' && string.content[index] != '\t')
    {
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xf580
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0xf570
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0xf570
movb $0x0, -0x1(%rbp)
jmp 0xf584
jmp 0xf572
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf534
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/str.c
// Function: strAppendPath
StringView strAppendPath(StringView path, StringView filename,
                         Allocator *a)
{
  const size_t new_path_length =
    sSizeAdd(sSizeAdd(path.length, 1), filename.length);

  char *raw_string = allocate(a, sSizeAdd(new_path_length, 1));
  memcpy(raw_string, path.content, path.length);
  raw_string[path.length] = '/';
  memcpy(&raw_string[path.length + 1], filename.content, filename.length);
  raw_string[new_path_length] = '\0';

  return (StringView){
    .content = raw_string,
    .length = new_path_length,
    .is_terminated = true,
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0xb8f0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xb8f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xb8f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x24c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x2250
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x8(%rcx), %rsi
movb $0x2f, (%rdx,%rsi)
movq -0x18(%rbp), %rdi
movq 0x8(%rcx), %rcx
addq $0x1, %rcx
addq %rcx, %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x2250
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/string-table.c
// Function: strTableNew
StringTable *strTableNew(CR_Region *region)
{
  StringTable *table = CR_RegionAlloc(region, sizeof(*table));
  table->region = region;
  table->associations = 0;
  table->capacity = 32; /* A small initial value allows the test suite to
                           cover table resizing. */

  for(size_t index = 0; index < sizeof(table->secret_key); index++)
  {
    table->secret_key[index] = sRand() % UINT8_MAX;
  }

  const size_t array_size =
    sSizeMul(table->capacity, sizeof(*table->buckets));
  table->buckets = sMalloc(array_size);
  CR_RegionAttach(table->region, releaseStringTable, table);
  memset(table->buckets, 0, array_size);

  return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x230e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x20, 0x10(%rax)
movq $0x0, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0xf8a7
callq 0xd480
movl $0xff, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, 0x20(%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf879
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x8, %esi
callq 0xb930
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xba70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2d(%rip), %rsi        # 0xf910
callq 0x232e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x2170
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/string-table.c
// Function: strTableMap
void strTableMap(StringTable *table, StringView key, void *data)
{
  if(table->associations == table->capacity)
  {
    doubleTableCapacity(table);
  }

  Bucket *bucket = CR_RegionAlloc(table->region, sizeof(*bucket));
  bucket->hash =
    siphash((const uint8_t *)key.content, key.length, table->secret_key);
  strSet(&bucket->key, key);
  bucket->data = data;

  /* Prepend the bucket to the bucket slot in the bucket array. */
  const size_t bucket_id = bucket->hash % table->capacity;
  bucket->next = table->buckets[bucket_id];
  table->buckets[bucket_id] = bucket;

  table->associations++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xf973
movq -0x8(%rbp), %rdi
callq 0xfa40
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x30, %esi
callq 0x230e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rdx
addq $0x20, %rdx
callq 0x221e0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf240
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/string-table.c
// Function: doubleTableCapacity
static void doubleTableCapacity(StringTable *table)
{
  const size_t new_capacity = sSizeMul(table->capacity, 2);
  const size_t new_array_size =
    sSizeMul(new_capacity, sizeof(*table->buckets));

  Bucket **new_buckets = sMalloc(new_array_size);
  memset(new_buckets, 0, new_array_size);

  /* Copy all associations into their new location. */
  for(size_t index = 0; index < table->capacity; index++)
  {
    Bucket *bucket = table->buckets[index];
    while(bucket)
    {
      Bucket *bucket_to_move = bucket;
      bucket = bucket->next;

      const size_t new_bucket_id = bucket_to_move->hash % new_capacity;
      bucket_to_move->next = new_buckets[new_bucket_id];
      new_buckets[new_bucket_id] = bucket_to_move;
    }
  }

  free(table->buckets);
  table->buckets = new_buckets;
  table->capacity = new_capacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0xb930
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0xb930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xba70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x2170
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xfb21
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xfb0e
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xfaba
jmp 0xfb10
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfa98
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/string-table.c
// Function: strTableGet
void *strTableGet(const StringTable *table, StringView key)
{
  const size_t hash =
    siphash((const uint8_t *)key.content, key.length, table->secret_key);
  const size_t bucket_id = hash % table->capacity;

  for(const Bucket *bucket = table->buckets[bucket_id]; bucket != NULL;
      bucket = bucket->next)
  {
    if(strIsEqual(key, bucket->key))
    {
      return bucket->data;
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
callq 0x221e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xfc11
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0xf4c0
testb $0x1, %al
jne 0xfbf3
jmp 0xfc01
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xfc19
jmp 0xfc03
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xfba2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2b-optimized.h
// Function: blake2b_init
int blake2b_init( blake2b_state *S, size_t outlen )
{
  blake2b_param P[1];

  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;

  P->digest_length = (uint8_t)outlen;
  P->key_length    = 0;
  P->fanout        = 1;
  P->depth         = 1;
  store32( &P->leaf_length, 0 );
  store32( &P->node_offset, 0 );
  store32( &P->xof_length, 0 );
  P->node_depth    = 0;
  P->inner_length  = 0;
  memset( P->reserved, 0, sizeof( P->reserved ) );
  memset( P->salt,     0, sizeof( P->salt ) );
  memset( P->personal, 0, sizeof( P->personal ) );

  return blake2b_init_param( S, P );
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xfc6e
cmpq $0x40, 0x40(%rsp)
jbe 0xfc7b
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0xfd10
movq 0x40(%rsp), %rax
movb %al, (%rsp)
movb $0x0, 0x1(%rsp)
movb $0x1, 0x2(%rsp)
movb $0x1, 0x3(%rsp)
movq %rsp, %rdi
addq $0x4, %rdi
xorl %esi, %esi
callq 0xfd20
movq %rsp, %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0xfd20
movq %rsp, %rdi
addq $0xc, %rdi
xorl %esi, %esi
callq 0xfd20
movb $0x0, 0x10(%rsp)
movb $0x0, 0x11(%rsp)
movq %rsp, %rdi
addq $0x12, %rdi
xorl %esi, %esi
movl $0xe, %edx
callq 0x2170
movq %rsp, %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2170
movq %rsp, %rdi
addq $0x30, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2170
movq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0xfd80
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2-impl.h
// Function: store32
static BLAKE2_INLINE void store32( void *dst, uint32_t w )
{
#if defined(NATIVE_LITTLE_ENDIAN)
  memcpy(dst, &w, sizeof w);
#else
  uint8_t *p = ( uint8_t * )dst;
  p[0] = (uint8_t)(w >>  0);
  p[1] = (uint8_t)(w >>  8);
  p[2] = (uint8_t)(w >> 16);
  p[3] = (uint8_t)(w >> 24);
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %eax
shrl $0x0, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
movl -0xc(%rsp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rsp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rsp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x18(%rsp), %rax
movb %cl, 0x3(%rax)
retq
nopw (%rax,%rax)