LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x20(%rsp)
je 0x7fd0
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7fd0
movq 0x38(%rsp), %rdi
leaq 0x2b39(%rip), %rsi      # 0xaaee
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x40(%rsp)
jmp 0x810d
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7fe5
jmp 0x801d
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *%rax
movq %rax, 0x40(%rsp)
jmp 0x810d
movq 0x28(%rsp), %rdi
movl $0x4, %esi
callq 0x7e80
testb $0x1, %al
jne 0x8035
jmp 0x80e9
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x8120
movq %rax, 0x8(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x8099
movq 0x38(%rsp), %rdi
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rsi
callq 0x78e0
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x8280
movq %rax, (%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x80de
movq 0x38(%rsp), %rdi
callq 0x7960
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x810d
jmp 0x80eb
movq 0x38(%rsp), %rdi
leaq 0x2a1b(%rip), %rsi      # 0xab12
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x28(%rsp)
jne 0x8158
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x40(%rsp)
jmp 0x8270
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x85b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x81e4
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
callq 0x6d00
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x78e0
jmp 0x8221
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
callq 0x6d00
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x18(%rax)
jne 0x8238
jmp 0x8257
jmp 0x823a
movq 0x10(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq %rax, 0x10(%rsp)
jmp 0x817e
movq 0x38(%rsp), %rdi
callq 0x7960
movq 0x20(%rsp), %rdi
callq 0x7c50
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x7cf0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x8960
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x8414
movq 0x18(%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x10(%rax)
jne 0x833e
jmp 0x8401
movq 0x18(%rsp), %rax
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rax), %rdi
callq 0x7c50
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x8(%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8378
jmp 0x83ff
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x8398
jmp 0x83e0
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rcx), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x83de
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x8444
jmp 0x83e0
jmp 0x83e2
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x835b
jmp 0x8401
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x8318
movq 0x5bdd(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
addq $0x20, %rdx
leaq 0x271a(%rip), %rsi      # 0xab48
movb $0x0, %al
callq 0x1120
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x8575
movq 0x20(%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x10(%rax)
jne 0x8493
jmp 0x8562
movq 0x20(%rsp), %rax
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rax), %rdi
callq 0x7c50
movq %rax, 0x10(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x10(%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x84cd
jmp 0x8560
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x84ed
jmp 0x8541
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x30(%rsp), %rax
jne 0x853f
movq 0x28(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x85a5
jmp 0x8541
jmp 0x8543
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x84b0
jmp 0x8562
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x846d
movq 0x5a7c(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
addq $0x20, %rdx
leaq 0x25dc(%rip), %rsi      # 0xab6b
movb $0x0, %al
callq 0x1120
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x7e80
testb $0x1, %al
jne 0x8828
jmp 0x883e
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x88a8
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x7e80
testb $0x1, %al
jne 0x8850
jmp 0x8897
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0x7e80
testb $0x1, %al
jne 0x8873
jmp 0x8897
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rcx), %rax
movq %rax, 0x20(%rsp)
jmp 0x88a6
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x8936
jmp 0x88a8
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x8300
movq %rax, 0x18(%rsp)
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
cmpq %rax, 0x18(%rsp)
je 0x88e0
movq 0x18(%rsp), %rdi
movl $0x5, %esi
callq 0x7e80
testb $0x1, %al
jne 0x88ec
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x8936
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x8280
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
movq %rax, 0x10(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x18(%rsp)
jne 0x89a2
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x8a2f
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rdi
callq 0x7c50
movq %rax, (%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, (%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x89d3
jmp 0x8a25
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x89f2
jmp 0x8a0b
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x85b0
movq %rax, 0x10(%rsp)
jmp 0x8a0d
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x89ba
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/write.c
// Function: write_number
static void write_number(FILE *f, double d) {
    if (isnan(d)) {
        fprintf(f, "+nan.0");
    } else if (isinf(d)) {
        if (d > 0) {
            fprintf(f, "+inf.0");
        } else {
            fprintf(f, "-inf.0");
        }
    } else {
        fprintf(f, "%.14g", d);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x9292
jmp 0x92aa
movq 0x10(%rsp), %rdi
leaq 0x1a61(%rip), %rsi      # 0xacff
movb $0x0, %al
callq 0x1120
jmp 0x9348
movsd 0x8(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps 0x19a6(%rip), %xmm2     # 0xac60
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x197c(%rip), %xmm1     # 0xac58
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x932d
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9318
movq 0x10(%rsp), %rdi
leaq 0x19f7(%rip), %rsi      # 0xad06
movb $0x0, %al
callq 0x1120
jmp 0x932b
movq 0x10(%rsp), %rdi
leaq 0x19e9(%rip), %rsi      # 0xad0d
movb $0x0, %al
callq 0x1120
jmp 0x9346
movq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x19d5(%rip), %rsi      # 0xad14
movb $0x1, %al
callq 0x1120
jmp 0x9348
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/write.c
// Function: write_cons
static void write_cons(FILE *f, cons_t *cons) {
    // First check if the list is circular
    // (we don't want to recurse forever)
    int32_t len = cons_len(PTR_VAL(cons));
    if (len == -1) {
        fprintf(f, "#<circular list>");
        return;
    }

    value_t arg, iter;
    SCM_FOREACH (arg, cons, iter) {
        write(f, arg);

        if (IS_NIL(AS_CONS(iter)->cdr)) {
            return;
        } else if (IS_CONS(AS_CONS(iter)->cdr)) {
            fprintf(f, " ");
        } else {
            fprintf(f, " . ");
            write(f, AS_CONS(iter)->cdr);
            return;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x96a0
movq %rax, %rdi
callq 0x6d70
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x9403
movq 0x20(%rsp), %rdi
leaq 0x1923(%rip), %rsi      # 0xad1a
movb $0x0, %al
callq 0x1120
jmp 0x9507
movq 0x18(%rsp), %rdi
callq 0x96a0
movq %rax, (%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, (%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x942d
jmp 0x9507
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x944f
jmp 0x94ea
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8d30
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x18(%rax)
jne 0x9481
jmp 0x9507
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
callq 0x9370
testb $0x1, %al
jne 0x94a0
jmp 0x94b5
movq 0x20(%rsp), %rdi
leaq 0x1881(%rip), %rsi      # 0xad2d
movb $0x0, %al
callq 0x1120
jmp 0x94e6
movq 0x20(%rsp), %rdi
leaq 0x186a(%rip), %rsi      # 0xad2b
movb $0x0, %al
callq 0x1120
movq 0x20(%rsp), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x8d30
jmp 0x9507
jmp 0x94e8
jmp 0x94ea
jmp 0x94ec
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x9411
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/write.c
// Function: write_string
static void write_string(FILE *f, string_t *str) {
    fprintf(f, "\"");

    for (uint32_t i = 0; i < str->len; i++) {
        char c = str->value[i];
        if (c == '\n') {
            fprintf(f, "\\n");
        } else if (c == '\\') {
            fprintf(f, "\\\\");
        } else if (c == '\"') {
            fprintf(f, "\\\"");
        } else {
            fprintf(f, "%c", c);
        }
    }

    fprintf(f, "\"");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x180c(%rip), %rsi      # 0xad36
movb $0x0, %al
callq 0x1120
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x95e7
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movb 0x18(%rax,%rcx), %al
movb %al, 0x3(%rsp)
movsbl 0x3(%rsp), %eax
cmpl $0xa, %eax
jne 0x957b
movq 0x10(%rsp), %rdi
leaq 0x17bd(%rip), %rsi      # 0xad2f
movb $0x0, %al
callq 0x1120
jmp 0x95d5
movsbl 0x3(%rsp), %eax
cmpl $0x5c, %eax
jne 0x959a
movq 0x10(%rsp), %rdi
leaq 0x17a1(%rip), %rsi      # 0xad32
movb $0x0, %al
callq 0x1120
jmp 0x95d3
movsbl 0x3(%rsp), %eax
cmpl $0x22, %eax
jne 0x95b9
movq 0x10(%rsp), %rdi
leaq 0x1785(%rip), %rsi      # 0xad35
movb $0x0, %al
callq 0x1120
jmp 0x95d1
movq 0x10(%rsp), %rdi
movsbl 0x3(%rsp), %edx
leaq 0x176e(%rip), %rsi      # 0xad38
movb $0x0, %al
callq 0x1120
jmp 0x95d3
jmp 0x95d5
jmp 0x95d7
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x9539
movq 0x10(%rsp), %rdi
leaq 0x1743(%rip), %rsi      # 0xad36
movb $0x0, %al
callq 0x1120
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/write.c
// Function: display
void display(FILE *f, value_t val) {
    // void is not printed with display
    if (!IS_STRING(val) && !IS_VOID(val)) {
        write(f, val);
    } else if (IS_STRING(val)) {
        string_t *str = AS_STRING(val);
        fprintf(f, "%.*s", str->len, str->value);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x9370
testb $0x1, %al
jne 0x9643
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
cmpq %rax, 0x8(%rsp)
je 0x9643
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8d30
jmp 0x968f
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x9370
testb $0x1, %al
jne 0x9658
jmp 0x968d
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movl 0x10(%rax), %edx
movq (%rsp), %rcx
addq $0x18, %rcx
leaq 0x1674(%rip), %rsi      # 0xacfa
movb $0x0, %al
callq 0x1120
jmp 0x968f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/write.c
// Function: write_vector
static void write_vector(FILE *f, vector_t *vec) {
    fprintf(f, "#(");
    for (uint32_t i = 0; i < vec->count; i++) {
        write(f, vec->data[i]);
        if (i + 1 != vec->count) {
            fprintf(f, " ");
        }
    }
    fprintf(f, ")");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1661(%rip), %rsi      # 0xad3b
movb $0x0, %al
callq 0x1120
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x9745
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x8d30
movl 0x4(%rsp), %eax
addl $0x1, %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
je 0x9736
movq 0x10(%rsp), %rdi
leaq 0x15fe(%rip), %rsi      # 0xad2d
movb $0x0, %al
callq 0x1120
jmp 0x9738
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x96e9
movq 0x10(%rsp), %rdi
leaq 0xfb8(%rip), %rsi       # 0xa709
movb $0x0, %al
callq 0x1120
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./twiddles.h
// Function: get_twiddle_sr
static inline complex double
get_twiddle_sr(unsigned i, unsigned log2_N)
{
#if defined(NO_TW)
  return cexp(-2 * M_PI * I * 3 * i / (1 << log2_N));

#elif defined(SHORT_TW)
  i *= 3;
  complex double tw = get_twiddle(i, log2_N);
  /* angle can be greater then pi */
  if (i >> (log2_N - 1))
    tw = -tw;
  return tw;
#else

  return twiddles_sr[i];
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
imull $0x3, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x27d0
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
shrl %cl, %eax
cmpl $0x0, %eax
je 0x292c
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chipkin[P]Linux-HighSpeedSerialMonitor/main.cpp
// Function: printHelp()
void printHelp()
{
    std::cout << std::endl;
    std::cout << "Command line arguments" << std::endl;
    std::cout << "   serialMonitor <port> <baudrate>" << std::endl;
    std::cout << "   <port>     - The TTY serial port that this application will monitor. Default: /dev/ttyS1" << std::endl;
    std::cout << "   <baudrate> - The baud rate of the TTY serial port Default: 38400" << std::endl;
    std::cout << std::endl;
    std::cout << "Examples:" << std::endl;
    std::cout << "   serialMonitor /dev/ttyS1 38400" << std::endl;
    std::cout << "   serialMonitor /dev/ttyS2" << std::endl;
    std::cout << "   serialMonitor /dev/ttyS3 9600" << std::endl;
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5b15(%rip), %rdi      # 0x7fd0
movq 0x5afe(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5b02(%rip), %rdi      # 0x7fd0
leaq 0x2b33(%rip), %rsi      # 0x5008
callq 0x2170
movq %rax, %rdi
movq 0x5adc(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5ae0(%rip), %rdi      # 0x7fd0
leaq 0x2b28(%rip), %rsi      # 0x501f
callq 0x2170
movq %rax, %rdi
movq 0x5aba(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5abe(%rip), %rdi      # 0x7fd0
leaq 0x2b29(%rip), %rsi      # 0x5042
callq 0x2170
movq %rax, %rdi
movq 0x5a98(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5a9c(%rip), %rdi      # 0x7fd0
leaq 0x2b63(%rip), %rsi      # 0x509e
callq 0x2170
movq %rax, %rdi
movq 0x5a76(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5a7a(%rip), %rdi      # 0x7fd0
movq 0x5a63(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5a67(%rip), %rdi      # 0x7fd0
leaq 0x2b72(%rip), %rsi      # 0x50e2
callq 0x2170
movq %rax, %rdi
movq 0x5a41(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5a45(%rip), %rdi      # 0x7fd0
leaq 0x2b5a(%rip), %rsi      # 0x50ec
callq 0x2170
movq %rax, %rdi
movq 0x5a1f(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5a23(%rip), %rdi      # 0x7fd0
leaq 0x2b5a(%rip), %rsi      # 0x510e
callq 0x2170
movq %rax, %rdi
movq 0x59fd(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x5a01(%rip), %rdi      # 0x7fd0
leaq 0x2b54(%rip), %rsi      # 0x512a
callq 0x2170
movq %rax, %rdi
movq 0x59db(%rip), %rsi      # 0x7fc0
callq 0x21a0
movq 0x59df(%rip), %rdi      # 0x7fd0
movq 0x59c8(%rip), %rsi      # 0x7fc0
callq 0x21a0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_RecvByte(unsigned char*)
bool mstp_RecvByte(uint8_t* buffer)
{
    if (serailFD == -1) {
        std::cerr << "Error: serial port has not been connected yet. " << std::endl;
        return false;
    }

    if (read(serailFD, buffer, 1) != 1) {
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpl $-0x1, 0x3ab1(%rip)     # 0x81d4
jne 0x474d
movq 0x38c4(%rip), %rdi      # 0x7ff0
leaq 0xc71(%rip), %rsi       # 0x53a4
callq 0x2170
movq %rax, %rdi
movq 0x387e(%rip), %rsi      # 0x7fc0
callq 0x21a0
movb $0x0, -0x1(%rbp)
jmp 0x4771
movl 0x3a81(%rip), %edi      # 0x81d4
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
cmpq $0x1, %rax
je 0x476d
movb $0x0, -0x1(%rbp)
jmp 0x4771
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_SendByte(unsigned char*, unsigned int)
bool mstp_SendByte(uint8_t* buffer, uint32_t length)
{
    if (serailFD == -1) {
        std::cerr << "Error: serial port has not been connected yet. " << std::endl;
        return false;
    }

    if (write(serailFD, buffer, length) != length) {
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $-0x1, 0x3a3e(%rip)     # 0x81d4
jne 0x47c0
movq 0x3851(%rip), %rdi      # 0x7ff0
leaq 0xbfe(%rip), %rsi       # 0x53a4
callq 0x2170
movq %rax, %rdi
movq 0x380b(%rip), %rsi      # 0x7fc0
callq 0x21a0
movb $0x0, -0x1(%rbp)
jmp 0x47e6
movl 0x3a0e(%rip), %edi      # 0x81d4
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2090
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
je 0x47e2
movb $0x0, -0x1(%rbp)
jmp 0x47e6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_Sleep(unsigned int)
void mstp_Sleep(uint32_t ms)
{
    // 1000 nano  seconds (nsec) == 1 micro seconds
    // 1000 micro seconds (us)  == 1 mili  seconds
    // 1000 mili  seconds (ms)  == 1 seconds
    //    1       second  (sec) == 1,000,000 micro seconds (us)

    uint32_t usec = ms * 1000;
    static struct timespec delay, rem;
    delay.tv_sec = usec / 1000000;

    delay.tv_nsec = (usec - (delay.tv_sec * 1000000)) * 1000;
    int ret = -1;
    while (ret != 0) {
        ret = nanosleep(&delay, &rem);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
imull $0x3e8, -0x4(%rbp), %eax # imm = 0x3E8
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, 0x39be(%rip)      # 0x81e8
movl -0x8(%rbp), %eax
imulq $0xf4240, 0x39b0(%rip), %rcx # imm = 0xF4240
subq %rcx, %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, 0x39a7(%rip)      # 0x81f0
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0xc(%rbp)
je 0x486e
leaq 0x398b(%rip), %rdi      # 0x81e8
leaq 0x3994(%rip), %rsi      # 0x81f8
callq 0x2060
movl %eax, -0xc(%rbp)
jmp 0x4850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_TimerDifference()
uint32_t mstp_TimerDifference()
{
    struct timeval end;
    gettimeofday(&end, NULL);

    static long seconds, useconds;
    seconds = end.tv_sec - highspeedTimer.tv_sec;
    useconds = end.tv_usec - highspeedTimer.tv_usec;
    // 1000000 microseconds in a second
    // Return the time in microsecond (us)
    return ((seconds)*1000000 + useconds);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22a0
movq -0x10(%rbp), %rax
subq 0x3918(%rip), %rax      # 0x81d8
movq %rax, 0x3941(%rip)      # 0x8208
movq -0x8(%rbp), %rax
subq 0x390e(%rip), %rax      # 0x81e0
movq %rax, 0x3937(%rip)      # 0x8210
imulq $0xf4240, 0x3924(%rip), %rax # imm = 0xF4240
addq 0x3925(%rip), %rax      # 0x8210
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x24e5
leaq 0x21b36(%rip), %rdi     # 0x24014
movb $0x0, %al
callq 0x4680
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x2561
movq -0x20(%rbp), %rax
leaq 0x21afc(%rip), %rcx     # 0x24004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2561
movq -0x10(%rbp), %rdi
callq 0x22a0
movq %rax, -0x18(%rbp)
jmp 0x2561
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x230e0
movq %rax, -0x18(%rbp)
jmp 0x2561
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x22ab0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x257a
movq -0x10(%rbp), %rsi
leaq 0x21abc(%rip), %rdi     # 0x2402f
movb $0x0, %al
callq 0x4680
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x230e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x230e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x229c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup-helpers.c
// Function: checkFileContentChanges
static void checkFileContentChanges(PathNode *node, PathState *state,
                                    const struct stat stats)
{
  uint8_t hash[FILE_HASH_SIZE];
  size_t bytes_used = FILE_HASH_SIZE;

  if(state->metadata.file_info.size > FILE_HASH_SIZE)
  {
    fileHash(node->path, stats, hash, NULL, NULL);
  }
  else
  {
    bytes_used = state->metadata.file_info.size;

    FileStream *stream = sFopenRead(node->path);
    sFread(hash, bytes_used, stream);
    bool stream_not_at_end = sFbytesLeft(stream);
    sFclose(stream);

    if(stream_not_at_end)
    {
      die("file has changed while checking for changes: \"" PRI_STR "\"",
          STR_FMT(node->path));
    }
  }

  if(memcmp(state->metadata.file_info.hash, hash, bytes_used) != 0)
  {
    backupHintSet(node->hint, BH_content_changed);
    backupHintSet(node->hint, BH_fresh_hash);

    memcpy(state->metadata.file_info.hash, hash, bytes_used);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x14, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x14, 0x20(%rax)
jbe 0x29cd
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
movq %rsp, %rax
movq %rax, %rdi
addq $0x18, %rdi
movl $0x12, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x4860
jmp 0x2a4e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xbad0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xbdc0
movq -0x40(%rbp), %rdi
callq 0xc410
andb $0x1, %al
movb %al, -0x41(%rbp)
movq -0x40(%rbp), %rdi
callq 0xc020
testb $0x1, -0x41(%rbp)
je 0x2a4c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x2163c(%rip), %rdi     # 0x24081
movb $0x0, %al
callq 0x4680
jmp 0x2a4e
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2200
cmpl $0x0, %eax
je 0x2ab3
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $-0x10, %ecx
orl $0x80, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $-0x10, %ecx
orl $0x100, %ecx            # imm = 0x100
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2250
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x25a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x25e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe600
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x48, %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %r8
leaq -0x20(%rbp), %rdi
callq 0x2b60
cmpl $0x20, %eax
je 0x2b28
jmp 0x2afd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %r8
callq 0x2fc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x30aa
movq -0x30(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x2ffd
jmp 0x3099
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3c30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3044
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %edx
callq 0x3d00
jmp 0x3097
cmpl $0x0, -0x14(%rbp)
je 0x3076
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3d80
testb $0x1, %al
jne 0x3076
jmp 0x3085
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3680
jmp 0x3095
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3d00
jmp 0x3097
jmp 0x3099
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2fe3
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/src/backup.c
// Function: finishBackupRecursively
static void finishBackupRecursively(Metadata *metadata,
                                    PathNode *node_list,
                                    StringView repo_path,
                                    StringView repo_tmp_file_path)
{
  for(PathNode *node = node_list; node != NULL; node = node->next)
  {
    /* Handle only new regular files. */
    if(node->history->state.type == PST_regular_file &&
       node->history->state.metadata.file_info.size > 0 &&
       (backupHintNoPol(node->hint) == BH_added ||
        backupHintNoPol(node->hint) == BH_symlink_to_regular ||
        backupHintNoPol(node->hint) == BH_directory_to_regular ||
        (node->hint & BH_content_changed)))
    {
      addFileToRepo(node, repo_path, repo_tmp_file_path);
    }

    finishBackupRecursively(metadata, node->subnodes, repo_path,
                            repo_tmp_file_path);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x325d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0x3200
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x3200
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x2, %eax
je 0x31bc
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x7, %eax
je 0x31bc
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x9, %eax
je 0x31bc
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x3200
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x3ea0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq 0x28(%rdx), %rsi
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x3120
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3148
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x50, %esi
callq 0x230e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0xb8f0
movq -0x30(%rbp), %rsi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq %rsp, %rdi
movl $0x18, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x3740
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x4, %eax
jne 0x356d
jmp 0x3673
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x358b
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
jmp 0x363d
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
orl $0x3, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x1c(%rax)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x363b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x50, %esi
callq 0x230e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0xb8f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x363d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3673
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x3540
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3649
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36e0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x36cb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3680
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x36a9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)