LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: to_buffer
local void to_buffer(struct readclass* readclass, struct job* job){
	if (job->buffer1 == NULL) job->buffer1 = malloc(1024*4);
	char* cur1 = job->buffer1;
	char (*reads1)[1024] = readclass->read1->reads;
	int i,j;
	for (i=0;i<4;i++){
		j=0;
		while( (*cur1++ = reads1[i][j++]) != '\n' ){}
	}
	*cur1 = '\0';
	job->l1 = strlen(job->buffer1);
	if (g.single_or_pair){
		if (job->buffer2 == NULL) job->buffer2 = malloc(1024*4);
		char* cur2 = job->buffer2;
		char (*reads2)[1024] = readclass->read2->reads;
		for (i=0;i<4;i++){
			j=0;
			while( (*cur2++ = reads2[i][j++]) != '\n' ){}
		}
		*cur2 = '\0';
		job->l2 = strlen(job->buffer2);
	}
		
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
testq %rax, %rax
jne 0x3d17
movl $0x1000, %edi           # imm = 0x1000
callq 0x21c0
movq %rax, 0x30(%rbx)
movq (%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x3d47
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x3d29
incq %rdx
addq $0x400, %rcx            # imm = 0x400
jmp 0x3d20
movb $0x0, (%rax)
movq 0x30(%rbx), %rdi
callq 0x20c0
movl %eax, 0x38(%rbx)
cmpb $0x0, 0x646b(%rip)      # 0xa1c8
je 0x3db6
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x3d76
movl $0x1000, %edi           # imm = 0x1000
callq 0x21c0
movq %rax, 0x40(%rbx)
movq 0x8(%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x3da7
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x3d89
incq %rdx
addq $0x400, %rcx            # imm = 0x400
jmp 0x3d80
movb $0x0, (%rax)
movq 0x40(%rbx), %rdi
callq 0x20c0
movl %eax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: free_pool
local void free_pool(struct pool* pool){
	int count = 0;
	struct space* space;
	possess(pool->have);
	while((space = pool->head) != NULL){
		pool->head = space->next;
		free_lock(space->use);
		free(space->readclass->stat);
		free(space->readclass->read1->adapter);
		if (g.single_or_pair) free(space->readclass->read2->adapter);
		free(space->readclass->read1);
		if (g.single_or_pair) free(space->readclass->read2);
		free(space);
		count++;
	}
	release(pool->have);
	free_lock(pool->have);
}

// Assembly:
pushq %rbx
movq 0x62dc(%rip), %rdi      # 0xa2c8
callq 0x5ccb
movq 0x62d8(%rip), %rbx      # 0xa2d0
testq %rbx, %rbx
je 0x407c
movq 0x10(%rbx), %rax
movq %rax, 0x62c8(%rip)      # 0xa2d0
movq (%rbx), %rdi
callq 0x5c7d
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq 0x8(%rbx), %rax
movq (%rax), %rax
movq 0x1420(%rax), %rdi
callq 0x2040
cmpb $0x0, 0x6191(%rip)      # 0xa1c8
je 0x404d
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1420(%rax), %rdi
callq 0x2040
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x2040
cmpb $0x0, 0x6168(%rip)      # 0xa1c8
je 0x406f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2040
jmp 0x3ff1
movq 0x6245(%rip), %rdi      # 0xa2c8
callq 0x5cfa
movq 0x6239(%rip), %rdi      # 0xa2c8
popq %rbx
jmp 0x5c7d
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: parameter
local int parameter(const char* str, void* p, const char* type){
	int len=strlen(str);
	int i=0;

	if (strcmp(type,"int")==0){
		while(i<len){
			if(isdigit(*(str+i))==0){
				return(0);
			}
			i++;
		}
		int* x=(int*)p;
		*x=(int)atoi(str);
		return(1);
	}else if (strcmp(type,"float")==0){
		int dot=0;
		while(i<len){
			if(*(str+i) == '.' && dot == 0){
				i++;
				dot++;
				continue;
			}
			if(isdigit(*(str+i))==0){
				return(0);
			}
			i++;
		}
		float* x=(float*)p;
		*x=(float)atof(str);
		return(1);
	}else if (strcmp(type,"str")==0){
		char* x=*(char**)p;
		strcpy(x,str);
		return(1);
	}else if (strcmp(type,"long")==0){
		while(i<len){
			if(isdigit(*(str+i))==0){
				return(0);
			}
			i++;
		}
		long* x=(long*)p;
		*x=atol(str);
		return(1);
	}else{
		return(0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20c0
movq %rax, %r15
leaq 0x1e89(%rip), %rsi      # 0x707e
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
je 0x5274
leaq 0x1ecc(%rip), %rsi      # 0x70d4
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
je 0x52a4
leaq 0x1f33(%rip), %rsi      # 0x7152
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
je 0x52f3
leaq 0x1e6e(%rip), %rsi      # 0x70a4
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
jne 0x52a0
xorl %r12d, %r12d
testl %r15d, %r15d
movl $0x0, %r13d
cmovgl %r15d, %r13d
cmpq %r12, %r13
je 0x5312
callq 0x2350
movq (%rax), %rax
movsbq (%r14,%r12), %rcx
incq %r12
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x5252
jmp 0x52a0
xorl %r12d, %r12d
testl %r15d, %r15d
movl $0x0, %r13d
cmovgl %r15d, %r13d
cmpq %r12, %r13
je 0x52e7
callq 0x2350
movq (%rax), %rax
movsbq (%r14,%r12), %rcx
incq %r12
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x5284
xorl %eax, %eax
jmp 0x5320
movslq %r15d, %r15
movb $0x1, %bpl
xorl %r12d, %r12d
movslq %r12d, %r12
notb %bpl
cmpq %r15, %r12
jge 0x5300
movsbq (%r14,%r12), %r13
cmpq $0x2e, %r13
setne %al
orb %bpl, %al
testb $0x1, %al
je 0x52e0
callq 0x2350
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r13,2)
je 0x52a0
incq %r12
jmp 0x52b3
incq %r12
xorl %ebp, %ebp
jmp 0x52ad
movq %r14, %rdi
callq 0x2290
movl %eax, (%rbx)
jmp 0x531d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2050
jmp 0x531d
movq %r14, %rdi
callq 0x2090
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx)
jmp 0x531d
movq %r14, %rdi
callq 0x2240
movq %rax, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/fqtools.c
// Function: push_job
local void push_job(struct job* job){
	struct job *here, **prior;
	possess(write_first);
	prior = &(write_head);
	while((here = *prior) != NULL){
		if (here->seq > job->seq){
			break;
		}
		prior = &(here->next);
	}
	job->next = here;
	*prior = job;
	twist(write_first,TO,write_head->seq);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x46e3(%rip), %rdi      # 0xa2b8
callq 0x5ccb
leaq 0x46df(%rip), %rax      # 0xa2c0
movq (%rax), %rcx
testq %rcx, %rcx
je 0x5bfa
movq (%rcx), %rdx
cmpq (%rbx), %rdx
jg 0x5bfa
addq $0x20, %rcx
movq %rcx, %rax
jmp 0x5be1
movq %rcx, 0x20(%rbx)
movq %rbx, (%rax)
movq 0x46b0(%rip), %rdi      # 0xa2b8
movq 0x46b1(%rip), %rax      # 0xa2c0
movq (%rax), %rdx
xorl %esi, %esi
popq %rbx
jmp 0x5e4d
nop
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: new_lock
lock* new_lock(long inital){
    lock* bolt = (lock*)malloc(sizeof(lock));
    if (pthread_mutex_init(&(bolt->mutex),NULL) ||
        pthread_cond_init(&(bolt->cond),NULL)){
        fail();
    }
    bolt->value = inital;
    return(bolt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x60
popq %rdi
callq 0x21c0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x2310
testl %eax, %eax
jne 0x5c5a
leaq 0x28(%r14), %rdi
xorl %esi, %esi
callq 0x2190
testl %eax, %eax
jne 0x5c5a
movq %rbx, 0x58(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4397(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x22b1(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: free_lock
void free_lock(lock* bolt){
    if (bolt){
        if (pthread_cond_destroy(&(bolt->cond)) ||
            pthread_mutex_destroy(&(bolt->mutex))){
            fail();
        }
    }
    free(bolt);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5c9f
leaq 0x28(%rbx), %rdi
callq 0x2250
testl %eax, %eax
jne 0x5ca8
movq %rbx, %rdi
callq 0x20e0
testl %eax, %eax
jne 0x5ca8
movq %rbx, %rdi
popq %rbx
jmp 0x2040
movq 0x4349(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x2263(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: launch
thread* launch(void (*probe)(void*), void* args){ //!!!
    struct capsule* capsule;
    thread* th;
    pthread_attr_t attr;

    possess(&(threads_lock));
    capsule = (struct capsule*)malloc(sizeof(struct capsule));
    capsule->probe = probe;
    capsule->payload = args;
    th = (thread*)malloc(sizeof(thread));
    if (pthread_attr_init(&attr) ||
        pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE) ||
        pthread_create(&(th->id),&attr, (void*)ignition,capsule) ||
        pthread_attr_destroy(&attr)){
        fail();
    }
    th->done = 0;
    th->next = threads;
    threads = th;
    release(&(threads_lock));
    return(th);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x72641(%rip), %rdi     # 0x78380
callq 0x5ccb
pushq $0x10
popq %rdi
callq 0x21c0
movq %rax, %r14
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
pushq $0x18
popq %rdi
callq 0x21c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2130
testl %eax, %eax
jne 0x5dd7
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x21a0
testl %eax, %eax
jne 0x5dd7
leaq 0x74(%rip), %rdx        # 0x5dfa
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x21f0
testl %eax, %eax
jne 0x5dd7
leaq 0x8(%rsp), %rdi
callq 0x2280
testl %eax, %eax
jne 0x5dd7
andl $0x0, 0x10(%rbx)
movq 0x7262d(%rip), %rax     # 0x783e0
movq %rax, 0x8(%rbx)
movq %rbx, 0x72622(%rip)     # 0x783e0
leaq 0x725bb(%rip), %rdi     # 0x78380
callq 0x5cfa
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x421a(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x2134(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: ignition
local void ignition(void* args){
    struct capsule* capsule = args; //!!!
    pthread_cleanup_push((void*)rtn, NULL);
    capsule->probe(capsule->payload);
    free(capsule);
    pthread_cleanup_pop(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x22f0
testl %eax, %eax
jne 0x5e40
movq %rsp, %r14
movq %r14, %rdi
callq 0x22d0
movq 0x8(%rbx), %rdi
callq *(%rbx)
movq %rbx, %rdi
callq 0x2040
movq %r14, %rdi
callq 0x20f0
callq 0x60da
addq $0x68, %rsp
popq %rbx
popq %r14
retq
callq 0x60da
movq %rsp, %rdi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: twist
void twist(lock* bolt, enum twist_op op, long val){
    if (op == TO){
        bolt->value = val;
    }else if(op == BY){
        bolt->value += val;
    }
    if (pthread_cond_broadcast(&(bolt->cond)) ||
        pthread_mutex_unlock(&(bolt->mutex))){
        fail();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
je 0x5e60
testl %esi, %esi
jne 0x5e64
movq %rdx, 0x58(%rbx)
jmp 0x5e64
addq %rdx, 0x58(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x2060
testl %eax, %eax
jne 0x5e7f
movq %rbx, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x5e7f
popq %rbx
retq
movq 0x4172(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x208c(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: wait_for
void wait_for(lock* bolt, enum wait_for op, long val){
    switch (op){
        case TO_BE:
            until(bolt->value == val)
                if (pthread_cond_wait(&(bolt->cond),&(bolt->mutex)))
                    fail();
            break;
        case NOT_TO_BE:
            until(bolt->value != val)
                if (pthread_cond_wait(&(bolt->cond),&(bolt->mutex)))
                    fail();
            break;
        case TO_MORE_THAN:
            until(bolt->value >= val)
                if (pthread_cond_wait(&(bolt->cond),&(bolt->mutex)))
                    fail();
            break;
        case TO_LESS_THAN:
            until(bolt->value <= val)
                if (pthread_cond_wait(&(bolt->cond),&(bolt->mutex)))
                    fail();
            break;      
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x3, %esi
ja 0x5f59
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0x204d(%rip), %rcx      # 0x7f0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
je 0x5f59
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x5ecc
jmp 0x5f36
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jge 0x5f59
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x5eeb
jmp 0x5f36
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jle 0x5f59
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x5f06
jmp 0x5f36
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jne 0x5f59
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x5f21
movq 0x40bb(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x1fd5(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: join
void join(thread* ally){
    thread *match,**prior;
    if (pthread_join(ally->id,NULL)) fail();
    possess(&(threads_lock));
    prior = &(threads);
    while((match = *prior) != NULL){
        if (match == ally)
            break;
        prior = &(match->next);
    }
    if (match == NULL) fail();
    if (match->done)
        threads_lock.value--;
    *prior = match->next;
    release(&(threads_lock));
    free(ally);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
callq 0x22e0
testl %eax, %eax
jne 0x5fc5
leaq 0x72408(%rip), %rdi     # 0x78380
callq 0x5ccb
leaq 0x7245c(%rip), %rcx     # 0x783e0
movq %rcx, %rax
movq (%rcx), %rdx
leaq 0x8(%rdx), %rcx
testq %rdx, %rdx
je 0x5f98
cmpq %rbx, %rdx
jne 0x5f84
testq %rdx, %rdx
je 0x5fc5
cmpl $0x0, 0x10(%rdx)
je 0x5faa
decq 0x7242e(%rip)           # 0x783d8
movq (%rcx), %rcx
movq %rcx, (%rax)
leaq 0x723c9(%rip), %rdi     # 0x78380
callq 0x5cfa
movq %rbx, %rdi
popq %rbx
jmp 0x2040
movq 0x402c(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x1f46(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: join_all
void join_all(void){
    thread *match,**prior;
    possess(&(threads_lock));
    while(threads != NULL){
        wait_for(&(threads_lock),NOT_TO_BE,0);
        prior = &(threads);
        while((match = *prior) != NULL){
            if (match->done)
                break;
            prior = &(match->next);
        }
        if (pthread_join(match->id, NULL) != 0)
            fail();
        threads_lock.value--;
        *prior = match->next;
        free(match);
    }
    release(&(threads_lock));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x72389(%rip), %rbx     # 0x78380
movq %rbx, %rdi
callq 0x5ccb
pushq $0x1
popq %rbp
leaq 0x723d7(%rip), %r15     # 0x783e0
cmpq $0x0, 0x723cf(%rip)     # 0x783e0
je 0x6062
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5ea2
movq %r15, %r12
movq (%r12), %r14
testq %r14, %r14
je 0x603b
cmpl $0x0, 0x10(%r14)
jne 0x603b
addq $0x8, %r14
movq %r14, %r12
jmp 0x6022
movq (%r14), %rdi
xorl %esi, %esi
callq 0x22e0
testl %eax, %eax
jne 0x6076
decq 0x72388(%rip)           # 0x783d8
movq 0x8(%r14), %rax
movq %rax, (%r12)
movq %r14, %rdi
callq 0x2040
jmp 0x6009
leaq 0x72317(%rip), %rdi     # 0x78380
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5cfa
movq 0x3f7b(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x1e95(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/yarn.c
// Function: rtn
local void rtn(void){
    pthread_t me;
    thread *match, **prior;

    me = pthread_self();

    possess(&(threads_lock));
    prior = &(threads);
    while((match = *prior) != NULL){
        if (pthread_equal(match->id,me)) 
            break;
        prior = &(match->next);
    }
    if (match==NULL) fail();
    match->done = 1;
    if (match != threads){
        *prior = match->next;
        match->next = threads;
        threads = match;
    }
    twist(&(threads_lock),BY,+1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x2220
movq %rax, %rbx
leaq 0x72292(%rip), %rdi     # 0x78380
callq 0x5ccb
leaq 0x722e6(%rip), %r15     # 0x783e0
movq (%r15), %r14
testq %r14, %r14
je 0x615b
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2200
testl %eax, %eax
jne 0x611a
addq $0x8, %r14
movq %r14, %r15
jmp 0x60fa
movl $0x1, 0x10(%r14)
cmpq 0x722b7(%rip), %r14     # 0x783e0
je 0x6144
movq 0x8(%r14), %rax
movq %rax, (%r15)
movq 0x722a7(%rip), %rax     # 0x783e0
movq %rax, 0x8(%r14)
movq %r14, 0x7229c(%rip)     # 0x783e0
leaq 0x72235(%rip), %rdi     # 0x78380
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x5e4d
movq 0x3e96(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x1db0(%rip), %rdi      # 0x7f1c
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %edi, %edi
callq 0x22b0
nop
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/hash.c
// Function: hash_string
unsigned int hash_string(const char* key, int htsize){
	unsigned long hash = 5381;
	while(*key){
		hash += (hash<<5) + (int)(*key++);
		if (hash >= htsize){
			hash = hash % htsize;
		}
	}
	return(hash);
}

// Assembly:
movslq %esi, %rcx
movl $0x1505, %eax           # imm = 0x1505
movsbq (%rdi), %rdx
testq %rdx, %rdx
je 0x61aa
incq %rdi
imulq $0x21, %rax, %rax
addq %rdx, %rax
cmpq %rcx, %rax
jb 0x6188
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
jmp 0x6188
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/hash.c
// Function: init_hash
hashtable* init_hash(void){
	hashtable* ht;
	ht=(hashtable*)malloc(sizeof(hashtable));
	ht->htsize=HT_SIZE;
	ht->bucketlengths=(int*)malloc(sizeof(int)*ht->htsize);
	ht->blist=(keyvalue**)malloc(sizeof(keyvalue*)*ht->htsize);
	int i;
	for(i=0;i<ht->htsize;i++){
		(ht->blist)[i]=NULL;
	}
	return(ht);
}

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq 0x21c0
movq %rax, %rbx
movl $0x100000, (%rax)       # imm = 0x100000
movl $0x400000, %edi         # imm = 0x400000
callq 0x21c0
movq %rax, 0x8(%rbx)
movl $0x800000, %edi         # imm = 0x800000
callq 0x21c0
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
cmpq $0x100000, %rcx         # imm = 0x100000
je 0x61ee
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x61db
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/hash.c
// Function: insert_keyvalue
void insert_keyvalue(hashtable** ht, char* key, int value){
	unsigned int hash_value=hash_string(key,(*ht)->htsize);
	keyvalue* newhash=(keyvalue*)malloc(sizeof(keyvalue));
	newhash->key=(char*)malloc(sizeof(char)*(strlen(key)+1));
	strcpy(newhash->key,key);
	newhash->key[strlen(key)]='\0';
	newhash->value=value;
	newhash->next=(*ht)->blist[hash_value];
	(*ht)->blist[hash_value]=newhash;
	(*ht)->bucketlengths[hash_value]++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movl (%r15), %esi
movq %r14, %rdi
callq 0x6180
movl %eax, (%rsp)
pushq $0x18
popq %rdi
callq 0x21c0
movq %rax, %r12
movq %r14, %rdi
callq 0x20c0
movq %rax, %r13
leaq 0x1(%rax), %rdi
callq 0x21c0
movq %rax, %rbp
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movb $0x0, (%rbp,%r13)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%r12)
movq 0x10(%r15), %rax
movl (%rsp), %ecx
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%r12)
movq %r12, (%rax,%rcx,8)
movq (%rbx), %rax
movq 0x8(%rax), %rax
incl (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/hash.c
// Function: get_index
char get_index(hashtable* ht, char* key){
	unsigned int hash_value=hash_string(key,ht->htsize);
	keyvalue* curkeyvalue=ht->blist[hash_value];
	while(curkeyvalue != NULL){
		if(strcmp(curkeyvalue->key, key)==0){
			return(0);
			break;
		}
		curkeyvalue=curkeyvalue->next;
	}
	return(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x6180
movl %eax, %r15d
shlq $0x3, %r15
addq 0x10(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x62c5
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2150
addq $0x10, %r15
testl %eax, %eax
jne 0x62a6
xorl %eax, %eax
jmp 0x62c7
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/annoroad[P]fqtools_plus/cutadapt.c
// Function: initalign
adapter_* initalign(const char* s1, const int min_overlap){
	adapter_* adapter = (adapter_*)malloc(sizeof(adapter_));
	adapter->min_overlap = min_overlap;
	strcpy(adapter->s1,s1);
	adapter->m = strlen(s1);
	adapter->s2 = NULL;
	adapter->columns = (Entry_*)malloc(sizeof(Entry_)*(adapter->m+1));
	adapter->result = (result_*)malloc(sizeof(result_));
	return(adapter);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x228, %edi            # imm = 0x228
callq 0x21c0
movq %rax, %rbx
movl %ebp, 0x18(%rax)
leaq 0x1c(%rax), %rdi
movq %r14, %rsi
callq 0x2050
movq %r14, %rdi
callq 0x20c0
movl %eax, 0x10(%rbx)
andq $0x0, 0x220(%rbx)
incl %eax
cltq
imulq $0xc, %rax, %rdi
callq 0x21c0
movq %rax, (%rbx)
pushq $0x18
popq %rdi
callq 0x21c0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x1312
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x30(%rbp)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3998
leaq 0x902(%rip), %rsi       # 0x422a
callq 0x1140
testq %rax, %rax
je 0x3996
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1130
movq %r14, %rdi
callq 0x10c0
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1130
leaq 0x1(%r15), %rdi
callq 0x10f0
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1050
movb $0x0, (%rbx,%r15)
movq %r14, %rdi
callq 0x1060
leaq 0x7e7(%rip), %rdi       # 0x4171
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x3998
xorl %ebx, %ebx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x235b
movq %rax, %rbx
movq 0x263f(%rip), %rax      # 0x5ff0
movq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x179f
pushq $0xa
popq %rdi
callq 0x1030
movq %r14, %rdi
callq 0x263b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26c2
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpb $0x1, 0xc10a(%rip)      # 0xe6a0
jne 0x25e6
testl %ebx, %ebx
leaq 0x70b5(%rip), %rax      # 0x9656
leaq 0x70aa(%rip), %rsi      # 0x9652
cmoveq %rax, %rsi
movl 0xc116(%rip), %edx      # 0xe6c8
incl %edx
movq 0xbf8d(%rip), %rax      # 0xe548
movq (%rax), %rcx
leaq 0x7094(%rip), %rdi      # 0x9659
xorl %eax, %eax
callq 0x2100
testl %ebx, %ebx
jne 0x2657
cmpl $0x0, 0xc0f1(%rip)      # 0xe6cc
je 0x2657
leaq 0x7081(%rip), %rdi      # 0x9665
jmp 0x263f
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
leaq 0x707d(%rip), %rax      # 0x9672
leaq 0x7079(%rip), %r14      # 0x9675
cmoveq %rax, %r14
xorl $0x5, %ebp
leaq 0x7072(%rip), %rdi      # 0x967c
xorl %eax, %eax
callq 0x2100
movl %ebp, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x26b9
leaq 0x705b(%rip), %rdi      # 0x967f
xorl %eax, %eax
callq 0x2100
testl %ebx, %ebx
jne 0x264b
cmpl $0x0, 0xc096(%rip)      # 0xe6cc
je 0x264b
leaq 0x6b65(%rip), %rdi      # 0x91a4
xorl %eax, %eax
callq 0x2100
callq 0x426c
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
addl %edi, %ebx
cmpb $0x1, 0xc034(%rip)      # 0xe6a0
jne 0x2678
decl %ebx
pushq $0x23
popq %rdi
callq 0x2030
leaq 0x703f(%rip), %r14      # 0x96be
leaq 0x6a4a(%rip), %r15      # 0x90d0
cmpl $0x11, %ebx
jl 0x269d
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
addl $-0x10, %ebx
jmp 0x2686
leaq 0x6fe9(%rip), %rdi      # 0x968d
leaq 0x6a25(%rip), %rdx      # 0x90d0
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0xd8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x282b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x2, 0xb93e(%rip)      # 0xe170
jl 0x28ca
movq %rdi, %r10
cmpb $0x0, 0xbd1e(%rip)      # 0xe560
je 0x2852
andl $0x0, 0xbd09(%rip)      # 0xe554
movb $0x0, 0xbd0e(%rip)      # 0xe560
testq %r10, %r10
je 0x28ca
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xbcdd(%rip), %rdi      # 0xe560
pushq $0x3f
popq %rsi
movq %r10, %rdx
callq 0x20a0
movb $0x0, 0xbd0a(%rip)      # 0xe59f
cmpl $0x3, 0xb8d4(%rip)      # 0xe170
jl 0x28ca
pushq $0x1
popq %rdi
callq 0x265c
leaq 0x68ca(%rip), %rsi      # 0x9177
leaq 0xbcac(%rip), %rdx      # 0xe560
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x26b9
incl 0xbc7c(%rip)            # 0xe540
incl 0xbc8a(%rip)            # 0xe554
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2935
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x2, 0xb834(%rip)      # 0xe170
jl 0x2a0e
cmpq $0x0, 0xbbfe(%rip)      # 0xe548
je 0x2a0e
cmpl $0x0, 0xbc49(%rip)      # 0xe5a0
je 0x2a0e
movq %rdi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x500(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %r10, %rdx
callq 0x20a0
movb $0x0, 0x3ff(%rbx)
pushq $0xa
popq %r14
pushq $0x3
popq %rbp
leaq 0x67dd(%rip), %r15      # 0x918f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x20f0
testq %rax, %rax
je 0x29f0
movq %rax, %r12
cmpb $0x1, 0xbb94(%rip)      # 0xe560
movl %ebp, %edi
sbbl $0x0, %edi
callq 0x265c
movl %r12d, %esi
subl %ebx, %esi
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2100
incq %r12
movq %r12, %rbx
jmp 0x29b2
cmpb $0x0, (%rbx)
je 0x2a0e
cmpb $0x1, 0xbb64(%rip)      # 0xe560
sbbl $0x0, %ebp
movl %ebp, %edi
callq 0x265c
movq %rbx, %rdi
callq 0x2080
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r13
movl %edx, %eax
movq %rsp, %rcx
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ebx
cmovgl %edx, %ebx
movq -0x30(%rbp), %rcx
cmpq %rax, %rbx
je 0x3ac4
movb $0x0, (%rcx,%rax)
incq %rax
jmp 0x3ab6
movq %r13, %rdi
callq 0x5b96
xorl %edi, %edi
cmpl %r15d, %eax
sete %dil
leaq 0x5a07(%rip), %rsi      # 0x94e3
leaq 0x5bdb(%rip), %rcx      # 0x96be
leaq 0x5a0f(%rip), %r8       # 0x94f9
pushq $0x30
popq %rdx
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x3b96
movq %r13, %rdi
callq 0x5df1
movq %rax, %r15
testq %rax, %rax
je 0x3b80
movq %r13, %r12
movq %r13, %rdi
movq %r15, %rsi
callq 0x5e7d
movl (%rax), %eax
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x3b2f
cmpl %eax, (%r14,%r13,4)
je 0x3b36
incq %r13
jmp 0x3b1f
xorl %edi, %edi
movl %ebx, %r13d
jmp 0x3b42
movq -0x30(%rbp), %rax
movzbl (%rax,%r13), %edi
xorl $0x1, %edi
leaq 0x599a(%rip), %rsi      # 0x94e3
pushq $0x38
popq %rdx
leaq 0x5b6b(%rip), %rcx      # 0x96be
leaq 0x59b9(%rip), %r8       # 0x9513
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x3b96
movl %r13d, %eax
movq -0x30(%rbp), %rcx
movb $0x1, (%rcx,%rax)
movq %r12, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x5e3a
jmp 0x3b04
movq %r13, %rdi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5d70
callq 0x2bce
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
xorl %eax, %eax
callq 0x48a0
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4ff0
movq %rax, %rbx
movq %rax, %rdi
callq 0x5b96
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x5919(%rip), %rsi      # 0x94e3
leaq 0x5aed(%rip), %rcx      # 0x96be
leaq 0x5955(%rip), %r8       # 0x952d
pushq $0x45
popq %rdx
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x3bf6
movq %rbx, %rdi
callq 0x5d70
xorl %eax, %eax
popq %rbx
jmp 0x4963
callq 0x2bce
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x48a0
movl 0xa88a(%rip), %eax      # 0xe4a0
movq %rsp, %rbx
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
subq %rcx, %rbx
movq %rbx, %rsp
leaq 0xa54e(%rip), %r14      # 0xe180
leaq 0x58aa(%rip), %r15      # 0x94e3
leaq 0x5a7e(%rip), %r12      # 0x96be
xorl %r13d, %r13d
cltq
cmpq %rax, %r13
jge 0x3cd0
movl (%r14), %eax
movl %eax, (%rbx,%r13,4)
movq %r14, %rdi
callq 0x4b6f
xorb $0x1, %al
movzbl %al, %edi
movq %r15, %rsi
pushq $0x54
popq %rdx
movq %r12, %rcx
leaq 0x58d0(%rip), %r8       # 0x9542
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x3ce5
movq %r14, %rdi
callq 0x4b6f
movzbl %al, %edi
movq %r15, %rsi
pushq $0x55
popq %rdx
movq %r12, %rcx
leaq 0x58ab(%rip), %r8       # 0x9543
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x3ce5
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4ff0
incq %r13
movq %rax, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x3a78
movl 0xa7d9(%rip), %eax      # 0xe4a0
addq $0x28, %r14
jmp 0x3c43
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4963
callq 0x2bce
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x48a0
movl 0xa795(%rip), %eax      # 0xe4a0
movq %rsp, %rbx
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
subq %rcx, %rbx
movq %rbx, %rsp
leaq 0xa459(%rip), %r14      # 0xe180
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x3d4d
movl (%r14), %eax
movl %eax, (%rbx,%r15,4)
movq %r14, %rdi
callq 0x4b6f
incq %r15
movl 0xa759(%rip), %eax      # 0xe4a0
addq $0x28, %r14
jmp 0x3d27
addq $0x4, %rbx
movq %rbx, -0x30(%rbp)
pushq $-0x1
popq %rbx
leaq 0xa421(%rip), %r14      # 0xe180
leaq 0x577d(%rip), %r15      # 0x94e3
leaq 0x5951(%rip), %r12      # 0x96be
xorl %ecx, %ecx
cltq
cmpq %rax, %rcx
jge 0x3e24
movq %rcx, -0x38(%rbp)
movl (%r14), %edi
callq 0x4de1
movzbl %al, %edi
movq %r15, %rsi
pushq $0x6b
popq %rdx
movq %r12, %rcx
leaq 0x57c9(%rip), %r8       # 0x9562
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x3e39
movl (%r14), %edi
callq 0x4de1
xorb $0x1, %al
movzbl %al, %edi
movq %r15, %rsi
pushq $0x6c
popq %rdx
movq %r12, %r13
movq %r12, %rcx
leaq 0x5799(%rip), %r8       # 0x9561
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x3e39
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4ff0
movq -0x38(%rbp), %r12
incq %r12
movl 0xa6b3(%rip), %edx      # 0xe4a0
addl %ebx, %edx
movq %rax, %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x3a78
movq %r12, %rcx
movl 0xa699(%rip), %eax      # 0xe4a0
decl %ebx
addq $0x28, %r14
addq $0x4, %r15
movq %r15, -0x30(%rbp)
leaq 0x56c7(%rip), %r15      # 0x94e3
movq %r13, %r12
jmp 0x3d6f
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4963
callq 0x2bce
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x4ff0
movq %rax, %r13
movq %rax, %rdi
callq 0x5b96
movl %eax, %ebp
movq %r13, %rdi
callq 0x5d70
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5200
xorl %edi, %edi
cmpl %ebp, %eax
sete %dil
leaq 0x54ee(%rip), %rsi      # 0x94e3
leaq 0x56c2(%rip), %rcx      # 0x96be
leaq 0x558a(%rip), %r8       # 0x958d
movl $0xa4, %edx
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x4022
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2bce
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x48a0
leaq 0xa144(%rip), %rbx      # 0xe180
movslq 0xa45d(%rip), %rax      # 0xe4a0
cmpq %rax, %r14
jge 0x4059
movq %rbx, %rdi
callq 0x4b6f
incq %r14
addq $0x28, %rbx
jmp 0x403c
leaq 0x5398(%rip), %rbx      # 0x93f8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3fa4
leaq 0x5326(%rip), %r14      # 0x939b
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3fa4
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3fa4
leaq 0x530c(%rip), %rbx      # 0x93a5
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3fa4
leaq 0x54d4(%rip), %rcx      # 0x9582
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3fa4
leaq 0x52d1(%rip), %rdi      # 0x9391
leaq 0x536f(%rip), %r14      # 0x9436
leaq 0x53c9(%rip), %rcx      # 0x9497
xorl %esi, %esi
movq %r14, %rdx
callq 0x3fa4
leaq 0x52d7(%rip), %rsi      # 0x93b6
xorl %edi, %edi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3fa4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4963
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x58cc
movq %rax, %r14
movq %rax, %rdi
callq 0x5b96
xorl %edi, %edi
cmpl %ebp, %eax
sete %dil
leaq 0x53ba(%rip), %rsi      # 0x94e3
leaq 0x558e(%rip), %rcx      # 0x96be
leaq 0x5496(%rip), %r8       # 0x95cd
movl $0xbf, %edx
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x41d8
movq %r14, %rdi
callq 0x5df1
movq %rax, %r15
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
leaq 0x5481(%rip), %rbp      # 0x95e4
testq %r15, %r15
je 0x41c2
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e7d
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5200
movl %eax, %r12d
xorl %edi, %edi
cmpl %r13d, %eax
setle %dil
leaq 0x534e(%rip), %rsi      # 0x94e3
movl $0xc4, %edx
leaq 0x551d(%rip), %rcx      # 0x96be
movq %rbp, %r8
xorl %eax, %eax
callq 0x23bc
testl %eax, %eax
je 0x41d8
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e3a
movq %rax, %r15
movl %r12d, %r13d
jmp 0x4163
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5d70
callq 0x2bce
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x48a0
leaq 0x9f8e(%rip), %rbx      # 0xe180
movslq 0xa2a7(%rip), %rax      # 0xe4a0
cmpq %rax, %r14
jge 0x420f
movq %rbx, %rdi
callq 0x4b6f
incq %r14
addq $0x28, %rbx
jmp 0x41f2
pushq $0x1
popq %rbx
leaq 0x51c6(%rip), %r14      # 0x93df
cmpl $0x3, %ebx
je 0x422c
movl %ebx, %edi
movq %r14, %rsi
callq 0x40fa
incl %ebx
jmp 0x4219
pushq $0x1
popq %rbx
leaq 0x5165(%rip), %r14      # 0x939b
cmpl $0x4, %ebx
je 0x4249
movl %ebx, %edi
movq %r14, %rsi
callq 0x40fa
incl %ebx
jmp 0x4236
pushq $0x1
popq %rbx
cmpl $0x7, %ebx
je 0x425e
movl %ebx, %edi
xorl %esi, %esi
callq 0x40fa
incl %ebx
jmp 0x424c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4963
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x576a(%rip), %rdi      # 0x9a33
callq 0x2080
leaq 0x9a93(%rip), %r14      # 0xdd68
leaq 0x5603(%rip), %rbx      # 0x98df
cmpq $0x0, (%r14)
je 0x42f6
movq -0x8(%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
addq $0x10, %r14
jmp 0x42dc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0xd0, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x44ec
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x2, 0x9c7d(%rip)      # 0xe170
jl 0x4560
movq %rdi, %rbx
pushq $0x1
popq %rdi
callq 0x265c
cmpl $0x3, 0x9c69(%rip)      # 0xe170
jl 0x451a
leaq 0x54ba(%rip), %rsi      # 0x99ca
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x26b9
leaq 0x20(%rsp), %rax
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x21d0
pushq $0xa
popq %rdi
callq 0x2030
cmpl $0x3, 0x9c1a(%rip)      # 0xe170
jl 0x4560
pushq $0xa
popq %rdi
callq 0x2030
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: compare_record_dates
int compare_record_dates(Pointer a, Pointer b){
    Record record_a = a;
    Record record_b = b;
    if(find)
        return strcmp(record_a->date, record_b->date);
    if(strcmp(record_a->date, record_b->date)){
        return strcmp(record_a->date, record_b->date);
    }else{
        return (record_a->id)-(record_b->id);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb 0x9f38(%rip), %bpl      # 0xe6f8
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
callq 0x2180
testl %eax, %eax
setne %cl
orb %bpl, %cl
testb $0x1, %cl
jne 0x47df
movl (%r14), %eax
subl (%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/giannisdravilas[P]Disease-Monitor/tests/../modules/DiseaseMonitor.c
// Function: compare_structs
int compare_structs(Pointer a, Pointer b){
    MapCount mapcount_a = a;
    MapCount mapcount_b = b;
    if(!strcmp(mapcount_a->disease, mapcount_b->disease)){
        if(!strcmp(mapcount_a->country, mapcount_b->country)){
            return strcmp(mapcount_a->date, mapcount_b->date);
        }else{
            return strcmp(mapcount_a->country, mapcount_b->country);
        }
    }else{
        return strcmp(mapcount_a->disease, mapcount_b->disease);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x2180
testl %eax, %eax
jne 0x4813
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2180
testl %eax, %eax
je 0x481b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180