LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: env_new
env_t *env_new(vm_t *vm, value_t variables, env_t *up) {
    env_t *env = (env_t *) vm_realloc(vm, NULL, 0, sizeof(env_t));

    ptr_init(vm, &env->p, T_ENV);

    env->variables = variables;
    env->up = up;

    vm->env = env;

    return env;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x20
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
movl $0x7, (%rax)
movb $0x0, 0x4(%rax)
movq (%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0x50(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: symbol_intern
symbol_t *symbol_intern(vm_t *vm, const char *name, size_t len) {
    for (symbol_t *s = vm->symbol_table; s != NULL; s = s->next) {
        if (s->len == len && memcmp(s->name, name, len * sizeof(char)) == 0) {
            return s;
        }
    }

    symbol_t *sym = symbol_new(vm, name, len);

    sym->next = vm->symbol_table;
    vm->symbol_table = sym;

    return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x4320
movl 0x10(%r14), %eax
cmpq %r15, %rax
jne 0x431a
leaq 0x20(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1170
testl %eax, %eax
je 0x433d
addq $0x18, %r14
jmp 0x42f6
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x40d7
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, 0x18(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: cons_fn
value_t cons_fn(vm_t *vm, value_t a, value_t b) {
    cons_t *result = cons_new(vm);
    result->car = a;
    result->cdr = b;
    return PTR_VAL(result);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x401c
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: cons_len
int32_t cons_len(value_t val) {
    int32_t len = 0;

    // Uses Floyd's cycle finding algorithm
    value_t fast, slow;
    fast = slow = val;

    while (true) {
        if (IS_NIL(fast)) {
            return len;
        }
        if (IS_CONS(fast) && !IS_NIL(AS_CONS(fast)->cdr) &&
            !IS_CONS(AS_CONS(fast)->cdr)) {
            return -2 - len;
        }
        fast = AS_CONS(fast)->cdr;
        ++len;
        if (IS_NIL(fast)) {
            return len;
        }
        if (IS_CONS(fast) && !IS_NIL(AS_CONS(fast)->cdr) &&
            !IS_CONS(AS_CONS(fast)->cdr)) {
            return -2 - len;
        }
        fast = AS_CONS(fast)->cdr;
        slow = AS_CONS(slow)->cdr;
        ++len;
        if (IS_EQ(fast, slow)) {
            return -1;
        }
    }
}

// Assembly:
movabsq $-0x4000000000001, %rcx # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
xorl %eax, %eax
movabsq $0x3ffffffffffff, %r8   # imm = 0x3FFFFFFFFFFFF
pushq $-0x1
popq %rsi
movq %rdi, %r9
cmpq %rdx, %rdi
je 0x440f
movq %rdi, %r10
andq %r8, %r10
cmpq %rcx, %rdi
jbe 0x43ca
cmpl $0x0, (%r10)
jne 0x43ca
movq 0x18(%r10), %rdi
cmpq %rdx, %rdi
je 0x43ca
cmpq %rcx, %rdi
jbe 0x4413
andq %r8, %rdi
cmpl $0x0, (%rdi)
jne 0x4413
movq 0x18(%r10), %r10
cmpq %rdx, %r10
je 0x4410
movq %r10, %rdi
andq %r8, %rdi
cmpq %rcx, %r10
jbe 0x43fa
cmpl $0x0, (%rdi)
jne 0x43fa
movq 0x18(%rdi), %r10
cmpq %rdx, %r10
je 0x43fa
cmpq %rcx, %r10
jbe 0x4417
andq %r8, %r10
cmpl $0x0, (%r10)
jne 0x4417
movq 0x18(%rdi), %rdi
andq %r8, %r9
movq 0x18(%r9), %r9
addl $0x2, %eax
cmpq %r9, %rdi
jne 0x439e
movl %esi, %eax
retq
incl %eax
retq
pushq $-0x2
jmp 0x4419
pushq $-0x3
popq %rcx
subl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: vector_push
void vector_push(vm_t *vm, vector_t *vec, value_t val) {
    if (vec->count + 1 > vec->capacity) {
        uint32_t capacity = vec->capacity ? vec->capacity << 1 : 2;
        vec->data = (value_t *) vm_realloc(vm, vec->data,
                                           vec->capacity * sizeof(value_t),
                                           capacity * sizeof(value_t));
        vec->capacity = capacity;
    }
    vec->data[vec->count++] = val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl 0x10(%rsi), %edx
movl 0x14(%rsi), %ecx
leal 0x1(%rcx), %esi
cmpl %edx, %esi
jbe 0x446b
leal (%rdx,%rdx), %eax
testq %rdx, %rdx
pushq $0x2
popq %r15
cmovnel %eax, %r15d
movq 0x18(%r14), %rsi
shlq $0x3, %rdx
leaq (,%r15,8), %rcx
callq 0x47f9
movq %rax, 0x18(%r14)
movl %r15d, 0x10(%r14)
movl 0x14(%r14), %ecx
leal 0x1(%rcx), %esi
jmp 0x446f
movq 0x18(%r14), %rax
movl %esi, 0x14(%r14)
movl %ecx, %ecx
movq %rbx, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: hash_string_like
static uint32_t hash_string_like(const char *s, uint32_t len) {
    uint32_t hash = HASH_SEED;

    for (uint32_t i = 0; i < len; i++) {
        hash ^= s[i];
        hash *= HASH_PRIME;
    }

    return hash;
}

// Assembly:
movl %esi, %ecx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x45eb
movsbl (%rdi,%rdx), %esi
xorl %esi, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
incq %rdx
jmp 0x45d5
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: error_runtime
void error_runtime(vm_t *vm, const char *format, ...) {
    vm->has_error = true;
    if (vm->config.error_fn == NULL) {
        return;
    }

    char message[256];

    va_list contents;
    va_start(contents, format);

    vsnprintf(message, 256, format, contents);

    va_end(contents);

    vm->config.error_fn(vm, -1, -1, message);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4645
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)
movb $0x1, 0x880(%rdi)
cmpq $0x0, 0x28(%rdi)
je 0x46a4
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r10, %rdx
callq 0x1080
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
movq %r14, %rcx
callq *0x28(%rbx)
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: scm_config_default
void scm_config_default(scm_config_t *config) {
    config->realloc_fn = scm_realloc_default;
    config->error_fn = NULL;
    config->load_fn = NULL;

    // TODO: tweak the initial and min heap sizes
    config->heap_size_initial = 512 * 1024;  // 512 kB
    config->heap_size_min = 64 * 1024;       //  64 kB
    config->heap_growth = 0.5;               //  50%
}

// Assembly:
leaq 0x29(%rip), %rax        # 0x46df
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x80000, 0x18(%rdi)    # imm = 0x80000
movq $0x10000, 0x20(%rdi)    # imm = 0x10000
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: vm_new
vm_t *vm_new(scm_config_t *config) {
    scm_realloc_fn reallocate = scm_realloc_default;
    if (config != NULL) reallocate = config->realloc_fn;

    vm_t *vm = (vm_t *) reallocate(NULL, sizeof(vm_t));

    memset(vm, 0, sizeof(vm_t));

    if (config != NULL) {
        memcpy(&vm->config, config, sizeof(scm_config_t));
    } else {
        scm_config_default(&vm->config);
    }

    vm->allocated = 0;
    vm->gc_threshold = vm->config.heap_size_initial;

    vm->symbol_table = NULL;

    vm->env = NULL;
    vm->reader = NULL;

    vm->top_env = NULL;

    vm->curval = NIL_VAL;
    vm->gensym_count = 0;

    vm->has_error = false;

    return vm;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdi, %rdi
je 0x4703
movq (%r14), %rax
jmp 0x470a
leaq -0x2b(%rip), %rax       # 0x46df
movl $0x888, %esi            # imm = 0x888
xorl %edi, %edi
callq *%rax
movq %rax, %rbx
movl $0x888, %edx            # imm = 0x888
movq %rax, %rdi
xorl %esi, %esi
callq 0x10e0
testq %r14, %r14
je 0x4750
movq %rbx, %rax
addq $0x20, %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x38(%rbx), %rax
jmp 0x4785
leaq -0x78(%rip), %rax       # 0x46df
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq $0x80000, 0x38(%rbx)    # imm = 0x80000
movq $0x10000, 0x40(%rbx)    # imm = 0x10000
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x48(%rbx)
movl $0x80000, %eax          # imm = 0x80000
andq $0x0, 0x8(%rbx)
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
andq $0x0, 0x60(%rbx)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x68(%rbx)
andl $0x0, 0x70(%rbx)
movb $0x0, 0x880(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: vm_free
void vm_free(vm_t *vm) {
    ptrvalue_t *ptr = vm->head;
    while (ptr != NULL) {
        ptrvalue_t *next = ptr->next;
        ptr_free(vm, ptr);
        ptr = next;
    }

    vm_realloc(vm, vm, 0, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x47e3
movq 0x8(%rsi), %r14
movq %rbx, %rdi
callq 0x3f0c
movq %r14, %rsi
jmp 0x47cd
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x47f9
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: vm_realloc
void *vm_realloc(vm_t *vm, void *ptr, size_t old_size, size_t new_size) {
    vm->allocated += new_size - old_size;

    if (new_size > 0 && vm->allocated > vm->gc_threshold) {
        vm_gc(vm);
    }
#if !NOGC
    if (vm->allocated > MAX_ALLOCATED) {
        error_runtime(
            vm,
            "Can't allocate - already allocated more than %d (MAX_ALLOCATED)!",
            MAX_ALLOCATED);
        vm->allocated -= new_size;
        return NULL;
    }
#endif  // !NOGC
    return vm->config.realloc_fn(ptr, new_size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, %rax
subq %rdx, %rax
addq 0x8(%rdi), %rax
movq %rax, 0x8(%rdi)
testq %rcx, %rcx
je 0x482c
cmpq 0x10(%r14), %rax
jbe 0x482c
movq %r14, %rdi
callq 0x4867
movq 0x8(%r14), %rax
cmpq $0x2000001, %rax        # imm = 0x2000001
jb 0x4856
leaq 0x2275(%rip), %rsi      # 0x6ab0
movq %r14, %rdi
movl $0x2000000, %edx        # imm = 0x2000000
xorl %eax, %eax
callq 0x45ec
subq %rbx, 0x8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%r14), %rax
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: vm_push_temp
void vm_push_temp(vm_t *vm, ptrvalue_t *ptr) {
    if (ptr == NULL) {
        error_runtime(vm, "Cannot have a NULL as a temporary root!");
    }
    if (vm->num_temp >= MAX_NUM_TEMP) {
        error_runtime(
            vm, "Trying to add a temporary root that is over limit (%d is max)",
            MAX_NUM_TEMP);
    }
    vm->temp[vm->num_temp++] = ptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jne 0x4a0d
leaq 0x20ee(%rip), %rsi      # 0x6af1
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
movq 0x78(%r14), %rax
cmpq $0x100, %rax            # imm = 0x100
jb 0x4a33
leaq 0x20f9(%rip), %rsi      # 0x6b19
movq %r14, %rdi
movl $0x100, %edx            # imm = 0x100
xorl %eax, %eax
callq 0x45ec
movq 0x78(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x78(%r14)
movq %rbx, 0x80(%r14,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: env_push
env_t *env_push(vm_t *vm, env_t *env, value_t vars, value_t vals) {
    value_t alist = NIL_VAL;
    value_t vars_iter, vals_iter;

    // TODO: should we create a macro - like SCM_ASSOC_FOREACH?
    for (vars_iter = vars, vals_iter = vals; IS_CONS(vars_iter);
         vars_iter = AS_CONS(vars_iter)->cdr,
        vals_iter = AS_CONS(vals_iter)->cdr) {
        if (!IS_CONS(vals_iter)) {
            // TODO: Add proper function arity?
            error_runtime(vm, "Number of arguments doesn't match!");
        }

        value_t par = AS_CONS(vars_iter)->car;
        value_t arg = AS_CONS(vals_iter)->car;

        value_t pair = cons_fn(vm, par, arg);
        value_t temp = cons_fn(vm, pair, alist);

        alist = temp;
    }
    if (!IS_NIL(vars_iter)) {
        value_t pair = cons_fn(vm, vars_iter, vals_iter);
        value_t temp = cons_fn(vm, pair, alist);

        alist = temp;
    }
    env_t *new_env = env_new(vm, alist, env);
    return new_env;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x7ffc000000000001, %r15 # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
cmpq %rbp, %rdx
jbe 0x4b40
movq %rdx, %rbx
andq %r13, %rbx
cmpl $0x0, (%rbx)
jne 0x4b4f
movq %rcx, %r12
andq %r13, %r12
cmpq %rbp, %rcx
jbe 0x4b02
cmpl $0x0, (%r12)
je 0x4b13
movq %r14, %rdi
leaq 0x206f(%rip), %rsi      # 0x6b7b
xorl %eax, %eax
callq 0x45ec
movq 0x10(%rbx), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x434c
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x434c
movq %rax, %r15
movq 0x18(%rbx), %rdx
movq 0x18(%r12), %rcx
jmp 0x4ae0
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, %rdx
je 0x4b6e
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x434c
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x434c
movq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a1
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: primitive_add
void primitive_add(vm_t *vm, env_t *env, const char *name, size_t len,
                   primitive_fn fn) {
    symbol_t *sym = symbol_intern(vm, name, len);

    primitive_t *prim = primitive_new(vm, fn);

    prim->name = sym;

    variable_add(vm, env, sym, PTR_VAL(prim));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x42e1
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4165
movq %r12, 0x10(%rax)
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rax, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4a76
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: apply
value_t apply(vm_t *vm, env_t *env, value_t fn, value_t args) {
    if (!IS_NIL(args) && !IS_CONS(args)) {
        error_runtime(vm, "|apply: Cannot apply to a non-list!");
        return NIL_VAL;
    }
    if (IS_PRIMITIVE(fn)) {
        primitive_t *prim = AS_PRIMITIVE(fn);
        return prim->fn(vm, env, args);
    } else if (IS_FUNCTION(fn)) {
        function_t *func = AS_FUNCTION(fn);
        value_t eargs = eval_list(vm, env, args);
        if (IS_PTR(eargs)) {
            vm_push_temp(vm, AS_PTR(eargs));
        }
        value_t result = apply_func(vm, env, func, eargs);
        if (IS_PTR(eargs)) {
            vm_pop_temp(vm);  // eargs
        }
        return result;
    }

    error_runtime(vm, "|apply: Cannot apply something else than a procedure!");
    return NIL_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x7ffc000000000001, %r14 # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r12  # imm = 0x3FFFFFFFFFFFF
cmpq %r14, %rcx
jne 0x4c42
cmpq %rbp, %r15
jbe 0x4c5b
andq %r12, %r15
movl (%r15), %eax
cmpl $0x4, %eax
je 0x4c7e
cmpl $0x3, %eax
jne 0x4c5b
movq 0x18(%r15), %rax
movq %rbx, %rdi
movq %rcx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
cmpq %rbp, %rcx
jbe 0x4c52
movq %rcx, %rax
andq %r12, %rax
cmpl $0x0, (%rax)
je 0x4c13
leaq 0x1f45(%rip), %rsi      # 0x6b9e
jmp 0x4c62
leaq 0x1f60(%rip), %rsi      # 0x6bc2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45ec
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x4cbf
movq %rax, %r13
cmpq %rbp, %rax
jbe 0x4c9f
andq %r13, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x49ed
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4d81
movq %rax, %r14
cmpq %rbp, %r13
jbe 0x4c6c
movq %rbx, %rdi
callq 0x4a4b
jmp 0x4c6c
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: eval_list
value_t eval_list(vm_t *vm, env_t *env, value_t list) {
    if (IS_NIL(list)) {
        return NIL_VAL;
    }
    cons_t *head = NULL;
    cons_t *tail = NULL;

    for (cons_t *cons = AS_CONS(list);; cons = AS_CONS(cons->cdr)) {
        value_t temp = eval(vm, env, cons->car);
        if (head == NULL) {
            head = tail = AS_CONS(cons_fn(vm, temp, NIL_VAL));
            vm_push_temp(vm, (ptrvalue_t *) (head));
        } else {
            tail->cdr = cons_fn(vm, temp, NIL_VAL);
            tail = AS_CONS(tail->cdr);
        }
        if (IS_NIL(cons->cdr)) {
            break;
        }
    }
    vm_pop_temp(vm);  // head
    return PTR_VAL(head);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
cmpq %rbx, %rdx
je 0x4d6f
movq %rdx, %r15
movq %rdi, %r14
movabsq $0x3ffffffffffff, %r12  # imm = 0x3FFFFFFFFFFFF
movq $0x0, 0x8(%rsp)
xorl %ebp, %ebp
andq %r12, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x4ebe
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x434c
movq %rax, %r13
cmpq $0x0, 0x8(%rsp)
je 0x4d36
movq %r13, 0x18(%rbp)
andq %r12, %r13
jmp 0x4d49
andq %r12, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x49ed
movq %r13, 0x8(%rsp)
movq %r13, %rbp
movq 0x18(%r15), %r15
cmpq %rbx, %r15
jne 0x4d00
movq %r14, %rdi
callq 0x4a4b
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
movq 0x8(%rsp), %rbx
orq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: apply_func
static value_t apply_func(vm_t *vm, env_t *env, function_t *func,
                          value_t args) {
    value_t params = func->params;
    env_t *new_env = func->env;
    new_env = env_push(vm, new_env, params, args);
    value_t body = func->body;
    return begin(vm, new_env, body);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
movq 0x20(%rbx), %rdx
callq 0x4ab0
movq 0x28(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5086
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: find
value_t find(env_t *env, symbol_t *sym) {
    for (env_t *e = env; e != NULL; e = e->up) {
        if (IS_NIL(e->variables)) {
            // we're not going to find anything here, let's move on
            continue;
        }
        value_t pair, iter;
        SCM_FOREACH (pair, AS_CONS(e->variables), iter) {
            symbol_t *key = AS_SYMBOL(AS_CONS(pair)->car);
            if (key == sym) {
                return AS_CONS(pair)->cdr;
            }
        }
    }

    fprintf(stderr, "|find: Error: Symbol %s not bound\n", sym->name);
    // error_runtime(vm, "|find: Symbol %s is not bound in environment!",
    // sym->name);
    return UNDEFINED_VAL;
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
testq %rdi, %rdi
je 0x4e14
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
jne 0x4de7
movq 0x18(%rdi), %rdi
jmp 0x4dd3
orq %rcx, %rsi
cmpq %rbx, %rsi
je 0x4de1
andq %rax, %rsi
movq 0x10(%rsi), %r8
andq %rax, %r8
movq 0x10(%r8), %r9
andq %rax, %r9
cmpq %rdx, %r9
je 0x4e0b
movq 0x18(%rsi), %rsi
jmp 0x4dea
movq 0x18(%r8), %rbx
movq %rbx, %rax
popq %rbx
retq
movq 0x51dd(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
addq $0x20, %rdx
leaq 0x1dcf(%rip), %rsi      # 0x6bf8
xorl %eax, %eax
callq 0x1130
addq $0x3, %rbx
jmp 0x4e0f
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: find_replace
value_t find_replace(env_t *env, symbol_t *sym, value_t new_val) {
    for (env_t *e = env; e != NULL; e = e->up) {
        if (IS_NIL(e->variables)) {
            // we're not going to find anything here, let's move on
            continue;
        }
        value_t pair, iter;
        SCM_FOREACH (pair, AS_CONS(e->variables), iter) {
            symbol_t *key = AS_SYMBOL(AS_CONS(pair)->car);
            if (key == sym) {
                AS_CONS(pair)->cdr = new_val;
                return new_val;
            }
        }
    }

    fprintf(stderr, "|find-replace: Error: Symbol %s not bound\n", sym->name);
    // error_runtime(vm, "|find: Symbol %s is not bound in environment!",
    // sym->name);
    return UNDEFINED_VAL;
}

// Assembly:
pushq %rbx
movq %rdx, %rax
movq %rsi, %rdx
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
testq %rdi, %rdi
je 0x4e99
movq 0x10(%rdi), %r8
cmpq %rbx, %r8
jne 0x4e6f
movq 0x18(%rdi), %rdi
jmp 0x4e5b
orq %rsi, %r8
cmpq %rbx, %r8
je 0x4e69
andq %rcx, %r8
movq 0x10(%r8), %r9
andq %rcx, %r9
movq 0x10(%r9), %r10
andq %rcx, %r10
cmpq %rdx, %r10
je 0x4e93
movq 0x18(%r8), %r8
jmp 0x4e72
movq %rax, 0x18(%r9)
popq %rbx
retq
movq 0x5158(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
addq $0x20, %rdx
leaq 0x1d6d(%rip), %rsi      # 0x6c1b
xorl %eax, %eax
callq 0x1130
addq $0x3, %rbx
movq %rbx, %rax
jmp 0x4e97
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: eval
value_t eval(vm_t *vm, env_t *env, value_t val) {
    if (IS_VAL(val) || IS_STRING(val) || IS_PROCEDURE(val) || IS_VECTOR(val) ||
        IS_ENV(val)) {
        // These values are self evaluating
        return val;
    } else if (IS_SYMBOL(val)) {
        // This is a variable
        symbol_t *sym = AS_SYMBOL(val);
        value_t result = find(env, sym);
        if (IS_UNDEFINED(result)) {
            error_runtime(vm, "|eval: Can't eval %s - symbol not bound!",
                          sym->name);
        }
        return result;
    } else if (IS_CONS(val)) {
        // It's a function application
        value_t expanded = expand(vm, env, val);

        if (!IS_EQ(expanded, val)) {
            // macros encountered and expanded, now eval the expanded value
            return eval(vm, env, expanded);
        }

        cons_t *cons = AS_CONS(val);
        value_t fn = eval(vm, env, cons->car);
        value_t args = cons->cdr;

        if (!IS_PROCEDURE(fn)) {
            error_runtime(vm, "|eval: Car of eval'd cons is not a procedure!");
        }
        return apply(vm, env, fn, args);
    }

    // This should be an assert
    error_runtime(vm, "|eval: Cannot eval - unknown value type!");
    return NIL_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
cmpq %rbp, %r12
jbe 0x4f80
movq %r12, %r15
andq %r13, %r15
movl (%r15), %eax
cmpl $0x7, %eax
ja 0x4fd1
testl %eax, %eax
jne 0x4f76
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4ff2
cmpq %r12, %rax
movq %rax, %r12
jne 0x4ee6
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ebe
movq %rax, %r12
movq 0x18(%r15), %r15
cmpq %rbp, %rax
jbe 0x4f46
movq %r12, %rax
andq %r13, %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x2, %eax
jb 0x4f57
leaq 0x1d22(%rip), %rsi      # 0x6c6f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45ec
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4bdf
movl $0xda, %ecx
btl %eax, %ecx
jae 0x4f92
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
jne 0x4fd1
movabsq $0x7ffc000000000004, %r13 # imm = 0x7FFC000000000004
movq %r14, %rdi
movq %r15, %rsi
callq 0x4db1
movq %rax, %r12
cmpq %r13, %rax
jne 0x4f80
addq $0x20, %r15
leaq 0x1c87(%rip), %rsi      # 0x6c46
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x45ec
movq %r13, %r12
jmp 0x4f80
leaq 0x1cc5(%rip), %rsi      # 0x6c9d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45ec
movabsq $0x7ffc000000000004, %r12 # imm = 0x7FFC000000000004
addq $-0x3, %r12
jmp 0x4f80
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: expand
value_t expand(vm_t *vm, env_t *env, value_t val) {
    symbol_t *sym;
    if (IS_SYMBOL(val)) {
        sym = AS_SYMBOL(val);
    } else if (IS_CONS(val) && IS_SYMBOL(AS_CONS(val)->car)) {
        sym = AS_SYMBOL(AS_CONS(val)->car);
    } else {
        return val;
    }

    value_t found = find(env, sym);
    if (IS_UNDEFINED(found) || !IS_MACRO(found)) {
        return val;
    }

    function_t *macro = AS_MACRO(found);
    value_t args = AS_CONS(val)->cdr;
    return apply_func(vm, env, macro, args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdx, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x5079
movq %rdi, %r14
movabsq $-0x4000000000001, %r13 # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x3ffffffffffff, %r12  # imm = 0x3FFFFFFFFFFFF
movq %rbx, %r15
andq %r12, %r15
movl (%r15), %ecx
movq %r15, %rax
cmpl $0x2, %ecx
je 0x5049
testl %ecx, %ecx
jne 0x5079
movq 0x10(%r15), %rax
cmpq %r13, %rax
jbe 0x5079
andq %r12, %rax
cmpl $0x2, (%rax)
jne 0x5079
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4db1
cmpq %r13, %rax
jbe 0x5079
andq %r12, %rax
cmpl $0x5, (%rax)
jne 0x5079
movq 0x18(%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4d81
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/vm.c
// Function: begin
value_t begin(vm_t *vm, env_t *env, value_t val) {
    value_t result = VOID_VAL;
    if (IS_NIL(val)) {
        return result;
    }
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(val), iter) { result = eval(vm, env, arg); }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movabsq $0x7ffc000000000001, %r12 # imm = 0x7FFC000000000001
cmpq %r12, %rdx
jne 0x50af
orq $0x4, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rbx
leaq 0x4(%r12), %rax
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
cmpq %r12, %rbx
je 0x50a5
andq %r13, %rbx
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ebe
movq 0x18(%rbx), %rbx
jmp 0x50d4
// File: /workspace/github_c_makefile_star2_O2/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 0x2562
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x2534
cmpl $0x2, %eax
je 0x2526
cmpl $0x1, %eax
jne 0x2551
movq %rbx, %rdi
callq 0x22d0
jmp 0x2544
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd104
jmp 0x2544
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xce02
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x2551
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xbac7(%rip), %rdi      # 0xe01f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3918
leaq 0xba9b(%rip), %rdi      # 0xe004
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rsi
callq 0xd104
movl $0x2, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rsi
callq 0xd104
movq %rax, %r14
movl $0x3, (%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xcd70
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2578
movq %rsp, %r15
movq %rax, (%r15)
movq (%r14), %rdi
callq 0x2590
movq %rax, 0x8(%r15)
movq %rbx, %rdi
callq 0x9d58
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 0x292c
cmpl $0x20, %eax
jne 0x28e8
movl 0x2c(%rbx), %edx
movq 0x48(%r14), %rcx
movq 0x50(%rbx), %rax
movq (%rax), %r8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d32
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0xa8, %rsp
movq %r8, 0x48(%rsp)
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsi), %r13
testq %r14, %r14
je 0x2e96
cmpl $0x0, 0x18(%r14)
jne 0x2e8d
movups (%r14), %xmm0
movaps %xmm0, 0x50(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x60(%rsp)
testq %r15, %r15
je 0x2e1d
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rdi
callq 0xa4e3
leaq 0x88(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x40(%rsp)
movups (%rcx), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r13, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2e1d
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x2dea
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x9418
jmp 0x2e13
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0xa564
testb %al, %al
jne 0x2e75
addq $0x60, %rbx
jmp 0x2dbf
testl %ebp, %ebp
je 0x2e68
movq 0x10(%r14), %rax
movq %rax, 0x80(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x70(%rsp)
movq 0x48(%rsp), %rbx
testq %rbx, %rbx
je 0x2e80
movq (%rbx), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x9418
testb %al, %al
jne 0x2e68
movq 0x30(%rbx), %rbx
jmp 0x2e3b
movq %r12, %rdi
movq %r14, %rsi
callq 0x353f
jmp 0x2e8d
movl 0x2c(%rbx), %edx
movq %r12, %rdi
movq %r14, %rsi
jmp 0x2e88
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x37d2
movq 0x30(%r14), %r14
jmp 0x2d57
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/src/backup.c
// Function: buildPathHistoryPoint
static PathHistory *buildPathHistoryPoint(Allocator *a, Metadata *metadata,
                                          const SearchResult result)
{
  PathHistory *point = CR_RegionAlloc(metadata->r, sizeof *point);

  point->backup = &metadata->current_backup;
  point->backup->ref_count = sSizeAdd(point->backup->ref_count, 1);

  setPathHistoryState(a, &point->state, result);

  point->next = NULL;

  return point;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
pushq $0x50
popq %rsi
callq 0xd104
movq %rax, %r15
leaq 0x8(%rbx), %rax
movq %rax, (%r15)
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x8188
movq (%r15), %rcx
movq %rax, 0x10(%rcx)
leaq 0x8(%r15), %rax
pushq $0x18
popq %rcx
leaq 0xe0(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rax, %rsi
callq 0x359c
andq $0x0, 0x48(%r15)
movq %r15, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x353e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rcx
cmpl $0x0, 0x8(%rcx)
je 0x3507
andl $0xfffffe00, %eax       # imm = 0xFFFFFE00
orl $0x3, %eax
movl %eax, 0x18(%rbx)
cmpl $0x3, 0x1c(%rbx)
setne %al
xorb $0x1, %dl
orb %al, %dl
jne 0x3510
movq (%r14), %rdi
pushq $0x50
popq %rsi
callq 0xd104
movq %rax, %r15
leaq 0x8(%r14), %rax
movq %rax, (%r15)
movq 0x18(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x8188
movq (%r15), %rcx
movq %rax, 0x10(%rcx)
andl $0x0, 0x8(%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x48(%r15)
movq %r15, 0x20(%rbx)
movb $0x1, %dl
jmp 0x3512
movl $0x1, 0x18(%rbx)
jmp 0x3512
xorl %edx, %edx
addq $0x28, %rbx
movzbl %dl, %ebp
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x3534
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x3486
addq $0x30, %rbx
jmp 0x3519
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AlxHnr[P]nano-backup/src/backup.c
// Function: prepareNodeForWipingRecursively
static void prepareNodeForWipingRecursively(Metadata *metadata,
                                            PathNode *node)
{
  prepareNodeForWiping(metadata, node);
  for(PathNode *subnode = node->subnodes; subnode != NULL;
      subnode = subnode->next)
  {
    prepareNodeForWipingRecursively(metadata, subnode);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3573
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x356b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x353f
addq $0x30, %rbx
jmp 0x3552
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3584
retq
andl $0xfffffe00, %eax       # imm = 0xFFFFFE00
orl $0x4, %eax
movl %eax, 0x18(%rsi)
decq 0x38(%rdi)
movq 0x20(%rsi), %rdi
jmp 0x37bf
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x4c(%r15), %rax
movq %rax, 0x4(%rsi)
movl (%r15), %eax
cmpl $0x4, %eax
je 0x3644
cmpl $0x2, %eax
je 0x35f1
cmpl $0x1, %eax
jne 0x365c
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 0x365c
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 0x8a69
movq 0x8(%r14), %rax
cmpq 0x60(%r15), %rax
jne 0x3666
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 0xa454
jmp 0x365c
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 0xa9d6(%rip), %rdi      # 0xe04b
xorl %eax, %eax
callq 0x3918
// File: /workspace/github_c_makefile_star2_O2/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), %eax
cmpl %edx, %eax
je 0x36e6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
orb $0x2, 0x19(%rsi)
cmpl $0x3, %eax
jne 0x36d7
movq %rdi, %r15
movq 0x20(%r14), %rax
cmpl $0x0, 0x8(%rax)
jne 0x36b5
movq (%rax), %rcx
decq 0x10(%rcx)
movq 0x48(%rax), %rax
movq %rax, 0x20(%r14)
movq 0x48(%rax), %rdi
testq %rdi, %rdi
je 0x36d1
callq 0x37bf
movq 0x20(%r14), %rax
andq $0x0, 0x48(%rax)
orb $0x4, 0x19(%r14)
cmpl $0x3, 0x8(%rax)
jne 0x36e7
movl %ebx, 0x1c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x36d7
movq %r15, %rdi
movq %r12, %rsi
callq 0x353f
addq $0x30, %r12
jmp 0x36eb
// File: /workspace/github_c_makefile_star2_O2/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 0x374b
cmpl $0x2, %esi
je 0x373d
cmpl $0x1, %esi
jne 0x3773
cmpl $0x2, %ecx
je 0x3761
cmpl $0x4, %ecx
jne 0x3773
pushq $0x6
jmp 0x3763
cmpl $0x1, %ecx
je 0x3759
cmpl $0x4, %ecx
jne 0x3773
pushq $0x8
jmp 0x3763
cmpl $0x1, %ecx
je 0x375d
cmpl $0x2, %ecx
jne 0x3773
pushq $0xa
jmp 0x3763
pushq $0x7
jmp 0x3763
pushq $0x9
jmp 0x3763
pushq $0x5
popq %rcx
movl $0xfffffe00, %esi       # imm = 0xFFFFFE00
andl 0x18(%r8), %esi
orl %ecx, %esi
movl %esi, 0x18(%r8)
leaq 0xa0(%rsp), %rsi
movzwl 0x18(%r8), %ecx
testw $0x1ff, %cx             # imm = 0x1FF
je 0x379f
cmpl $0x0, 0x28(%rsi)
je 0x37b7
movq (%rax), %rdi
movq %rdx, %rsi
addq $0x98, %rsp
jmp 0x359c
addq $0x30, %rsi
pushq $0x12
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
movq %r8, %rsi
callq 0x25cc
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x367c
testl %ebp, %ebp
je 0x37fb
cmpl $0x2, %ebp
jne 0x380c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x353f
cmpq $0x0, 0x28(%rbx)
je 0x381e
movq 0x20(%rbx), %rax
cmpl $0x3, 0x8(%rax)
jne 0x381e
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3486
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3573
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x388f
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 0x90d1
testb %al, %al
je 0x38fe
movl %ebp, %eax
leaq 0xa8ab(%rip), %rcx      # 0xe16c
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0xa851(%rip), %rsi      # 0xe120
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2250
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2390
leaq 0xa838(%rip), %rdi      # 0xe126
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x23d0
jmp 0x390c
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_O2/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 0x397b
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 0x10656(%rip), %r15     # 0x13ff8
movq (%r15), %rcx
leaq 0xa7f8(%rip), %rdi      # 0xe1a4
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x23d0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2390
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x21f0
pushq $0x1
popq %rdi
callq 0x23c0