LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_begin_test_line__
static void
test_begin_test_line__(const struct test__* test)
{
    if(!test_tap__) {
        if(test_verbose_level__ >= 3) {
            test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Test %s:\n", test->name);
            test_current_already_logged__++;
        } else if(test_verbose_level__ >= 1) {
            int n;
            char spaces[48];

            n = test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Test %s... ", test->name);
            memset(spaces, ' ', sizeof(spaces));
            if(n < (int) sizeof(spaces))
                printf("%.*s", (int) sizeof(spaces) - n, spaces);
        } else {
            test_current_already_logged__ = 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x9e1d(%rip)      # 0xf6a0
jne 0x5926
cmpl $0x3, 0x98e0(%rip)      # 0xf170
jl 0x58bd
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x6765(%rip), %rsi      # 0xc00a
movb $0x0, %al
callq 0x2770
movl 0x9c8e(%rip), %eax      # 0xf540
addl $0x1, %eax
movl %eax, 0x9c85(%rip)      # 0xf540
jmp 0x5924
cmpl $0x1, 0x98ac(%rip)      # 0xf170
jl 0x5918
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x673b(%rip), %rsi      # 0xc014
movb $0x0, %al
callq 0x2770
movl %eax, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
movl $0x30, %edx
callq 0x2110
cmpl $0x30, -0xc(%rbp)
jge 0x5916
movl $0x30, %esi
subl -0xc(%rbp), %esi
leaq -0x40(%rbp), %rdx
leaq 0x5d39(%rip), %rdi      # 0xb648
movb $0x0, %al
callq 0x20e0
jmp 0x5922
movl $0x1, 0x9c1e(%rip)      # 0xf540
jmp 0x5924
jmp 0x5926
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: compare_record_dates
int compare_record_dates(Pointer a, Pointer b){
    Record record_a = a;
    Record record_b = b;
    if(find)
        return strcmp(record_a->date, record_b->date);
    if(strcmp(record_a->date, record_b->date)){
        return strcmp(record_a->date, record_b->date);
    }else{
        return (record_a->id)-(record_b->id);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x9d21(%rip)      # 0xf6f8
je 0x59f3
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2160
movl %eax, -0x4(%rbp)
jmp 0x5a36
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2160
cmpl $0x0, %eax
je 0x5a27
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2160
movl %eax, -0x4(%rbp)
jmp 0x5a36
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: compare_structs
int compare_structs(Pointer a, Pointer b){
    MapCount mapcount_a = a;
    MapCount mapcount_b = b;
    if(!strcmp(mapcount_a->disease, mapcount_b->disease)){
        if(!strcmp(mapcount_a->country, mapcount_b->country)){
            return strcmp(mapcount_a->date, mapcount_b->date);
        }else{
            return strcmp(mapcount_a->country, mapcount_b->country);
        }
    }else{
        return strcmp(mapcount_a->disease, mapcount_b->disease);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x5af6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x5adc
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2160
movl %eax, -0x4(%rbp)
jmp 0x5b0c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2160
movl %eax, -0x4(%rbp)
jmp 0x5b0c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x2160
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: dm_init
void dm_init(){
    map_ids_records = map_create(compare_ints, NULL, NULL);
    map_set_hash_function(map_ids_records, hash_int);
    map_diseases_dates = map_create(compare_diseases, NULL, NULL);
    map_set_hash_function(map_diseases_dates, hash_string);
    map_countries_dates = map_create(compare_countries, NULL, NULL);
    map_set_hash_function(map_countries_dates, hash_string);

    map_disease_country_date = map_create(compare_structs, NULL, NULL);
    map_set_hash_function(map_disease_country_date, hash_struct_disease_country_date);

    map_NULL_diseases = map_create(compare_diseases, NULL, NULL);
    map_set_hash_function(map_NULL_diseases, hash_string);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x2cb(%rip), %rdi      # 0x5930
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x7c0c
movq %rax, 0x9b02(%rip)      # 0xf710
movq 0x9afb(%rip), %rdi      # 0xf710
leaq 0x2c0c(%rip), %rsi      # 0x8828
callq 0x87bb
leaq -0x2d8(%rip), %rdi      # 0x5950
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x7c0c
movq %rax, 0x9add(%rip)      # 0xf718
movq 0x9ad6(%rip), %rdi      # 0xf718
leaq 0x2b91(%rip), %rsi      # 0x87da
callq 0x87bb
leaq -0x2d5(%rip), %rdi      # 0x5980
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x7c0c
movq %rax, 0x9ab8(%rip)      # 0xf720
movq 0x9ab1(%rip), %rdi      # 0xf720
leaq 0x2b64(%rip), %rsi      # 0x87da
callq 0x87bb
leaq -0x212(%rip), %rdi      # 0x5a70
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x7c0c
movq %rax, 0x9a93(%rip)      # 0xf728
movq 0x9a8c(%rip), %rdi      # 0xf728
leaq 0x2bab(%rip), %rsi      # 0x884e
callq 0x87bb
leaq -0x35f(%rip), %rdi      # 0x5950
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x7c0c
movq %rax, 0x9a46(%rip)      # 0xf708
movq 0x9a3f(%rip), %rdi      # 0xf708
leaq 0x2b0a(%rip), %rsi      # 0x87da
callq 0x87bb
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: update_map_count
void update_map_count(Map map, Record record){

    //Δημιουργούμε ένα mapcount με τα στοιχεία που θέλουμε να εισαγάγουμε στο Map
    MapCount mapcount = malloc(sizeof(*mapcount));
    mapcount->disease = strdup(record->disease);
    mapcount->country = strdup(record->country);
    mapcount->date = strdup(record->date);

    MapNode found = map_find_node(map, mapcount);

    // Αν υπάρχει ήδη key με αυτά τα στοιχεία, τότε αυξάνουμε το value
    if(found){
        Pointer value = map_node_value(map, found);
        (*(int *)value)++;
        free(mapcount->disease);
        free(mapcount->country);
        free(mapcount->date);
        free(mapcount);

    // Αλλιώς εισάγουμε ένα νέο key με αυτά τα στοιχεία και value 1 αφού είναι η πρώτη φορά
    // που εισάγεται στο map_disease_country_date key με αυτά τα στοιχεία
    }else{
        map_insert(map, mapcount, create_int(1));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x21a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x86d5
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5f6a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x86bb
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x22a0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22a0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22a0
movq -0x18(%rbp), %rdi
callq 0x22a0
jmp 0x5f94
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x5bc0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x7ee6
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: dm_remove_record
bool dm_remove_record(int id){

    // Βρίσκουμε το record με το συγκεκριμένο id
    Record record = map_find(map_ids_records, &id);

    // Αν όντως υπάρχει
    if(record){

        // Βρίσκουμε την εγγραφή με τα αντίστοιχα στοιχεία στα map_disease_country_date,
        // map_NULL_diseases και μειώνουμε τα values τους κατά 1
        MapCount mapcount = malloc(sizeof(*mapcount));
        mapcount->disease = record->disease;
        mapcount->country = record->country;
        mapcount->date = record->date;
        (*(int*)map_find(map_disease_country_date, mapcount))--;
        (*(int*)map_find(map_NULL_diseases, record->disease))--;

        // Αφαιρούμε το record και από τα Maps που χρησιμποιεί η map_get_records()
        set_remove(map_node_value(map_diseases_dates, map_find_node(map_diseases_dates, record->disease)), record);
        set_remove(map_node_value(map_countries_dates, map_find_node(map_countries_dates, record->country)), record);
        map_remove(map_ids_records, &id);

        free(mapcount);

        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq 0x93ce(%rip), %rdi      # 0xf710
leaq -0x8(%rbp), %rsi
callq 0x826d
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6456
movl $0x18, %edi
callq 0x21a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x938a(%rip), %rdi      # 0xf728
movq -0x18(%rbp), %rsi
callq 0x826d
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x9353(%rip), %rdi      # 0xf708
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x826d
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x9348(%rip), %rax      # 0xf718
movq %rax, -0x28(%rbp)
movq 0x933d(%rip), %rdi      # 0xf718
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x86d5
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x86bb
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x9988
movq 0x9319(%rip), %rax      # 0xf720
movq %rax, -0x20(%rbp)
movq 0x930e(%rip), %rdi      # 0xf720
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x86d5
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x86bb
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x9988
movq 0x92d2(%rip), %rdi      # 0xf710
leaq -0x8(%rbp), %rsi
callq 0x80e6
movq -0x18(%rbp), %rdi
callq 0x22a0
movb $0x1, -0x1(%rbp)
jmp 0x645a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: get_date_from_node
SetNode get_date_from_node(Set set, Date date_from){

    // Αν date_from == NULL επιστρέφουμε τον πρώτο κόμβο του Set, αφού η dm_get_records()
    // θα πρέπει να επιστρέψει όλα τα records μέχρι date_to
    if(!date_from){
        return set_first(set);
    }else{
        Record record = malloc(sizeof(*record));
        record->date = strdup(date_from);

        // Αλλάζουμε προσωρινά το find σε true ώστε η CompareFunc να συγκρίνει αποκλειστικά με
        // βάση τις ημερομηνίες και όχι τα ids
        find = true;
        SetNode node = set_find_node(set, record);
        find = false;

        free(record->date);
        free(record);
        return node;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6496
movq -0x10(%rbp), %rdi
callq 0x9ae6
movq %rax, -0x8(%rbp)
jmp 0x64f5
movl $0x28, %edi
callq 0x21a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, 0x9239(%rip)      # 0xf6f8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9baa
movq %rax, -0x28(%rbp)
movb $0x0, 0x9221(%rip)      # 0xf6f8
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x22a0
movq -0x20(%rbp), %rdi
callq 0x22a0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: get_date_to_node
SetNode get_date_to_node(Set set, Date date_to){

    // Αν date_to == NULL επιστρέφουμε SET_EOF, αφού η dm_get_records()
    // θα πρέπει να επιστρέψει όλα τα records από date_from και μετά
    if(!date_to){
        return SET_EOF;
    }else{
        Record record = malloc(sizeof(*record));
        record->id = -1;
        record->country = NULL;
        record->disease = NULL;
        record->name = NULL;
        record->date = strdup(date_to);

        // Αλλάζουμε προσωρινά το find σε true ώστε η CompareFunc να συγκρίνει αποκλειστικά με
        // βάση τις ημερομηνίες και όχι τα ids
        find = true;
        SetNode node = set_find_node(set, record);
        find = false;

        // Θέλουμε να επιτρέψουμε τον επόμενο του node, αφού το Set θα πρέπει να διατρεχθεί
        // μέχρι και τον node, οπότε στη συνθήκη της for() θα πρέπει να χρησιμοποιηθεί ο
        // επόμενος κόμβος.
        if(node){
            free(record->date);
            free(record);
            return set_next(set, node);
        }else{
            set_insert(set, record);
            SetNode next = set_next(set, set_find_node(set, record));
            set_remove(set, record);
            free(record->date);
            free(record);
            return next;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6524
movq $0x0, -0x8(%rbp)
jmp 0x6620
movl $0x28, %edi
callq 0x21a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, 0x917d(%rip)      # 0xf6f8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9baa
movq %rax, -0x28(%rbp)
movb $0x0, 0x9165(%rip)      # 0xf6f8
cmpq $0x0, -0x28(%rbp)
je 0x65c3
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x22a0
movq -0x20(%rbp), %rdi
callq 0x22a0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9b5c
movq %rax, -0x8(%rbp)
jmp 0x6620
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x98e8
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9baa
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9b5c
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9988
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x22a0
movq -0x20(%rbp), %rdi
callq 0x22a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/ct_dit_bi.c
// Function: ct_fft_bi
static inline void
ct_fft_bi(const complex double * restrict in,
	   complex double * restrict out,
	   int log2_N)
{
  unsigned N = 1 << log2_N;

  /* stage 0 */
  BIT_REVERSE2_LOOP(i, j, N, {
      ct_dit_bf2_0(1, N / 2, out + i, in + j);
  });

  /* stages 1 to log2_N - 1 */
  for (unsigned j = 1; j < log2_N; j++)
    {
      unsigned s = log2_N - j - 1;
      unsigned l = 1 << j;

      for (unsigned i = 0; i < (1 << s); i++)
	{
	  complex double *t = out + (i << (j + 1));

          for (unsigned k = 0; k < l; k++)
            ct_dit_bf2(l, t + k, get_twiddle(k << s, log2_N));
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x1f37
movl -0x18(%rbp), %esi
shrl %esi
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rcx
movl -0x24(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movl $0x1, %edi
callq 0x2060
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
xorl $-0x1, %eax
movl -0x28(%rbp), %ecx
xorl -0x2c(%rbp), %ecx
bsrl %ecx, %edx
xorl $0x1f, %edx
movl $0x1f, %ecx
subl %edx, %ecx
shrl %cl, %eax
andl -0x20(%rbp), %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1ecf
jmp 0x1f39
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x2023
movl -0x14(%rbp), %eax
subl -0x30(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jae 0x2013
movq -0x10(%rbp), %rax
movl -0x3c(%rbp), %edx
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jae 0x2003
movl -0x38(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movl -0x4c(%rbp), %edi
movl -0x34(%rbp), %ecx
shll %cl, %edi
movl -0x14(%rbp), %esi
callq 0x2270
movl -0x6c(%rbp), %edi
movq -0x68(%rbp), %rsi
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
callq 0x2110
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1fa8
jmp 0x2005
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1f6c
jmp 0x2015
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1f40
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_08/count_b_t_n.c
// Function: main
int main(void)
{
  int blanks_nr = 0;
  int tabs_nr = 0;
  int newlines_nr = 0;

  char c;
  while ((c = getchar()) != EOF)
  {
    if (c == ' ')
    {
      ++blanks_nr;
    }
    else if (c == '\t')
    {
      ++tabs_nr;
    }
    else if (c == '\n')
    {
      ++newlines_nr;
    }
  }

  printf("blanks_nr: %d\ntabs_nr: %d\nnewlines_nr: %d\n",
         blanks_nr, tabs_nr, newlines_nr);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
callq 0x1040
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x11c4
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jne 0x1198
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11c2
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
jne 0x11ac
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11c0
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x11be
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11c0
jmp 0x11c2
jmp 0x1174
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq 0xe30(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/6-Memory/global_vs_static.c
// Function: main
int main(void) {
	int local_int = 0;
	static int static_int = 0;

	printf("local_int  addr = %p\n", &local_int);
	printf("static_int addr = %p\n", &static_int);
	printf("global_int addr = %p\n", &global_int);
	printf("addr difference = %d\n",
		(char *) &static_int - (char *) &global_int
	);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq 0xea7(%rip), %rdi       # 0x2004
leaq -0x8(%rbp), %rsi
movb $0x0, %al
callq 0x1030
leaq 0xeab(%rip), %rdi       # 0x201a
leaq 0x2ec2(%rip), %rsi      # 0x4038
movb $0x0, %al
callq 0x1030
leaq 0xeac(%rip), %rdi       # 0x2030
leaq 0x2ea9(%rip), %rsi      # 0x4034
movb $0x0, %al
callq 0x1030
leaq 0xead(%rip), %rdi       # 0x2046
leaq 0x2e98(%rip), %rsi      # 0x4038
leaq 0x2e8d(%rip), %rax      # 0x4034
subq %rax, %rsi
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ulisses[P]ftp-client-server/dir.c
// Function: main
int main(){
	char linha[200];
	FILE *f, *p;
	
	f = fopen("dir.cmd", "w");
	
	p = popen("/bin/ls -f", "r");
	while(fgets(linha, 200, p)!=NULL) fprintf(f, "%s", linha);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe7b(%rip), %rdi       # 0x2004
leaq 0xe7c(%rip), %rsi       # 0x200c
callq 0x1060
movq %rax, -0xd8(%rbp)
leaq 0xe6b(%rip), %rdi       # 0x200e
leaq 0xe6f(%rip), %rsi       # 0x2019
callq 0x1050
movq %rax, -0xe0(%rbp)
leaq -0xd0(%rbp), %rdi
movq -0xe0(%rbp), %rdx
movl $0xc8, %esi
callq 0x1030
cmpq $0x0, %rax
je 0x11f2
movq -0xd8(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq 0xe32(%rip), %rsi       # 0x201b
movb $0x0, %al
callq 0x1040
jmp 0x11b6
movl $0x1, %eax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_segment_clear
void xlink_segment_clear(xlink_segment *segment) {
  free(segment->data);
  free(segment->mask);
  free(segment->publics);
  free(segment->datas);
  free(segment->relocs);
  memset(segment, 0, sizeof(xlink_segment));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_segment_get_alignment
int xlink_segment_get_alignment(xlink_segment *seg) {
  switch (seg->attrib.align) {
    case OMF_SEGMENT_BYTE : {
      return 0;
    }
    case OMF_SEGMENT_WORD : {
      return 1;
    }
    case OMF_SEGMENT_DWORD : {
      return 2;
    }
    case OMF_SEGMENT_PARA : {
      return 4;
    }
    case OMF_SEGMENT_PAGE : {
      return 12;
    }
    default : {
      XLINK_ERROR(1,
       ("Unsupported alignment %s:%i for segment %s",
       OMF_SEGDEF_ALIGN[seg->attrib.align], seg->attrib.align,
       xlink_segment_get_name(seg)));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
shrb $0x5, %al
movzbl %al, %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x2847
movq -0x18(%rbp), %rax
leaq 0xb7ff(%rip), %rcx      # 0xe010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x28a2
movl $0x1, -0x4(%rbp)
jmp 0x28a2
movl $0x2, -0x4(%rbp)
jmp 0x28a2
movl $0x4, -0x4(%rbp)
jmp 0x28a2
movl $0xc, -0x4(%rbp)
jmp 0x28a2
jmp 0x2849
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
shrb $0x5, %al
movzbl %al, %eax
movl %eax, %ecx
leaq 0x147b1(%rip), %rax     # 0x17010
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
shrb $0x5, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2760
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq %rax, %rcx
leaq 0xbf14(%rip), %rdi      # 0xe7a5
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_reloc_get_addend
const char *xlink_reloc_get_addend(xlink_reloc *rel) {
  static char str[256];
  switch (rel->location) {
    case OMF_LOCATION_8BIT :
    case OMF_LOCATION_8BIT_HIGH : {
      sprintf(str, "0x%02x", (uint8_t)rel->addend.offset);
      break;
    }
    case OMF_LOCATION_16BIT :
    case OMF_LOCATION_SEGMENT :
    case OMF_LOCATION_16BIT_LOADER : {
      sprintf(str, "0x%04x", (uint16_t)rel->addend.offset);
      break;
    }
    case OMF_LOCATION_32BIT :
    case OMF_LOCATION_32BIT_LOADER : {
      sprintf(str, "0x%08x", (uint32_t)rel->addend.offset);
      break;
    }
    case OMF_LOCATION_FAR :
    case OMF_LOCATION_48BIT :
    case OMF_LOCATION_48BIT_PHARLAP : {
      sprintf(str, "0x%04x:0x%08x", (uint16_t)rel->addend.segment,
       (uint32_t)rel->addend.offset);
      break;
    }
    default : {
      XLINK_ERROR(1, ("Unsupported location %i", rel->location));
    }
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0xd, %rax
ja 0x2bfe
movq -0x10(%rbp), %rax
leaq 0xb4b8(%rip), %rcx      # 0xe024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movzbl %al, %edx
leaq 0x149ba(%rip), %rdi     # 0x17540
leaq 0xbc6b(%rip), %rsi      # 0xe7f8
movb $0x0, %al
callq 0x21b0
jmp 0x2c1f
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movzwl %ax, %edx
leaq 0x14996(%rip), %rdi     # 0x17540
leaq 0xbc4e(%rip), %rsi      # 0xe7ff
movb $0x0, %al
callq 0x21b0
jmp 0x2c1f
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %edx
leaq 0x14978(%rip), %rdi     # 0x17540
leaq 0xbc3e(%rip), %rsi      # 0xe80d
movb $0x0, %al
callq 0x21b0
jmp 0x2c1f
movq -0x8(%rbp), %rax
movzwl 0x38(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
leaq 0x14952(%rip), %rdi     # 0x17540
leaq 0xbc11(%rip), %rsi      # 0xe806
movb $0x0, %al
callq 0x21b0
jmp 0x2c1f
jmp 0x2c00
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0xbc06(%rip), %rdi      # 0xe814
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
leaq 0x1491a(%rip), %rax     # 0x17540
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_library_clear
void xlink_library_clear(xlink_library *lib) {
  int i;
  for (i = 0; i < lib->nmodules; i++) {
    xlink_module_clear(lib->modules[i]);
    free(lib->modules[i]);
  }
  free(lib->modules);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x2ef4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2c30
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2eb3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_clear
void xlink_binary_clear(xlink_binary *bin) {
  int i;
  for (i = 0; i < bin->nmodules; i++) {
    xlink_module_clear(bin->modules[i]);
    free(bin->modules[i]);
  }
  for (i = 0; i < bin->nlibrarys; i++) {
    xlink_library_clear(bin->librarys[i]);
    free(bin->librarys[i]);
  }
  free(bin->modules);
  free(bin->librarys);
  free(bin->segments);
  free(bin->externs);
  memset(bin, 0, sizeof(xlink_binary));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x2fa4
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2c30
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f63
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x2fec
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2ea0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2fab
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_add_record
int xlink_omf_add_record(xlink_omf *omf, xlink_omf_record *rec) {
  XLINK_ERROR(
   omf->nrecords == 0 && rec->type != OMF_THEADR && rec->type != OMF_LHEADR,
   ("%s not the first record in module", xlink_omf_record_get_name(rec->type)));
  omf->nrecords++;
  omf->records =
   xlink_realloc(omf->records, omf->nrecords*sizeof(xlink_omf_record));
  omf->records[omf->nrecords - 1] = *rec;
  return omf->nrecords;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x30a0
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %eax
cmpl $0x80, %eax
je 0x30a0
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %eax
cmpl $0x82, %eax
je 0x30a0
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %edi
callq 0x3110
movq %rax, %rsi
leaq 0xb7a3(%rip), %rdi      # 0xe832
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x30a2
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
shlq $0x4, %rsi
callq 0xaed0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_get_name
static const char *xlink_omf_record_get_name(xlink_omf_record_type type) {
  switch (type & ~1) {
    case OMF_THEADR : return "THEADR";
    case OMF_LHEADR : return "LHEADR";
    case OMF_MODEND : return "MODEND";
    case OMF_EXTDEF : return "EXTDEF";
    case OMF_PUBDEF : return "PUBDEF";
    case OMF_FIXUPP : return "FIXUPP";
    case OMF_GRPDEF : return "GRPDEF";
    case OMF_LNAMES : return "LNAMES";
    case OMF_SEGDEF : return "SEGDEF";
    case OMF_LEDATA : return "LEDATA";
    case OMF_LIDATA : return "LIDATA";
    case OMF_COMDEF : return "COMDEF";
    case OMF_LEXTDEF : return "LEXTDEF";
    case OMF_LPUBDEF : return "LPUBDEF";
    case OMF_CEXTDEF : return "CEXTDEF";
    case OMF_COMDAT : return "COMDAT";
    case OMF_LLNAMES : return "LLNAMES";
    default : return "??????";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $-0x2, %eax
addl $-0x80, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4a, %eax
ja 0x3238
movq -0x18(%rbp), %rax
leaq 0xaf22(%rip), %rcx      # 0xe05c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc7a3(%rip), %rax      # 0xf8ed
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc79a(%rip), %rax      # 0xf8f4
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc791(%rip), %rax      # 0xf8fb
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc7c3(%rip), %rax      # 0xf93d
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc7ab(%rip), %rax      # 0xf935
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc768(%rip), %rax      # 0xf902
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc75f(%rip), %rax      # 0xf909
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc792(%rip), %rax      # 0xf94c
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc746(%rip), %rax      # 0xf910
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc740(%rip), %rax      # 0xf917
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc73a(%rip), %rax      # 0xf91e
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc734(%rip), %rax      # 0xf925
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc72e(%rip), %rax      # 0xf92c
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc729(%rip), %rax      # 0xf934
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc724(%rip), %rax      # 0xf93c
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc71f(%rip), %rax      # 0xf944
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc719(%rip), %rax      # 0xf94b
movq %rax, -0x8(%rbp)
jmp 0x3243
leaq 0xc714(%rip), %rax      # 0xf953
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_module_find_segment
xlink_segment *xlink_module_find_segment(xlink_module *mod, const char *name) {
  xlink_segment *ret;
  int i;
  ret = NULL;
  for (i = 1; i <= mod->nsegments; i++) {
    xlink_segment *seg;
    seg = xlink_module_get_segment(mod, i);
    if (strcmp(name, seg->name->str) == 0) {
      XLINK_ERROR(ret != NULL,
       ("Duplicate segment definition found for name %s in %s", name,
       mod->filename));
      ret = seg;
    }
  }
  XLINK_ERROR(ret == NULL,
   ("Could not find segment definition %s in %s", name, mod->filename));
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x130(%rcx), %eax
jg 0x3c8b
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3440
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x10, %rsi
callq 0x20d0
cmpl $0x0, %eax
jne 0x3c7e
jmp 0x3c4a
cmpq $0x0, -0x18(%rbp)
je 0x3c74
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xac5d(%rip), %rdi      # 0xe8c0
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x3c76
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3c80
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c0f
jmp 0x3c8d
cmpq $0x0, -0x18(%rbp)
jne 0x3cb7
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xac4f(%rip), %rdi      # 0xe8f5
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x3cb9
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_module_find_public
xlink_public *xlink_module_find_public(xlink_module *mod, const char *symb) {
  xlink_public *ret;
  int i;
  ret = NULL;
  for (i = 1; i <= mod->npublics; i++) {
    xlink_public *pub;
    pub = xlink_module_get_public(mod, i);
    /* TODO: Why was this check added? */
    if (/*pub->is_local &&*/ strcmp(symb, pub->name) == 0) {
      XLINK_ERROR(ret != NULL,
       ("Duplicate local public definition found for symbol %s in %s", symb,
       mod->filename));
      ret = pub;
    }
  }
  XLINK_ERROR(ret == NULL,
   ("Could not find local public definition %s in %s", symb, mod->filename));
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x150(%rcx), %eax
jg 0x3d67
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3700
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x24, %rsi
callq 0x20d0
cmpl $0x0, %eax
jne 0x3d5a
jmp 0x3d26
cmpq $0x0, -0x18(%rbp)
je 0x3d50
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xabe1(%rip), %rdi      # 0xe920
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x3d52
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3d5c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3cef
jmp 0x3d69
cmpq $0x0, -0x18(%rbp)
jne 0x3d93
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xabda(%rip), %rdi      # 0xe95c
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x3d95
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_module_find_extern
xlink_extern *xlink_module_find_extern(xlink_module *mod, const char *name) {
  xlink_extern *ret;
  int i;
  ret = NULL;
  for (i = 1; i <= mod->nexterns; i++) {
    xlink_extern *ext;
    ext = xlink_module_get_extern(mod, i);
    if (!ext->is_local && strcmp(name, ext->name) == 0) {
      XLINK_ERROR(ret != NULL,
       ("Duplicate extern definition found for name %s in %s", name,
       mod->filename));
      ret = ext;
    }
  }
  XLINK_ERROR(ret == NULL,
   ("Could not find extern definition %s in %s", name, mod->filename));
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x160(%rcx), %eax
jg 0x3e47
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x39c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x114(%rax)
jne 0x3e37
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
callq 0x20d0
cmpl $0x0, %eax
jne 0x3e37
jmp 0x3e03
cmpq $0x0, -0x18(%rbp)
je 0x3e2d
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xab70(%rip), %rdi      # 0xe98c
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x3e2f
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3e39
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3dbf
jmp 0x3e49
cmpq $0x0, -0x18(%rbp)
jne 0x3e73
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xab5e(%rip), %rdi      # 0xe9c0
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x3e75
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_process_segment
void xlink_binary_process_segment(xlink_binary *bin, xlink_segment *segment) {
  int i;
  if (xlink_binary_has_segment(bin, segment)) {
    return;
  }
  xlink_binary_add_segment(bin, segment);
  for (i = 1; i <= segment->nrelocs; i++) {
    xlink_reloc *rel;
    rel = xlink_segment_get_reloc(segment, i);
    switch (rel->target) {
      case OMF_TARGET_EXT : {
        xlink_extern *ext;
        ext = xlink_module_get_extern(segment->module, rel->target_idx);
        if (!xlink_binary_has_extern(bin, ext)) {
          xlink_binary_add_extern(bin, ext);
        }
        break;
      }
      case OMF_TARGET_SEG : {
        xlink_segment *seg;
        seg = xlink_module_get_segment(segment->module, rel->target_idx);
        xlink_binary_process_segment(bin, seg);
        break;
      }
      default : {
        XLINK_ERROR(1, ("Unsupported target T%i", rel->target));
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4510
cmpl $0x0, %eax
je 0x46c7
jmp 0x47a7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4440
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jg 0x47a7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2630
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x4, %eax
je 0x474f
jmp 0x470c
movl -0x34(%rbp), %eax
subl $0x6, %eax
jne 0x4776
jmp 0x4716
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x39c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4640
cmpl $0x0, %eax
jne 0x474d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4570
jmp 0x4797
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x3440
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x46a0
jmp 0x4797
jmp 0x4778
movq -0x20(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0xa313(%rip), %rdi      # 0xea99
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x4799
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x46db
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_read_dword
static uint32_t xlink_omf_record_read_dword(xlink_omf_record *rec) {
  uint32_t ret;
  ret = *(uint32_t *)(rec->buf + rec->idx);
  rec->idx += 4;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_read_word
static uint16_t xlink_omf_record_read_word(xlink_omf_record *rec) {
  uint16_t ret;
  ret = *(uint16_t *)(rec->buf + rec->idx);
  rec->idx += 2;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movw (%rax,%rcx), %ax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rax)
movw -0xa(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_read_length
unsigned int xlink_omf_record_read_length(xlink_omf_record *rec) {
  unsigned int length;
  length = xlink_omf_record_read_byte(rec);
  switch (length) {
    case 0x81 : {
      return xlink_omf_record_read_word(rec);
    }
    case 0x84 : {
      length = xlink_omf_record_read_word(rec);
      return (xlink_omf_record_read_byte(rec) << 16) | length;
    }
    case 0x88 : {
      return xlink_omf_record_read_dword(rec);
    }
    default : {
      XLINK_ERROR(length > 0x80, ("Invalid length %i", length));
      return length;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4cf0
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x81, %eax
je 0x4c72
jmp 0x4c5a
movl -0x18(%rbp), %eax
subl $0x84, %eax
je 0x4c83
jmp 0x4c66
movl -0x18(%rbp), %eax
subl $0x88, %eax
je 0x4ca9
jmp 0x4cb7
movq -0x10(%rbp), %rdi
callq 0x4bf0
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x4ce5
movq -0x10(%rbp), %rdi
callq 0x4bf0
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4cf0
movzbl %al, %eax
shll $0x10, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4ce5
movq -0x10(%rbp), %rdi
callq 0x4bc0
movl %eax, -0x4(%rbp)
jmp 0x4ce5
jmp 0x4cb9
cmpl $0x80, -0x14(%rbp)
jbe 0x4cdd
movl -0x14(%rbp), %esi
leaq 0x9e3f(%rip), %rdi      # 0xeb0b
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x4cdf
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_read_string
const char *xlink_omf_record_read_string(xlink_omf_record *rec) {
  static char str[256];
  int len = xlink_omf_record_read_byte(rec);
  if (len != 0) {
    memcpy(str, &rec->buf[rec->idx], len);
  }
  str[len] = '\0';
  rec->idx += len;
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4cf0
movzbl %al, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x4d63
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
leaq 0x128e2(%rip), %rdi     # 0x17640
callq 0x2100
movslq -0xc(%rbp), %rcx
leaq 0x128d2(%rip), %rax     # 0x17640
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
leaq 0x128ba(%rip), %rax     # 0x17640
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_read_lidata_block
unsigned int xlink_omf_record_read_lidata_block(xlink_omf_record *rec) {
  unsigned int repeat_count;
  unsigned int block_count;
  unsigned int size;
  repeat_count = xlink_omf_record_read_numeric(rec);
  block_count = xlink_omf_record_read_word(rec);
  printf("%i * ", repeat_count);
  if (block_count) {
    int i;
    printf("(");
    size = 0;
    for (i = 0; i < block_count; i++) {
      size += xlink_omf_record_read_lidata_block(rec);
      if (i > 0) printf(" + ");
    }
    printf(")");
  }
  else {
    size = xlink_omf_record_read_byte(rec);
    rec->idx += size;
    printf("%i", size);
  }
  return repeat_count * size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4b70
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4bf0
movzwl %ax, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
leaq 0x9d5c(%rip), %rdi      # 0xeb1d
movb $0x0, %al
callq 0x20a0
cmpl $0x0, -0x10(%rbp)
je 0x4e32
leaq 0x9d4e(%rip), %rdi      # 0xeb23
movb $0x0, %al
callq 0x20a0
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x4e22
movq -0x8(%rbp), %rdi
callq 0x4d90
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x4e15
leaq 0x9d17(%rip), %rdi      # 0xeb25
movb $0x0, %al
callq 0x20a0
jmp 0x4e17
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4dea
leaq 0xab5e(%rip), %rdi      # 0xf987
movb $0x0, %al
callq 0x20a0
jmp 0x4e5f
movq -0x8(%rbp), %rdi
callq 0x4cf0
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %esi
leaq 0xa3fd(%rip), %rdi      # 0xf255
movb $0x0, %al
callq 0x20a0
movl -0xc(%rbp), %eax
imull -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)