LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sGetCurrentDir
StringView sGetCurrentDir(Allocator *a)
{
  const int old_errno = errno;
  size_t capacity = 4;
  char *buffer = allocate(getTemporaryBuffer(false), capacity);

  while(true)
  {
    errno = 0;
    if(getcwd(buffer, capacity) != NULL)
    {
      errno = old_errno;
      return strCopy(str(buffer), a);
    }
    if(errno != ERANGE)
    {
      dieErrno("failed to determine current working directory");
    }

    capacity = sSizeMul(capacity, 2);
    buffer = allocate(getTemporaryBuffer(false), capacity);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
callq 0x2060
movq %rax, %r15
movl (%rax), %r14d
pushq $0x4
popq %r13
pushq $0x2
popq %r12
xorl %edi, %edi
callq 0x8f86
movq %rax, %rdi
movq %r13, %rsi
callq 0x24fc
movq %rax, %rbp
andl $0x0, (%r15)
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
testq %rax, %rax
jne 0x8f35
cmpl $0x22, (%r15)
jne 0x8f78
movq %r13, %rdi
movq %r12, %rsi
callq 0x81a0
movq %rax, %r13
jmp 0x8ef6
movl %r14d, (%r15)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa3d0
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0xa466
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5dc4(%rip), %rdi      # 0xed43
xorl %eax, %eax
callq 0x39d8
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: getTemporaryBuffer
static Allocator *getTemporaryBuffer(const bool secondary)
{
  static Allocator *buffer[2] = { NULL, NULL };
  if(buffer[secondary] == NULL)
  {
    buffer[secondary] =
      allocatorWrapOneSingleGrowableBuffer(CR_GetGlobalRegion());
  }
  return buffer[secondary];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xb2dd(%rip), %r14      # 0x14270
movq (%r14,%rbx,8), %rax
testq %rax, %rax
jne 0x8fad
callq 0xce90
movq %rax, %rdi
callq 0x2590
movq %rax, (%r14,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/src/safe-wrappers.c
// Function: sReadLine
bool sReadLine(FILE *stream, Allocator *a, StringView *result_out)
{
  const int old_errno = errno;

  size_t capacity = 4; /* Small value to test growth. */
  char *buffer = allocate(getTemporaryBuffer(false), capacity);
  size_t length_used = 0;

  while(true)
  {
    errno = 0;
    const int character = fgetc(stream);
    if(character == EOF)
    {
      if(errno != 0) dieErrno("failed to read line");

      if(length_used == 0)
      {
        strSet(result_out, str(""));
        errno = old_errno;
        return false;
      }
    }
    if(character == EOF || character == '\n' || character == '\r' ||
       character == '\0')
    {
      strSet(result_out, strCopy(strUnterminated(buffer, length_used), a));
      errno = old_errno;
      return true;
    }

    buffer[length_used] = (char)character;
    length_used++;

    if(length_used == capacity)
    {
      capacity = sSizeMul(capacity, 2);
      buffer = allocate(getTemporaryBuffer(false), capacity);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, %r15
movq %rdi, %r13
callq 0x2060
movq %rax, %r14
movl (%rax), %eax
movl %eax, 0x24(%rsp)
pushq $0x4
popq %rbp
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x8f86
movq %rax, %rdi
movq %rbp, %rsi
callq 0x24fc
movq %rax, %rbx
andl $0x0, (%r14)
movq %r13, %rdi
callq 0x21b0
cmpl $0xd, %eax
je 0x9041
testl %eax, %eax
je 0x9041
cmpl $0xa, %eax
je 0x9041
cmpl $-0x1, %eax
je 0x9032
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %rbp
jne 0x8ff7
movq %rbp, %rdi
pushq $0x2
popq %rsi
callq 0x81a0
movq %rax, %rbp
jmp 0x8fe2
cmpl $0x0, (%r14)
jne 0x90c3
testq %r12, %r12
je 0x90ab
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xa3ec
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa466
movb $0x1, %bpl
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xa454
movl 0x24(%rsp), %eax
movl %eax, (%r14)
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56ed(%rip), %rsi      # 0xe79f
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0xa3d0
xorl %ebp, %ebp
jmp 0x9079
leaq 0x5ca7(%rip), %rdi      # 0xed71
xorl %eax, %eax
callq 0x39d8
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
callq 0x22b0
cmpl $-0x1, %eax
je 0x9100
movl %eax, %ebx
callq 0x2060
movq %rax, %r14
movl (%rax), %ebp
movl %ebx, %edi
callq 0x20b0
movl %ebp, (%r14)
cmpl $0x1, %eax
sete %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5c7e(%rip), %rdi      # 0xed85
xorl %eax, %eax
callq 0x39d8
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x2060
movq %rax, %r14
movl (%rax), %ebp
andl $0x0, (%rax)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x8342
movq %rax, %rbx
leaq 0x20(%rsp), %r15
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2240
cmpq %rbx, (%r15)
je 0x9180
testq %rax, %rax
js 0x9189
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0x9172
cmpl $0x22, (%r14)
je 0x9192
movl %ebp, (%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c28(%rip), %rdi      # 0xedaf
jmp 0x9199
leaq 0x5c3f(%rip), %rdi      # 0xedcf
jmp 0x9199
leaq 0x5c65(%rip), %rdi      # 0xedfe
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/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 %rax
xorl %edi, %edi
callq 0x22a0
cmpq $-0x1, %rax
je 0x91b3
popq %rcx
retq
leaq 0x5c6d(%rip), %rdi      # 0xee27
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x18, %rsp
leaq 0x8(%rsp), %rsi
xorl %edi, %edi
callq 0x20e0
cmpl $-0x1, %eax
je 0x9204
movq 0x8(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x81dc
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %rsi
callq 0x81c4
addq $0x18, %rsp
retq
leaq 0x5c1c(%rip), %rdi      # 0xee27
xorl %eax, %eax
callq 0x39d8
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x0, 0xb047(%rip)      # 0x14260
jne 0x23f0
pushq %rbx
callq 0x91a3
movq %rax, %rbx
callq 0x20f0
shll $0x9, %ebx
addl %eax, %ebx
movl %ebx, %edi
callq 0x2220
movb $0x1, 0xb020(%rip)      # 0x14260
popq %rbx
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %r14
leaq 0xe0(%rsp), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movaps (%r12), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x88e8
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rbx), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x9326
movq 0x50(%rsp), %rbx
testq %rbx, %rbx
jle 0x92fd
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0x8243
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd126
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x8403
movq %r15, %rdi
callq 0x87e5
movl %eax, %ebp
movq %r15, %rdi
callq 0x859c
testb %bpl, %bpl
je 0x9310
movl 0x8(%r12), %esi
movq (%r12), %rdx
leaq 0x5b6a(%rip), %rdi      # 0xee65
jmp 0x9336
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xd126
movq %rax, %r14
movb $0x0, (%rax)
xorl %ebx, %ebx
movq %r14, %rax
movq %rbx, %rdx
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%r12), %esi
movq (%r12), %rdx
leaq 0x5b12(%rip), %rdi      # 0xee48
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x40
popq %rsi
callq 0xd104
movq %rax, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x8342
pushq $0x9
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x21e0
testl %eax, %eax
jne 0x93aa
leaq 0x86(%rip), %rsi        # 0x9413
movq %r15, %rdi
movq %r14, %rdx
callq 0xd1db
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
leaq 0x68(%rsp), %r13
movl %eax, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2290
movq %rax, %r15
xorl %edi, %edi
callq 0x8f86
movq %rax, %rdi
movq %r15, %rsi
callq 0x24fc
movq %rax, %r12
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x2290
movl 0x8(%r13), %esi
movq (%r13), %rdx
leaq 0x50(%rsp), %rax
movl 0x8(%rax), %r9d
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x5a82(%rip), %rdi      # 0xee88
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x9cdd
cmpl $0x0, 0x2c(%r14)
je 0x9cbb
cmpb $0x1, 0x30(%r14)
jne 0x9cd7
movl 0x2c(%rbx), %eax
movl %eax, 0x2c(%r14)
movb $0x1, 0x30(%r14)
movq 0x38(%rbx), %rax
movq %rax, 0x38(%r14)
movq %r14, %rdi
callq 0x9c9a
addq $0x60, %r14
jmp 0x9ca5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xd040
movq %rax, %r14
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x9246
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xa3ec
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x9458
movq %rax, %rbx
movq %r14, %rdi
callq 0xd21a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r15
callq 0xd040
movq %rax, %r14
movl $0x80, %esi
movq %rax, %rdi
callq 0xd104
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x2590
movq %rax, 0x20(%rbx)
leaq 0x8(%rbx), %r12
leaq 0x46ae(%rip), %rsi      # 0xe448
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0xa3d0
movq 0x20(%rbx), %rsi
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0xa466
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0xa454
movq %r14, %rdi
callq 0x2590
movq %rax, 0x28(%rbx)
movl 0x2c(%r15), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9e57
andq $0x0, 0x40(%rbx)
movq 0x50(%r15), %rax
movq (%rax), %rax
movq %rax, 0x30(%rbx)
andq $0x0, 0x78(%rbx)
movq $0x4, 0x70(%rbx)
movq %r14, %rdi
callq 0x2590
movq %rax, %r14
movq %rax, 0x68(%rbx)
movq 0x70(%rbx), %rsi
pushq $0x28
popq %rdi
callq 0x81a0
movq %r14, %rdi
movq %rax, %rsi
callq 0x24fc
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rcx, 0x40(%rdi)
testq %rsi, %rsi
je 0x9ea8
movq %rsi, %r14
cmpl $0x0, 0x2c(%rsi)
jne 0x9e85
cmpb $0x0, 0x48(%r14)
je 0x9ed7
movb $0x1, 0x38(%rbx)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x8602
movq %rax, 0x48(%rbx)
movq 0x40(%r14), %rax
jmp 0x9ec7
movb $0x1, 0x38(%rbx)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x8602
movq %rax, 0x48(%rbx)
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movl %ebp, 0x58(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb $0x0, 0x38(%rbx)
movq 0x40(%r14), %rax
movq %rax, 0x48(%rbx)
jmp 0x9ece
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rsi), %rax
testq %rax, %rax
je 0xa1aa
decq %rax
movq %rax, 0x78(%rsi)
movq 0x60(%rsi), %rcx
imulq $0x28, %rax, %rax
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movups %xmm0, 0x38(%rsi)
movups %xmm1, 0x48(%rsi)
movq 0x20(%rcx,%rax), %rax
movq %rax, 0x58(%rsi)
pushq $0x10
jmp 0xa1b4
movq (%rsi), %rdi
callq 0xd21a
pushq $0x20
popq %rbp
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2190
movl %ebp, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %rsi
movq 0x40(%rdi), %rdx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0xa3ec
movq 0x28(%r14), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0xa466
movq 0x20(%r14), %rsi
movq 0xb0(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0xa0(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0xa6c6
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xa454
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0xa2c0
cmpq $0x0, 0x40(%r14)
je 0xa2c0
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x88e8
jmp 0xa2dc
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8947
movl $0xf000, %eax           # imm = 0xF000
andl 0x38(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
je 0xa2f7
cmpl $0xa000, %eax           # imm = 0xA000
jne 0xa2fd
pushq $0x2
jmp 0xa2f9
pushq $0x1
popq %r12
jmp 0xa30f
xorl %ecx, %ecx
cmpl $0x4000, %eax           # imm = 0x4000
setne %cl
leal 0x4(,%rcx,4), %r12d
movl %r12d, (%rbx)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movl $0x90, %edx
callq 0x2280
testq %r14, %r14
je 0xa346
orl %r12d, 0x28(%r14)
cmpl $0x4, %r12d
jne 0xa3bb
movq 0x78(%r15), %rdi
cmpq 0x70(%r15), %rdi
jne 0xa386
pushq $0x2
popq %rsi
callq 0x81a0
movq %rax, 0x70(%r15)
movq 0x68(%r15), %r12
pushq $0x28
popq %rdi
movq %rax, %rsi
callq 0x81a0
movq %r12, %rdi
movq %rax, %rsi
callq 0x24fc
movq %rax, 0x60(%r15)
movq 0x78(%r15), %rdi
jmp 0xa38a
movq 0x60(%r15), %rax
imulq $0x28, %rdi, %rcx
movq 0x58(%r15), %rdx
movq %rdx, 0x20(%rax,%rcx)
movups 0x38(%r15), %xmm0
movups 0x48(%r15), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incq 0x78(%r15)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x9e57
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x8188
movq %rbx, %rdi
movq %rax, %rsi
callq 0x24fc
movq %rax, %rbx
movq 0x20(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2280
movb $0x0, (%rbx,%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rsi, %rdi
callq 0xa40f
movq %rax, (%rbx)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
leaq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rdi
leaq -0x1(%rdx), %r8
xorl %esi, %esi
movq %rdi, %r9
subq %rsi, %r9
je 0xa4ce
cmpb $0x2f, (%r8,%rdi)
jne 0xa4ce
incq %rsi
decq %r8
jmp 0xa4b7
movq %rdx, (%rax)
movq %r9, 0x8(%rax)
xorl %edx, %edx
testq %rsi, %rsi
jne 0xa4df
movl 0x10(%rcx), %edx
movb %dl, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
leaq 0x8(%rsp), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
leaq -0x1(%rsi), %r9
xorl %edx, %edx
movq %rdi, %r8
subq %rdx, %r8
je 0xa50f
cmpb $0x2f, (%r9,%rdi)
je 0xa50f
incq %rdx
decq %r9
jmp 0xa4f8
leaq (%rsi,%rdi), %r9
negq %rdx
leaq (%rdi,%rdx), %r10
cmpq $0x2, %r10
jb 0xa530
cmpb $0x2f, -0x2(%r9,%rdx)
jne 0xa530
decq %r8
decq %rdx
jmp 0xa516
movq %rsi, (%rax)
xorl %esi, %esi
subq $0x1, %r8
cmovaeq %r8, %rsi
movq %rsi, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq %rdx, %r9
movq %r9, 0x18(%rax)
negq %rdx
movq %rdx, 0x20(%rax)
movb 0x10(%rcx), %cl
movb %cl, 0x28(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
movq 0x48(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8188
movq 0x60(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x8188
movq %rax, %r12
movq %rax, %rdi
movq %rbp, %rsi
callq 0x8188
movq %r13, %rdi
movq %rax, %rsi
callq 0x24fc
movq %rax, %r13
movq 0x40(%rsp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2280
leaq (%r14,%r13), %rdi
incq %rdi
movb $0x2f, -0x1(%rdi)
movq 0x58(%rsp), %rsi
movq %r15, %rdx
callq 0x2280
movb $0x0, (%r13,%r12)
movq %r13, (%rbx)
movq %r12, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x30
popq %rsi
callq 0xd104
movq %rax, %rbx
movq %r14, (%rax)
andq $0x0, 0x18(%rax)
movq $0x20, 0x10(%rax)
pushq $0x20
popq %r14
movl $0xff, %ebp
cmpq $0x30, %r14
je 0xa7a6
callq 0x9212
cltd
idivl %ebp
movb %dl, (%rbx,%r14)
incq %r14
jmp 0xa78f
movq 0x10(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x81a0
movq %rax, %r14
movq %rax, %rdi
callq 0x8214
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x1e(%rip), %rsi        # 0xa7e9
movq %rbx, %rdx
callq 0xd1db
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2190
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rbp
movq 0x18(%rdi), %rdi
cmpq 0x10(%rbx), %rdi
jne 0xa89c
movq %r14, 0x20(%rsp)
pushq $0x2
popq %rsi
callq 0x81a0
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rax, %rdi
callq 0x81a0
movq %rax, %r13
movq %rax, %rdi
callq 0x8214
movq %rax, %r12
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2190
movq 0x10(%rbx), %rcx
movq 0x8(%rbx), %rdi
cmpq %rcx, %r14
je 0xa88a
movq (%rdi,%r14,8), %rsi
testq %rsi, %rsi
je 0xa885
movq (%rsi), %rax
movq 0x28(%rsi), %rdi
xorl %edx, %edx
divq %r15
movq (%r12,%rdx,8), %rax
movq %rax, 0x28(%rsi)
movq %rsi, (%r12,%rdx,8)
movq %rdi, %rsi
jmp 0xa863
incq %r14
jmp 0xa856
callq 0x2040
movq %r12, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0x20(%rsp), %r14
movq (%rbx), %rdi
pushq $0x30
popq %rsi
callq 0xd104
movq %rax, %r15
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
leaq 0x20(%rbx), %rdx
callq 0xcbe0
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movups (%rbp), %xmm0
movups %xmm0, (%rsp)
callq 0xa454
movq %r14, 0x20(%r15)
movq (%r15), %rax
xorl %edx, %edx
divq 0x10(%rbx)
movq 0x8(%rbx), %rax
movq (%rax,%rdx,8), %rcx
movq %rcx, 0x28(%r15)
movq %r15, (%rax,%rdx,8)
incq 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
leaq 0x60(%rsp), %r12
movq (%r12), %rdi
movq 0x8(%r12), %rsi
leaq 0x20(%r15), %rdx
callq 0xcbe0
xorl %ebx, %ebx
xorl %edx, %edx
divq 0x10(%r15)
movq %rdx, %r14
shlq $0x3, %r14
addq 0x8(%r15), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xa981
movq 0x18(%r14), %rax
movq %rax, 0x28(%rsp)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0xa564
testb %al, %al
jne 0xa97d
addq $0x28, %r14
jmp 0xa940
movq 0x20(%r14), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq -0x41(%rsi), %rax
cmpq $-0x40, %rax
jae 0xa9a6
pushq $-0x1
popq %rax
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb %bl, (%rsp)
movw $0x100, 0x1(%rsp)       # imm = 0x100
movb $0x1, 0x3(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsp)
movups %xmm0, 0x14(%rsp)
movups %xmm0, 0x24(%rsp)
movups %xmm0, 0x30(%rsp)
xorl %r15d, %r15d
movl $0xf8, %edx
xorl %esi, %esi
callq 0x2190
leaq 0x466f(%rip), %rax      # 0xf060
cmpq $0x40, %r15
je 0xaa08
movb (%rsp,%r15), %cl
xorb (%r15,%rax), %cl
movb %cl, (%r14,%r15)
incq %r15
jmp 0xa9f1
movq %rbx, 0xe8(%r14)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2b-optimized.h
// Function: blake2b_update
int blake2b_update( blake2b_state *S, const void *pin, size_t inlen )
{
  const unsigned char * in = (const unsigned char *)pin;
  if( inlen > 0 )
  {
    size_t left = S->buflen;
    size_t fill = BLAKE2B_BLOCKBYTES - left;
    if( inlen > fill )
    {
      S->buflen = 0;
      memcpy( S->buf + left, in, fill ); /* Fill buffer */
      blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
      blake2b_compress( S, S->buf ); /* Compress */
      in += fill; inlen -= fill;
      while(inlen > BLAKE2B_BLOCKBYTES) {
        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
        blake2b_compress( S, in );
        in += BLAKE2B_BLOCKBYTES;
        inlen -= BLAKE2B_BLOCKBYTES;
      }
    }
    memcpy( S->buf + S->buflen, in, inlen );
    S->buflen += inlen;
  }
  return 0;
}

// Assembly:
testq %rdx, %rdx
je 0xaaf6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xe0(%rdi), %rax
movl $0x80, %ebp
movl $0x80, %r12d
subq %rax, %r12
movq %rdx, %r15
subq %r12, %r15
jbe 0xaacb
andq $0x0, 0xe0(%rbx)
leaq 0x60(%rbx), %r13
leaq (%rbx,%rax), %rdi
addq $0x60, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2280
movq 0x40(%rbx), %rax
subq $-0x80, %rax
movq %rax, 0x40(%rbx)
sbbq $-0x1, 0x48(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xaaf9
addq %r12, %r14
cmpq $0x81, %r15
jb 0xaac2
movq 0x40(%rbx), %rax
leaq (%rax,%rbp), %rcx
movq %rcx, 0x40(%rbx)
cmpq $-0x80, %rax
sbbq $-0x1, 0x48(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaaf9
addq %rbp, %r14
addq $-0x80, %r15
jmp 0xaa90
movq 0xe0(%rbx), %rax
jmp 0xaace
movq %rdx, %r15
leaq (%rbx,%rax), %rdi
addq $0x60, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2280
addq %r15, 0xe0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2b-optimized.h
// Function: blake2b_final
int blake2b_final( blake2b_state *S, void *out, size_t outlen )
{
  if( out == NULL || outlen < S->outlen )
    return -1;

  if( blake2b_is_lastblock( S ) )
    return -1;

  blake2b_increment_counter( S, S->buflen );
  blake2b_set_lastblock( S );
  memset( S->buf + S->buflen, 0, BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
  blake2b_compress( S, S->buf );

  memcpy( out, &S->h[0], S->outlen );
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbp
testq %rsi, %rsi
je 0xcbd3
movq %rdi, %rbx
cmpq %rdx, 0xe8(%rdi)
ja 0xcbd3
cmpq $0x0, 0x50(%rbx)
jne 0xcbd3
movq %rsi, %r14
movq 0xe0(%rbx), %rax
addq %rax, 0x40(%rbx)
adcq $0x0, 0x48(%rbx)
cmpb $0x0, 0xf0(%rbx)
je 0xcb94
orq $-0x1, 0x58(%rbx)
orq $-0x1, 0x50(%rbx)
leaq 0x60(%rbx), %r15
leaq (%rbx,%rax), %rdi
addq $0x60, %rdi
movl $0x80, %edx
subq %rax, %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x2190
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaaf9
movq 0xe8(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2280
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/alloc-growable.c
// Function: CR_RegionAllocGrowable
void *CR_RegionAllocGrowable(CR_Region *r, size_t size)
{
  if(size == 0)
  {
    CR_ExitFailure("unable to allocate 0 bytes");
  }

  CR_StaticAssert(sizeof(Header) % 8 == 0);
  const size_t chunk_size = CR_SafeAdd(sizeof(Header), size);

  void **attached_pointer = CR_RegionAlloc(r, sizeof *attached_pointer);

  Header *header = malloc(chunk_size);
  if(header == NULL)
  {
    CR_ExitFailure("failed to allocate %zu bytes", chunk_size);
  }

  *attached_pointer = header;
  header->attached_pointer = attached_pointer;
  header->capacity = size;

  CR_RegionAttach(r, freeAttachedPointer, attached_pointer);

  ASAN_POISON_MEMORY_REGION(header, sizeof(Header));
  return header + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xcddb
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0xd2b0
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0xd104
movq %rax, %r12
movq %r15, %rdi
callq 0x22d0
testq %rax, %rax
je 0xcde9
movq %rax, %r13
movq %rax, (%r12)
movq %r12, (%rax)
movq %r14, 0x8(%rax)
leaq 0x3b(%rip), %rsi        # 0xcdfa
movq %rbx, %rdi
movq %r12, %rdx
callq 0xd1db
addq $0x10, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1222(%rip), %rdi      # 0xe004
xorl %eax, %eax
callq 0x3918
leaq 0x123e(%rip), %rdi      # 0xe02e
movq %r15, %rsi
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/alloc-growable.c
// Function: CR_EnsureCapacity
void *CR_EnsureCapacity(void *ptr, size_t size)
{
  if(size == 0)
  {
    CR_ExitFailure("unable to allocate 0 bytes");
  }
  else if(ptr == NULL)
  {
    return CR_RegionAllocGrowable(CR_GetGlobalRegion(), size);
  }

  Header *header = (Header *)ptr - 1;
  ASAN_UNPOISON_MEMORY_REGION(header, sizeof(Header));
  if(size <= header->capacity)
  {
    ASAN_POISON_MEMORY_REGION(header, sizeof(Header));
    return ptr;
  }

  const size_t chunk_size = CR_SafeAdd(sizeof(Header), size);
  Header *reallocated_header = realloc(header, chunk_size);
  if(reallocated_header == NULL)
  {
    CR_ExitFailure("failed to reallocate %zu bytes", chunk_size);
  }

  *reallocated_header->attached_pointer = reallocated_header;
  reallocated_header->capacity = size;

  ASAN_POISON_MEMORY_REGION(reallocated_header, sizeof(Header));
  return reallocated_header + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xce6e
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0xce59
cmpq %rbx, -0x8(%r14)
jae 0xce50
addq $-0x10, %r14
pushq $0x10
popq %rdi
movq %rbx, %rsi
callq 0xd2b0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2340
testq %rax, %rax
je 0xce7c
movq %rax, %r14
movq (%rax), %rax
movq %r14, (%rax)
movq %rbx, 0x8(%r14)
addq $0x10, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xce90
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xcd70
leaq 0x118f(%rip), %rdi      # 0xe004
xorl %eax, %eax
callq 0x3918
leaq 0x223d(%rip), %rdi      # 0xf0c0
movq %r15, %rsi
xorl %eax, %eax
callq 0x3918
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/global-region.c
// Function: CR_GetGlobalRegion
CR_Region *CR_GetGlobalRegion(void)
{
  static CR_Region *r = NULL;
  if(r == NULL)
  {
    r = CR_RegionNew();
  }

  return r;
}

// Assembly:
movq 0x73e9(%rip), %rax      # 0x14280
testq %rax, %rax
je 0xce9d
retq
pushq %rax
callq 0xd040
movq %rax, 0x73d6(%rip)      # 0x14280
addq $0x8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/mempool.c
// Function: CR_MempoolNew
CR_Mempool *CR_MempoolNew(CR_Region *r, size_t object_size,
                          CR_FailableDestructor *explicit_destructor,
                          CR_ReleaseCallback *implicit_destructor)
{
  if(object_size == 0)
  {
    CR_ExitFailure("unable to create memory pool for allocating zero size objects");
  }
  CR_StaticAssert(sizeof(Header) % 8 == 0);

  CR_Mempool *mp = CR_RegionAlloc(r, sizeof *mp);
  mp->r = r;
  mp->explicit_destructor = explicit_destructor;
  mp->implicit_destructor = implicit_destructor;
  mp->chunk_size = CR_SafeAdd(sizeof(Header), object_size);
  mp->allocated_chunks = NULL;
  mp->released_chunks = NULL;
  CR_RegionAttach(r, destroyObjects, mp);

  return mp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xcf16
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x30
popq %rsi
callq 0xd104
movq %rax, %r13
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0xd2b0
movq %rax, 0x18(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r13)
leaq 0x26(%rip), %rsi        # 0xcf24
movq %rbx, %rdi
movq %r13, %rdx
callq 0xd1db
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x21c2(%rip), %rdi      # 0xf0df
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/mempool.c
// Function: CR_MempoolAlloc
void *CR_MempoolAlloc(CR_Mempool *mp)
{
  Header *header = getAvailableChunk(mp);

  header->destructor_state = DS_disabled;
  header->mp = mp;
  header->prev = NULL;

  /* Prepend header to the mempools allocated chunk list. */
  header->next = mp->allocated_chunks;
  mp->allocated_chunks = header;

  if(header->next != NULL)
  {
    ASAN_UNPOISON_MEMORY_REGION(header->next, sizeof(Header));
    header->next->prev = header;
    ASAN_POISON_MEMORY_REGION(header->next, sizeof(Header));
  }

  ASAN_POISON_MEMORY_REGION(header, sizeof(Header));
  return header + 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xcf7a
movq 0x18(%rax), %rcx
movq %rcx, 0x28(%rbx)
testq %rcx, %rcx
je 0xcf86
andq $0x0, 0x10(%rcx)
jmp 0xcf86
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xd104
andl $0x0, (%rax)
movq %rbx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x20(%rbx)
testq %rcx, %rcx
je 0xcfa7
movq %rax, 0x10(%rcx)
addq $0x20, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: checkedMalloc
static void *checkedMalloc(size_t size)
{
  void *data = malloc(size);
  if(data == NULL)
  {
    CR_ExitFailure("failed to allocate %zu bytes", size);
  }

  return data;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x22d0
testq %rax, %rax
je 0xd0f3
popq %rbx
retq
leaq 0xf34(%rip), %rdi       # 0xe02e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: allocFromChunk
static void *allocFromChunk(CR_Region *r, Chunk *chunk, size_t size)
{
  if(size == 0)
  {
    CR_ExitFailure("unable to allocate 0 bytes");
  }

  if(size <= chunk->capacity - chunk->bytes_used)
  {
    return popBytesFromChunk(chunk, size);
  }
  else if(size < chunk->next_chunk_size - sizeof(ChunkList))
  {
    ChunkList *element = checkedMalloc(chunk->next_chunk_size);

    chunk->chunk = (unsigned char *)element;
    chunk->bytes_used = sizeof *element;
    chunk->capacity = chunk->next_chunk_size;

    element->next = r->chunk_list;
    r->chunk_list = element;

    chunk->next_chunk_size = CR_SafeMultiply(chunk->next_chunk_size, 2);

    return popBytesFromChunk(chunk, size);
  }
  else
  {
    ChunkList *element = checkedMalloc(CR_SafeAdd(sizeof(ChunkList), size));

    element->next = r->chunk_list;
    r->chunk_list = element;

    return element + 1;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0xd1cd
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rax
subq %rcx, %rax
cmpq %rdx, %rax
jae 0xd196
movq %rdi, %r15
movq 0x18(%r14), %rdi
leaq -0x8(%rdi), %rax
cmpq %rbx, %rax
jbe 0xd1a5
callq 0xd0e3
movq %rax, (%r14)
movq $0x8, 0x8(%r14)
movq 0x18(%r14), %rdi
movq %rdi, 0x10(%r14)
movq 0x40(%r15), %rcx
movq %rcx, (%rax)
movq %rax, 0x40(%r15)
pushq $0x2
popq %rsi
callq 0xd2c8
movq %rax, 0x18(%r14)
movq 0x8(%r14), %rcx
movq (%r14), %rax
addq %rcx, %rax
addq %rcx, %rbx
movq %rbx, 0x8(%r14)
jmp 0xd1c7
pushq $0x8
popq %rdi
movq %rbx, %rsi
callq 0xd2b0
movq %rax, %rdi
callq 0xd0e3
movq 0x40(%r15), %rcx
movq %rcx, (%rax)
movq %rax, 0x40(%r15)
addq $0x8, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe30(%rip), %rdi       # 0xe004
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: CR_RegionAttach
void CR_RegionAttach(CR_Region *r, CR_ReleaseCallback *callback, void *data)
{
  /* Store the callback inside the region as the current pending
     callback. This is required in case the following allocation
     fails and terminates the program. */
  r->pending_callback = callback;
  r->pending_callback_data = data;

  CallbackList *element = allocFromChunkWithPadding(r, sizeof *element);

  r->pending_callback = NULL;
  r->pending_callback_data = NULL;

  /* Prepend the callback to the regions callback-list. */
  element->callback = callback;
  element->data = data;

  element->next = r->callback_list;
  r->callback_list = element;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, 0x50(%rdi)
movq %rdx, 0x58(%rdi)
pushq $0x18
popq %rsi
callq 0xd106
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r15)
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq 0x48(%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x48(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: CR_RegionRelease
void CR_RegionRelease(CR_Region *r)
{
  /* Call all attached callbacks. */
  if(r->pending_callback != NULL)
  {
    r->pending_callback(r->pending_callback_data);
  }
  for(CallbackList *element = r->callback_list;
      element != NULL; element = element->next)
  {
    element->callback(element->data);
  }

  /* Detach the region from the region-list. */
  if(r->prev != NULL)
  {
    r->prev->next = r->next;
  }
  if(r->next != NULL)
  {
    r->next->prev = r->prev;
  }
  if(r == region_list)
  {
    region_list = region_list->next;
  }

  /* Free all chunks associated with the region. */
  ChunkList *element = r->chunk_list;
  while(element != NULL)
  {
    ChunkList *next = element->next;
    free(element);
    element = next;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0xd230
movq 0x58(%rbx), %rdi
callq *%rax
leaq 0x48(%rbx), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xd249
movq 0x8(%r14), %rdi
callq *(%r14)
addq $0x10, %r14
jmp 0xd234
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
testq %rax, %rax
je 0xd25a
movq %rcx, 0x68(%rax)
testq %rcx, %rcx
je 0xd263
movq %rax, 0x60(%rcx)
movq 0x701e(%rip), %rax      # 0x14288
cmpq %rbx, %rax
jne 0xd27a
movq 0x68(%rax), %rax
movq %rax, 0x700e(%rip)      # 0x14288
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xd290
movq (%rdi), %rbx
callq 0x2040
movq %rbx, %rdi
jmp 0xd27e
addq $0x8, %rsp
popq %rbx
popq %r14
retq