LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x24b8
movq 0x10bce(%rip), %r14     # 0x12ff8
movq (%r14), %rdi
cmpq $0x0, 0x20(%rbx)
leaq 0xc058(%rip), %rax      # 0xe491
leaq 0xc04b(%rip), %rdx      # 0xe48b
cmoveq %rax, %rdx
leaq 0xbe55(%rip), %rsi      # 0xe2a0
xorl %eax, %eax
callq 0x2250
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x4aa6
movq (%r14), %rcx
leaq 0xbe33(%rip), %rdi      # 0xe2a4
pushq $0xa
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x23d0
movq (%r14), %rdi
movl 0x38(%rsp), %ecx
movq 0x30(%rsp), %r8
leaq 0xbe1d(%rip), %rdx      # 0xe2af
pushq $0x6
popq %rsi
xorl %eax, %eax
callq 0x3cd8
movq (%r14), %rcx
leaq 0xbe0e(%rip), %rdi      # 0xe2b4
pushq $0x2
popq %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x23d0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10b2d(%rip), %r13     # 0x12ff8
movq (%r13), %rdi
leaq 0xbd0c(%rip), %rdx      # 0xe1e2
pushq $0x6
popq %rsi
xorl %eax, %eax
callq 0x3cd8
movq (%r13), %rcx
leaq 0xbe64(%rip), %r14      # 0xe34f
pushq $0x2
popq %r15
pushq $0x1
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x23d0
movq (%r13), %rdi
leaq 0xbf75(%rip), %rdx      # 0xe481
pushq $0x8
popq %rsi
xorl %eax, %eax
callq 0x3cd8
movq (%r13), %rdi
leaq 0xbf66(%rip), %rdx      # 0xe487
pushq $0x2
popq %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3cd8
movq (%r13), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x23d0
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/allocator.c
// Function: allocate
void *allocate(Allocator *a, const size_t size)
{
  if(size == 0)
  {
    die("unable to allocate 0 bytes");
  }

  void *data = NULL;
  switch(a->type)
  {
    case ALT_always_failing: /* Leave data pointing to NULL. */ break;
    case ALT_malloc: data = malloc(size); break;
    case ALT_region: data = CR_RegionAlloc(a->pointers.r, size); break;
    case ALT_single_growable_buffer:
      a->pointers.growable_buffer =
        CR_EnsureCapacity(a->pointers.growable_buffer, size);
      data = a->pointers.growable_buffer;
      break;
  }

  if(data == NULL)
  {
    die("out of memory: failed to allocate %zu bytes", size);
  }
  return data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x28a5
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x2884
cmpl $0x2, %eax
je 0x2876
cmpl $0x1, %eax
jne 0x2896
movq %rbx, %rdi
callq 0x22d0
jmp 0x2898
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xdd40
jmp 0x2898
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xda26
movq %rax, 0x8(%r14)
jmp 0x2898
xorl %eax, %eax
testq %rax, %rax
je 0x28b3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb758(%rip), %rdi      # 0xe004
xorl %eax, %eax
callq 0x3dc4
leaq 0xb765(%rip), %rdi      # 0xe01f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3dc4
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/allocator.c
// Function: allocatorWrapRegion
Allocator *allocatorWrapRegion(CR_Region *r)
{
  Allocator *a = CR_RegionAlloc(r, sizeof *a);
  a->type = ALT_region;
  a->pointers.r = r;
  return a;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10, %esi
callq 0xdd40
movl $0x2, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/allocator.c
// Function: allocatorWrapOneSingleGrowableBuffer
Allocator *allocatorWrapOneSingleGrowableBuffer(CR_Region *r)
{
  Allocator *a = CR_RegionAlloc(r, sizeof *a);
  a->type = ALT_single_growable_buffer;
  a->pointers.growable_buffer = CR_RegionAllocGrowable(r, 1);
  return a;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %esi
callq 0xdd40
movq %rax, %r14
movl $0x3, (%rax)
movl $0x1, %esi
movq %rbx, %rdi
callq 0xd990
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/backup.c
// Function: initiateBackup
void initiateBackup(Metadata *metadata, SearchNode *root_node)
{
  AllocatorPair allocator_pair = {
    .a = allocatorWrapRegion(metadata->r),
    .reusable_buffer = allocatorWrapOneSingleGrowableBuffer(metadata->r),
  };

  SearchIterator *context = searchNew(root_node);
  while(initiateMetadataRecursively(
          &allocator_pair, metadata, &metadata->paths, context,
          *root_node->ignore_expressions) != SRT_end_of_search)
    ;

  handleNotFoundSubnodes(metadata, root_node, root_node->policy,
                         metadata->paths, *root_node->ignore_expressions);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x28cc
movq %rsp, %r15
movq %rax, (%r15)
movq (%r14), %rdi
callq 0x28e6
movq %rax, 0x8(%r15)
movq %rbx, %rdi
callq 0xa8a0
movq %rax, %r12
leaq 0x48(%r14), %r13
movq 0x50(%rbx), %rax
movq (%rax), %r8
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x2c88
cmpl $0x20, %eax
jne 0x2c44
movl 0x2c(%rbx), %edx
movq 0x48(%r14), %rcx
movq 0x50(%rbx), %rax
movq (%rax), %r8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3169
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/backup.c
// Function: handleNotFoundSubnodes
static void handleNotFoundSubnodes(Metadata *metadata,
                                   const SearchNode *node_match,
                                   const BackupPolicy node_policy,
                                   PathNode *subnode_list,
                                   const RegexList *ignore_list)
{
  for(PathNode *subnode = subnode_list; subnode != NULL;
      subnode = subnode->next)
  {
    if(subnode->hint != BH_none)
    {
      continue;
    }

    /* Find the node in the search tree matching the current subnode. */
    SearchNode *subnode_match =
      matchesSearchSubnodes(subnode->path, node_match);
    if(subnode_match != NULL)
    {
      handleRemovedPath(metadata, subnode, subnode_match->policy);
    }
    else if(node_policy == BPOL_none ||
            matchesIgnoreList(subnode->path, ignore_list))
    {
      prepareNodeForWipingRecursively(metadata, subnode);
    }
    else
    {
      handleRemovedPath(metadata, subnode, node_policy);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, 0x3c(%rsp)
testq %rcx, %rcx
je 0x3337
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %r8, %r8
setne 0x3b(%rsp)
cmpl $0x0, 0x18(%r14)
jne 0x3319
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x70(%rsp)
testq %r15, %r15
je 0x3264
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x80(%rsp), %rdi
callq 0xb0a5
leaq 0x98(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x50(%rsp)
movups (%rcx), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x40(%r15), %rbp
testq %rbp, %rbp
sete %r13b
je 0x3264
movq 0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x322a
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x9f28
jmp 0x3254
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movups (%rbp), %xmm0
movups %xmm0, (%rsp)
callq 0xb126
testb %al, %al
jne 0x325e
movq 0x60(%rbp), %rbp
jmp 0x31fe
testb $0x1, %r13b
je 0x3266
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x327e
movl 0x2c(%rbp), %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3c78
jmp 0x3319
cmpl $0x0, 0x3c(%rsp)
je 0x330e
movq 0x10(%r14), %rax
movq %rax, 0x90(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x80(%rsp)
movb 0x3b(%rsp), %bpl
testq %rbx, %rbx
je 0x3309
movq (%rbx), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x9f28
movq %rbx, %r13
movb 0x3b(%rsp), %bpl
testb %al, %al
jne 0x3309
movq 0x30(%r13), %r13
testq %r13, %r13
setne %bpl
je 0x3309
movq (%r13), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x9f28
jmp 0x32d4
testb %bpl, %bpl
je 0x3328
movq %r12, %rdi
movq %r14, %rsi
callq 0x39bb
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x319b
jmp 0x3337
movq %r12, %rdi
movq %r14, %rsi
movl 0x3c(%rsp), %edx
jmp 0x3274
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/backup.c
// Function: markAsRemovedRecursively
static void markAsRemovedRecursively(Metadata *metadata, PathNode *node,
                                     bool extend_tracked_histories)
{
  if(backupHintNoPol(node->hint) == BH_not_part_of_repository)
  {
    return;
  }
  if(node->history->state.type == PST_non_existing)
  {
    backupHintSet(node->hint, BH_unchanged);
  }
  else
  {
    backupHintSet(node->hint, BH_removed);
    extend_tracked_histories &= (node->policy == BPOL_track);

    if(extend_tracked_histories)
    {
      PathHistory *point = CR_RegionAlloc(metadata->r, sizeof *point);
      point->backup = &metadata->current_backup;
      point->backup->ref_count = sSizeAdd(point->backup->ref_count, 1);
      point->state.type = PST_non_existing;
      point->next = node->history;
      node->history = point;
    }
  }

  for(PathNode *subnode = node->subnodes; subnode != NULL;
      subnode = subnode->next)
  {
    markAsRemovedRecursively(metadata, subnode, extend_tracked_histories);
  }
}

// Assembly:
movl 0x18(%rsi), %eax
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
cmpl $0x4, %ecx
je 0x39ba
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rcx
cmpl $0x0, 0x8(%rcx)
je 0x3986
andl $0xfffffe00, %eax       # imm = 0xFFFFFE00
orl $0x3, %eax
movl %eax, 0x18(%r14)
cmpl $0x3, 0x1c(%r14)
sete %al
andb %dl, %al
movl %eax, %edx
cmpb $0x1, %al
jne 0x398e
movq (%rbx), %rdi
movl $0x50, %esi
callq 0xdd40
movq %rax, %r15
leaq 0x8(%rbx), %rax
movq %rax, (%r15)
movq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0x8924
movq (%r15), %rcx
movq %rax, 0x10(%rcx)
movl $0x0, 0x8(%r15)
movq 0x20(%r14), %rax
movq %rax, 0x48(%r15)
movq %r15, 0x20(%r14)
movb $0x1, %dl
jmp 0x398e
movl $0x1, 0x18(%r14)
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x39b0
movzbl %dl, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x38fb
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x399a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x18(%rsi), %eax
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
cmpl $0x4, %ecx
jne 0x39fd
retq
andl $0xfffffe00, %eax       # imm = 0xFFFFFE00
orl $0x4, %eax
movl %eax, 0x18(%rsi)
decq 0x38(%rdi)
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x39fc
movq (%rax), %rcx
decq 0x10(%rcx)
movq 0x48(%rax), %rax
jmp 0x3a10
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x50(%rsp), %r15
movl 0x4c(%r15), %eax
movl %eax, 0x4(%rsi)
movl 0x50(%r15), %eax
movl %eax, 0x8(%rsi)
movl (%r15), %eax
cmpl $0x4, %eax
je 0x3ad0
cmpl $0x2, %eax
je 0x3a7d
cmpl $0x1, %eax
jne 0x3ae8
movl $0x1, (%rbx)
movl 0x48(%r15), %eax
movl %eax, 0x10(%rbx)
movq 0x88(%r15), %rax
movq %rax, 0x18(%rbx)
movq 0x60(%r15), %rax
movq %rax, 0x20(%rbx)
jmp 0x3ae8
movq %rdi, %rsi
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x934a
movq 0x8(%r14), %rax
cmpq 0x60(%r15), %rax
jne 0x3af2
movl $0x2, (%rbx)
addq $0x10, %rbx
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xaff1
jmp 0x3ae8
movl $0x3, (%rbx)
movl 0x48(%r15), %eax
movl %eax, 0x10(%rbx)
movq 0x88(%r15), %rax
movq %rax, 0x18(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl 0x10(%r15), %esi
movq 0x8(%r15), %rdx
leaq 0xa54a(%rip), %rdi      # 0xe04b
xorl %eax, %eax
callq 0x3dc4
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x1c(%rsi), %ecx
cmpl %edx, %ecx
je 0x3b8e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl 0x18(%rsi), %eax
movl %eax, %edx
orl $0x200, %edx            # imm = 0x200
movl %edx, 0x18(%rsi)
cmpl $0x3, %ecx
jne 0x3b7f
movq %rdi, %r15
movq 0x20(%r14), %rcx
cmpl $0x0, 0x8(%rcx)
jne 0x3b4b
movq (%rcx), %rdx
decq 0x10(%rdx)
movq 0x48(%rcx), %rcx
movq %rcx, 0x20(%r14)
movq 0x20(%r14), %rcx
movq 0x48(%rcx), %rdx
testq %rdx, %rdx
je 0x3b79
movq (%rdx), %rsi
decq 0x10(%rsi)
movq 0x48(%rdx), %rdx
testq %rdx, %rdx
jne 0x3b58
movq $0x0, 0x48(%rcx)
orl $0x600, %eax            # imm = 0x600
movl %eax, 0x18(%r14)
cmpl $0x3, 0x8(%rcx)
jne 0x3b8f
movl %ebx, 0x1c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r14), %r12
testq %r12, %r12
je 0x3b7f
movq %r15, %rdi
movq %r12, %rsi
callq 0x39bb
movq 0x30(%r12), %r12
jmp 0x3b93
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x98, %rsp
movq %rsi, %r8
movq %rdi, %rax
movl 0xa0(%rsp), %ecx
movq 0x20(%rsi), %rsi
movl 0x8(%rsi), %esi
cmpl $0x3, %esi
je 0x3bf6
cmpl $0x2, %esi
je 0x3be5
cmpl $0x1, %esi
jne 0x3c29
cmpl $0x2, %ecx
je 0x3c15
cmpl $0x4, %ecx
jne 0x3c29
movl $0x6, %ecx
jmp 0x3c1a
cmpl $0x1, %ecx
je 0x3c07
cmpl $0x4, %ecx
jne 0x3c29
movl $0x8, %ecx
jmp 0x3c1a
cmpl $0x1, %ecx
je 0x3c0e
cmpl $0x2, %ecx
jne 0x3c29
movl $0xa, %ecx
jmp 0x3c1a
movl $0x7, %ecx
jmp 0x3c1a
movl $0x9, %ecx
jmp 0x3c1a
movl $0x5, %ecx
movl $0xfffffe00, %esi       # imm = 0xFFFFFE00
andl 0x18(%r8), %esi
orl %ecx, %esi
movl %esi, 0x18(%r8)
leaq 0xa0(%rsp), %rsi
movzwl 0x18(%r8), %ecx
testl $0x1ff, %ecx            # imm = 0x1FF
je 0x3c56
cmpl $0x0, 0x28(%rsi)
je 0x3c70
movq (%rax), %rdi
movq %rdx, %rsi
addq $0x98, %rsp
jmp 0x3a22
addq $0x30, %rsi
movl $0x12, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
movq %r8, %rsi
callq 0x2924
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3b08
testl %ebp, %ebp
je 0x3ca1
cmpl $0x2, %ebp
jne 0x3cb2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x39bb
cmpq $0x0, 0x28(%rbx)
je 0x3cc6
movq 0x20(%rbx), %rax
cmpl $0x3, 0x8(%rax)
jne 0x3cc6
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x38fb
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x39ec
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x3d37
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rsp)
callq 0x9b8f
testb %al, %al
je 0x3daa
movl %ebp, %eax
leaq 0xa403(%rip), %rcx      # 0xe16c
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0xa3a9(%rip), %rsi      # 0xe120
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2250
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2390
leaq 0xa390(%rip), %rdi      # 0xe126
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x23d0
jmp 0x3db8
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2390
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3e27
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0xf1aa(%rip), %r15      # 0x12ff8
movq (%r15), %rcx
leaq 0xa34c(%rip), %rdi      # 0xe1a4
movl $0xb, %esi
movl $0x1, %edx
callq 0x23d0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2390
movq (%r15), %rsi
movl $0xa, %edi
callq 0x21f0
movl $0x1, %edi
callq 0x23c0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3eef
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0xf0e2(%rip), %r15      # 0x12ff8
movq (%r15), %rcx
leaq 0xa284(%rip), %rdi      # 0xe1a4
movl $0xb, %esi
movl $0x1, %edx
callq 0x23d0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2390
movq (%r15), %rbx
callq 0x2060
movl (%rax), %edi
callq 0x23e0
leaq 0xa25d(%rip), %rsi      # 0xe1b0
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2250
movl $0x1, %edi
callq 0x23c0
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdx, 0x28(%rsp)
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
movq 0x1a8(%rsp), %r14
movq 0x1b0(%rsp), %rbx
movq 0x170(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x160(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x89df
movq %rax, %r13
movq 0xf27e(%rip), %rdi      # 0x13240
movq %rbx, %rsi
callq 0xda26
movq %rax, 0xf26f(%rip)      # 0x13240
leaq 0x30(%rsp), %rdi
movl $0x14, %esi
callq 0xb5c4
testq %r14, %r14
je 0x402d
leaq 0x30(%rsp), %rbp
cmpq %rbx, %r14
movq %rbx, %r12
cmovbq %r14, %r12
movq 0xf245(%rip), %rdi      # 0x13240
movq %r12, %rsi
movq %r13, %rdx
callq 0x8bcc
movq 0xf233(%rip), %rsi      # 0x13240
movq %rbp, %rdi
movq %r12, %rdx
callq 0xb64a
testq %r15, %r15
je 0x4028
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq *%r15
subq %r12, %r14
jne 0x3fea
movq %r13, %rdi
callq 0x9018
movl %eax, %ebx
movq %r13, %rdi
callq 0x8d89
testb %bl, %bl
jne 0x4069
leaq 0x30(%rsp), %rdi
movl $0x14, %edx
movq 0x20(%rsp), %rsi
callq 0xd780
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x160(%rsp), %rax
movl 0x8(%rax), %esi
movq (%rax), %rdx
leaq 0xa138(%rip), %rdi      # 0xe1b6
xorl %eax, %eax
callq 0x3dc4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdx, %rdx
je 0x43b5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1ff, %ecx            # imm = 0x1FF
leaq 0xef77(%rip), %r12      # 0x13248
leaq 0x18(%rsp), %r13
movl 0x18(%rbx), %eax
andl %ecx, %eax
cmpl $0x4, %eax
je 0x439a
movq 0x20(%rbx), %rbp
testq %rbp, %rbp
je 0x4386
cmpl $0x1, 0x8(%rbp)
jne 0x437d
cmpq $0x15, 0x28(%rbp)
jb 0x437d
leaq 0x18(%rbp), %rsi
movq %r12, %rdi
callq 0x775c
movq 0xef33(%rip), %rsi      # 0x13248
movq %r13, %rdi
callq 0xaf28
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0xb53a
testq %rax, %rax
jne 0x437d
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0xb003
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %esi
movq %r14, %rdi
callq 0xb41f
movq 0x48(%rbp), %rbp
jmp 0x42e8
movq 0x28(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x42a5
movl $0x1ff, %ecx            # imm = 0x1FF
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x42d6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x60(%rsp), %rax
movq 0x8(%rsi), %rdx
leaq (%rax,%rdx), %rsi
incq %rsi
notq %rdx
addq 0x68(%rsp), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xaf44
movq 0x18(%rbx), %rdi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0xb53a
movq %rax, %r14
testq %rax, %rax
je 0x4433
movq 0x30(%rbx), %r12
testq %r12, %r12
je 0x4466
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %r15
callq 0xb5be
movq 0x38(%rbx), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq *%r12
jmp 0x4466
movq 0x20(%rbx), %rdi
movl $0x1, %esi
callq 0x8924
movq %rax, 0x20(%rbx)
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%r15), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4466
movq 0x28(%rbx), %rdi
movq 0x30(%r15), %rsi
callq 0x8924
movq %rax, 0x28(%rbx)
testq %r14, %r14
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %xmm1
punpckldq 0x9d7b(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x9d83(%rip), %xmm1     # 0xe210
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cmpq $0x3e8, %rdi            # imm = 0x3E8
jb 0x44cd
xorl %eax, %eax
movsd 0x9d74(%rip), %xmm1     # 0xe220
movsd 0x9d74(%rip), %xmm2     # 0xe228
mulsd %xmm1, %xmm0
leaq 0x1(%rax), %rcx
ucomisd %xmm2, %xmm0
jbe 0x44cf
cmpq $0x3, %rax
movq %rcx, %rax
jb 0x44b4
jmp 0x44cf
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x455d
movsd 0x9d50(%rip), %xmm1     # 0xe230
mulsd %xmm0, %xmm1
movsd 0x9d4c(%rip), %xmm2     # 0xe238
cvttsd2si %xmm1, %rax
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rdx
movq %rax, %r8
sarq $0x3f, %r8
andq %rdx, %r8
orq %rax, %r8
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
movq %r8, %rax
mulq %rdx
shrq $0x2, %rdx
andq $-0x2, %rdx
leaq (%rdx,%rdx,4), %rax
cvttsd2si %xmm0, %rdx
subq %rax, %r8
subsd %xmm2, %xmm0
cvttsd2si %xmm0, %rax
movq %rdx, %rsi
sarq $0x3f, %rsi
andq %rax, %rsi
orq %rdx, %rsi
leaq 0x9d38(%rip), %rax      # 0xe280
movsbl (%rcx,%rax), %ecx
leaq 0x9d3b(%rip), %rdi      # 0xe28e
movq %r8, %rdx
xorl %eax, %eax
jmp 0x2150
leaq 0x9d22(%rip), %rdi      # 0xe286
movb $0x1, %al
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x4618
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x28(%r14)
je 0x4604
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x45f2
jmp 0x4611
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e1
jmp 0x45f9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x20(%rdi), %rax
cmpl $0x0, 0x8(%rax)
je 0x51a0
movq %rax, %rcx
jmp 0x51a9
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x519b
pushq %rax
movq 0xde1f(%rip), %rax      # 0x12fd0
movq (%rax), %rax
movl 0x8(%rcx), %edx
cmpl $0x2, %edx
leaq 0x9285(%rip), %rcx      # 0xe446
leaq 0x95da(%rip), %r10      # 0xe7a2
cmovneq %r10, %rcx
movl 0x8(%rdi), %r8d
movq (%rdi), %r9
cmpl $0x3, %edx
leaq 0x926b(%rip), %rdx      # 0xe448
cmovneq %r10, %rdx
movq %rdx, (%rsp)
leaq 0x9251(%rip), %rdx      # 0xe43d
movq %rax, %rdi
xorl %eax, %eax
callq 0x3cd8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rdx
testq %rdi, %rdi
leaq 0x9593(%rip), %rax      # 0xe7a2
movq %r14, %rsi
cmoveq %rax, %rsi
cmpq $0x1, %rdi
leaq 0x923c(%rip), %rcx      # 0xe45d
cmoveq %rax, %rcx
leaq 0x9221(%rip), %rdi      # 0xe44d
xorl %eax, %eax
callq 0x2150
testq %rbx, %rbx
je 0x5258
leaq 0x921b(%rip), %rdi      # 0xe45a
movq %r14, %rsi
xorl %eax, %eax
callq 0x2150
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4478
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x10, %bpl
je 0x5280
movq 0x40(%rbx), %rdi
movl $0x1, %esi
callq 0x8924
movq %rax, 0x40(%rbx)
testb $0x20, %bpl
je 0x5298
movq 0x40(%rbx), %rdi
movl $0x1, %esi
callq 0x8924
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/integrity.c
// Function: checkIntegrity
ListOfBrokenPathNodes *checkIntegrity(
  CR_Region *r, const Metadata *metadata, StringView repo_path,
  IntegrityProgressCallback progress_callback, void *callback_user_data)
{
  IntegrityCheckContext ctx = {
    .r = r,
    .broken_nodes = NULL,
    .repo_path = repo_path,
    .progress_callback = progress_callback,
    .callback_user_data = callback_user_data,
  };

  /* Dry run to populate `ctx->files_to_hash_total_size`. */
  CR_Region *disposable_r = attachDisposableRegion(&ctx);
  checkIntegrityRecursively(&ctx, metadata->paths, addToTotalFileSize);
  CR_RegionRelease(disposable_r);
  disposable_r = attachDisposableRegion(&ctx);

  /* Do a real check. */
  checkIntegrityRecursively(&ctx, metadata->paths, storedFileIsHealthy);
  CR_RegionRelease(disposable_r);

  return ctx.broken_nodes;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rsp, %rbx
movq %rdi, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movaps 0x80(%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x90(%rsp), %rsi
movq %rsi, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movq %rdx, 0x50(%rbx)
movq %rcx, 0x58(%rbx)
movq %rbx, %rdi
callq 0x5341
movq %rax, %r15
movq 0x48(%r14), %rsi
leaq 0x1dd(%rip), %rdx       # 0x54da
movq %rbx, %rdi
callq 0x5390
movq %r15, %rdi
callq 0xde6a
movq %rbx, %rdi
callq 0x5341
movq %rax, %r15
movq 0x48(%r14), %rsi
leaq 0x1d0(%rip), %rdx       # 0x54f3
movq %rbx, %rdi
callq 0x5390
movq %r15, %rdi
callq 0xde6a
movq 0x8(%rbx), %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/integrity.c
// Function: attachDisposableRegion
static CR_Region *attachDisposableRegion(IntegrityCheckContext *ctx)
{
  CR_Region *disposable_r = CR_RegionNew();
  ctx->reusable_buffer_allocator =
    allocatorWrapOneSingleGrowableBuffer(disposable_r);
  ctx->unique_subpath_buffer = CR_RegionAllocGrowable(disposable_r, 1);
  ctx->unique_subpath_cache = strTableNew(disposable_r);
  ctx->unique_subpath_cache_key_allocator =
    allocatorWrapRegion(disposable_r);
  return disposable_r;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xdc7c
movq %rax, %r14
movq %rax, %rdi
callq 0x28e6
movq %rax, 0x28(%rbx)
movl $0x1, %esi
movq %r14, %rdi
callq 0xd990
movq %rax, 0x30(%rbx)
movq %r14, %rdi
callq 0xb374
movq %rax, 0x38(%rbx)
movq %r14, %rdi
callq 0x28cc
movq %rax, 0x40(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/integrity.c
// Function: checkIntegrityRecursively
static void
checkIntegrityRecursively(IntegrityCheckContext *ctx,
                          const PathNode *node_list,
                          CheckFileCallback check_file_callback)
{
  for(const PathNode *node = node_list; node != NULL; node = node->next)
  {
    for(const PathHistory *point = node->history; point != NULL;
        point = point->next)
    {
      if(!historyPointIsHealthy(ctx, point, check_file_callback))
      {
        ListOfBrokenPathNodes *broken_node =
          CR_RegionAlloc(ctx->r, sizeof(*broken_node));
        broken_node->node = node;
        broken_node->next = ctx->broken_nodes;
        ctx->broken_nodes = broken_node;
        break;
      }
    }
    checkIntegrityRecursively(ctx, node->subnodes, check_file_callback);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x54d9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rdi), %r12
movq 0x20(%r14), %r13
testq %r13, %r13
je 0x54af
cmpl $0x1, 0x8(%r13)
jne 0x548a
cmpq $0x15, 0x28(%r13)
jb 0x548a
leaq 0x18(%r13), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x775c
movq 0x30(%r15), %rsi
leaq 0x18(%rsp), %rdi
callq 0xaf28
movq 0x38(%r15), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xb53a
testq %rax, %rax
je 0x541f
cmpq $0x1, %rax
sete %bpl
jmp 0x5485
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq *%rbx
movl %eax, %ebp
movq 0x40(%r15), %rsi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0xb003
movq 0x38(%r15), %rdi
movzbl %bpl, %eax
movl $0x2, %esi
subq %rax, %rsi
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xb41f
testb %bpl, %bpl
je 0x5493
movq 0x48(%r13), %r13
jmp 0x53b8
movq (%r15), %rdi
movl $0x10, %esi
callq 0xdd40
movq %r14, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r15)
movq 0x28(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x5390
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x53b4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/integrity.c
// Function: storedFileIsHealthy
static bool storedFileIsHealthy(IntegrityCheckContext *ctx,
                                const RegularFileInfo *file_info,
                                StringView unique_subpath)
{
  StringView path_to_stored_file = strAppendPath(
    ctx->repo_path, unique_subpath, ctx->reusable_buffer_allocator);

  if(!sPathExists(path_to_stored_file))
  {
    callProgressCallback(ctx, file_info->size);
    return false;
  }

  const struct stat stats = sLStat(path_to_stored_file);
  if(!S_ISREG(stats.st_mode))
  {
    callProgressCallback(ctx, file_info->size);
    return false;
  }
  if((uint64_t)stats.st_size != file_info->size)
  {
    callProgressCallback(ctx, file_info->size);
    return false;
  }

  uint8_t hash[FILE_HASH_SIZE];
  fileHash(path_to_stored_file, stats, hash, fileHashCallback, ctx);
  return memcmp(file_info->hash, hash, FILE_HASH_SIZE) == 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq 0x1a0(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0x190(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x20(%rdi), %rax
movq %rax, 0x10(%rsp)
movups 0x10(%rdi), %xmm0
movups %xmm0, (%rsp)
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0xb2df
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movdqu (%r15), %xmm0
movdqu %xmm0, (%rsp)
callq 0x90a4
testb %al, %al
je 0x562a
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movdqu 0xa8(%rsp), %xmm0
movdqu %xmm0, (%rsp)
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
callq 0x91bf
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%r15), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x562a
movq 0x10(%r14), %rdi
cmpq %rdi, 0x110(%rsp)
jne 0x5650
leaq 0x18(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
movl $0x12, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0xa8(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x71(%rip), %rsi        # 0x565b
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x3f6c
movdqu 0x18(%r14), %xmm0
movd 0x28(%r14), %xmm1
movd 0x10(%r15), %xmm2
pcmpeqb %xmm1, %xmm2
pcmpeqb (%r15), %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
sete %al
jmp 0x5643
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x5641
movq 0x10(%r14), %rdi
movq 0x48(%rbx), %rsi
movq 0x58(%rbx), %rdx
callq *%rax
xorl %eax, %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r14
popq %r15
retq
movq 0x50(%rbx), %rax
testq %rax, %rax
jne 0x5637
jmp 0x5641
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/metadata.c
// Function: metadataNew
Metadata *metadataNew(CR_Region *r)
{
  Metadata *metadata = CR_RegionAlloc(r, sizeof *metadata);
  metadata->r = r;

  metadata->current_backup.id = 0;
  metadata->current_backup.completion_time = 0;
  metadata->current_backup.ref_count = 0;

  metadata->backup_history_length = 0;
  metadata->backup_history = NULL;

  metadata->config_history = NULL;

  metadata->total_path_count = 0;
  metadata->path_table = strTableNew(metadata->r);
  metadata->paths = NULL;

  return metadata;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x50, %esi
callq 0xdd40
movq %rax, %r14
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
xorl %r15d, %r15d
movq %r15, 0x38(%rax)
movq %rbx, %rdi
callq 0xb374
movq %rax, 0x40(%r14)
movq %r15, 0x48(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/AlxHnr[P]nano-backup/src/metadata.c
// Function: readFullPathHistory
static PathHistory *readFullPathHistory(Allocator *region_wrapper,
                                        const FileContent content,
                                        size_t *reader_position,
                                        StringView metadata_path,
                                        Metadata *metadata)
{
  const size_t history_length =
    readSize(content, reader_position, metadata_path);

  if(history_length == 0)
  {
    return NULL;
  }

  PathHistory *first_point = readPathHistory(
    region_wrapper, content, reader_position, metadata_path, metadata);
  PathHistory *current_point = first_point;

  for(size_t counter = 1; counter < history_length; counter++)
  {
    current_point->next = readPathHistory(
      region_wrapper, content, reader_position, metadata_path, metadata);
    current_point = current_point->next;
  }

  return first_point;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x6181
testq %rax, %rax
je 0x5975
movq %rax, %rbp
leaq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x61fa
cmpq $0x1, %rbp
je 0x5977
decq %rbp
movq %r14, 0x30(%rsp)
movq %r13, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq %rax, %r13
leaq 0x70(%rsp), %r14
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x61fa
movq %rax, 0x48(%r13)
movq %rax, %r13
decq %rbp
jne 0x5939
movq 0x20(%rsp), %rax
jmp 0x5977
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq