LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/cutadapt.c
// Function: readfq
static char readfq(adaptline_* adaptline){
	char line[1024];
	char* cur = NULL;
	char* cur1 = NULL;
	if (gzgets(adaptline->gzfp,line,1024)!=NULL){
		cur = line+1;
		cur1 = adaptline->id;
		while(*cur!='\n'){
			*cur1++ = *cur++;
		}
		*cur1 = '\0';
	}else return(1);
	if (gzgets(adaptline->gzfp,line,1024)!=NULL){
		cur = line;
		cur1 = adaptline->adapter->s2;
		int i=0;
		while(*cur!='\n'){
			*cur1++ = *cur++;
			i++;
		}
		*cur1 = '\0';
		adaptline->adapter->n = i;
	}else return(1);
	if (gzgets(adaptline->gzfp,line,1024)!=NULL){}
	else return(1);
	if (gzgets(adaptline->gzfp,line,1024)!=NULL){}
	else return(1);
	return(0);
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x428(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x428(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x20(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
cmpq $0x0, %rax
je 0x9350
leaq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x428(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x9346
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
jmp 0x9311
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
jmp 0x935d
movb $0x1, 0x437(%rsp)
jmp 0x9473
movq 0x428(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x20(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
cmpq $0x0, %rax
je 0x9407
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x428(%rsp), %rax
movq (%rax), %rax
movq 0x220(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x93eb
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x93ab
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movl 0xc(%rsp), %ecx
movq 0x428(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x14(%rax)
jmp 0x9411
movb $0x1, 0x437(%rsp)
jmp 0x9473
movq 0x428(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x20(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
cmpq $0x0, %rax
je 0x9434
jmp 0x943e
movb $0x1, 0x437(%rsp)
jmp 0x9473
movq 0x428(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x20(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
cmpq $0x0, %rax
je 0x9461
jmp 0x946b
movb $0x1, 0x437(%rsp)
jmp 0x9473
movb $0x0, 0x437(%rsp)
movb 0x437(%rsp), %al
addq $0x438, %rsp            # imm = 0x438
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/cutadapt.c
// Function: printmatch
static void printmatch(adaptline_* adaptline){
	char* seq = adaptline->adapter->s2;
	int len = adaptline->adapter->n;
	result_* align = adaptline->adapter->result;
	char seq1[1024];
	char seq2[1024];
	char seq3[1024];
	memset(seq1,0,1024);
	memset(seq2,0,1024);
	memset(seq3,0,1024);
	memcpy(seq1,seq,align->start2);
	memcpy(seq2,seq+align->start2,align->stop2-align->start2);
	memcpy(seq3,seq+align->stop2, len - align->stop2);
	fprintf(stdout,"%s\t%d\t%d\t%d\t%s\t%s\t%s\n",adaptline->id,align->errors,align->start2,align->stop2,seq1,seq2,seq3);
		
}

// Assembly:
subq $0xc48, %rsp            # imm = 0xC48
movq %rdi, 0xc40(%rsp)
movq 0xc40(%rsp), %rax
movq (%rax), %rax
movq 0x220(%rax), %rax
movq %rax, 0xc38(%rsp)
movq 0xc40(%rsp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
movl %eax, 0xc34(%rsp)
movq 0xc40(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xc28(%rsp)
leaq 0x820(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2110
leaq 0x420(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2110
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2110
leaq 0x820(%rsp), %rdi
movq 0xc38(%rsp), %rsi
movq 0xc28(%rsp), %rax
movslq 0x8(%rax), %rdx
callq 0x2160
leaq 0x420(%rsp), %rdi
movq 0xc38(%rsp), %rsi
movq 0xc28(%rsp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rsi
movq 0xc28(%rsp), %rax
movl 0xc(%rax), %eax
movq 0xc28(%rsp), %rcx
subl 0x8(%rcx), %eax
movslq %eax, %rdx
callq 0x2160
leaq 0x20(%rsp), %rdi
movq 0xc38(%rsp), %rsi
movq 0xc28(%rsp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rsi
movl 0xc34(%rsp), %eax
movq 0xc28(%rsp), %rcx
subl 0xc(%rcx), %eax
movslq %eax, %rdx
callq 0x2160
movq 0x3a1f(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movq 0xc40(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0xc28(%rsp), %rax
movl 0x14(%rax), %ecx
movq 0xc28(%rsp), %rax
movl 0x8(%rax), %r8d
movq 0xc28(%rsp), %rax
movl 0xc(%rax), %r9d
leaq 0x820(%rsp), %r11
leaq 0x420(%rsp), %r10
leaq 0x20(%rsp), %rax
leaq 0x1c4e(%rip), %rsi      # 0xb255
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x2150
addq $0xc48, %rsp            # imm = 0xC48
retq
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/flat.c
// Function: main
int
main(int argc, char **argv) 
{
    flctx _cctx; ctx *cctx = (ctx*)&_cctx; flctx *ctx = &_cctx;
    FILE *f; char *m = 0, *lft; long l, val; int c, ad = 1, i, state = 0; 
    v *cl = mkCons(0,0), *v, *n, *r, *benv, *e, *a;
    memset(&_cctx, 0, sizeof(_cctx));
    
    if (argv[1] && (f = fopen(argv[1],"r"))) {
        fseek(f, 0, SEEK_END); 
        l = ftell(f);
        fseek(f, 0, SEEK_SET); 
        m = (char *)malloc(l+1);
        fread(m, 1, l, f);
        m[l] = 0;
        fclose(f);
        printf("%s", m);
    }
    v = scan(cctx, m);
    
    print(cctx, stderr, v ); printf("\n");

    l_init(cctx) ;
    
    eval_flat(ctx, v);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x50(%rbp)
movl $0x1, -0x70(%rbp)
movl $0x0, -0x78(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x1330
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1080
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5138
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x11c0(%rip), %rsi      # 0x626d
callq 0x1120
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x5138
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1110
movq -0x48(%rbp), %rdi
callq 0x10a0
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1110
movq -0x60(%rbp), %rdi
addq $0x1, %rdi
callq 0x10d0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x1, %esi
callq 0x1030
movq -0x50(%rbp), %rax
movq -0x60(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x48(%rbp), %rdi
callq 0x1040
movq -0x50(%rbp), %rsi
leaq 0x106e(%rip), %rdi      # 0x619f
movb $0x0, %al
callq 0x1070
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3240
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rdi
movq 0x2e99(%rip), %rax      # 0x7ff0
movq (%rax), %rsi
movq -0x88(%rbp), %rdx
callq 0x1b80
leaq 0x108c(%rip), %rdi      # 0x61f9
movb $0x0, %al
callq 0x1070
movq -0x38(%rbp), %rdi
callq 0x35f0
movq -0x40(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x36f0
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_finish_test_line__
static void
test_finish_test_line__(int result)
{
    if(test_tap__) {
        const char* str = (result == 0) ? "ok" : "not ok";

        printf("%s %u - %s\n", str, test_current_index__ + 1, test_current_unit__->name);

        if(result == 0  &&  test_timer__) {
            printf("# Duration: ");
            test_timer_print_diff__();
            printf("\n");
        }
    } else {
        int color = (result == 0) ? TEST_COLOR_GREEN_INTENSIVE__ : TEST_COLOR_RED_INTENSIVE__;
        const char* str = (result == 0) ? "OK" : "FAILED";
        printf("[ ");
        test_print_in_color__(color, str);
        printf(" ]");

        if(result == 0  &&  test_timer__) {
            printf("  ");
            test_timer_print_diff__();
        }

        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0xd0be(%rip)      # 0xf6a0
je 0x265a
movl -0x4(%rbp), %edx
leaq 0x901d(%rip), %rax      # 0xb60b
leaq 0x901a(%rip), %rcx      # 0xb60f
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl 0xd0be(%rip), %edx      # 0xf6c8
addl $0x1, %edx
movq 0xcf34(%rip), %rax      # 0xf548
movq (%rax), %rcx
leaq 0x8ff4(%rip), %rdi      # 0xb612
movb $0x0, %al
callq 0x20e0
cmpl $0x0, -0x4(%rbp)
jne 0x2655
cmpl $0x0, 0xd09a(%rip)      # 0xf6cc
je 0x2655
leaq 0x8fe3(%rip), %rdi      # 0xb61e
movb $0x0, %al
callq 0x20e0
callq 0x4e60
leaq 0x91a1(%rip), %rdi      # 0xb7ef
movb $0x0, %al
callq 0x20e0
jmp 0x26e6
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 0x8fb4(%rip), %rax      # 0xb62e
leaq 0x8faa(%rip), %rcx      # 0xb62b
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq 0x8fa2(%rip), %rdi      # 0xb635
movb $0x0, %al
callq 0x20e0
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movb $0x0, %al
callq 0x2770
leaq 0x8f89(%rip), %rdi      # 0xb638
movb $0x0, %al
callq 0x20e0
cmpl $0x0, -0x4(%rbp)
jne 0x26d8
cmpl $0x0, 0xd009(%rip)      # 0xf6cc
je 0x26d8
leaq 0x8a70(%rip), %rdi      # 0xb13c
movb $0x0, %al
callq 0x20e0
callq 0x4e60
leaq 0x9110(%rip), %rdi      # 0xb7ef
movb $0x0, %al
callq 0x20e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_line_indent__
static void
test_line_indent__(int level)
{
    static const char spaces[] = "                ";
    int n = level * 2;

    if(test_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, 0xcf96(%rip)      # 0xf6a0
je 0x2729
cmpl $0x0, -0x8(%rbp)
jle 0x2729
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
leaq 0x8f24(%rip), %rdi      # 0xb646
movb $0x0, %al
callq 0x20e0
jmp 0x272b
cmpl $0x10, -0x8(%rbp)
jle 0x2751
leaq 0x8f44(%rip), %rdi      # 0xb67c
leaq 0x8991(%rip), %rsi      # 0xb0d0
movb $0x0, %al
callq 0x20e0
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x8(%rbp)
jmp 0x272b
movl -0x8(%rbp), %esi
leaq 0x8eed(%rip), %rdi      # 0xb648
leaq 0x896e(%rip), %rdx      # 0xb0d0
movb $0x0, %al
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_case__
void
test_case__(const char* fmt, ...)
{
    va_list args;

    if(test_verbose_level__ < 2)
        return;

    if(test_case_name__[0]) {
        test_case_current_already_logged__ = 0;
        test_case_name__[0] = '\0';
    }

    if(fmt == NULL)
        return;

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

    if(test_verbose_level__ >= 3) {
        test_line_indent__(1);
        test_print_in_color__(TEST_COLOR_DEFAULT_INTENSIVE__, "Case %s:\n", test_case_name__);
        test_current_already_logged__++;
        test_case_current_already_logged__++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2955
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, 0xc7ed(%rip)      # 0xf170
jge 0x298a
jmp 0x2a43
cmpb $0x0, 0xcbcf(%rip)      # 0xf560
je 0x29a4
movl $0x0, 0xcbb7(%rip)      # 0xf554
movb $0x0, 0xcbbc(%rip)      # 0xf560
cmpq $0x0, -0x8(%rbp)
jne 0x29b0
jmp 0x2a43
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 0xcb7d(%rip), %rdi      # 0xf560
movl $0x3f, %esi
callq 0x2080
leaq -0x20(%rbp), %rax
movb $0x0, 0xcba7(%rip)      # 0xf59f
cmpl $0x3, 0xc771(%rip)      # 0xf170
jl 0x2a43
movl $0x1, %edi
callq 0x26f0
movl $0x3, %edi
leaq 0x86f8(%rip), %rsi      # 0xb10f
leaq 0xcb42(%rip), %rdx      # 0xf560
movb $0x0, %al
callq 0x2770
movl 0xcb15(%rip), %eax      # 0xf540
addl $0x1, %eax
movl %eax, 0xcb0c(%rip)      # 0xf540
movl 0xcb1a(%rip), %eax      # 0xf554
addl $0x1, %eax
movl %eax, 0xcb11(%rip)      # 0xf554
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_message__
void
test_message__(const char* fmt, ...)
{
    char buffer[TEST_MSG_MAXSIZE];
    char* line_beg;
    char* line_end;
    va_list args;

    if(test_verbose_level__ < 2)
        return;

    /* We allow extra message only when something is already wrong in the
     * current test. */
    if(test_current_unit__ == NULL  ||  !test_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;
        test_line_indent__(test_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') {
        test_line_indent__(test_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 0x2a97
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, 0xc6ab(%rip)      # 0xf170
jge 0x2acc
jmp 0x2bfc
cmpq $0x0, 0xca74(%rip)      # 0xf548
je 0x2adf
cmpl $0x0, 0xcac3(%rip)      # 0xf5a0
jne 0x2ae4
jmp 0x2bfc
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 0x20d0
movq %rax, -0x420(%rbp)
cmpq $0x0, -0x420(%rbp)
jne 0x2b64
jmp 0x2bbc
movsbl 0xc9f5(%rip), %ecx      # 0xf560
movl $0x2, %edi
movl $0x3, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x26f0
movq -0x420(%rbp), %rax
movq -0x418(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
movq -0x418(%rbp), %rdx
leaq 0x8586(%rip), %rdi      # 0xb127
movb $0x0, %al
callq 0x20e0
movq -0x420(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x418(%rbp)
jmp 0x2b40
movq -0x418(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2bfc
movsbl 0xc98e(%rip), %ecx      # 0xf560
movl $0x2, %edi
movl $0x3, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x26f0
movq -0x418(%rbp), %rsi
leaq 0x8ccb(%rip), %rdi      # 0xb8c0
movb $0x0, %al
callq 0x20e0
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_timer_init__
static void
    test_timer_init__(void)
    {
        if(test_timer__ == 1)
            test_timer_id__ = CLOCK_MONOTONIC;
        else if(test_timer__ == 2)
            test_timer_id__ = CLOCK_PROCESS_CPUTIME_ID;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0xb871(%rip)      # 0xf6cc
jne 0x3e69
movl $0x1, 0xb889(%rip)      # 0xf6f0
jmp 0x3e7e
cmpl $0x2, 0xb85c(%rip)      # 0xf6cc
jne 0x3e7c
movl $0x2, 0xb874(%rip)      # 0xf6f0
jmp 0x3e7e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_remember__
static void
test_remember__(int i)
{
    if(test_details__[i].flags & TEST_FLAG_RUN__)
        return;

    test_details__[i].flags |= TEST_FLAG_RUN__;
    test_count__++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0xb802(%rip), %rax      # 0xf690
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3ea6
jmp 0x3ed2
movq 0xb7e3(%rip), %rax      # 0xf690
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl (%rax), %ecx
orl $0x1, %ecx
movb %cl, (%rax)
movq 0xb7d1(%rip), %rax      # 0xf698
addq $0x1, %rax
movq %rax, 0xb7c6(%rip)      # 0xf698
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_is_tracer_present__
static int
test_is_tracer_present__(void)
{
    char buf[256+32+1];
    int tracer_present = 0;
    int fd;
    ssize_t n_read;

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

    n_read = read(fd, buf, sizeof(buf)-1);
    while(n_read > 0) {
        static const char pattern[] = "TracerPid:";
        const char* field;

        buf[n_read] = '\0';
        field = strstr(buf, pattern);
        if(field != NULL  &&  field < buf + sizeof(buf) - 32) {
            pid_t tracer_pid = (pid_t) atoi(field + sizeof(pattern) - 1);
            tracer_present = (tracer_pid != 0);
            break;
        }

        if(n_read == sizeof(buf)-1) {
            memmove(buf, buf + sizeof(buf)-1 - 32, 32);
            n_read = read(fd, buf+32, sizeof(buf)-1-32);
            if(n_read > 0)
                n_read += 32;
        }
    }

    close(fd);
    return tracer_present;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl $0x0, -0x134(%rbp)
leaq 0x7feb(%rip), %rdi      # 0xbee7
xorl %esi, %esi
movb $0x0, %al
callq 0x2200
movl %eax, -0x138(%rbp)
cmpl $-0x1, -0x138(%rbp)
jne 0x3f20
movl $0x0, -0x4(%rbp)
jmp 0x405f
movl -0x138(%rbp), %edi
leaq -0x130(%rbp), %rsi
movl $0x120, %edx            # imm = 0x120
callq 0x2130
movq %rax, -0x140(%rbp)
cmpq $0x0, -0x140(%rbp)
jle 0x404b
movq -0x140(%rbp), %rax
movb $0x0, -0x130(%rbp,%rax)
leaq -0x130(%rbp), %rdi
leaq 0x717e(%rip), %rsi      # 0xb0e7
callq 0x2280
movq %rax, -0x148(%rbp)
cmpq $0x0, -0x148(%rbp)
je 0x3fce
movq -0x148(%rbp), %rax
leaq -0x130(%rbp), %rcx
addq $0x121, %rcx            # imm = 0x121
addq $-0x20, %rcx
cmpq %rcx, %rax
jae 0x3fce
movq -0x148(%rbp), %rdi
addq $0xb, %rdi
addq $-0x1, %rdi
callq 0x2220
movl %eax, -0x14c(%rbp)
cmpl $0x0, -0x14c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x134(%rbp)
jmp 0x404b
cmpq $0x120, -0x140(%rbp) # imm = 0x120
jne 0x4046
leaq -0x130(%rbp), %rax
leaq -0x130(%rbp), %rcx
addq $0x121, %rcx            # imm = 0x121
addq $-0x1, %rcx
addq $-0x20, %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl -0x138(%rbp), %edi
leaq -0x130(%rbp), %rsi
addq $0x20, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x2130
movq %rax, -0x140(%rbp)
cmpq $0x0, -0x140(%rbp)
jle 0x4044
movq -0x140(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x140(%rbp)
jmp 0x4046
jmp 0x3f3e
movl -0x138(%rbp), %edi
callq 0x2120
movl -0x134(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: check_record_list
void check_record_list(List result, int ids[], int size) {
	bool found[size];
	for (int i = 0; i < size; i++)
		found[i] = false;

	TEST_ASSERT(list_size(result) == size);

	for (ListNode node = list_first(result); node != LIST_EOF; node = list_next(result, node)) {
		int id = ((Record)list_node_value(result, node))->id;

		int pos;
		for (pos = 0; pos < size && ids[pos] != id; pos++)
			;
		TEST_ASSERT(pos < size && !found[pos]);

		found[pos] = true;
	}

	list_destroy(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x43af
movq -0x48(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4390
jmp 0x43b1
movq -0x8(%rbp), %rdi
callq 0x787e
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x70d0(%rip), %rsi      # 0xb49c
movl $0x30, %edx
leaq 0x72a4(%rip), %rcx      # 0xb67c
leaq 0x70d3(%rip), %r8       # 0xb4b2
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x43f0
callq 0x2e60
jmp 0x43f2
jmp 0x43f4
movq -0x8(%rbp), %rdi
callq 0x7ad9
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x44d4
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7b65
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x49(%rbp)
jge 0x4446
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x3c(%rbp), %eax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x444f
jmp 0x445c
jmp 0x4451
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x4425
jmp 0x445e
movl -0x40(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x4a(%rbp)
jge 0x447b
movq -0x48(%rbp), %rax
movslq -0x40(%rbp), %rcx
movb (%rax,%rcx), %al
xorb $-0x1, %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x7012(%rip), %rsi      # 0xb49c
movl $0x38, %edx
leaq 0x71e6(%rip), %rcx      # 0xb67c
leaq 0x702f(%rip), %r8       # 0xb4cc
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x44ae
callq 0x2e60
jmp 0x44b0
jmp 0x44b2
movq -0x48(%rbp), %rax
movslq -0x40(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7b22
movq %rax, -0x38(%rbp)
jmp 0x4401
movq -0x8(%rbp), %rdi
callq 0x7a58
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: test_init
void test_init(void) {
	dm_init();

	List list = dm_get_records(NULL, NULL, NULL, NULL);
	TEST_ASSERT(list_size(list) == 0);
	list_destroy(list);

	dm_destroy();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, %al
callq 0x5bf0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdi
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x6630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x787e
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x6f6c(%rip), %rsi      # 0xb49c
movl $0x45, %edx
leaq 0x7140(%rip), %rcx      # 0xb67c
leaq 0x6fa3(%rip), %r8       # 0xb4e6
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x4554
callq 0x2e60
jmp 0x4556
movq -0x8(%rbp), %rdi
callq 0x7a58
movb $0x0, %al
callq 0x5ce0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: test_insert
void test_insert(void) {
	dm_init();

	int ids[record_no];

	for(int i = 0; i < record_no; i++) {
		ids[i] = records[i].id;

		// Εισαγωγή της εγγραφής i
		TEST_ASSERT(!dm_insert_record(&records[i]));	
		TEST_ASSERT( dm_insert_record(&records[i]));		// replace, returns true

		// Ελεγχος ότι το monitor περιέχει όλες τις εγγραφές μέχρι και το i
		List list = dm_get_records(NULL, NULL, NULL, NULL);
		check_record_list(list, ids, i+1);
	}

	dm_destroy();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
callq 0x5bf0
movl 0xaf1b(%rip), %eax      # 0xf4a0
movq %rsp, %rcx
movq %rcx, -0x8(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq %rcx, %rsp
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xaee7(%rip), %eax      # 0xf4a0
jge 0x46af
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0xabb2(%rip), %rcx      # 0xf180
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movl (%rcx), %edx
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movslq -0x14(%rbp), %rax
leaq 0xab97(%rip), %rdi      # 0xf180
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x5fa0
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x6e99(%rip), %rsi      # 0xb49c
movl $0x54, %edx
leaq 0x706d(%rip), %rcx      # 0xb67c
leaq 0x6ee5(%rip), %r8       # 0xb4fb
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x4627
callq 0x2e60
jmp 0x4629
jmp 0x462b
jmp 0x462d
movslq -0x14(%rbp), %rax
leaq 0xab48(%rip), %rdi      # 0xf180
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x5fa0
andb $0x1, %al
movzbl %al, %edi
leaq 0x6e4c(%rip), %rsi      # 0xb49c
movl $0x55, %edx
leaq 0x7020(%rip), %rcx      # 0xb67c
leaq 0x6e99(%rip), %r8       # 0xb4fc
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x4674
callq 0x2e60
jmp 0x4676
jmp 0x4678
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdi
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x6630
movq -0x28(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x4350
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x45b0
movb $0x0, %al
callq 0x5ce0
movq -0x8(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: test_remove
void test_remove(void) {
	dm_init();

	// insert records
	int ids[record_no];
	for(int i = 0; i < record_no; i++) {
		ids[i] = records[i].id;
		dm_insert_record(&records[i]);	
	}

	for(int i = 0; i < record_no; i++) {
		// Delete της εγγραφής i
		TEST_ASSERT(dm_remove_record(records[i].id));	
		TEST_ASSERT(!dm_remove_record(records[i].id));		// already deleted, returns false

		// Ελεγχος ότι το monitor περιέχει όλες τις εγγραφές από το i μέχρι το τέλος
		List list = dm_get_records(NULL, NULL, NULL, NULL);
		check_record_list(list, &ids[i+1], record_no-i-1);
	}

	dm_destroy();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
callq 0x5bf0
movl 0xadbb(%rip), %eax      # 0xf4a0
movq %rsp, %rcx
movq %rcx, -0x8(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq %rcx, %rsp
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xad87(%rip), %eax      # 0xf4a0
jge 0x475c
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0xaa56(%rip), %rcx      # 0xf180
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movl (%rcx), %edx
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movslq -0x14(%rbp), %rax
leaq 0xaa3b(%rip), %rdi      # 0xf180
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x5fa0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4710
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0xad34(%rip), %eax      # 0xf4a0
jge 0x485e
jmp 0x4774
movslq -0x18(%rbp), %rcx
leaq 0xaa01(%rip), %rax      # 0xf180
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
callq 0x6330
andb $0x1, %al
movzbl %al, %edi
leaq 0x6d03(%rip), %rsi      # 0xb49c
movl $0x6b, %edx
leaq 0x6ed7(%rip), %rcx      # 0xb67c
leaq 0x6d6f(%rip), %r8       # 0xb51b
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x47bd
callq 0x2e60
jmp 0x47bf
jmp 0x47c1
jmp 0x47c3
movslq -0x18(%rbp), %rcx
leaq 0xa9b2(%rip), %rax      # 0xf180
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
callq 0x6330
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x6cb2(%rip), %rsi      # 0xb49c
movl $0x6c, %edx
leaq 0x6e86(%rip), %rcx      # 0xb67c
leaq 0x6d1d(%rip), %r8       # 0xb51a
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x480e
callq 0x2e60
jmp 0x4810
jmp 0x4812
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdi
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x6630
movq -0x28(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movl 0xac5b(%rip), %edx      # 0xf4a0
subl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x4350
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4763
movb $0x0, %al
callq 0x5ce0
movq -0x8(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: count_and_test
void count_and_test(String disease, String country, Date date_from, Date date_to) {
	List recs = dm_get_records(disease, country, date_from, date_to);
	int count = list_size(recs);
	list_destroy(recs);

	TEST_ASSERT(dm_count_records(disease, country, date_from, date_to) == count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6630
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x787e
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7a58
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6960
cmpl -0x2c(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x694f(%rip), %rsi      # 0xb49c
movl $0xa4, %edx
leaq 0x6b23(%rip), %rcx      # 0xb67c
leaq 0x69e6(%rip), %r8       # 0xb546
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x4b71
callq 0x2e60
jmp 0x4b73
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: test_count_records
void test_count_records(void) {
	dm_init();

	// insert records
	for(int i = 0; i < record_no; i++)
		dm_insert_record(&records[i]);	

	// try various search criteria
	count_and_test("Pale Mare", NULL,        NULL,         NULL        );
	count_and_test(NULL,        "Targaryen", NULL,         NULL        );
	count_and_test("Pale Mare", "Targaryen", NULL,         NULL        );
	count_and_test(NULL,        NULL,        "0301-01-01", NULL        );
	count_and_test(NULL,        NULL,        NULL,         "0297-01-01");
	count_and_test("Grayscale", NULL,        "0299-01-01", "0300-01-01");
	count_and_test(NULL,        "Lannister", "0299-01-01", "0301-01-01");

	dm_destroy();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, %al
callq 0x5bf0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xa901(%rip), %eax      # 0xf4a0
jge 0x4bc3
movslq -0x4(%rbp), %rax
leaq 0xa5d4(%rip), %rdi      # 0xf180
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x5fa0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b96
leaq 0x67e7(%rip), %rdi      # 0xb3b1
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x4ae0
xorl %eax, %eax
movl %eax, %ecx
leaq 0x6770(%rip), %rsi      # 0xb354
movq %rcx, %rdi
movq %rcx, %rdx
callq 0x4ae0
leaq 0x67bb(%rip), %rdi      # 0xb3b1
leaq 0x6757(%rip), %rsi      # 0xb354
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x4ae0
xorl %eax, %eax
movl %eax, %ecx
leaq 0x674a(%rip), %rdx      # 0xb35e
movq %rcx, %rdi
movq %rcx, %rsi
callq 0x4ae0
xorl %eax, %eax
movl %eax, %edx
leaq 0x6911(%rip), %rcx      # 0xb53b
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x4ae0
leaq 0x670e(%rip), %rdi      # 0xb34a
xorl %eax, %eax
movl %eax, %esi
leaq 0x67a8(%rip), %rdx      # 0xb3ef
leaq 0x6802(%rip), %rcx      # 0xb450
callq 0x4ae0
xorl %eax, %eax
movl %eax, %edi
leaq 0x6711(%rip), %rsi      # 0xb36f
leaq 0x678a(%rip), %rdx      # 0xb3ef
leaq 0x66f2(%rip), %rcx      # 0xb35e
callq 0x4ae0
movb $0x0, %al
callq 0x5ce0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: run_and_test_top_diseases
void run_and_test_top_diseases(int k, String country) {
	List result = dm_top_diseases(k, country);
	int last_count = INT_MAX;

	TEST_ASSERT(list_size(result) == k);

	for (ListNode node = list_first(result); node != LIST_EOF; node = list_next(result, node)) {
		String disease = list_node_value(result, node);
		int count = dm_count_records(disease, country, NULL, NULL);
		TEST_ASSERT(count <= last_count);
		last_count = count;
	}

	list_destroy(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x7470
movq %rax, -0x18(%rbp)
movl $0x7fffffff, -0x1c(%rbp) # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rdi
callq 0x787e
cmpl -0x4(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x67db(%rip), %rsi      # 0xb49c
movl $0xbf, %edx
leaq 0x69af(%rip), %rcx      # 0xb67c
leaq 0x68b2(%rip), %r8       # 0xb586
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x4ce5
callq 0x2e60
jmp 0x4ce7
movq -0x18(%rbp), %rdi
callq 0x7ad9
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4d7a
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7b65
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6960
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setle %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x6764(%rip), %rsi      # 0xb49c
movl $0xc4, %edx
leaq 0x6938(%rip), %rcx      # 0xb67c
leaq 0x6852(%rip), %r8       # 0xb59d
movb $0x0, %al
callq 0x23a0
cmpl $0x0, %eax
jne 0x4d5c
callq 0x2e60
jmp 0x4d5e
movl -0x34(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7b22
movq %rax, -0x28(%rbp)
jmp 0x4cf4
movq -0x18(%rbp), %rdi
callq 0x7a58
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/DiseaseMonitor_test.c
// Function: test_top_diseases
void test_top_diseases(void) {
	dm_init();

	// insert records
	for(int i = 0; i < record_no; i++)
		dm_insert_record(&records[i]);	

	// try various search criteria
	for (int k = 1; k <= 2; k++)
		run_and_test_top_diseases(k, "Stark");

	for (int k = 1; k <= 3; k++)
		run_and_test_top_diseases(k, "Targaryen");

	for (int k = 1; k <= 6; k++)
		run_and_test_top_diseases(k, NULL);

	dm_destroy();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, %al
callq 0x5bf0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xa6f1(%rip), %eax      # 0xf4a0
jge 0x4dd3
movslq -0x4(%rbp), %rax
leaq 0xa3c4(%rip), %rdi      # 0xf180
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x5fa0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4da6
movl $0x1, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jg 0x4dfa
movl -0x8(%rbp), %edi
leaq 0x65ae(%rip), %rsi      # 0xb398
callq 0x4c80
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4dda
movl $0x1, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jg 0x4e21
movl -0xc(%rbp), %edi
leaq 0x6543(%rip), %rsi      # 0xb354
callq 0x4c80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e01
movl $0x1, -0x10(%rbp)
cmpl $0x6, -0x10(%rbp)
jg 0x4e45
movl -0x10(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c80
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4e28
movb $0x0, %al
callq 0x5ce0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_timer_diff__
static double
    test_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 0x6231(%rip), %xmm0     # 0xb0f8
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 0x6204(%rip), %xmm0     # 0xb0f8
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 0x61d8(%rip), %xmm1     # 0xb0f8
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_cmdline_handle_short_opt_group__
static int
test_cmdline_handle_short_opt_group__(const TEST_CMDLINE_OPTION__* options,
                    const char* arggroup,
                    int (*callback)(int /*optval*/, const char* /*arg*/))
{
    const TEST_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 & TEST_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 ? TEST_CMDLINE_OPTID_MISSINGARG__ : TEST_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 0x5023
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x4fa2
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x4f92
jmp 0x4fa2
jmp 0x4f94
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x4f6f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x4fd1
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x4fd1
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 0x500b
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 0x5013
jmp 0x5023
jmp 0x5015
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f52
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_list_names__
static void
test_list_names__(void)
{
    const struct test__* test;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x6872(%rip), %rdi      # 0xb8b1
movb $0x0, %al
callq 0x20e0
leaq 0x9d13(%rip), %rax      # 0xed60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x507f
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x6854(%rip), %rdi      # 0xb8be
movb $0x0, %al
callq 0x20e0
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x5051
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_lookup__
static int
test_lookup__(const char* pattern)
{
    int i;
    int n = 0;

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

    /* Try word match. */
    for(i = 0; i < (int) test_list_size__; i++) {
        if(test_name_contains_word__(test_list__[i].name, pattern)) {
            test_remember__(i);
            n++;
        }
    }
    if(n > 0)
        return n;

    /* Try relaxed match. */
    for(i = 0; i < (int) test_list_size__; i++) {
        if(strstr(test_list__[i].name, pattern) != NULL) {
            test_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 0xa404(%rip), %rcx      # 0xf688
cmpl %ecx, %eax
jge 0x52cb
movslq -0x14(%rbp), %rcx
leaq 0x9acd(%rip), %rax      # 0xed60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x52be
movl -0x14(%rbp), %edi
callq 0x3e80
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x52cb
jmp 0x52c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x527a
cmpl $0x0, -0x18(%rbp)
jle 0x52dc
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x539d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0xa39b(%rip), %rcx      # 0xf688
cmpl %ecx, %eax
jge 0x5332
movslq -0x14(%rbp), %rcx
leaq 0x9a64(%rip), %rax      # 0xed60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x53b0
cmpl $0x0, %eax
je 0x5325
movl -0x14(%rbp), %edi
callq 0x3e80
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5327
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52e3
cmpl $0x0, -0x18(%rbp)
jle 0x5340
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x539d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0xa337(%rip), %rcx      # 0xf688
cmpl %ecx, %eax
jge 0x5397
movslq -0x14(%rbp), %rcx
leaq 0x9a00(%rip), %rax      # 0xed60
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2280
cmpq $0x0, %rax
je 0x538a
movl -0x14(%rbp), %edi
callq 0x3e80
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x538c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5347
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/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_name_contains_word__
static int
test_name_contains_word__(const char* name, const char* pattern)
{
    static const char word_delim[] = " \t-_.";
    const char* substr;
    size_t pattern_len;
    int starts_on_word_boundary;
    int ends_on_word_boundary;

    pattern_len = strlen(pattern);

    substr = strstr(name, pattern);
    while(substr != NULL) {
        starts_on_word_boundary = (substr == name || strchr(word_delim, substr[-1]) != NULL);
        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 0x2280
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5493
movq -0x20(%rbp), %rcx
movb $0x1, %al
cmpq -0x10(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x5416
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %esi
leaq 0x5cda(%rip), %rdi      # 0xb0e1
callq 0x20d0
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 0x5459
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x5c97(%rip), %rdi      # 0xb0e1
callq 0x20d0
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 0x5479
cmpl $0x0, -0x30(%rbp)
je 0x5479
movl $0x1, -0x4(%rbp)
jmp 0x549a
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
callq 0x2280
movq %rax, -0x20(%rbp)
jmp 0x53de
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/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_error__
static void
test_error__(const char* fmt, ...)
{
    va_list args;

    if(test_verbose_level__ == 0)
        return;

    if(test_verbose_level__ >= 2) {
        test_line_indent__(1);
        if(test_verbose_level__ >= 3)
            test_print_in_color__(TEST_COLOR_RED_INTENSIVE__, "ERROR: ");
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
        printf("\n");
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5515
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, 0x9c2d(%rip)      # 0xf170
jne 0x554a
jmp 0x55d3
cmpl $0x2, 0x9c1f(%rip)      # 0xf170
jl 0x55bc
movl $0x1, %edi
callq 0x26f0
cmpl $0x3, 0x9c0c(%rip)      # 0xf170
jl 0x5579
movl $0x5, %edi
leaq 0x6a3b(%rip), %rsi      # 0xbfad
movb $0x0, %al
callq 0x2770
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 0x21c0
leaq -0x20(%rbp), %rax
leaq 0x623a(%rip), %rdi      # 0xb7ef
movb $0x0, %al
callq 0x20e0
cmpl $0x3, 0x9bad(%rip)      # 0xf170
jl 0x55d3
leaq 0x6223(%rip), %rdi      # 0xb7ef
movb $0x0, %al
callq 0x20e0
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)