LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/virtual-machine/virtual-machine.c
// Function: virtual_machine_conf
void virtual_machine_conf(virtual_machine_type_t vm, bytecode_type_t bc, size_t stack_size, size_t start_heap_size_b, int trace)
{
    vm->bc = bc;
    vm->ip = bc->op_codes;
    
    vm->stack_cap = stack_size;
    SAFE_MALLOC(vm->stack, vm->stack_cap);
    vm->stack_top = vm->stack;

    vm->gc = create_garbage_collector();
    garbage_collector_conf(vm->gc, start_heap_size_b, &(vm->stack), &(vm->stack_top), trace);

    vm->trace = trace;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r15
movq %rdi, %r14
movq %rsi, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdx, 0x20(%rdi)
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %r12
movq %r12, %rdi
callq 0x1130
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0xd7be
leaq 0x10(%r14), %r12
leaq 0x18(%r14), %r13
movq %rax, 0x18(%r14)
xorl %eax, %eax
callq 0xe2fc
movq %rax, 0x28(%r14)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebx, %r8d
callq 0xe318
movl %ebx, 0x30(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x3c37
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/virtual-machine/virtual-machine.c
// Function: create_obj
struct OBJECT*create_obj(virtual_machine_type_t vm)
{
    size_t i;

    size_t properties_num = READ_BYTE();
    
    struct OBJECT*obj = garbage_collector_malloc_obj(vm->gc, properties_num);
    
    for (i = 0; i < properties_num; i++) {
        struct VALUE key = virtual_machine_stack_pop(vm);
        struct VALUE val = virtual_machine_stack_pop(vm);
        
        obj->properties[i].key = key.int_val;
        obj->properties[i].val = val;
    }
    
    obj->properties_len = properties_num;
    obj->properties_cap = properties_num * 2;

    return obj;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rdi
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r14
movq %r14, %rsi
callq 0xe34f
testq %r14, %r14
je 0xd840
movq %rax, %rcx
addq $0x18, %rcx
movq %r14, %rdx
movq 0x18(%rbx), %rsi
leaq -0x18(%rsi), %rdi
movq %rdi, 0x18(%rbx)
movq -0x10(%rsi), %rdi
leaq -0x30(%rsi), %r8
movq %r8, 0x18(%rbx)
movq -0x20(%rsi), %r8
movq %r8, 0x10(%rsp)
movups -0x30(%rsi), %xmm0
movaps %xmm0, (%rsp)
movq %rdi, -0x8(%rcx)
movaps (%rsp), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rsi
movq %rsi, 0x10(%rcx)
addq $0x20, %rcx
decq %rdx
jne 0xd7fa
movq %r14, (%rax)
addq %r14, %r14
movq %r14, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/virtual-machine/virtual-machine.c
// Function: create_arr
struct ARRAY*create_arr(virtual_machine_type_t vm)
{
    size_t i;

    size_t arr_len = READ_BYTE();

    struct ARRAY*arr = garbage_collector_malloc_arr(vm->gc, arr_len);

    for (i = 0; i < arr_len; i++) {
        struct VALUE val = virtual_machine_stack_pop(vm);
        arr->values[i] = val;
    }
    arr->len = arr_len;

    return arr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rdi
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r14
movq %r14, %rsi
callq 0xe569
testq %r14, %r14
je 0xd8a7
movq %rax, %rcx
addq $0x10, %rcx
movq %r14, %rdx
movq 0x18(%rbx), %rsi
leaq -0x18(%rsi), %rdi
movq %rdi, 0x18(%rbx)
movups -0x18(%rsi), %xmm0
movq -0x8(%rsi), %rsi
movq %rsi, 0x10(%rcx)
movups %xmm0, (%rcx)
addq $0x18, %rcx
decq %rdx
jne 0xd883
movq %r14, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_conf
void garbage_collector_conf(garbage_collector_type_t gc, size_t sizemem_start, struct VALUE**stack, struct VALUE**stack_top, int trace)
{
    gc->stack = stack;
    gc->stack_top = stack_top;
    allocator_malloc_pool(&(gc->a), sizemem_start);
    allocator_malloc_pool(&(gc->b), sizemem_start);

    gc->trace = trace;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %r8d, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
addq $0x10, %rdi
callq 0xe9c8
leaq 0x60(%r15), %rdi
movq %r14, %rsi
callq 0xe9c8
movl %ebx, 0xc8(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_malloc_obj
struct OBJECT*garbage_collector_malloc_obj(garbage_collector_type_t gc, size_t start_properties_num)
{
    size_t start_properties_cap = start_properties_num * 2;
    size_t sizemem = sizeof(char) + sizeof(struct OBJECT) + sizeof(struct PROPERTY) * start_properties_cap;
    
    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return malloc_obj_force(gc, start_properties_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, NULL, sizemem);

    return malloc_obj_force(gc, start_properties_cap, sizemem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
shlq $0x6, %rax
leaq 0x11(%rax), %r15
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0xe378
orq $0x33, %rax
cmpq %rax, 0x1(%rcx)
jae 0xe385
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xe3b3
addq %rbx, %rbx
addq $0x10, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xea80
movb $0x2, (%rax)
leaq 0x1(%rax), %rcx
movq $0x0, 0x1(%rax)
movq %rbx, 0x9(%rax)
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: run_gc
static void run_gc(garbage_collector_type_t gc, void**ptr, size_t ptr_sizemem)
{
    struct ALLOCATOR tmp;

    int need_realloc;

    if (gc->trace) {
        printf("\t<info>GC</info>\n");
    }

    run_gc_inner(gc, ptr);

    /* check if realloc is needed. */
    need_realloc = ((gc->b.busy_list.sizemem + gc->b.busy_list.count * BLOCK_OVERHEAD) +
                    (ptr_sizemem + BLOCK_OVERHEAD)) >= gc->b.sizemem / 2;

    if (need_realloc) {
        size_t new_sizemem = (gc->b.sizemem + (ptr_sizemem + BLOCK_OVERHEAD)) * 2;

        tmp = gc->a;
        gc->a = gc->b;
        gc->b = tmp;
        
        allocator_free_pool(&(gc->b));
        allocator_malloc_pool(&(gc->b), new_sizemem);

        run_gc_inner(gc, ptr);

        allocator_free_pool(&(gc->a));
        allocator_malloc_pool(&(gc->a), new_sizemem);
    }

    tmp = gc->a;
    gc->a = gc->b;
    gc->b = tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0xc8(%rdi)
je 0xe3de
leaq 0x27ad(%rip), %rdi      # 0x10b86
callq 0x1050
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe661
leaq 0x60(%rbx), %r14
movq 0x68(%rbx), %r12
movq 0xa0(%rbx), %rax
movq %rax, %rcx
shlq $0x5, %rcx
leaq (%rcx,%rax,2), %rax
addq $0x22, %r13
movq 0xa8(%rbx), %rcx
addq %r13, %rcx
addq %rax, %rcx
movq %r12, %rax
shrq %rax
cmpq %rax, %rcx
jb 0xe487
addq %r13, %r12
addq %r12, %r12
leaq 0x10(%rbx), %r13
movq %rsp, %rax
movl $0xa, %ecx
movq %rax, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %r13, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %r14, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
callq 0xea6b
movq %r14, %rdi
movq %r12, %rsi
callq 0xe9c8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe661
movq %r13, %rdi
callq 0xea6b
movq %r13, %rdi
movq %r12, %rsi
callq 0xe9c8
addq $0x10, %rbx
movq %rsp, %rax
movl $0xa, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %r14, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_realloc_obj
struct OBJECT*garbage_collector_realloc_obj(garbage_collector_type_t gc, struct OBJECT*obj, size_t new_properties_num)
{
    size_t new_properties_cap = new_properties_num * 2;
    size_t sizemem = sizeof(char) + sizeof(struct OBJECT) + sizeof(struct PROPERTY) * new_properties_cap;

    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return realloc_obj_force(gc, obj, new_properties_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, (void**) &obj, sizemem);

    return realloc_obj_force(gc, obj, new_properties_cap, sizemem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rsp)
movq %rdx, %rax
shlq $0x6, %rax
leaq 0x11(%rax), %r12
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0xe4f9
movq %rsi, %r15
orq $0x33, %rax
cmpq %rax, 0x1(%rcx)
jae 0xe50d
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe3b3
movq (%r15), %r15
addq %rbx, %rbx
decq %r15
leaq 0x10(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xec6e
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe80b
movq %rbx, 0x9(%r12)
incq %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_malloc_arr
struct ARRAY*garbage_collector_malloc_arr(garbage_collector_type_t gc, size_t arr_len)
{
    size_t start_arr_cap = arr_len * 2;
    size_t sizemem = sizeof(char) + sizeof(struct ARRAY) + sizeof(struct VALUE) * start_arr_cap;
    
    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return malloc_arr_force(gc, start_arr_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, NULL, sizemem);

    return malloc_arr_force(gc, start_arr_cap, sizemem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r15
addq $0x11, %r15
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xe59a
leaq (%rcx,%rcx,2), %rcx
addq $0x33, %rcx
cmpq %rcx, 0x1(%rax)
jae 0xe5a7
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xe3b3
addq %rbx, %rbx
addq $0x10, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xea80
movb $0x3, (%rax)
leaq 0x1(%rax), %rcx
movq $0x0, 0x1(%rax)
movq %rbx, 0x9(%rax)
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: garbage_collector_realloc_arr
struct ARRAY*garbage_collector_realloc_arr(garbage_collector_type_t gc, struct ARRAY*arr, size_t new_arr_len)
{
    size_t new_arr_cap = new_arr_len * 2;
    size_t sizemem = sizeof(struct ARRAY) + sizeof(struct VALUE) * new_arr_cap;

    if ((gc->a.free_list.last != NULL) && (BLOCK_L_DATA_LEN(gc->a.free_list.last) >= (sizemem + BLOCK_OVERHEAD))) {
        return realloc_arr_force(gc, arr, new_arr_cap, sizemem);
    }

    /* need garbage collection. */
    run_gc(gc, (void**) &arr, sizemem);

    return realloc_arr_force(gc, arr, new_arr_cap, sizemem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rsp)
movq %rdx, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r12
addq $0x10, %r12
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xe610
movq %rsi, %r15
leaq (%rcx,%rcx,2), %rcx
addq $0x32, %rcx
cmpq %rcx, 0x1(%rax)
jae 0xe624
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe3b3
movq (%r15), %r15
addq %rbx, %rbx
decq %r15
leaq 0x10(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xec6e
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe80b
movq %rbx, 0x9(%r12)
incq %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: lookup_new_location
static void*lookup_new_location(garbage_collector_type_t gc, void*ptr)
{
    void*o = BLOCK_PTR_FROM_DATA((((char*) ptr) - 1));
    
    if (ptrs_map_get(&(gc->ptrs_map), o) == NULL) {
        ptrs_map_set(&(gc->ptrs_map), o, gc->b.free_list.first);

        allocator_malloc_block(&(gc->b), BLOCK_L_DATA_LEN(o));
        memcpy(BLOCK_DATA(gc->b.busy_list.last), BLOCK_DATA(o), BLOCK_L_DATA_LEN(o));
    }

    return (((char*) BLOCK_DATA(ptrs_map_get(&(gc->ptrs_map), o))) + 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq -0x1a(%rsi), %rbx
leaq 0xb0(%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe97a
testq %rax, %rax
jne 0xe7f2
leaq 0x60(%r12), %r13
movq 0x70(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe921
movq -0x19(%r15), %rsi
movq %r13, %rdi
callq 0xea80
movq 0x98(%r12), %rdi
addq $0x19, %rdi
movq -0x19(%r15), %rdx
decq %r15
movq %r15, %rsi
callq 0x1120
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe97a
addq $0x1a, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/garbage-collector.c
// Function: change_one_ptr
static void change_one_ptr(garbage_collector_type_t gc, char*prev_ptr, char*new_ptr)
{
    struct VALUE*stack = (*(gc->stack));
    struct VALUE*stack_top = (*(gc->stack_top));

    struct VALUE*val;
    
    void*cur;

    for (val = stack; val != stack_top; val++) {
        change_vals_ptr(val, prev_ptr, new_ptr);
    }

    cur = gc->a.busy_list.first;

    while (cur != NULL) {
        size_t i;
        char*ptr = BLOCK_DATA(cur);
        if (ptr[0] == VALUE_TYPE_OBJ) {
            struct OBJECT*obj = (struct OBJECT*) (ptr + 1);
            for (i = 0; i < obj->properties_len; i++) {
                val = &(obj->properties[i].val);
                change_vals_ptr(val, prev_ptr, new_ptr);
            }
        } else if (ptr[0] == VALUE_TYPE_ARR) {
            size_t i;
            struct ARRAY*arr = (struct ARRAY*) (ptr + 1);
            for (i = 0; i < arr->len; i++) {
                val = &(arr->values[i]);
                change_vals_ptr(val, prev_ptr, new_ptr);
            }
        }
        cur = BLOCK_LIST_NEXT(cur);
    }
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq (%rax), %rax
movq (%rcx), %rcx
cmpq %rcx, %rax
je 0xe854
leaq 0x1(%rsi), %r8
leaq 0x1(%rdx), %r9
movl 0x10(%rax), %r10d
cmpl $0x3, %r10d
je 0xe841
cmpl $0x2, %r10d
jne 0xe84b
cmpq %r8, 0x8(%rax)
je 0xe847
cmpl $0x3, %r10d
jne 0xe84b
cmpq %r8, 0x8(%rax)
jne 0xe84b
movq %r9, 0x8(%rax)
addq $0x18, %rax
cmpq %rcx, %rax
jne 0xe825
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0xe8fe
incq %rsi
incq %rdx
movzbl 0x19(%rax), %ecx
cmpl $0x3, %ecx
je 0xe8b4
cmpl $0x2, %ecx
jne 0xe8f1
cmpq $0x0, 0x1a(%rax)
je 0xe8f1
leaq 0x3a(%rax), %rcx
xorl %edi, %edi
movl 0x8(%rcx), %r8d
cmpl $0x3, %r8d
je 0xe89d
cmpl $0x2, %r8d
jne 0xe8a5
cmpq %rsi, (%rcx)
je 0xe8a2
cmpl $0x3, %r8d
jne 0xe8a5
cmpq %rsi, (%rcx)
jne 0xe8a5
movq %rdx, (%rcx)
incq %rdi
addq $0x20, %rcx
cmpq 0x1a(%rax), %rdi
jb 0xe882
jmp 0xe8f1
cmpq $0x0, 0x1a(%rax)
je 0xe8f1
leaq 0x32(%rax), %rcx
xorl %edi, %edi
movl 0x8(%rcx), %r8d
cmpl $0x3, %r8d
je 0xe8dc
cmpl $0x2, %r8d
jne 0xe8e4
cmpq %rsi, (%rcx)
je 0xe8e1
cmpl $0x3, %r8d
jne 0xe8e4
cmpq %rsi, (%rcx)
jne 0xe8e4
movq %rdx, (%rcx)
incq %rdi
addq $0x18, %rcx
cmpq 0x1a(%rax), %rdi
jb 0xe8c1
movq 0x11(%rax), %rax
testq %rax, %rax
jne 0xe867
retq
nop
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/ptrs-map.c
// Function: ptrs_map_set
void ptrs_map_set(ptrs_map_type_t pm, void*key, void*val)
{
    size_t i;

    if (key == NULL) {
        fprintf(stderr, "insertion null-key in map is prohibited\n");
        exit(1);
    }

    for (i = 0; i < pm->len; i++) {
        if (pm->elems[i].key == key) {
            pm->elems[i].val = val;
            return;
        }
    }

    if (pm->len == pm->cap) {
        fprintf(stderr, "non enough memory in map to handle new value\n");
        exit(1);
    }

    pm->elems[pm->len].key = key;
    pm->elems[pm->len].val = val;
    pm->len++;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0xe970
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xe949
movq (%rdi), %rcx
addq $0x8, %rcx
movq %rax, %r8
cmpq %rsi, -0x8(%rcx)
je 0xe96b
addq $0x10, %rcx
decq %r8
jne 0xe93a
cmpq 0x10(%rdi), %rax
je 0xe975
movq (%rdi), %rcx
movq %rax, %r8
shlq $0x4, %r8
movq %rsi, (%rcx,%r8)
movq %rdx, 0x8(%rcx,%r8)
incq %rax
movq %rax, 0x8(%rdi)
jmp 0xe96e
movq %rdx, (%rcx)
popq %rax
retq
callq 0x3cbb
callq 0x3c96
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/ptrs-map.c
// Function: ptrs_map_get
void*ptrs_map_get(ptrs_map_type_t pm, void*key)
{
    size_t i;

    if (key == NULL) {
        fprintf(stderr, "selection by null-key from map is prohibited\n");
        exit(1);
    }

    for (i = 0; i < pm->len; i++) {
        if (pm->elems[i].key == key) {
            return pm->elems[i].val;
        }
    }

    return NULL;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0xe9ac
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xe9a3
movq (%rdi), %rdx
addq $0x8, %rdx
xorl %eax, %eax
cmpq %rsi, -0x8(%rdx)
je 0xe9a7
addq $0x10, %rdx
decq %rcx
jne 0xe992
jmp 0xe9aa
xorl %eax, %eax
jmp 0xe9aa
movq (%rdx), %rax
popq %rcx
retq
callq 0x3ce0
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_malloc_pool
void allocator_malloc_pool(allocator_type_t a, size_t sizemem)
{
    if (sizemem < MIN_BLOCK_LEN) {
        fprintf(stderr, "not enough memory for allocator:\n");
        fprintf(stderr, "got:         %ld bytes\n", sizemem);
        fprintf(stderr, "minimum:     %ld bytes;\n", MIN_BLOCK_LEN);
        fprintf(stderr, "recommended: %ld bytes;\n", MIN_BLOCK_LEN * 1024 * 1024);
        
        exit(EXIT_FAILURE);
    }
    
    a->sizemem = sizemem;
    SAFE_MALLOC(a->mem, a->sizemem);

    allocator_clean_pool(a);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x22, %rsi
jbe 0xe9fb
movq %rdi, %r14
movq %rbx, 0x8(%rdi)
movq %rbx, %rdi
callq 0x1130
movq %rax, (%r14)
testq %rax, %rax
je 0xea03
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xea0b
movq %rbx, %rdi
callq 0x3d33
movq %rbx, %rdi
callq 0x3d05
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_clean_pool
void allocator_clean_pool(allocator_type_t a)
{
    size_t len = a->sizemem - BLOCK_OVERHEAD;

    BLOCK_L_FLAG(a->mem) = FREE_BLOCK;
    BLOCK_L_DATA_LEN(a->mem) = len;
    BLOCK_LIST_PREV(a->mem) = NULL;
    BLOCK_LIST_NEXT(a->mem) = NULL;
    BLOCK_R_DATA_LEN(a->mem) = len;
    BLOCK_R_FLAG(a->mem) = FREE_BLOCK;

    a->free_list.first = a->mem;
    a->free_list.last = a->mem;
    a->free_list.count = 1;
    a->free_list.sizemem = a->sizemem - BLOCK_OVERHEAD;

    a->busy_list.first = NULL;
    a->busy_list.last = NULL;
    a->busy_list.count = 0;
    a->busy_list.sizemem = 0;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq $-0x22, %rcx
xorl %edx, %edx
movb %dl, (%rax)
movq (%rdi), %rax
movq %rcx, 0x1(%rax)
movq %rdx, 0x9(%rax)
movq (%rdi), %rax
movq %rdx, 0x11(%rax)
movq (%rdi), %rax
movq 0x1(%rax), %rsi
movq %rcx, 0x19(%rax,%rsi)
movq 0x1(%rax), %rcx
movb %dl, 0x21(%rax,%rcx)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
addq $-0x22, %rcx
movq %rcx, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_malloc_block
void*allocator_malloc_block(allocator_type_t a, size_t sizemem)
{
    void*cur;

    if ((BLOCK_L_DATA_LEN(a->free_list.last) + BLOCK_OVERHEAD) < sizemem) {
        return NULL;
    }

    cur = allocator_list_search_by_sizemem(&(a->free_list), sizemem);

    /* remove block from list. */
    allocator_list_remove_elem(&(a->free_list), cur);
    
    if (BLOCK_L_DATA_LEN(cur) < (sizemem + MIN_BLOCK_LEN)) {
        /* don't need to divide block. */
        BLOCK_L_FLAG(cur) = BUSY_BLOCK;
        BLOCK_R_FLAG(cur) = BUSY_BLOCK;
        allocator_list_push_back(&(a->busy_list), cur);
        
        return BLOCK_DATA(cur);
    }

    size_t len = BLOCK_L_DATA_LEN(cur) - sizemem - BLOCK_OVERHEAD;
    void*tmp_block;
    /* have to divide block. */
    
    /* split block into two smaller blocks (one of them will contain data). */
    
    /* put busy block to busy list. */
    BLOCK_L_FLAG(cur) = BUSY_BLOCK;
    BLOCK_L_DATA_LEN(cur) = sizemem;
    BLOCK_LIST_PREV(cur) = NULL;
    BLOCK_LIST_NEXT(cur) = NULL;
    BLOCK_R_DATA_LEN(cur) = sizemem;
    BLOCK_R_FLAG(cur) = BUSY_BLOCK;
    allocator_list_push_back(&(a->busy_list), cur);
    
    /* put free block to free list. */
    tmp_block = BLOCK_ARR_NEXT(cur);
    BLOCK_L_FLAG(tmp_block) = FREE_BLOCK;
    BLOCK_L_DATA_LEN(tmp_block) = len;
    BLOCK_LIST_PREV(tmp_block) = NULL;
    BLOCK_LIST_NEXT(tmp_block) = NULL;
    BLOCK_R_DATA_LEN(tmp_block) = len;
    BLOCK_R_FLAG(tmp_block) = FREE_BLOCK;
    allocator_list_insert_elem(&(a->free_list), tmp_block);
    
    return BLOCK_DATA(cur);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
movq 0x1(%rax), %rax
addq $0x22, %rax
cmpq %rsi, %rax
jae 0xeaa4
xorl %r13d, %r13d
jmp 0xeb76
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq (%r14), %r15
testq %r15, %r15
je 0xeac2
cmpq %r12, 0x1(%r15)
jae 0xeac5
movq 0x11(%r15), %r15
jmp 0xeab1
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0xeb88
movq 0x1(%r15), %rbp
leaq 0x23(%r12), %rax
cmpq %rax, %rbp
jae 0xeafd
movb $0x1, %al
movb %al, (%r15)
leaq 0x19(%r15), %r13
movb %al, 0x21(%r15,%rbp)
addq $0x30, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xebc0
jmp 0xeb76
subq %r12, %rbp
leaq -0x22(%rbp), %rax
movq %rax, (%rsp)
movb $0x1, %al
movb %al, (%r15)
movq %r12, 0x1(%r15)
leaq 0x19(%r15), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%r15)
movq %r12, 0x19(%r15,%r12)
movq 0x1(%r15), %rcx
movb %al, 0x21(%r15,%rcx)
addq $0x30, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xebc0
movq 0x1(%r15), %rax
leaq (%r15,%rax), %rcx
addq $0x19, %rcx
leaq (%r15,%rax), %rsi
addq $0x22, %rsi
xorl %eax, %eax
movb %al, (%rsi)
movq (%rsp), %rdx
movq %rdx, 0x1(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rsi)
movq %rdx, (%rbp,%rcx)
movq 0x1(%rsi), %rdx
movb %al, 0x2a(%rdx,%rcx)
movq %r14, %rdi
callq 0xebf7
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_list_insert_elem
static void allocator_list_insert_elem(struct ALLOCATOR_LIST*list, void*elem)
{
    size_t len = BLOCK_L_DATA_LEN(elem);
    void*list_next = allocator_list_search_by_sizemem(list, len);

    if (list_next == NULL) {
        allocator_list_push_back(list, elem);
    } else {
        void*prev_elem;
        
        if (BLOCK_LIST_PREV(list_next) == NULL) {
            allocator_list_push_front(list, elem);
            return;
        }

        BLOCK_LIST_PREV(elem) = BLOCK_LIST_PREV(list_next);
        prev_elem = BLOCK_LIST_PREV(list_next);
        BLOCK_LIST_NEXT(prev_elem) = elem;
        BLOCK_LIST_NEXT(elem) = list_next;
        BLOCK_LIST_PREV(list_next) = elem;

        list->count++;
        list->sizemem += BLOCK_L_DATA_LEN(elem);
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0xec15
movq 0x1(%rsi), %rdx
movq %rax, %rcx
cmpq %rdx, 0x1(%rcx)
jae 0xec17
movq 0x11(%rcx), %rcx
testq %rcx, %rcx
jne 0xec06
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xebc0
movq 0x9(%rcx), %rdx
testq %rdx, %rdx
je 0xec3b
movq %rdx, 0x9(%rsi)
movq 0x9(%rcx), %rax
movq %rsi, 0x11(%rax)
movq %rcx, 0x11(%rsi)
movq %rsi, 0x9(%rcx)
jmp 0xec61
movq %rax, 0x11(%rsi)
movq $0x0, 0x9(%rsi)
movq (%rdi), %rax
testq %rax, %rax
je 0xec53
movq %rsi, 0x9(%rax)
movq %rsi, (%rdi)
cmpq $0x0, 0x8(%rdi)
jne 0xec61
movq %rsi, 0x8(%rdi)
incq 0x10(%rdi)
movq 0x1(%rsi), %rax
addq %rax, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_18/dcl.c
// Function: main
int main(void)
{
  while (get_next_token() != EOF)
  {
    if (next_token == '\n')
    {
      continue;
    }

    strcpy(data_type, token);
    out[0] = '\0';

    dcl();

    if (next_token != '\n')
    {
      if (next_token == NAME)
      {
        printf("Syntax Error: '%s' unexpected.\n", token);
      }
      else
      {
        printf("Syntax Error: '%c' unexpected.\n", next_token);
      }

      do
      {
        get_next_token();
      } while (next_token != '\n' && next_token != EOF);
    }
    else
    {
      printf("%s:%s %s\n", name, out, data_type);
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1280
cmpl $-0x1, %eax
je 0x126f
leaq 0x2ec4(%rip), %rbx      # 0x4090
leaq 0x2f2d(%rip), %r14      # 0x4100
leaq 0x3386(%rip), %r12      # 0x4560
leaq 0x2f8f(%rip), %r13      # 0x4170
leaq 0xe1c(%rip), %rbp       # 0x2004
leaq 0xe35(%rip), %r15       # 0x2024
cmpl $0xa, 0x2e8a(%rip)      # 0x4080
je 0x1265
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1030
movb $0x0, 0x2f66(%rip)      # 0x4170
callq 0x1369
movl 0x2e6b(%rip), %esi      # 0x4080
cmpl $0xa, %esi
je 0x122d
testl %esi, %esi
jne 0x1246
movq %rbp, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1250
leaq 0xe10(%rip), %rdi       # 0x2044
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1060
jmp 0x1265
movq %r15, %rdi
xorl %eax, %eax
callq 0x1060
callq 0x1280
movl 0x2e25(%rip), %eax      # 0x4080
cmpl $-0x1, %eax
je 0x1265
cmpl $0xa, %eax
jne 0x1250
callq 0x1280
cmpl $-0x1, %eax
jne 0x11ef
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_18/dcl.c
// Function: dir_dcl
void dir_dcl(void)
{
  if (next_token == PAREN_OPEN)
  {
    dcl();

    if (next_token != PAREN_CLOSE)
    {
      puts("Syntax Error: missing ')'.");
    }
  }
  else if (next_token == NAME)
  {
    strcpy(name, token);
  }
  else
  {
    puts("Syntax Error: expected name or (dcl).");
  }

  while ((next_token = get_next_token()) == PARENS || next_token == BRACKETS)
  {
    if (next_token == PARENS)
    {
      strcat(out, " function returning");
    }
    else if (next_token == BRACKETS)
    {
      strcat(out, " array[");
      strcat(out, token);
      strcat(out, "] of");
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x2b83(%rip), %eax      # 0x4080
testl %eax, %eax
je 0x151d
cmpl $0x28, %eax
jne 0x1532
callq 0x1369
cmpl $0x29, 0x2b6e(%rip)     # 0x4080
je 0x153e
leaq 0xb42(%rip), %rdi       # 0x205d
jmp 0x1539
leaq 0x303c(%rip), %rdi      # 0x4560
leaq 0x2bd5(%rip), %rsi      # 0x4100
callq 0x1030
jmp 0x153e
leaq 0xb3f(%rip), %rdi       # 0x2078
callq 0x1040
callq 0x1280
movl %eax, 0x2b37(%rip)      # 0x4080
leal -0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0x15cf
leaq 0x2c18(%rip), %rbx      # 0x4170
movabsq $0x5b796172726120, %r15 # imm = 0x5B796172726120
leaq 0x2b97(%rip), %r14      # 0x4100
cmpl $0x2, %eax
je 0x1590
cmpl $0x1, %eax
jne 0x15bb
movq %rbx, %rdi
callq 0x1050
movups 0xb1c(%rip), %xmm0      # 0x209e
movups %xmm0, (%rax,%rbx)
movl $0x676e69, 0x10(%rax,%rbx) # imm = 0x676E69
jmp 0x15bb
movq %rbx, %rdi
callq 0x1050
movq %r15, (%rax,%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x1050
movl $0x666f205d, (%rax,%rbx) # imm = 0x666F205D
movb $0x0, 0x4(%rax,%rbx)
callq 0x1280
movl %eax, 0x2aba(%rip)      # 0x4080
movl %eax, %ecx
decl %ecx
cmpl $0x2, %ecx
jb 0x1569
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/tests/decimal.c
// Function: factorial
struct tt_dec *factorial(int i, int j)
{
	struct tt_dec *dec;

	if (i == j) {
		dec = tt_dec_alloc(0);
		tt_dec_from_uint(dec, i);
		return dec;
	}

	int m = (i + j) / 2;
	struct tt_dec *dec1 = factorial(i, m);
	struct tt_dec *dec2 = factorial(m+1, j);

	dec = tt_dec_alloc(dec1->_prec + dec2->_prec);
	tt_dec_mul(dec, dec1, dec2);

	tt_dec_free(dec1);
	tt_dec_free(dec2);

	return dec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
cmpl %esi, %edi
jne 0x2cd1
xorl %edi, %edi
callq 0x4380
movq %rax, %rbx
movslq %r14d, %rsi
movq %rax, %rdi
callq 0x4724
jmp 0x2d28
movl %esi, %ebx
leal (%rbx,%r14), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movl %r14d, %edi
movl %ebp, %esi
callq 0x2cac
movq %rax, %r14
incl %ebp
movl %ebp, %edi
movl %ebx, %esi
callq 0x2cac
movq %rax, %r15
movl 0x8(%rax), %edi
addl 0x8(%r14), %edi
callq 0x4380
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x562f
movq %r14, %rdi
callq 0x445e
movq %r15, %rdi
callq 0x445e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/tests/decimal.c
// Function: get_num
static long double get_num(char *s, int lmin, int lmax)
{
	long double ld = 0;

	s[0] = ((rand() & 1)) ? '-' : '+';

	/* len: lmin+1 ~ lmax+1 */
	int len = lmin + rand() % (lmax - lmin + 1) + 1;
	for (int i = 1; i < len; i++) {
		s[i] = rand() % 10;
		ld *= 10;
		ld += s[i];
		s[i] += '0';
	}
	s[len] = '\0';

	if (s[0] == '-')
		ld = -ld;

	return ld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x21e0
andb $0x1, %al
addb %al, %al
addb $0x2b, %al
movb %al, (%rbx)
callq 0x21e0
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cltq
leaq 0x2(%rax), %r14
fldz
testl %eax, %eax
js 0x421c
fstp %st(0)
movl %r14d, %r15d
fldz
movl $0x1, %r12d
fstpt 0xc(%rsp)
callq 0x21e0
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
fldt 0xc(%rsp)
fmuls 0x8e64(%rip)            # 0xd068
subl %ecx, %eax
movl %eax, 0x8(%rsp)
fiaddl 0x8(%rsp)
addb $0x30, %al
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %r15
jne 0x41d6
movb $0x0, (%rbx,%r14)
cmpb $0x2d, (%rbx)
fld %st(0)
fchs
fxch %st(1)
fcmove %st(1), %st
fstp %st(1)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/tests/decimal.c
// Function: deq
static bool deq(double d1, double d2, double prec)
{
	if (isnan(d1))
		return isnan(d2);
	if (isinf(d1))
		return isinf(d2) && signbit(d1) == signbit(d2);
	if (d1 == 0)
		return d2 == 0;
	long double dd = (long double)d1 - (long double)d2;
	dd /= d1;
	return dd < prec;
}

// Assembly:
ucomisd %xmm0, %xmm0
jp 0x42bc
movq %xmm0, %rax
movq %rax, %rdx
btrq $0x3f, %rdx
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rdx
jne 0x4278
movq %xmm1, %rdx
movq %rdx, %rsi
btrq $0x3f, %rsi
cmpq %rcx, %rsi
sete %cl
xorq %rdx, %rax
setns %al
andb %cl, %al
retq
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jne 0x4292
jp 0x4292
cmpeqsd %xmm3, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
retq
movsd %xmm0, -0x8(%rsp)
fldl -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
fld %st(0)
fsubl -0x10(%rsp)
fdivp %st, %st(1)
movsd %xmm2, -0x18(%rsp)
fldl -0x18(%rsp)
fucompi %st(1), %st
fstp %st(0)
seta %al
retq
ucomisd %xmm1, %xmm1
setp %al
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/tests/decimal.c
// Function: gen_float
static double gen_float(int mexp)
{
	union {
		uint64_t i;
		double d;
	} v = {
		.i = 0,
	};

	/* Sign: 0,1 */
	if (rand() & 1)
		v.i |= 1ULL << 63;

	/* Exponent: -mexp ~ +mexp */
	double _exp = (double)(rand() % (mexp + 1));	/* 0 ~ mexp */
	if (rand() & 1)
		_exp = -_exp;
	int e = 1023;
	if (_exp > 0)
		e = (int)(_exp / log10(2) + 1023);
	else if (_exp < 0)
		e = (int)(_exp / log10(2) + 1024);
	v.i |= ((int64_t)e) << 52;

	/* Mantissa */
	int64_t i64 = rand();
	i64 *= rand();
	v.i |= (i64 & ((1ULL << 52) - 1));

	return v.d;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
callq 0x21e0
movl %eax, %ebx
callq 0x21e0
incl %ebp
cltd
idivl %ebp
cvtsi2sd %edx, %xmm0
movapd %xmm0, (%rsp)
callq 0x21e0
testb $0x1, %al
je 0x4300
movapd (%rsp), %xmm1
xorpd 0x8d32(%rip), %xmm1     # 0xd030
jmp 0x4305
movapd (%rsp), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x4321
divsd 0x8d39(%rip), %xmm1     # 0xd050
addsd 0x8d41(%rip), %xmm1     # 0xd060
jmp 0x433d
movl $0x3ff, %r14d           # imm = 0x3FF
ucomisd %xmm1, %xmm0
jbe 0x4342
divsd 0x8d1b(%rip), %xmm1     # 0xd050
addsd 0x8d1b(%rip), %xmm1     # 0xd058
cvttsd2si %xmm1, %r14d
shlq $0x3f, %rbx
shlq $0x34, %r14
orq %rbx, %r14
callq 0x21e0
movslq %eax, %rbx
callq 0x21e0
cltq
imulq %rbx, %rax
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
andq %rax, %rcx
orq %r14, %rcx
movq %rcx, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/write.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };
	pthread_t threads[2];

	stress_parse_args(argc, argv, &args);
	_STRESS_MUST(strlen(args.d), "a base directory must be specified");

	thread_arg_t thread1arg = { .count = args.n,
		                    .base_dir = args.d,
		                    .thread_num = 0 };
	thread_arg_t thread2arg = { .count = args.n,
		                    .base_dir = args.d,
		                    .thread_num = 1 };

	srand(time(NULL));

	_STRESS_MUST(
	  (!pthread_create(&threads[0], NULL, &thread_handler, &thread1arg)),
	  "Unexpected error creating stdout thread");
	_STRESS_MUST(
	  (!pthread_create(&threads[1], NULL, &thread_handler, &thread2arg)),
	  "Unexpected error creating stderr thread");

	_STRESS_MUST((!pthread_join(threads[0], NULL)),
	             "Unexpected error waiting for stdout thread");

	_STRESS_MUST((!pthread_join(threads[1], NULL)),
	             "Unexpected error waiting for stderr thread");

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2040, %rsp           # imm = 0x2040
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x38(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x18f9
cmpb $0x0, 0x1005(%r14)
je 0x2022
leaq 0x103d(%rsp), %rax
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movl -0x1005(%rax), %ecx
movl %ecx, 0xc(%rbx)
movq %rax, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
movl %ecx, 0x24(%rsp)
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10e0
leaq -0x49d(%rip), %rdx      # 0x1b2b
movq %rsp, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1130
testl %eax, %eax
jne 0x2027
leaq 0x8(%rsp), %rdi
leaq -0x4ba(%rip), %rdx      # 0x1b2b
leaq 0x18(%rsp), %rcx
xorl %esi, %esi
callq 0x1130
testl %eax, %eax
jne 0x202c
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x11a0
testl %eax, %eax
jne 0x2031
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x11a0
testl %eax, %eax
jne 0x2036
xorl %eax, %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r14
popq %rbp
retq
callq 0x16f4
callq 0x141c
callq 0x14d2
callq 0x1588
callq 0x163e
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/test.c
// Function: test_digest_case
static int
test_digest_case(const struct libkeccak_spec *restrict spec, const char *restrict suffix,
                 const char *restrict msg, size_t bytes, size_t bits, const char *restrict expected_answer)
{
	struct libkeccak_state state;
	int ret;
	if (libkeccak_state_initialise(&state, spec)) {
		perror("libkeccak_state_initialise");
		return -1;
	}
	ret = test_digest_case_inited(&state, spec, suffix, msg, bytes, bits, expected_answer);
	libkeccak_state_fast_destroy(&state);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x88f0
testl %eax, %eax
jne 0x4709
movq %r13, (%rsp)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x471c
movl %eax, %ebx
movq 0x118(%r13), %rdi
callq 0x1030
movq $0x0, 0x118(%r13)
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a6c(%rip), %rdi      # 0xa17c
callq 0x1120
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x46f5
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/test.c
// Function: test_digest_case_inited
static int
test_digest_case_inited(struct libkeccak_state *restrict state, const struct libkeccak_spec *restrict spec,
                        const char *restrict suffix, const char *restrict msg, size_t bytes, size_t bits,
                        const char *restrict expected_answer)
{
	unsigned char *restrict hashsum;
	char *restrict hexsum;
	int ok;

	hashsum = malloc((size_t)((spec->output + 7) / 8));
	if (!hashsum) {
		perror("malloc");
		return -1;
	}
	hexsum = malloc((size_t)((spec->output + 7) / 8 * 2 + 1));
	if (!hexsum) {
		perror("malloc");
		return -1;
	}

	if (libkeccak_digest(state, msg, bytes, bits, suffix, hashsum)) {
		perror("libkeccak_digest");
		return -1;
	}

	libkeccak_behex_lower(hexsum, hashsum, (size_t)((spec->output + 7) / 8));
	ok = !strcmp(hexsum, expected_answer);
	printf("%s%s\n", ok ? "OK" : "Fail: ", ok ? "" : hexsum);
	if (!ok)
		printf("  r, c, n = %li, %li, %li\n", spec->bitrate, spec->capacity, spec->output);

	free(hashsum);
	free(hexsum);

	return ok - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, %rbp
movq 0x10(%rsi), %rbx
leaq 0x7(%rbx), %rax
leaq 0xe(%rbx), %r13
testq %rax, %rax
cmovnsq %rax, %r13
sarq $0x3, %r13
movq %r13, %rdi
callq 0x10e0
testq %rax, %rax
je 0x4848
movq %rax, %r15
movq %r12, 0x8(%rsp)
leaq 0x1(,%r13,2), %rdi
callq 0x10e0
testq %rax, %rax
je 0x4848
movq %rax, %r12
movq %rbp, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq %r15, %r9
callq 0x7fd4
testl %eax, %eax
jne 0x4851
movq 0x60(%rsp), %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x8f64
movq %r12, %rdi
movq %r14, %rsi
callq 0x10c0
movl %eax, %r13d
testl %eax, %eax
leaq 0x6f0d(%rip), %rax      # 0xb6e7
leaq 0xc71d(%rip), %rsi      # 0x10efe
cmovneq %rax, %rsi
leaq 0x6320(%rip), %rdx      # 0xab0c
cmovneq %r12, %rdx
leaq 0x6eea(%rip), %rdi      # 0xb6e1
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1080
testl %r13d, %r13d
je 0x4822
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x6ed6(%rip), %rdi      # 0xb6ee
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1080
movq %r15, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x1030
negl %r13d
sbbl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5962(%rip), %rdi      # 0xa1b1
jmp 0x4858
leaq 0x6e78(%rip), %rdi      # 0xb6d0
callq 0x1120
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x4837
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/test.c
// Function: test_digest_case_cshake
static int
test_digest_case_cshake(const struct libkeccak_spec *restrict spec, const char *restrict suffix,
                        const void *n_text, size_t n_len, size_t n_bits, const char *n_suffix,
                        const void *s_text, size_t s_len, size_t s_bits, const char *s_suffix,
                        const char *restrict msg, size_t bytes, size_t bits, const char *restrict expected_answer)
{
	struct libkeccak_state state;
	int ret;
	if (libkeccak_state_initialise(&state, spec)) {
		perror("libkeccak_state_initialise");
		return -1;
	}
	libkeccak_cshake_initialise(&state, n_text, n_len, n_bits, n_suffix, s_text, s_len, s_bits, s_suffix);
	ret = test_digest_case_inited(&state, spec, suffix, msg, bytes, bits, expected_answer);
	libkeccak_state_fast_destroy(&state);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x88f0
testl %eax, %eax
jne 0x4917
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movq %rbp, (%rsp)
leaq 0x6261(%rip), %rsi      # 0xab0c
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r13, %r9
callq 0x8330
movq 0x178(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq 0x170(%rsp), %r9
callq 0x471c
movl %eax, %ebx
movq 0x118(%rbp), %rdi
callq 0x1030
movq $0x0, 0x118(%rbp)
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x585e(%rip), %rdi      # 0xa17c
callq 0x1120
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x4903
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/test.c
// Function: test_squeeze_case
static int
test_squeeze_case(struct libkeccak_state *restrict state, const struct libkeccak_spec *restrict spec,
                  long int fast_squeezes, long int squeezes, int fast_digest, void *restrict hashsum,
                  char *restrict hexsum, const char *restrict expected_answer)
{
#define message "withdrew hypothesis snakebird qmc2"
	long int i;
	int ok;

	libkeccak_state_reset(state);
	if (libkeccak_digest(state, message, strlen(message), 0, LIBKECCAK_SHA3_SUFFIX, fast_digest ? NULL : hashsum)) {
		perror("libkeccak_digest");
		return -1;
	}

	libkeccak_fast_squeeze(state, fast_squeezes);
	for (i = fast_squeezes; i < squeezes; i++)
		libkeccak_squeeze(state, hashsum);

	libkeccak_behex_lower(hexsum, hashsum, (size_t)((spec->output + 7) / 8));
	ok = !strcmp(hexsum, expected_answer);
	printf("%s%s\n", ok ? "OK" : "Fail: ", ok ? "" : hexsum);
	if (!ok)
		printf("  r, c, n = %li, %li, %li\n", spec->bitrate, spec->capacity, spec->output);

	return ok - 1;
#undef message
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movq %r14, 0x108(%rdi)
movl $0xc8, %edx
xorl %esi, %esi
callq 0x1090
testl %ebx, %ebx
cmoveq %r15, %r14
leaq 0x5a97(%rip), %rsi      # 0xa5bb
leaq 0xbc1c(%rip), %r8       # 0x10747
movl $0x22, %edx
movq %rbp, %rdi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x7fd4
testl %eax, %eax
jne 0x4c1f
movq 0xd8(%rbp), %rax
decq %rax
cqto
idivq 0xc8(%rbp)
leaq 0x1(%rax), %rsi
imulq %r12, %rsi
movq %rbp, %rdi
callq 0x8286
subq %r12, %r13
jle 0x4b7d
movq %rbp, %rdi
movq %r15, %rsi
callq 0x82e8
decq %r13
jne 0x4b6d
movq 0x10(%rsp), %r14
movq 0x10(%r14), %r12
leaq 0x7(%r12), %rax
leaq 0xe(%r12), %rdx
testq %rax, %rax
cmovnsq %rax, %rdx
sarq $0x3, %rdx
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x8f64
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x10c0
movl %eax, %ebx
testl %eax, %eax
leaq 0xc33c(%rip), %rax      # 0x10efe
leaq 0x6b1e(%rip), %rsi      # 0xb6e7
cmoveq %rax, %rsi
leaq 0x5f38(%rip), %rdx      # 0xab0c
cmovneq %r13, %rdx
leaq 0x6b02(%rip), %rdi      # 0xb6e1
xorl %eax, %eax
callq 0x1080
testl %ebx, %ebx
je 0x4c10
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x6af6(%rip), %rdi      # 0xb6ee
movq %r12, %rcx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6aaa(%rip), %rdi      # 0xb6d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1120
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/libkeccak_cshake_initialise.c
// Function: encode_left
static size_t
encode_left(struct libkeccak_state *restrict state, uint8_t *restrict buf, size_t byterate, size_t value, size_t off)
{
	size_t x, n, j, i = off;

	for (x = value, n = 0; x; x >>= 8)
		n += 1;
	if (!n)
		n = 1;
	buf[i++] = (uint8_t)n;
	if (i == byterate) {
		libkeccak_zerocopy_update(state, buf, byterate);
		i = 0;
	}

	for (j = 0; j < n;) {
		buf[i++] = (uint8_t)(value >> ((n - ++j) << 3));
		if (i == byterate) {
			libkeccak_zerocopy_update(state, buf, byterate);
			i = 0;
		}
	}

	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
testq %rcx, %rcx
je 0x873f
movq %rbx, %rdx
movq %rbx, %rcx
incq %r13
shrq $0x8, %rcx
cmpq $0xff, %rdx
movq %rcx, %rdx
ja 0x872c
cmpq $0x1, %r13
adcq $0x0, %r13
movb %r13b, (%r15,%rax)
incq %rax
cmpq %r14, %rax
jne 0x8763
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4c3c
xorl %eax, %eax
leaq -0x8(,%r13,8), %r13
movq %rbx, %rdx
movl %r13d, %ecx
shrq %cl, %rdx
movb %dl, (%r15,%rax)
incq %rax
cmpq %r14, %rax
jne 0x8790
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4c3c
xorl %eax, %eax
addq $-0x8, %r13
cmpq $-0x8, %r13
jne 0x876b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/libkeccak_cshake_initialise.c
// Function: feed_text
static size_t
feed_text(struct libkeccak_state *restrict state, uint8_t *restrict buf, const uint8_t *restrict text, size_t bytes,
          size_t bits, const char *restrict suffix, size_t off, size_t byterate, size_t *restrict bitoffp)
{
	size_t n, bitoff;

	if (off) {
		n = bytes < byterate - off ? bytes : byterate - off;
		memcpy(&buf[off], text, n);
		off += n;
		if (off == byterate) {
			libkeccak_zerocopy_update(state, buf, byterate);
			off = 0;
		}
		text = &text[n];
		bytes -= n;
	}
	if (bytes) {
		n = bytes;
		n -= bytes %= byterate;
		libkeccak_zerocopy_update(state, text, n);
		text = &text[n];
	}
	memcpy(&buf[off], text, bytes + !!bits);
	off += bytes;
	bitoff = bits;
	if (!bitoff)
		buf[off] = 0;
	for (; *suffix; suffix++) {
		if (*suffix == '1')
			buf[off] |= (uint8_t)(1 << bitoff);
		if (++bitoff == 8) {
			if (++off == byterate) {
				libkeccak_zerocopy_update(state, buf, byterate);
				off = 0;
			}
			bitoff = 0;
			buf[off] = 0;
		}
	}

	*bitoffp = bitoff;
	return off;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rdx, %r8
movq %rsi, %r14
movq %rdi, %r15
movq 0x58(%rsp), %r12
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x8823
movq %r12, %rbp
subq %rax, %rbp
cmpq %rcx, %rbp
movq %rcx, (%rsp)
cmovaeq %rcx, %rbp
leaq (%r14,%rax), %rdi
movq %r8, 0x8(%rsp)
movq %r8, %rsi
movq %rbp, %rdx
callq 0x10d0
movq 0x50(%rsp), %rax
addq %rbp, %rax
cmpq %r12, %rax
jne 0x8812
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4c3c
xorl %eax, %eax
movq 0x8(%rsp), %r8
addq %rbp, %r8
movq (%rsp), %rcx
subq %rbp, %rcx
jmp 0x8825
xorl %eax, %eax
testq %rcx, %rcx
movq %rax, 0x10(%rsp)
je 0x8864
movq %rcx, %rax
xorl %edx, %edx
divq %r12
movq %rdx, %rbp
subq %rdx, %rcx
movq %rcx, (%rsp)
movq %r15, %rdi
movq %r8, %rsi
movq %rcx, %rdx
movq %r8, 0x8(%rsp)
callq 0x4c3c
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r8
addq (%rsp), %r8
jmp 0x8866
xorl %ebp, %ebp
leaq (%r14,%rax), %rdi
xorl %edx, %edx
testq %r13, %r13
setne %dl
addq %rbp, %rdx
movq %r8, %rsi
callq 0x10d0
addq 0x10(%rsp), %rbp
testq %r13, %r13
jne 0x88c8
movb $0x0, (%r14,%rbp)
jmp 0x88c8
movl $0x1, %eax
movl %r13d, %ecx
shll %cl, %eax
orb %al, (%r14,%rbp)
incq %r13
cmpq $0x8, %r13
jne 0x88c5
incq %rbp
cmpq %r12, %rbp
jne 0x88bd
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4c3c
xorl %ebp, %ebp
movb $0x0, (%r14,%rbp)
xorl %r13d, %r13d
incq %rbx
movzbl (%rbx), %eax
cmpl $0x31, %eax
je 0x888e
testl %eax, %eax
jne 0x889c
movq 0x60(%rsp), %rax
movq %r13, (%rax)
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop