LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: prepareNodeForWiping
static void prepareNodeForWiping(Metadata *metadata, PathNode *node)
{
  if(backupHintNoPol(node->hint) == BH_not_part_of_repository)
  {
    return;
  }

  backupHintSet(node->hint, BH_not_part_of_repository);
  metadata->total_path_count--;

  decrementRefCounts(node->history);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x4, %eax
jne 0x3703
jmp 0x3737
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0x4, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3ad0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: setPathHistoryState
static void setPathHistoryState(Allocator *a, PathState *state,
                                const SearchResult result)
{
  state->uid = result.stats.st_uid;
  state->gid = result.stats.st_gid;

  if(result.type == SRT_regular_file)
  {
    state->type = PST_regular_file;
    state->metadata.file_info.permission_bits = result.stats.st_mode;
    state->metadata.file_info.modification_time = result.stats.st_mtime;
    state->metadata.file_info.size = result.stats.st_size;
  }
  else if(result.type == SRT_symlink)
  {
    StringView target = sSymlinkReadTarget(result.path, a);
    if((off_t)target.length != result.stats.st_size)
    {
      die("symlink changed while reading: \"" PRI_STR "\"",
          STR_FMT(result.path));
    }

    state->type = PST_symlink;
    strSet(&state->metadata.symlink_target, target);
  }
  else if(result.type == SRT_directory)
  {
    state->type = PST_directory;
    state->metadata.directory_info.permission_bits = result.stats.st_mode;
    state->metadata.directory_info.modification_time =
      result.stats.st_mtime;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x4c(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x4(%rcx)
movl 0x50(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x8(%rcx)
cmpl $0x1, (%rax)
jne 0x37a9
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x1, (%rcx)
movl 0x48(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x10(%rcx)
movq 0x88(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x3878
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3844
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rsi
leaq -0x28(%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 0xc810
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x60(%rcx), %rax
je 0x380e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movl %ecx, %esi
movq 0x8(%rax), %rdx
leaq 0x20854(%rip), %rdi     # 0x2405b
movb $0x0, %al
callq 0x4680
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%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
jmp 0x3876
movq -0x30(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x3874
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x3, (%rcx)
movl 0x48(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x10(%rcx)
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3876
jmp 0x3878
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: handlePolicyChanges
static void handlePolicyChanges(Metadata *metadata, PathNode *node,
                                const BackupPolicy policy)
{
  if(node->policy == policy)
  {
    return;
  }

  backupHintSet(node->hint, BH_policy_changed);
  if(node->policy == BPOL_track)
  {
    if(node->history->state.type == PST_non_existing)
    {
      node->history->backup->ref_count--;
      node->history = node->history->next;
    }

    if(node->history->next != NULL)
    {
      decrementRefCounts(node->history->next);
      node->history->next = NULL;

      backupHintSet(node->hint, BH_loses_history);
    }

    if(node->history->state.type != PST_directory)
    {
      for(PathNode *subnode = node->subnodes; subnode != NULL;
          subnode = subnode->next)
      {
        prepareNodeForWipingRecursively(metadata, subnode);
      }
    }
  }

  node->policy = policy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x38a4
jmp 0x398d
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x1c(%rax)
jne 0x3983
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x38ff
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x3943
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x48(%rax), %rdi
callq 0x3ad0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x3, 0x8(%rax)
je 0x3981
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x397f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3680
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x395d
jmp 0x3981
jmp 0x3983
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: handleNodeChanges
static void handleNodeChanges(AllocatorPair *allocator_pair,
                              PathNode *node, PathState *state,
                              const SearchResult result)
{
  handleFiletypeChanges(node, result);

  if(backupHintNoPol(node->hint) == BH_none)
  {
    applyNodeChanges(allocator_pair, node, state, result.stats);
  }
  else if(result.policy != BPOL_none)
  {
    setPathHistoryState(allocator_pair->a, state, result);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rax
leaq 0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rsp, %rdi
movl $0x18, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x20(%rbp), %rdi
callq 0x3b10
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x0, %eax
jne 0x3a25
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdx
addq $0x30, %rsi
movq %rsp, %rdi
movl $0x12, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x2640
jmp 0x3a60
movq -0x28(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x3a5e
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rsp, %rdi
movl $0x18, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x3740
jmp 0x3a60
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: handleFiletypeChanges
static void handleFiletypeChanges(PathNode *node,
                                  const SearchResult result)
{
  if(node->history->state.type == PST_regular_file)
  {
    if(result.type == SRT_symlink)
    {
      backupHintSet(node->hint, BH_regular_to_symlink);
    }
    else if(result.type == SRT_directory)
    {
      backupHintSet(node->hint, BH_regular_to_directory);
    }
  }
  else if(node->history->state.type == PST_symlink)
  {
    if(result.type == SRT_regular_file)
    {
      backupHintSet(node->hint, BH_symlink_to_regular);
    }
    else if(result.type == SRT_directory)
    {
      backupHintSet(node->hint, BH_symlink_to_directory);
    }
  }
  else if(node->history->state.type == PST_directory)
  {
    if(result.type == SRT_regular_file)
    {
      backupHintSet(node->hint, BH_directory_to_regular);
    }
    else if(result.type == SRT_symlink)
    {
      backupHintSet(node->hint, BH_directory_to_symlink);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0x3b77
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3b50
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0x5, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x3b72
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x3b70
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0x6, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x3b72
jmp 0x3c23
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x2, 0x8(%rax)
jne 0x3bcb
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x3ba7
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0x7, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x3bc9
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x3bc7
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0x8, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x3bc9
jmp 0x3c21
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x3, 0x8(%rax)
jne 0x3c1f
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x3bfb
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0x9, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x3c1d
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3c1b
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0xa, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x3c1d
jmp 0x3c1f
jmp 0x3c21
jmp 0x3c23
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: matchesSearchSubnodes
static SearchNode *matchesSearchSubnodes(StringView path,
                                         const SearchNode *result)
{
  if(result != NULL)
  {
    StringView path_tail = strSplitPath(path).tail;
    for(SearchNode *node = result->subnodes; node != NULL;
        node = node->next)
    {
      if(searchNodeMatches(node, path_tail))
      {
        return node;
      }
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3ceb
movq -0x68(%rbp), %rax
leaq -0x58(%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 0xf390
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x3ce9
movq -0x60(%rbp), %rdi
leaq -0x28(%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 0x3e00
testb $0x1, %al
jne 0x3ccf
jmp 0x3cd9
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3cf3
jmp 0x3cdb
movq -0x60(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x3c9c
jmp 0x3ceb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: handleRemovedPath
static void handleRemovedPath(Metadata *metadata, PathNode *node,
                              const BackupPolicy policy)
{
  handlePolicyChanges(metadata, node, policy);

  if(policy == BPOL_mirror)
  {
    prepareNodeForWipingRecursively(metadata, node);
  }
  else if(policy == BPOL_none &&
          (node->subnodes == NULL ||
           node->history->state.type != PST_directory))
  {
    prepareNodeForWiping(metadata, node);
  }
  else
  {
    markAsRemovedRecursively(metadata, node, true);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3880
cmpl $0x2, -0x14(%rbp)
jne 0x3d38
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3680
jmp 0x3d7a
cmpl $0x0, -0x14(%rbp)
jne 0x3d66
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3d57
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x3, 0x8(%rax)
je 0x3d66
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36e0
jmp 0x3d78
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3540
jmp 0x3d7a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: matchesIgnoreList
static bool matchesIgnoreList(StringView path,
                              const RegexList *ignore_list)
{
  for(const RegexList *item = ignore_list; item != NULL; item = item->next)
  {
    if(sRegexIsMatching(item->regex, path))
    {
      return true;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3de8
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xd7a0
testb $0x1, %al
jne 0x3dd2
jmp 0x3dd8
movb $0x1, -0x1(%rbp)
jmp 0x3dec
jmp 0x3dda
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3d9c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: searchFileDuplicates
static bool searchFileDuplicates(PathNode *node, StringView repo_path,
                                 const struct stat stats)
{
  RegularFileInfo *file_info = &node->history->state.metadata.file_info;
  file_info->slot = 0;

  while(repoRegularFileExists(repo_path, file_info))
  {
    if(equalsToStoredFile(node, repo_path, stats))
    {
      return true;
    }
    if(file_info->slot == UINT8_MAX)
    {
      die("overflow calculating slot number");
    }

    file_info->slot++;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x8, %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x2c(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%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 0x9950
testb $0x1, %al
jne 0x4177
jmp 0x41eb
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsp, %rax
movq %rax, %rdi
addq $0x18, %rdi
movl $0x12, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
callq 0x43a0
testb $0x1, %al
jne 0x41b6
jmp 0x41bc
movb $0x1, -0x1(%rbp)
jmp 0x41ef
movq -0x18(%rbp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0xff, %eax
jne 0x41d9
leaq 0x1ff0a(%rip), %rdi     # 0x240dc
movb $0x0, %al
callq 0x4680
movq -0x18(%rbp), %rax
movb 0x2c(%rax), %cl
addb $0x1, %cl
movb %cl, 0x2c(%rax)
jmp 0x414b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/colors.c
// Function: colorPrintf
void colorPrintf(FILE *stream, TextColor color, const char *format, ...)
{
  va_list arguments;
  va_start(arguments, format);
  const bool colorize = sIsTTY(stream);

  if(colorize) fprintf(stream, "\033[%sm", color_codes[color]);
  vfprintf(stream, format, arguments);
  if(colorize) fprintf(stream, "\033[0m");

  va_end(arguments);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x45cb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rdi
callq 0xd290
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x4645
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x24bcd(%rip), %rax     # 0x29200
movq (%rax,%rcx,8), %rdx
leaq 0x1faf2(%rip), %rsi     # 0x24130
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2350
testb $0x1, -0x31(%rbp)
je 0x466e
movq -0x8(%rbp), %rdi
leaq 0x1facf(%rip), %rsi     # 0x24136
movb $0x0, %al
callq 0x2230
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/error-handling.c
// Function: die
void die(const char *format, ...)
{
  va_list arguments;
  va_start(arguments, format);

  fprintf(stderr, "nb: error: ");
  vfprintf(stderr, format, arguments);
  fprintf(stderr, "\n");

  va_end(arguments);

  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x46b5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x248f1(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1fa68(%rip), %rsi     # 0x24179
movb $0x0, %al
callq 0x2230
movq 0x248d9(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2350
movq 0x248c2(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x20069(%rip), %rsi     # 0x247a9
movb $0x0, %al
callq 0x2230
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/error-handling.c
// Function: dieErrno
void dieErrno(const char *format, ...)
{
  va_list arguments;
  va_start(arguments, format);

  fprintf(stderr, "nb: error: ");
  vfprintf(stderr, format, arguments);
  fprintf(stderr, ": %s\n", strerror(errno));

  va_end(arguments);

  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4795
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x24811(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1f988(%rip), %rsi     # 0x24179
movb $0x0, %al
callq 0x2230
movq 0x247f9(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2350
movq 0x247e2(%rip), %rax     # 0x28ff8
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0xd8(%rbp), %rdi
movq %rax, %rdx
leaq 0x1f948(%rip), %rsi     # 0x24185
movb $0x0, %al
callq 0x2230
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x2380
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/file-hash.c
// Function: fileHash
void fileHash(StringView filepath, struct stat stats, uint8_t *hash_out,
              HashProgressCallback progress_callback,
              void *callback_user_data)
{
  const size_t blocksize = stats.st_blksize;
  uint64_t bytes_left = stats.st_size;
  FileStream *stream = sFopenRead(filepath);

  static unsigned char *buffer = NULL;
  buffer = CR_EnsureCapacity(buffer, blocksize);

  blake2b_state state;
  blake2b_init(&state, FILE_HASH_SIZE);

  while(bytes_left > 0)
  {
    const size_t bytes_to_read =
      bytes_left > blocksize ? blocksize : bytes_left;

    sFread(buffer, bytes_to_read, stream);
    blake2b_update(&state, buffer, bytes_to_read);
    bytes_left -= bytes_to_read;

    if(progress_callback != NULL)
    {
      progress_callback(bytes_to_read, callback_user_data);
    }
  }

  const bool stream_not_at_end = sFbytesLeft(stream);
  sFclose(stream);

  if(stream_not_at_end)
  {
    die("file changed while calculating hash: \"" PRI_STR "\"",
        STR_FMT(filepath));
  }

  blake2b_final(&state, hash_out, FILE_HASH_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
leaq 0x28(%rbp), %rcx
leaq 0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x38(%rcx), %rdx
movq %rdx, -0x20(%rbp)
movq 0x30(%rcx), %rcx
movq %rcx, -0x28(%rbp)
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, -0x30(%rbp)
movq 0x249d1(%rip), %rdi     # 0x29290
movq -0x20(%rbp), %rsi
callq 0x22ab0
movq %rax, 0x249c1(%rip)     # 0x29290
leaq -0x128(%rbp), %rdi
movl $0x14, %esi
callq 0xfc50
cmpq $0x0, -0x28(%rbp)
jbe 0x497b
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x4902
movq -0x20(%rbp), %rax
movq %rax, -0x148(%rbp)
jmp 0x490d
movq -0x28(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rax
movq %rax, -0x130(%rbp)
movq 0x2496e(%rip), %rdi     # 0x29290
movq -0x130(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xbdc0
movq 0x24957(%rip), %rsi     # 0x29290
movq -0x130(%rbp), %rdx
leaq -0x128(%rbp), %rdi
callq 0xfe30
movq -0x130(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4976
movq -0x10(%rbp), %rax
movq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x48e0
movq -0x30(%rbp), %rdi
callq 0xc410
andb $0x1, %al
movb %al, -0x131(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc020
testb $0x1, -0x131(%rbp)
je 0x49bc
movq -0x140(%rbp), %rax
movq 0x8(%rax), %rcx
movl %ecx, %esi
movq (%rax), %rdx
leaq 0x1f7d6(%rip), %rdi     # 0x2418b
movb $0x0, %al
callq 0x4680
movq -0x8(%rbp), %rsi
leaq -0x128(%rbp), %rdi
movl $0x14, %edx
callq 0x21ff0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/garbage-collector.c
// Function: populateTableRecursively
static void populateTableRecursively(Allocator *a, StringTable *table,
                                     const PathNode *nodes)
{
  for(const PathNode *node = nodes; node != NULL; node = node->next)
  {
    if(backupHintNoPol(node->hint) == BH_not_part_of_repository)
    {
      continue;
    }

    for(const PathHistory *point = node->history; point != NULL;
        point = point->next)
    {
      if(point->state.type != PST_regular_file ||
         point->state.metadata.file_info.size <= FILE_HASH_SIZE)
      {
        continue;
      }

      static char *buffer = NULL;
      repoBuildRegularFilePath(&buffer, &point->state.metadata.file_info);
      StringView path = str(buffer);

      if(strTableGet(table, path) == NULL)
      {
        strTableMap(table, strCopy(path, a), (void *)0x1);
      }
    }

    populateTableRecursively(a, table, node->subnodes);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4e2b
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x4, %eax
jne 0x4d10
jmp 0x4e1a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4e05
movq -0x28(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x4d3c
movq -0x28(%rbp), %rax
cmpq $0x14, 0x28(%rax)
ja 0x4d41
jmp 0x4df4
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
addq $0x10, %rsi
leaq 0x24544(%rip), %rdi     # 0x29298
callq 0x9a70
movq 0x24538(%rip), %rsi     # 0x29298
leaq -0x40(%rbp), %rdi
callq 0xf100
movq -0x10(%rbp), %rdi
leaq -0x40(%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 0xfb50
cmpq $0x0, %rax
jne 0x4df2
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x40(%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 -0x58(%rbp), %rax
movl $0x1, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf940
jmp 0x4df4
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4d1c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x4cd0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4cef
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/garbage-collector.c
// Function: shouldBeRemoved
static bool shouldBeRemoved(StringView path, const struct stat *stats,
                            void *user_data)
{
  GCContext *ctx = user_data;

  StringView path_relative_to_repo =
    strUnterminated(&path.content[ctx->repo_path.length + 1],
                    path.length - ctx->repo_path.length - 1);
  if(strTableGet(ctx->paths_to_preserve, path_relative_to_repo) != NULL)
  {
    if(ctx->progress_callback != NULL)
    {
      ctx->progress_callback(ctx->statistics.deleted_items_total_size,
                             strTableCountMappings(ctx->paths_to_preserve),
                             ctx->callback_user_data);
    }
    return false;
  }

  ctx->statistics.deleted_items_count =
    sSizeAdd(ctx->statistics.deleted_items_count, 1);
  if(S_ISREG(stats->st_mode))
  {
    ctx->statistics.deleted_items_total_size =
      sSizeAdd(ctx->statistics.deleted_items_total_size, stats->st_size);
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rsi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0x1, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
subq 0x8(%rax), %rdx
subq $0x1, %rdx
leaq -0x38(%rbp), %rdi
callq 0xf140
movq -0x20(%rbp), %rax
movq 0x18(%rax), %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 0xfb50
cmpq $0x0, %rax
je 0x4f02
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4efc
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xfc30
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rdx
callq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x4f56
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0xb8f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4f52
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xb8f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: printHumanReadableSize
void printHumanReadableSize(const uint64_t size)
{
  static const char units[] = "bKMGT";
  double converted_value = (double)size;
  size_t unit_index = 0;

  while(converted_value > 999.9 && unit_index + 2 < sizeof(units))
  {
    converted_value /= 1024.0;
    unit_index++;
  }

  if(unit_index == 0)
  {
    printf("%.0lf b", converted_value);
  }
  else
  {
    const uint64_t fraction = (uint64_t)(converted_value * 10.0) % 10;
    printf("%" PRIu64 ".%" PRIu64 " %ciB", (uint64_t)converted_value,
           fraction, units[unit_index]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movaps 0x1f24d(%rip), %xmm1    # 0x241d0
movq -0x8(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1f24c(%rip), %xmm1    # 0x241e0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorl %eax, %eax
movsd 0x1f231(%rip), %xmm1    # 0x241f0
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
jbe 0x4fda
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq $0x6, %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4fe3
jmp 0x5007
movsd -0x10(%rbp), %xmm0
movsd 0x1f218(%rip), %xmm1    # 0x24208
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4fb0
cmpq $0x0, -0x18(%rbp)
jne 0x5026
movsd -0x10(%rbp), %xmm0
leaq 0x1f220(%rip), %rdi     # 0x2423a
movb $0x1, %al
callq 0x2130
jmp 0x50cc
movsd -0x10(%rbp), %xmm0
movsd 0x1f1c5(%rip), %xmm1    # 0x241f8
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x1f1b2(%rip), %xmm2    # 0x24200
subsd %xmm2, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rcx
movq -0x30(%rbp), %rax
movq %rdx, %rcx
shrq $0x2, %rcx
andq $-0x2, %rcx
leaq (%rcx,%rcx,4), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1f17a(%rip), %rax     # 0x24234
movsbl (%rax,%rcx), %ecx
leaq 0x1f17d(%rip), %rdi     # 0x24242
movb $0x0, %al
callq 0x2130
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: warnUnmatchedExpressions
static void warnUnmatchedExpressions(const RegexList *expression_list,
                                     const char *target_name)
{
  for(const RegexList *expression = expression_list; expression != NULL;
      expression = expression->next)
  {
    if(!expression->has_matched)
    {
      warnConfigLineNr(expression->line_nr);
      fprintf(stderr, "regex never matched a %s: ", target_name);
      warnPathNewline(expression->expression);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5388
movq -0x18(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0x5378
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x57d0
movq 0x23cbb(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1ef7c(%rip), %rsi     # 0x242c7
movb $0x0, %al
callq 0x2230
movq -0x18(%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 0x5920
jmp 0x537a
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5318
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: containsContentChanges
static bool containsContentChanges(const ChangeSummary *changes)
{
  return changes->new_items.affected_items_count > 0 ||
    changes->removed_items.affected_items_count > 0 ||
    changes->lost_items.affected_items_count > 0 ||
    changes->changed_items.affected_items_count > 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, (%rcx)
movb %al, -0x9(%rbp)
ja 0x56f6
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x10(%rcx)
movb %al, -0x9(%rbp)
ja 0x56f6
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x20(%rcx)
movb %al, -0x9(%rbp)
ja 0x56f6
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
seta %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: warnNodeMatches
void warnNodeMatches(const SearchNode *node, StringView string)
{
  warnConfigLineNr(node->line_nr);
  fprintf(stderr, "%s ", typeOf(node));
  warnPath(node->name);
  fprintf(stderr, " matches \"");
  colorPrintf(stderr, TC_yellow, "" PRI_STR "", STR_FMT(string));
  fprintf(stderr, "\"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x57d0
movq 0x238d0(%rip), %rax     # 0x28ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5870
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x1eb0e(%rip), %rsi     # 0x24254
movb $0x0, %al
callq 0x2230
movq -0x8(%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 0x58b0
movq 0x23882(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1ead8(%rip), %rsi     # 0x24258
movb $0x0, %al
callq 0x2230
movq -0x10(%rbp), %rax
movq 0x23866(%rip), %rcx     # 0x28ff8
movq (%rcx), %rdi
movq 0x8(%rax), %rcx
movq (%rax), %r8
movl $0x6, %esi
leaq 0x1eabb(%rip), %rdx     # 0x24263
movb $0x0, %al
callq 0x4590
movq 0x23842(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1eaa8(%rip), %rsi     # 0x24268
movb $0x0, %al
callq 0x2230
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: warnConfigLineNr
static void warnConfigLineNr(const size_t line_nr)
{
  colorPrintf(stderr, TC_yellow, "config");
  fprintf(stderr, ": ");
  colorPrintf(stderr, TC_blue, "line ");
  colorPrintf(stderr, TC_red, "%zu", line_nr);
  fprintf(stderr, ": ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x23815(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
movl $0x6, %esi
leaq 0x1e9c5(%rip), %rdx     # 0x241b7
movb $0x0, %al
callq 0x4590
movq 0x237f8(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1eaf9(%rip), %rsi     # 0x24303
movb $0x0, %al
callq 0x2230
movq 0x237e0(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
movl $0x8, %esi
leaq 0x1ec10(%rip), %rdx     # 0x24437
movb $0x0, %al
callq 0x4590
movq 0x237c3(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
movl $0x2, %esi
leaq 0x1ebf5(%rip), %rdx     # 0x2443d
movb $0x0, %al
callq 0x4590
movq 0x237a2(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1eaa3(%rip), %rsi     # 0x24303
movb $0x0, %al
callq 0x2230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: getExistingState
static const PathState *getExistingState(const PathNode *node)
{
  if(node->history->state.type == PST_non_existing &&
     node->history->next != NULL)
  {
    return &node->history->next->state;
  }

  return &node->history->state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x59ab
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x59ab
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x48(%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x59bb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: matchesRegexList
static bool matchesRegexList(const PathNode *node,
                             RegexList *expression_list)
{
  for(RegexList *expression = expression_list; expression != NULL;
      expression = expression->next)
  {
    if(sRegexIsMatching(expression->regex, node->path))
    {
      expression->has_matched = true;
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5a3c
movq -0x20(%rbp), %rax
movq (%rax), %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 0xd7a0
testb $0x1, %al
jne 0x5a1e
jmp 0x5a2c
movq -0x20(%rbp), %rax
movb $0x1, 0x28(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5a40
jmp 0x5a2e
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x59e8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: changeSummaryAdd
static void changeSummaryAdd(ChangeSummary *a, const ChangeSummary *b)
{
  changeDetailAdd(&a->new_items, b->new_items.affected_items_count,
                  b->new_items.affected_items_total_size);
  changeDetailAdd(&a->removed_items, b->removed_items.affected_items_count,
                  b->removed_items.affected_items_total_size);
  changeDetailAdd(&a->lost_items, b->lost_items.affected_items_count,
                  b->lost_items.affected_items_total_size);
  changeDetailAdd(&a->changed_items, b->changed_items.affected_items_count,
                  b->changed_items.affected_items_total_size);
  a->changed_attributes =
    sSizeAdd(a->changed_attributes, b->changed_attributes);
  a->other_changes_exist |= b->other_changes_exist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x6570
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x6570
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x6570
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
callq 0x6570
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xb8f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movb 0x48(%rax), %al
andb $0x1, %al
movzbl %al, %edx
movq -0x8(%rbp), %rax
movb 0x48(%rax), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: printNodePath
static void printNodePath(const PathNode *node, const TextColor color)
{
  const PathState *state = getExistingState(node);

  colorPrintf(stdout, color, "%s" PRI_STR "%s",
              state->type == PST_symlink ? "^" : "", STR_FMT(node->path),
              state->type == PST_directory ? "/" : "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5970
movq %rax, -0x18(%rbp)
movq 0x22c9d(%rip), %rax     # 0x28fc0
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x1e474(%rip), %rcx     # 0x247aa
leaq 0x1e0bf(%rip), %rax     # 0x243fc
cmpl $0x2, %edx
cmoveq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %r8d
movq -0x8(%rbp), %rax
movq (%rax), %r9
movq -0x18(%rbp), %rax
movl (%rax), %r10d
leaq 0x1e446(%rip), %rax     # 0x247aa
leaq 0x1e093(%rip), %rdx     # 0x243fe
cmpl $0x3, %r10d
cmoveq %rdx, %rax
leaq 0x1e079(%rip), %rdx     # 0x243f3
movq %rax, (%rsp)
movb $0x0, %al
callq 0x4590
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: printPrefix
static void printPrefix(bool *printed_prefix)
{
  if(*printed_prefix)
  {
    printf(", ");
  }
  else
  {
    printf(" (");
    *printed_prefix = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
je 0x63b5
leaq 0x1e054(%rip), %rdi     # 0x24400
movb $0x0, %al
callq 0x2130
jmp 0x63ca
leaq 0x1e386(%rip), %rdi     # 0x24742
movb $0x0, %al
callq 0x2130
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: printChangeDetail
static void printChangeDetail(const ChangeDetail details,
                              const char *prefix)
{
  printf("%s%zu item%s", details.affected_items_count > 0 ? prefix : "",
         details.affected_items_count,
         details.affected_items_count == 1 ? "" : "s");

  if(details.affected_items_total_size > 0)
  {
    printf(", %s", prefix);
    printHumanReadableSize(details.affected_items_total_size);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x63f5
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6402
leaq 0x1e3ae(%rip), %rax     # 0x247aa
movq %rax, -0x20(%rbp)
jmp 0x6402
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rdi
leaq 0x1dffe(%rip), %rcx     # 0x24413
leaq 0x1e38e(%rip), %rax     # 0x247aa
cmpq $0x1, %rdi
cmoveq %rax, %rcx
leaq 0x1dfd8(%rip), %rdi     # 0x24403
movb $0x0, %al
callq 0x2130
cmpq $0x0, -0x8(%rbp)
jbe 0x6454
movq -0x18(%rbp), %rsi
leaq 0x1dfcc(%rip), %rdi     # 0x24410
movb $0x0, %al
callq 0x2130
movq -0x8(%rbp), %rdi
callq 0x4f70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: printSummarizedDetail
static void printSummarizedDetail(const ChangeSummary *summary,
                                  bool *printed_prefix)
{
  if(summary->new_items.affected_items_count > 0)
  {
    printPrefix(printed_prefix);
    printChangeDetail(summary->new_items, "+");
  }

  ChangeDetail deleted_items = summary->removed_items;
  changeDetailAdd(&deleted_items, summary->lost_items.affected_items_count,
                  summary->lost_items.affected_items_total_size);
  if(deleted_items.affected_items_count > 0)
  {
    printPrefix(printed_prefix);
    printChangeDetail(deleted_items, "-");
  }
  if(summary->changed_items.affected_items_count > 0)
  {
    printPrefix(printed_prefix);
    printf("%zu changed", summary->changed_items.affected_items_count);
  }
  if(summary->changed_attributes > 0)
  {
    printPrefix(printed_prefix);
    printf("%zu metadata change%s", summary->changed_attributes,
           summary->changed_attributes == 1 ? "" : "s");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x649a
movq -0x10(%rbp), %rdi
callq 0x6390
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
leaq 0x1df53(%rip), %rdx     # 0x243e8
callq 0x63d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
leaq -0x20(%rbp), %rdi
callq 0x6570
cmpq $0x0, -0x20(%rbp)
jbe 0x64eb
movq -0x10(%rbp), %rdi
callq 0x6390
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x1df04(%rip), %rdx     # 0x243ea
callq 0x63d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jbe 0x6515
movq -0x10(%rbp), %rdi
callq 0x6390
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
leaq 0x1df07(%rip), %rdi     # 0x24415
movb $0x0, %al
callq 0x2130
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jbe 0x655d
movq -0x10(%rbp), %rdi
callq 0x6390
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
leaq 0x1ded3(%rip), %rdx     # 0x24413
leaq 0x1e263(%rip), %rax     # 0x247aa
cmpq $0x1, %rcx
cmoveq %rax, %rdx
leaq 0x1decb(%rip), %rdi     # 0x24421
movb $0x0, %al
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: changeDetailAdd
static void changeDetailAdd(ChangeDetail *details, const size_t count,
                            const uint64_t size)
{
  details->affected_items_count =
    sSizeAdd(details->affected_items_count, count);
  details->affected_items_total_size =
    sUint64Add(details->affected_items_total_size, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xb8f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xb990
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/informations.c
// Function: incrementExtraChangedAttributes
static void incrementExtraChangedAttributes(ChangeSummary *changes,
                                            const BackupHint hint)
{
  if(hint & BH_owner_changed)
  {
    changes->changed_attributes = sSizeAdd(changes->changed_attributes, 1);
  }
  if(hint & BH_permissions_changed)
  {
    changes->changed_attributes = sSizeAdd(changes->changed_attributes, 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x65f7
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movl $0x1, %esi
callq 0xb8f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0xc(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x661f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movl $0x1, %esi
callq 0xb8f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop