LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/stribob192r2/ssse3/stribob.c
// Function: sbob_get
void sbob_get(sbob_t *sb, sbob_pad_t pad, void *out, size_t len)
{
    int j;
    size_t i;

    j = sb->l;
    for (i = 0; i < len; i++) {
        if (j == SBOB_RATE) {
            sb->s.b[SBOB_RATE] ^= pad;
            SBOB_PI(&sb->s);
            j = 0;
        }
        ((uint8_t *) out)[i] = sb->s.b[j++];
    }
    sb->l = j;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x167c
cmpl $0x20, 0x14(%rsp)
jne 0x1647
movzbl 0x2f(%rsp), %edx
movq 0x30(%rsp), %rax
movzbl 0x20(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x20(%rax)
movq 0x30(%rsp), %rdi
callq 0x1080
movl $0x0, 0x14(%rsp)
movq 0x30(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x14(%rsp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x160f
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x40(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/stribob192r2/ssse3/stribob.c
// Function: sbob_cmp
int sbob_cmp(sbob_t *sb, sbob_pad_t pad, const void *in, size_t len)
{
    int j, d;
    size_t i;

    j = sb->l;
    d = 0;
    for (i = 0; i < len; i++) {
        if (j == SBOB_RATE) {
            sb->s.b[SBOB_RATE] ^= pad;
            SBOB_PI(&sb->s);
            j = 0;
        }
        if (d == 0)
            d = ((int) ((const uint8_t *) in)[i]) - ((int) sb->s.b[j]);
        j++;
    }
    sb->l = j;

    return d;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x1743
cmpl $0x20, 0x14(%rsp)
jne 0x16ff
movzbl 0x2f(%rsp), %edx
movq 0x30(%rsp), %rax
movzbl 0x20(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x20(%rax)
movq 0x30(%rsp), %rdi
callq 0x1080
movl $0x0, 0x14(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x1728
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movslq 0x14(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x16c7
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x40(%rax)
movl 0x10(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/stribob192r2/ssse3/stribob.c
// Function: sbob_enc
void sbob_enc(sbob_t *sb, sbob_pad_t pad,
    void *out, const void *in, size_t len)
{
    int j;
    size_t i;

    j = sb->l;
    for (i = 0; i < len; i++) {
        if (j == SBOB_RATE) {
            sb->s.b[SBOB_RATE] ^= pad;
            SBOB_PI(&sb->s);
            j = 0;
        }
        sb->s.b[j] ^= ((const uint8_t *) in)[i];
        ((uint8_t *) out)[i] = sb->s.b[j++];
    }
    sb->l = j;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0xc(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x1823
cmpl $0x20, 0xc(%rsp)
jne 0x17ce
movzbl 0x2f(%rsp), %edx
movq 0x30(%rsp), %rax
movzbl 0x20(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x20(%rax)
movq 0x30(%rsp), %rdi
callq 0x1080
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %esi
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x30(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xc(%rsp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1793
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x40(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_finish_test_line_
static void
acutest_finish_test_line_(int result)
{
    if(acutest_tap_) {
        const char* str = (result == 0) ? "ok" : "not ok";

        printf("%s %d - %s\n", str, acutest_current_index_ + 1, acutest_current_test_->name);

        if(result == 0  &&  acutest_timer_) {
            printf("# Duration: ");
            acutest_timer_print_diff_();
            printf("\n");
        }
    } else {
        int color = (result == 0) ? ACUTEST_COLOR_GREEN_INTENSIVE_ : ACUTEST_COLOR_RED_INTENSIVE_;
        const char* str = (result == 0) ? "OK" : "FAILED";
        printf("[ ");
        acutest_colored_printf_(color, "%s", str);
        printf(" ]");

        if(result == 0  &&  acutest_timer_) {
            printf("  ");
            acutest_timer_print_diff_();
        }

        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x9cfe(%rip)      # 0xc2c0
je 0x263a
movl -0x4(%rbp), %edx
leaq 0x601a(%rip), %rax      # 0x85e8
leaq 0x6017(%rip), %rcx      # 0x85ec
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl 0x9cfe(%rip), %edx      # 0xc2e8
addl $0x1, %edx
movq 0x9b74(%rip), %rax      # 0xc168
movq (%rax), %rcx
leaq 0x5ff1(%rip), %rdi      # 0x85ef
movb $0x0, %al
callq 0x20d0
cmpl $0x0, -0x4(%rbp)
jne 0x2635
cmpl $0x0, 0x9cda(%rip)      # 0xc2ec
je 0x2635
leaq 0x5fe0(%rip), %rdi      # 0x85fb
movb $0x0, %al
callq 0x20d0
callq 0x5280
leaq 0x619b(%rip), %rdi      # 0x87c9
movb $0x0, %al
callq 0x20d0
jmp 0x26cd
movl -0x4(%rbp), %edx
movl $0x5, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edx
leaq 0x5fb1(%rip), %rax      # 0x860b
leaq 0x5fa7(%rip), %rcx      # 0x8608
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq 0x5f9f(%rip), %rdi      # 0x8612
movb $0x0, %al
callq 0x20d0
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rdx
leaq 0x5fce(%rip), %rsi      # 0x8656
movb $0x0, %al
callq 0x2760
leaq 0x5f7f(%rip), %rdi      # 0x8615
movb $0x0, %al
callq 0x20d0
cmpl $0x0, -0x4(%rbp)
jne 0x26bf
cmpl $0x0, 0x9c42(%rip)      # 0xc2ec
je 0x26bf
leaq 0x5a29(%rip), %rdi      # 0x80dc
movb $0x0, %al
callq 0x20d0
callq 0x5280
leaq 0x6103(%rip), %rdi      # 0x87c9
movb $0x0, %al
callq 0x20d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_line_indent_
static void
acutest_line_indent_(int level)
{
    static const char spaces[] = "                ";
    int n = level * 2;

    if(acutest_tap_  &&  n > 0) {
        n--;
        printf("#");
    }

    while(n > 16) {
        printf("%s", spaces);
        n -= 16;
    }
    printf("%.*s", n, spaces);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, 0x9bc6(%rip)      # 0xc2c0
je 0x2719
cmpl $0x0, -0x8(%rbp)
jle 0x2719
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
leaq 0x5f11(%rip), %rdi      # 0x8623
movb $0x0, %al
callq 0x20d0
jmp 0x271b
cmpl $0x10, -0x8(%rbp)
jle 0x2741
leaq 0x5f2e(%rip), %rdi      # 0x8656
leaq 0x5941(%rip), %rsi      # 0x8070
movb $0x0, %al
callq 0x20d0
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x8(%rbp)
jmp 0x271b
movl -0x8(%rbp), %esi
leaq 0x5eda(%rip), %rdi      # 0x8625
leaq 0x591e(%rip), %rdx      # 0x8070
movb $0x0, %al
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_case_
acutest_case_(const char* fmt, ...)
{
    va_list args;

    if(acutest_verbose_level_ < 2)
        return;

    if(acutest_case_name_[0]) {
        acutest_case_already_logged_ = 0;
        acutest_case_name_[0] = '\0';
    }

    if(fmt == NULL)
        return;

    va_start(args, fmt);
    vsnprintf(acutest_case_name_, sizeof(acutest_case_name_) - 1, fmt, args);
    va_end(args);
    acutest_case_name_[sizeof(acutest_case_name_) - 1] = '\0';

    if(acutest_verbose_level_ >= 3) {
        acutest_line_indent_(1);
        acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Case %s:\n", acutest_case_name_);
        acutest_test_already_logged_++;
        acutest_case_already_logged_++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2945
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0x97d5(%rip)      # 0xc148
jge 0x297a
jmp 0x2a33
cmpb $0x0, 0x97ff(%rip)      # 0xc180
je 0x2994
movl $0x0, 0x97e7(%rip)      # 0xc174
movb $0x0, 0x97ec(%rip)      # 0xc180
cmpq $0x0, -0x8(%rbp)
jne 0x29a0
jmp 0x2a33
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq 0x97ad(%rip), %rdi      # 0xc180
movl $0x3f, %esi
callq 0x2080
leaq -0x20(%rbp), %rax
movb $0x0, 0x97d7(%rip)      # 0xc1bf
cmpl $0x3, 0x9759(%rip)      # 0xc148
jl 0x2a33
movl $0x1, %edi
callq 0x26e0
movl $0x3, %edi
leaq 0x56a8(%rip), %rsi      # 0x80af
leaq 0x9772(%rip), %rdx      # 0xc180
movb $0x0, %al
callq 0x2760
movl 0x9745(%rip), %eax      # 0xc160
addl $0x1, %eax
movl %eax, 0x973c(%rip)      # 0xc160
movl 0x974a(%rip), %eax      # 0xc174
addl $0x1, %eax
movl %eax, 0x9741(%rip)      # 0xc174
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_message_
acutest_message_(const char* fmt, ...)
{
    char buffer[TEST_MSG_MAXSIZE];
    char* line_beg;
    char* line_end;
    va_list args;

    if(acutest_verbose_level_ < 2)
        return;

    /* We allow extra message only when something is already wrong in the
     * current test. */
    if(acutest_current_test_ == NULL  ||  !acutest_cond_failed_)
        return;

    va_start(args, fmt);
    vsnprintf(buffer, TEST_MSG_MAXSIZE, fmt, args);
    va_end(args);
    buffer[TEST_MSG_MAXSIZE-1] = '\0';

    line_beg = buffer;
    while(1) {
        line_end = strchr(line_beg, '\n');
        if(line_end == NULL)
            break;
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%.*s\n", (int)(line_end - line_beg), line_beg);
        line_beg = line_end + 1;
    }
    if(line_beg[0] != '\0') {
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%s\n", line_beg);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
testb %al, %al
je 0x2a87
movaps %xmm0, -0x4c0(%rbp)
movaps %xmm1, -0x4b0(%rbp)
movaps %xmm2, -0x4a0(%rbp)
movaps %xmm3, -0x490(%rbp)
movaps %xmm4, -0x480(%rbp)
movaps %xmm5, -0x470(%rbp)
movaps %xmm6, -0x460(%rbp)
movaps %xmm7, -0x450(%rbp)
movq %r9, -0x4c8(%rbp)
movq %r8, -0x4d0(%rbp)
movq %rcx, -0x4d8(%rbp)
movq %rdx, -0x4e0(%rbp)
movq %rsi, -0x4e8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0x9693(%rip)      # 0xc148
jge 0x2abc
jmp 0x2bec
cmpq $0x0, 0x96a4(%rip)      # 0xc168
je 0x2acf
cmpl $0x0, 0x96f3(%rip)      # 0xc1c0
jne 0x2ad4
jmp 0x2bec
leaq -0x440(%rbp), %rax
leaq -0x4f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x440(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x2080
leaq -0x440(%rbp), %rax
movb $0x0, -0x11(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rdi
movl $0xa, %esi
callq 0x20c0
movq %rax, -0x420(%rbp)
cmpq $0x0, -0x420(%rbp)
jne 0x2b54
jmp 0x2bac
movsbl 0x9625(%rip), %ecx      # 0xc180
movl $0x2, %edi
movl $0x3, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x26e0
movq -0x420(%rbp), %rax
movq -0x418(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
movq -0x418(%rbp), %rdx
leaq 0x5536(%rip), %rdi      # 0x80c7
movb $0x0, %al
callq 0x20d0
movq -0x420(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x418(%rbp)
jmp 0x2b30
movq -0x418(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2bec
movsbl 0x95be(%rip), %ecx      # 0xc180
movl $0x2, %edi
movl $0x3, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x26e0
movq -0x418(%rbp), %rsi
leaq 0x5cb5(%rip), %rdi      # 0x889a
movb $0x0, %al
callq 0x20d0
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_abort_
void
acutest_abort_(void)
{
    if(acutest_abort_has_jmp_buf_) {
        longjmp(acutest_abort_jmp_buf_, 1);
    } else {
        if(acutest_current_test_ != NULL)
            acutest_fini_(acutest_current_test_->name);
        abort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x9369(%rip)      # 0xc1c4
je 0x2e6e
leaq 0x936c(%rip), %rdi      # 0xc1d0
movl $0x1, %esi
callq 0x21b0
cmpq $0x0, 0x92f2(%rip)      # 0xc168
je 0x2e87
movq 0x92e9(%rip), %rax      # 0xc168
movq (%rax), %rdi
callq 0x2e90
callq 0x2030
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_timer_init_
static void
    acutest_timer_init_(void)
    {
        if(acutest_timer_ == 1)
            acutest_timer_id_ = CLOCK_MONOTONIC;
        else if(acutest_timer_ == 2)
            acutest_timer_id_ = CLOCK_PROCESS_CPUTIME_ID;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0x8471(%rip)      # 0xc2ec
jne 0x3e89
movl $0x1, 0x8489(%rip)      # 0xc310
jmp 0x3e9e
cmpl $0x2, 0x845c(%rip)      # 0xc2ec
jne 0x3e9c
movl $0x2, 0x8474(%rip)      # 0xc310
jmp 0x3e9e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_remember_
static void
acutest_remember_(int i)
{
    if(acutest_test_data_[i].flags & ACUTEST_FLAG_RUN_)
        return;

    acutest_test_data_[i].flags |= ACUTEST_FLAG_RUN_;
    acutest_count_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x8402(%rip), %rax      # 0xc2b0
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3ec6
jmp 0x3ef2
movq 0x83e3(%rip), %rax      # 0xc2b0
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl (%rax), %ecx
orl $0x1, %ecx
movb %cl, (%rax)
movq 0x83d1(%rip), %rax      # 0xc2b8
addq $0x1, %rax
movq %rax, 0x83c6(%rip)      # 0xc2b8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_is_tracer_present_
static int
acutest_is_tracer_present_(void)
{
    /* Must be large enough so the line 'TracerPid: ${PID}' can fit in. */
    static const int OVERLAP = 32;

    char buf[512];
    int tracer_present = 0;
    int fd;
    size_t n_read = 0;

    fd = open("/proc/self/status", O_RDONLY);
    if(fd == -1)
        return 0;

    while(1) {
        static const char pattern[] = "TracerPid:";
        const char* field;

        while(n_read < sizeof(buf) - 1) {
            ssize_t n;

            n = read(fd, buf + n_read, sizeof(buf) - 1 - n_read);
            if(n <= 0)
                break;
            n_read += n;
        }
        buf[n_read] = '\0';

        field = strstr(buf, pattern);
        if(field != NULL  &&  field < buf + sizeof(buf) - OVERLAP) {
            pid_t tracer_pid = (pid_t) atoi(field + sizeof(pattern) - 1);
            tracer_present = (tracer_pid != 0);
            break;
        }

        if(n_read == sizeof(buf) - 1) {
            /* Move the tail with the potentially incomplete line we're looking
             * for to the beginning of the buffer. */
            memmove(buf, buf + sizeof(buf) - 1 - OVERLAP, OVERLAP);
            n_read = OVERLAP;
        } else {
            break;
        }
    }

    close(fd);
    return tracer_present;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl $0x0, -0x214(%rbp)
movq $0x0, -0x220(%rbp)
leaq 0x4f9a(%rip), %rdi      # 0x8ec1
xorl %esi, %esi
movb $0x0, %al
callq 0x21d0
movl %eax, -0x218(%rbp)
cmpl $-0x1, -0x218(%rbp)
jne 0x3f4b
movl $0x0, -0x4(%rbp)
jmp 0x408d
jmp 0x3f4d
jmp 0x3f4f
cmpq $0x1ff, -0x220(%rbp) # imm = 0x1FF
jae 0x3fab
movl -0x218(%rbp), %edi
leaq -0x210(%rbp), %rsi
addq -0x220(%rbp), %rsi
movl $0x1ff, %edx            # imm = 0x1FF
subq -0x220(%rbp), %rdx
callq 0x2120
movq %rax, -0x230(%rbp)
cmpq $0x0, -0x230(%rbp)
jg 0x3f94
jmp 0x3fab
movq -0x230(%rbp), %rax
addq -0x220(%rbp), %rax
movq %rax, -0x220(%rbp)
jmp 0x3f4f
movq -0x220(%rbp), %rax
movb $0x0, -0x210(%rbp,%rax)
leaq -0x210(%rbp), %rdi
leaq 0x40c8(%rip), %rsi      # 0x8090
callq 0x2240
movq %rax, -0x228(%rbp)
cmpq $0x0, -0x228(%rbp)
je 0x402d
movq -0x228(%rbp), %rax
leaq -0x210(%rbp), %rcx
addq $0x200, %rcx            # imm = 0x200
addq $-0x20, %rcx
cmpq %rcx, %rax
jae 0x402d
movq -0x228(%rbp), %rdi
addq $0xb, %rdi
addq $-0x1, %rdi
callq 0x21f0
movl %eax, -0x234(%rbp)
cmpl $0x0, -0x234(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x214(%rbp)
jmp 0x4079
cmpq $0x1ff, -0x220(%rbp) # imm = 0x1FF
jne 0x4072
leaq -0x210(%rbp), %rax
leaq -0x210(%rbp), %rcx
addq $0x200, %rcx            # imm = 0x200
addq $-0x1, %rcx
addq $-0x20, %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x20, -0x220(%rbp)
jmp 0x4074
jmp 0x4079
jmp 0x3f4d
movl -0x218(%rbp), %edi
callq 0x2110
movl -0x214(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTSet_test.c
// Function: insert_and_test
void insert_and_test(Set set, int* value) {

	set_insert(set, value);
	TEST_ASSERT(set_is_proper(set));
	int search = *value;
	TEST_ASSERT(set_find(set, &search) == value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x63f0
movq -0x8(%rbp), %rdi
callq 0x6a00
andb $0x1, %al
movzbl %al, %edi
leaq 0x3ebf(%rip), %rsi      # 0x82e1
movl $0x26, %edx
leaq 0x4228(%rip), %rcx      # 0x8656
leaq 0x3eba(%rip), %r8       # 0x82ef
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4446
callq 0x2e50
jmp 0x4448
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5e20
cmpq -0x10(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x3e70(%rip), %rsi      # 0x82e1
movl $0x28, %edx
leaq 0x41d9(%rip), %rcx      # 0x8656
leaq 0x3e7e(%rip), %r8       # 0x8302
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4495
callq 0x2e50
jmp 0x4497
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTSet_test.c
// Function: shuffle
void shuffle(int** array, int n) {
	for (int i = 0; i < n; i++) {
		int j = i + rand() / (RAND_MAX / (n - i) + 1);
		int* t = array[j];
		array[j] = array[i];
		array[i] = t;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4532
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x2250
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl $0x1, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x44b6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTSet_test.c
// Function: test_create
void test_create(void) {

	// Δημιουργούμε ένα κενό set (χωρίς συνάρτηση αποδεύσμευσης)
	Set set = set_create(compare_ints, NULL);
	set_set_destroy_value(set, NULL);

	TEST_ASSERT(set != NULL);
	TEST_ASSERT(set_size(set) == 0);

	set_destroy(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x17f(%rip), %rdi      # 0x43d0
xorl %eax, %eax
movl %eax, %esi
callq 0x5d80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x69d0
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x3d64(%rip), %rsi      # 0x82e1
movl $0x3f, %edx
leaq 0x40cd(%rip), %rcx      # 0x8656
leaq 0x3d92(%rip), %r8       # 0x8322
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x45a1
callq 0x2e50
jmp 0x45a3
jmp 0x45a5
movq -0x8(%rbp), %rdi
callq 0x5e00
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x3d21(%rip), %rsi      # 0x82e1
movl $0x40, %edx
leaq 0x408a(%rip), %rcx      # 0x8656
leaq 0x3d5b(%rip), %r8       # 0x832e
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x45e4
callq 0x2e50
jmp 0x45e6
movq -0x8(%rbp), %rdi
callq 0x6230
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTSet_test.c
// Function: test_insert
void test_insert(void) {

	Set set = set_create(compare_ints, free);

	int N = 1000;

	int** value_array = malloc(N * sizeof(*value_array));

	// Δοκιμάζουμε την insert με νέες τιμές κάθε φορά και με αυτόματο free
	for (int i = 0; i < N; i++) {
		
		value_array[i] = create_int(i);

		insert_and_test(set, value_array[i]);

		TEST_ASSERT(set_size(set) == (i + 1));

	}

	// Δοκιμάζουμε την insert με τιμές που υπάρχουν ήδη στο Set
	// και ελέγχουμε ότι δεν ενημερώθηκε το size (καθώς δεν προστέθηκε νέος κόμβος)
	int* new_value = create_int(0);
	insert_and_test(set, new_value);

	TEST_ASSERT(set_size(set) == N);

	set_destroy(set);

	// Δοκιμάζουμε την insert χωρίς αυτόματο free
	Set set2 = set_create(compare_ints, NULL);
	
	int local_value1 = 0, local_value2 = 1, local_value3 = 1;

	insert_and_test(set2, &local_value1);
	insert_and_test(set2, &local_value2);
	insert_and_test(set2, &local_value3);		// ισοδύναμη τιμή => replace
	
	set_destroy(set2);
	free(value_array);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x23f(%rip), %rdi      # 0x43d0
movq 0x79aa(%rip), %rsi      # 0xbfc0
callq 0x5d80
movq %rax, -0x8(%rbp)
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x46cc
movl -0x1c(%rbp), %edi
callq 0x43a0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x43f0
movq -0x8(%rbp), %rdi
callq 0x5e00
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x3c4b(%rip), %rsi      # 0x82e1
movl $0x54, %edx
leaq 0x3fb4(%rip), %rcx      # 0x8656
leaq 0x3c98(%rip), %r8       # 0x8341
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x46ba
callq 0x2e50
jmp 0x46bc
jmp 0x46be
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x463e
xorl %edi, %edi
callq 0x43a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x43f0
movq -0x8(%rbp), %rdi
callq 0x5e00
cmpl -0xc(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x3be2(%rip), %rsi      # 0x82e1
movl $0x5d, %edx
leaq 0x3f4b(%rip), %rcx      # 0x8656
leaq 0x3c48(%rip), %r8       # 0x835a
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4723
callq 0x2e50
jmp 0x4725
movq -0x8(%rbp), %rdi
callq 0x6230
leaq -0x365(%rip), %rdi      # 0x43d0
xorl %eax, %eax
movl %eax, %esi
callq 0x5d80
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x43f0
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x43f0
movq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x43f0
movq -0x30(%rbp), %rdi
callq 0x6230
movq -0x18(%rbp), %rdi
callq 0x2270
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_timer_diff_
static double
    acutest_timer_diff_(struct timespec start, struct timespec end)
    {
        double endns;
        double startns;

        endns = end.tv_sec;
        endns *= 1e9;
        endns += end.tv_nsec;

        startns = start.tv_sec;
        startns *= 1e9;
        startns += start.tv_nsec;

        return ((endns - startns)/ 1e9);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
cvtsi2sdq -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x2db9(%rip), %xmm0     # 0x80a0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdq -0x18(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdq -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x2d8c(%rip), %xmm0     # 0x80a0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdq -0x8(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd 0x2d60(%rip), %xmm1     # 0x80a0
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_cmdline_handle_short_opt_group_
static int
acutest_cmdline_handle_short_opt_group_(const ACUTEST_CMDLINE_OPTION_* options,
                    const char* arggroup,
                    int (*callback)(int /*optval*/, const char* /*arg*/))
{
    const ACUTEST_CMDLINE_OPTION_* opt;
    int i;
    int ret = 0;

    for(i = 0; arggroup[i] != '\0'; i++) {
        for(opt = options; opt->id != 0; opt++) {
            if(arggroup[i] == opt->shortname)
                break;
        }

        if(opt->id != 0  &&  !(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_)) {
            ret = callback(opt->id, NULL);
        } else {
            /* Unknown option. */
            char badoptname[3];
            badoptname[0] = '-';
            badoptname[1] = arggroup[i];
            badoptname[2] = '\0';
            ret = callback((opt->id != 0 ? ACUTEST_CMDLINE_OPTID_MISSINGARG_ : ACUTEST_CMDLINE_OPTID_UNKNOWN_),
                            badoptname);
        }

        if(ret != 0)
            break;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5443
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x53c2
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x53b2
jmp 0x53c2
jmp 0x53b4
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x538f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x53f1
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x53f1
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %edi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl %eax, -0x28(%rbp)
jmp 0x542b
movb $0x2d, -0x2b(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %edx
movl $0x80000001, %edi       # imm = 0x80000001
movl $0x80000002, %ecx       # imm = 0x80000002
cmpl $0x0, %edx
cmovnel %ecx, %edi
leaq -0x2b(%rbp), %rsi
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x5433
jmp 0x5443
jmp 0x5435
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5372
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_list_names_
static void
acutest_list_names_(void)
{
    const struct acutest_test_* test;

    printf("Unit tests:\n");
    for(test = &acutest_list_[0]; test->func != NULL; test++)
        printf("  %s\n", test->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x342c(%rip), %rdi      # 0x888b
movb $0x0, %al
callq 0x20d0
leaq 0x68f3(%rip), %rax      # 0xbd60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x549f
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x340e(%rip), %rdi      # 0x8898
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x5471
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_lookup_
static int
acutest_lookup_(const char* pattern)
{
    int i;
    int n = 0;

    /* Try exact match. */
    for(i = 0; i < (int) acutest_list_size_; i++) {
        if(strcmp(acutest_list_[i].name, pattern) == 0) {
            acutest_remember_(i);
            n++;
            break;
        }
    }
    if(n > 0)
        return n;

    /* Try word match. */
    for(i = 0; i < (int) acutest_list_size_; i++) {
        if(acutest_name_contains_word_(acutest_list_[i].name, pattern)) {
            acutest_remember_(i);
            n++;
        }
    }
    if(n > 0)
        return n;

    /* Try relaxed match. */
    for(i = 0; i < (int) acutest_list_size_; i++) {
        if(strstr(acutest_list_[i].name, pattern) != NULL) {
            acutest_remember_(i);
            n++;
        }
    }

    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x6c04(%rip), %rcx      # 0xc2a8
cmpl %ecx, %eax
jge 0x56eb
movslq -0x14(%rbp), %rcx
leaq 0x66ad(%rip), %rax      # 0xbd60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
cmpl $0x0, %eax
jne 0x56de
movl -0x14(%rbp), %edi
callq 0x3ea0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x56eb
jmp 0x56e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x569a
cmpl $0x0, -0x18(%rbp)
jle 0x56fc
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x57bd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x6b9b(%rip), %rcx      # 0xc2a8
cmpl %ecx, %eax
jge 0x5752
movslq -0x14(%rbp), %rcx
leaq 0x6644(%rip), %rax      # 0xbd60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x57d0
cmpl $0x0, %eax
je 0x5745
movl -0x14(%rbp), %edi
callq 0x3ea0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5747
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5703
cmpl $0x0, -0x18(%rbp)
jle 0x5760
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x57bd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x6b37(%rip), %rcx      # 0xc2a8
cmpl %ecx, %eax
jge 0x57b7
movslq -0x14(%rbp), %rcx
leaq 0x65e0(%rip), %rax      # 0xbd60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2240
cmpq $0x0, %rax
je 0x57aa
movl -0x14(%rbp), %edi
callq 0x3ea0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x57ac
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5767
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_name_contains_word_
static int
acutest_name_contains_word_(const char* name, const char* pattern)
{
    static const char word_delim[] = " \t-_/.,:;";
    const char* substr;
    size_t pattern_len;

    pattern_len = strlen(pattern);

    substr = strstr(name, pattern);
    while(substr != NULL) {
        int starts_on_word_boundary = (substr == name || strchr(word_delim, substr[-1]) != NULL);
        int ends_on_word_boundary = (substr[pattern_len] == '\0' || strchr(word_delim, substr[pattern_len]) != NULL);

        if(starts_on_word_boundary && ends_on_word_boundary)
            return 1;

        substr = strstr(substr+1, pattern);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2240
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x58b3
movq -0x20(%rbp), %rcx
movb $0x1, %al
cmpq -0x10(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x5836
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %esi
leaq 0x285a(%rip), %rdi      # 0x8081
callq 0x20c0
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x32(%rbp)
je 0x5879
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x2817(%rip), %rdi      # 0x8081
callq 0x20c0
cmpq $0x0, %rax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x5899
cmpl $0x0, -0x30(%rbp)
je 0x5899
movl $0x1, -0x4(%rbp)
jmp 0x58ba
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
callq 0x2240
movq %rax, -0x20(%rbp)
jmp 0x57fe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_error_
acutest_error_(const char* fmt, ...)
{
    if(acutest_verbose_level_ == 0)
        return;

    if(acutest_verbose_level_ >= 2) {
        va_list args;

        acutest_line_indent_(1);
        if(acutest_verbose_level_ >= 3)
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "ERROR: ");
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
        printf("\n");
    }

    if(acutest_verbose_level_ >= 3) {
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5935
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x67e5(%rip)      # 0xc148
jne 0x596a
jmp 0x59f3
cmpl $0x2, 0x67d7(%rip)      # 0xc148
jl 0x59dc
movl $0x1, %edi
callq 0x26e0
cmpl $0x3, 0x67c4(%rip)      # 0xc148
jl 0x5999
movl $0x5, %edi
leaq 0x35f5(%rip), %rsi      # 0x8f87
movb $0x0, %al
callq 0x2760
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x21a0
leaq -0x20(%rbp), %rax
leaq 0x2df4(%rip), %rdi      # 0x87c9
movb $0x0, %al
callq 0x20d0
cmpl $0x3, 0x6765(%rip)      # 0xc148
jl 0x59f3
leaq 0x2ddd(%rip), %rdi      # 0x87c9
movb $0x0, %al
callq 0x20d0
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../include/acutest.h
// Function: acutest_begin_test_line_
static void
acutest_begin_test_line_(const struct acutest_test_* test)
{
    if(!acutest_tap_) {
        if(acutest_verbose_level_ >= 3) {
            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Test %s:\n", test->name);
            acutest_test_already_logged_++;
        } else if(acutest_verbose_level_ >= 1) {
            int n;
            char spaces[48];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x65ed(%rip)      # 0xc2c0
jne 0x5d76
cmpl $0x3, 0x6468(%rip)      # 0xc148
jl 0x5d0d
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x32ef(%rip), %rsi      # 0x8fe4
movb $0x0, %al
callq 0x2760
movl 0x645e(%rip), %eax      # 0xc160
addl $0x1, %eax
movl %eax, 0x6455(%rip)      # 0xc160
jmp 0x5d74
cmpl $0x1, 0x6434(%rip)      # 0xc148
jl 0x5d68
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x32c5(%rip), %rsi      # 0x8fee
movb $0x0, %al
callq 0x2760
movl %eax, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
movl $0x30, %edx
callq 0x2100
cmpl $0x30, -0xc(%rbp)
jge 0x5d66
movl $0x30, %esi
subl -0xc(%rbp), %esi
leaq -0x40(%rbp), %rdx
leaq 0x28c6(%rip), %rdi      # 0x8625
movb $0x0, %al
callq 0x20d0
jmp 0x5d72
movl $0x1, 0x63ee(%rip)      # 0xc160
jmp 0x5d74
jmp 0x5d76
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: set_create
Set set_create(CompareFunc compare, DestroyFunc destroy_value) {
	assert(compare != NULL);

	Set set = malloc(sizeof(*set));
	set->root = NULL;     // Kενό δέντρο.
	set->size = 0;
	set->compare = compare;
	set->destroy_value = destroy_value;

	return set;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d99
jmp 0x5db8
leaq 0x325a(%rip), %rdi      # 0x8ffa
leaq 0x3263(%rip), %rsi      # 0x900a
movl $0x22e, %edx            # imm = 0x22E
leaq 0x3276(%rip), %rcx      # 0x9029
callq 0x20f0
movl $0x20, %edi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: set_remove
bool set_remove(Set set, Pointer value) {

	bool removed;
	Pointer old_value = NULL;
	
	set->root = node_remove(set->root, set->compare, value, &removed, &old_value);

	if (removed) {
		set->size--;    // Το size αλλάζει μόνο αν πραγματικά αφαιρεθεί ένας κόμβος.

		if (set->destroy_value != NULL)
			set->destroy_value(old_value);
	}

	return removed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x11(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x5f60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
testb $0x1, -0x11(%rbp)
je 0x5f50
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5f4e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x5f50
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: node_find_min
static SetNode node_find_min(BTreeNode node) {
	if (node == NULL)
		return NULL;

	return node->children[0] != NULL
		? node_find_min(node->children[0])		// Υπάρχει το πιο αριστερό υποδέντρο, η μικρότερη τιμή βρίσκεται εκεί.
		: node->set_nodes[0];					// Αλλιώς ο μικρότερος set κόμβος είναι ο πρώτος σε αυτόν τον btree κόμβο
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x614d
movq $0x0, -0x8(%rbp)
jmp 0x617f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x616b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6130
movq %rax, -0x18(%rbp)
jmp 0x6177
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: node_find_max
static SetNode node_find_max(BTreeNode node) {
	if (node == NULL)
		return NULL;

	return node->children[node->count] != NULL
		? node_find_max(node->children[node->count] )	// Υπάρχει το πιο δεξί υποδέντρο, η μεγαλύτερη τιμή βρίσκεται εκεί.
		: node->set_nodes[node->count-1];				// Αλλιώς ο μεγαλύτερος set κόμβος είναι ο τελευταίος σε αυτόν τον btree κόμβο
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x61cd
movq $0x0, -0x8(%rbp)
jmp 0x621c
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x61fb
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x61b0
movq %rax, -0x18(%rbp)
jmp 0x6214
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: btree_destroy
static void btree_destroy(BTreeNode node, DestroyFunc destroy_value) {
	if (node == NULL)
		return;
	
	// Πρώτα κατάστρεψε τα παιδιά.
	for (int i = 0; i <= node->count; i++)
		btree_destroy(node->children[i], destroy_value);

	for (int i = 0; i < node->count; i++) {
		if (destroy_value != NULL)
			destroy_value(node->set_nodes[i]->value);	// Κατάστρεψε τις τιμές.

		free(node->set_nodes[i]);						// και free το set_node
	}

	free(node);  // Αποδέσμευσε το node.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x627c
jmp 0x6304
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x62af
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x6260
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6283
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x62fb
cmpq $0x0, -0x10(%rbp)
je 0x62de
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movq 0x40(%rcx,%rdx,8), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rdi
callq 0x2270
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x62b6
movq -0x8(%rbp), %rdi
callq 0x2270
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: node_find
static BTreeNode node_find(BTreeNode node, CompareFunc compare, Pointer value, int* index) {
	if (node == NULL)
		return NULL;

	int i;  // Ορίζει τη διαχωριστική τιμή σε σχέση με την οποιά αναζητούμε την τιμή.
	for (i = 0; i < node->count; i++) {
		int compare_res = compare(value, node->set_nodes[i]->value); // Aποθήκευση για να μην καλέσουμε την compare 2 φορές.

		if (compare_res == 0) {
			*index = i;
			return node;  // Η τιμή βρέθηκε στον τρέχοντα κόμβο.

		} else if (compare_res < 0) {
			// Αφού η τιμή που αναζητούμε είναι μικρότερη της διαχωριστικής τιμής
			// τότε βρίσκεται στο αριστερό παιδί που ορίζει η διαχωριστική τιμή (παιδί i)
			break;
		}
	}

	// Αν είμαστε σε φύλλο, η τιμή δεν βρέθηκε αλλά μπορεί να προστεθεί εδώ. Αλλιώς συνεχίζουμε στο παιδί i
	if (is_leaf(node)) {
		*index = -1;
		return node;
	} else {
		return node_find(node->children[i], compare, value, index);  
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x633c
movq $0x0, -0x8(%rbp)
jmp 0x63e0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x639b
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq 0x40(%rcx,%rdx,8), %rcx
movq (%rcx), %rsi
callq *%rax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x6384
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x63e0
cmpl $0x0, -0x30(%rbp)
jge 0x638c
jmp 0x639b
jmp 0x638e
jmp 0x6390
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6343
movq -0x10(%rbp), %rdi
callq 0x6d20
testb $0x1, %al
jne 0x63aa
jmp 0x63be
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x63e0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6310
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: set_insert
void set_insert(Set set, Pointer value) {
	bool inserted;
	Pointer old_value;

	set->root = node_insert(set->root, set->compare, value, &inserted, &old_value);

	// Το size αλλάζει μόνο αν μπει νέος κόμβος. Στα updates κάνουμε destroy την παλιά τιμή
	if (inserted)
		set->size++;
	else if (set->destroy_value != NULL)
		set->destroy_value(old_value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x11(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x6460
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
testb $0x1, -0x11(%rbp)
je 0x643f
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x645a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6458
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x645a
addq $0x20, %rsp
popq %rbp
retq