LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/annoroad[P]fqtools_plus/fqtools.c
// Function: check_ployAT
local char check_ployAT(char* seq, int ployAT){
	if (ployAT>0){
		int seqlen = strlen(seq);
		int i;
		int count;
		if (seq[0] == 'A' || seq[0] == 'T') count = 1;
		for(i=1;i<seqlen;i++){
			if (seq[i]=='A' || seq[i]=='T'){
				if (seq[i] == seq[i-1]){
					count++;
					if (count == ployAT) return(1);
					continue;
				}
			}
			count = 0;
		}
	}
	return(0);
}

// Assembly:
testl %esi, %esi
jle 0x406d
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x20c0
cmpl $0x2, %eax
jl 0x4063
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1, %edx
movl $0x1, %ecx
movzbl (%r14,%rcx), %edi
xorl %esi, %esi
cmpl $0x54, %edi
je 0x404a
cmpl $0x41, %edi
jne 0x4059
cmpb -0x1(%r14,%rcx), %dil
jne 0x4059
incl %edx
movl %edx, %esi
cmpl %ebx, %edx
je 0x4070
incq %rcx
movl %esi, %edx
cmpq %rcx, %rax
jne 0x4039
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
movb $0x1, %al
jmp 0x4065
// File: /workspace/github_c_makefile_star2_O3/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 0x42a2
movl $0x1000, %edi           # imm = 0x1000
callq 0x21c0
movq %rax, 0x30(%rbx)
movq (%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x42ae
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x42ab
movb $0x0, (%rax)
movq 0x30(%rbx), %rdi
callq 0x20c0
movl %eax, 0x38(%rbx)
cmpb $0x0, 0x6ee2(%rip)      # 0xb1c8
je 0x433d
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x42ff
movl $0x1000, %edi           # imm = 0x1000
callq 0x21c0
movq %rax, 0x40(%rbx)
movq 0x8(%r14), %rcx
addq $0x1d, %rcx
xorl %edx, %edx
movq %rcx, %rsi
movb (%rsi), %dil
movb %dil, (%rax)
incq %rax
incq %rsi
cmpb $0xa, %dil
jne 0x430c
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x4309
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_O3/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 0x6d38(%rip), %rdi      # 0xb2c8
callq 0x6265
movq 0x6d34(%rip), %rbx      # 0xb2d0
testq %rbx, %rbx
je 0x4620
movq 0x10(%rbx), %rax
movq %rax, 0x6d24(%rip)      # 0xb2d0
movq (%rbx), %rdi
callq 0x6235
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, 0x6bed(%rip)      # 0xb1c8
je 0x45f1
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, 0x6bc4(%rip)      # 0xb1c8
je 0x4613
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2040
jmp 0x4595
movq 0x6ca1(%rip), %rdi      # 0xb2c8
callq 0x6276
movq 0x6c95(%rip), %rdi      # 0xb2c8
popq %rbx
jmp 0x6235
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20c0
movq %rax, %r15
leaq 0x1927(%rip), %rsi      # 0x70da
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
je 0x5807
leaq 0x196a(%rip), %rsi      # 0x7130
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
je 0x5846
leaq 0x19d5(%rip), %rsi      # 0x71ae
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
je 0x58c1
leaq 0x1910(%rip), %rsi      # 0x7100
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
je 0x58ce
xorl %eax, %eax
jmp 0x590a
testl %r15d, %r15d
jle 0x5837
callq 0x2350
movq (%rax), %rcx
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %edx, %edx
movsbq (%r14,%rdx), %rsi
testb $0x8, 0x1(%rcx,%rsi,2)
je 0x590a
incq %rdx
cmpq %rdx, %r15
jne 0x581f
movq %r14, %rdi
callq 0x2290
movl %eax, (%rbx)
jmp 0x5905
movq %rbx, 0x8(%rsp)
testl %r15d, %r15d
jle 0x58aa
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x10(%rsp)
movb $0x1, %bpl
xorl %r13d, %r13d
movslq %r13d, %rbx
leal 0x1(%rbx), %r13d
notb %bpl
movsbq (%r14,%rbx), %r12
cmpq $0x2e, %r12
setne %al
orb %bpl, %al
testb $0x1, %al
je 0x58a3
callq 0x2350
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r12,2)
je 0x5800
incq %rbx
incl %r13d
cmpq 0x10(%rsp), %rbx
jl 0x586d
jmp 0x58aa
xorl %ebp, %ebp
cmpl %r15d, %r13d
jl 0x5863
movq %r14, %rdi
callq 0x2090
cvtsd2ss %xmm0, %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
jmp 0x5905
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2050
jmp 0x5905
testl %r15d, %r15d
jle 0x58fa
callq 0x2350
movq (%rax), %rcx
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %edx, %edx
movsbq (%r14,%rdx), %rsi
testb $0x8, 0x1(%rcx,%rsi,2)
je 0x590a
incq %rdx
cmpq %rdx, %r15
jne 0x58e6
movq %r14, %rdi
callq 0x2240
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5125(%rip), %rdi      # 0xb2b8
callq 0x6265
movq 0x5121(%rip), %rax      # 0xb2c0
leaq 0x511a(%rip), %rcx      # 0xb2c0
testq %rax, %rax
je 0x61c6
movq (%rbx), %rdx
cmpq %rdx, (%rax)
jg 0x61d0
movq %rax, %rcx
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x61ca
cmpq %rdx, (%rax)
jle 0x61b3
jmp 0x61cc
xorl %eax, %eax
jmp 0x61d0
xorl %eax, %eax
addq $0x20, %rcx
movq %rax, 0x20(%rbx)
movq %rbx, (%rcx)
movq 0x50da(%rip), %rdi      # 0xb2b8
movq 0x50db(%rip), %rax      # 0xb2c0
movq (%rax), %rdx
xorl %esi, %esi
popq %rbx
jmp 0x6394
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x60, %edi
callq 0x21c0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x2310
testl %eax, %eax
jne 0x6230
leaq 0x28(%r14), %rdi
xorl %esi, %esi
callq 0x2190
testl %eax, %eax
jne 0x6230
movq %rbx, 0x58(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25a2
// File: /workspace/github_c_makefile_star2_O3/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 0x6257
leaq 0x28(%rbx), %rdi
callq 0x2250
testl %eax, %eax
jne 0x6260
movq %rbx, %rdi
callq 0x20e0
testl %eax, %eax
jne 0x6260
movq %rbx, %rdi
popq %rbx
jmp 0x2040
callq 0x25c6
// File: /workspace/github_c_makefile_star2_O3/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 0x730e3(%rip), %rdi     # 0x79380
callq 0x6265
movl $0x10, %edi
callq 0x21c0
movq %rax, %r14
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
movl $0x18, %edi
callq 0x21c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2130
testl %eax, %eax
jne 0x633c
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x21a0
testl %eax, %eax
jne 0x633c
leaq 0x59(%rip), %rdx        # 0x6341
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x21f0
testl %eax, %eax
jne 0x633c
leaq 0x8(%rsp), %rdi
callq 0x2280
testl %eax, %eax
jne 0x633c
movl $0x0, 0x10(%rbx)
movq 0x730c8(%rip), %rax     # 0x793e0
movq %rax, 0x8(%rbx)
movq %rbx, 0x730bd(%rip)     # 0x793e0
leaq 0x73056(%rip), %rdi     # 0x79380
callq 0x6276
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x2632
// File: /workspace/github_c_makefile_star2_O3/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 0x6387
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 0x65ca
addq $0x68, %rsp
popq %rbx
popq %r14
retq
callq 0x65ca
movq %rsp, %rdi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O3/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 0x63a7
testl %esi, %esi
jne 0x63ab
movq %rdx, 0x58(%rbx)
jmp 0x63ab
addq %rdx, 0x58(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x2060
testl %eax, %eax
jne 0x63c6
movq %rbx, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x63c6
popq %rbx
retq
callq 0x2656
// File: /workspace/github_c_makefile_star2_O3/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 0x6469
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0x1b80(%rip), %rcx      # 0x7f68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
je 0x6469
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x63f5
callq 0x26e6
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jge 0x6469
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x6413
callq 0x269e
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jle 0x6469
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x6431
callq 0x267a
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jne 0x6469
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x644f
callq 0x26c2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x64d5
leaq 0x72ef8(%rip), %rdi     # 0x79380
callq 0x6265
leaq 0x72f4c(%rip), %rcx     # 0x793e0
movq %rcx, %rax
movq (%rcx), %rdx
leaq 0x8(%rdx), %rcx
testq %rdx, %rdx
je 0x64a8
cmpq %rbx, %rdx
jne 0x6494
testq %rdx, %rdx
je 0x64da
cmpl $0x0, 0x10(%rdx)
je 0x64ba
decq 0x72f1e(%rip)           # 0x793d8
movq (%rcx), %rcx
movq %rcx, (%rax)
leaq 0x72eb9(%rip), %rdi     # 0x79380
callq 0x6276
movq %rbx, %rdi
popq %rbx
jmp 0x2040
callq 0x270a
callq 0x272e
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x72e92(%rip), %rdi     # 0x79380
callq 0x6265
cmpq $0x0, 0x72ee5(%rip)     # 0x793e0
je 0x658b
leaq 0x72e78(%rip), %rbx     # 0x79380
leaq 0x72ed1(%rip), %r15     # 0x793e0
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x63cb
movq 0x72ebb(%rip), %rax     # 0x793e0
movq %r15, %r12
movl $0x0, %r14d
testq %rax, %rax
je 0x655c
cmpl $0x0, 0x10(%rax)
movq %r15, %r12
movq %rax, %r14
jne 0x655c
movq %rax, %r12
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x6553
cmpl $0x0, 0x10(%rax)
je 0x653f
jmp 0x6555
xorl %eax, %eax
addq $0x8, %r12
movq %rax, %r14
movq (%r14), %rdi
xorl %esi, %esi
callq 0x22e0
testl %eax, %eax
jne 0x65a2
decq 0x72e67(%rip)           # 0x793d8
movq 0x8(%r14), %rax
movq %rax, (%r12)
movq %r14, %rdi
callq 0x2040
cmpq $0x0, 0x72e57(%rip)     # 0x793e0
jne 0x650f
leaq 0x72dee(%rip), %rdi     # 0x79380
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6276
callq 0x2752
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
callq 0x2220
movq %rax, %rbx
leaq 0x72d9f(%rip), %rdi     # 0x79380
callq 0x6265
movq 0x72df3(%rip), %r14     # 0x793e0
testq %r14, %r14
je 0x667b
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2200
testl %eax, %eax
je 0x6611
leaq 0x72dd4(%rip), %r12     # 0x793e0
movq %r14, %r15
jmp 0x6633
movq %r14, %r15
movq %r15, %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x667b
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2200
testl %eax, %eax
je 0x6614
addq $0x8, %r12
movl $0x1, 0x10(%r15)
cmpq %r14, %r15
je 0x665a
movq 0x8(%r15), %rax
movq %rax, (%r12)
movq 0x72d91(%rip), %rax     # 0x793e0
movq %rax, 0x8(%r15)
movq %r15, 0x72d86(%rip)     # 0x793e0
leaq 0x72d1f(%rip), %rdi     # 0x79380
movl $0x1, %edx
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6394
callq 0x279a
// File: /workspace/github_c_makefile_star2_O3/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:
movb (%rdi), %dl
testb %dl, %dl
je 0x66b9
movslq %esi, %rcx
incq %rdi
movl $0x1505, %eax           # imm = 0x1505
movsbq %dl, %rdx
movq %rax, %rsi
shlq $0x5, %rsi
addq %rsi, %rax
addq %rdx, %rax
cmpq %rcx, %rax
jb 0x66af
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x6691
retq
movl $0x1505, %eax           # imm = 0x1505
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x18, %edi
callq 0x21c0
movq %rax, %rbx
movl $0x100000, (%rax)       # imm = 0x100000
movl $0x400000, %edi         # imm = 0x400000
callq 0x21c0
movq %rax, 0x8(%rbx)
movl $0x1, %edi
movl $0x800000, %esi         # imm = 0x800000
callq 0x2140
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movb (%rsi), %dl
testb %dl, %dl
movq %rax, 0x10(%rsp)
je 0x6756
movslq (%rax), %rcx
leaq 0x1(%r14), %rsi
movl $0x1505, %eax           # imm = 0x1505
movsbq %dl, %rdx
movq %rax, %rdi
shlq $0x5, %rdi
addq %rdi, %rax
addq %rdx, %rax
cmpq %rcx, %rax
jb 0x6749
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x672b
movl %eax, %ebp
jmp 0x675b
movl $0x1505, %ebp           # imm = 0x1505
movl $0x18, %edi
callq 0x21c0
movq %rax, %r15
movq %r14, %rdi
callq 0x20c0
movq %rax, %r12
leaq 0x1(%rax), %rdi
callq 0x21c0
movq %rax, %r13
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movb $0x0, (%r13,%r12)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%r15)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax,%rbp,8), %rcx
movq %rcx, 0x10(%r15)
movq %r15, (%rax,%rbp,8)
movq (%rbx), %rax
movq 0x8(%rax), %rax
incl (%rax,%rbp,4)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movb (%rsi), %dl
testb %dl, %dl
je 0x680d
movslq (%rdi), %rcx
leaq 0x1(%rbx), %rsi
movl $0x1505, %eax           # imm = 0x1505
movsbq %dl, %rdx
movq %rax, %r8
shlq $0x5, %r8
addq %r8, %rax
addq %rdx, %rax
cmpq %rcx, %rax
jb 0x6800
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x67e2
movl %eax, %eax
jmp 0x6812
movl $0x1505, %eax           # imm = 0x1505
movq 0x10(%rdi), %rcx
movq (%rcx,%rax,8), %r14
movb $0x1, %bpl
testq %r14, %r14
je 0x6839
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2150
testl %eax, %eax
je 0x6837
movq 0x10(%r14), %r14
jmp 0x681d
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, 0x220(%rbx)
incl %eax
cltq
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
callq 0x21c0
movq %rax, (%rbx)
movl $0x18, %edi
callq 0x21c0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x4378
leaq 0xf34(%rip), %rsi       # 0x523a
callq 0x1140
testq %rax, %rax
je 0x4378
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1130
movq %rbx, %rdi
callq 0x10c0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1130
leaq 0x1(%r15), %rdi
callq 0x10f0
movq %rax, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1050
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
callq 0x1060
leaq 0xe15(%rip), %rdi       # 0x5181
movq %r14, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x437b
xorl %r14d, %r14d
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x271a
movq %rax, %r14
movq 0x2c5c(%rip), %rax      # 0x6ff0
movq (%rax), %r15
movl $0x18, %edi
callq 0x10f0
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movl $0x80, %r8d
xorl %r9d, %r9d
callq 0x15c7
movl $0xa, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x2ac8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b91
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xbee5(%rip)      # 0xe6c0
jne 0x282b
testl %ebx, %ebx
leaq 0x6e70(%rip), %rax      # 0x9656
leaq 0x6e65(%rip), %rsi      # 0x9652
cmoveq %rax, %rsi
movl 0xbef1(%rip), %edx      # 0xe6e8
incl %edx
movq 0xbd68(%rip), %rax      # 0xe568
movq (%rax), %rcx
leaq 0x6e4f(%rip), %rdi      # 0x9659
xorl %eax, %eax
callq 0x2100
testl %ebx, %ebx
jne 0x289e
cmpl $0x0, 0xbecc(%rip)      # 0xe6ec
je 0x289e
leaq 0x6e3c(%rip), %rdi      # 0x9665
jmp 0x2884
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
leaq 0x6e38(%rip), %rax      # 0x9672
leaq 0x6e34(%rip), %r14      # 0x9675
cmoveq %rax, %r14
xorl $0x5, %ebp
leaq 0x6e2d(%rip), %rdi      # 0x967c
xorl %eax, %eax
callq 0x2100
movl %ebp, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2909
leaq 0x6e16(%rip), %rdi      # 0x967f
xorl %eax, %eax
callq 0x2100
testl %ebx, %ebx
jne 0x2890
cmpl $0x0, 0xbe71(%rip)      # 0xe6ec
je 0x2890
leaq 0x6920(%rip), %rdi      # 0x91a4
xorl %eax, %eax
callq 0x2100
callq 0x44cf
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %ebx, %ebx
cmpb $0x1, 0xbe0d(%rip)      # 0xe6c0
jne 0x28c1
decl %ebx
movl $0x23, %edi
callq 0x2030
cmpl $0x11, %ebx
jl 0x28ed
leaq 0x6df1(%rip), %r14      # 0x96be
leaq 0x67fc(%rip), %r15      # 0x90d0
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
leal -0x10(%rbx), %esi
cmpl $0x20, %ebx
movl %esi, %ebx
ja 0x28d4
jmp 0x28ef
movl %ebx, %esi
leaq 0x6d97(%rip), %rdi      # 0x968d
leaq 0x67d3(%rip), %rdx      # 0x90d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x2a7b
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, 0xb70e(%rip)      # 0xe190
jl 0x2b23
movq %rdi, %r10
cmpb $0x0, 0xbaee(%rip)      # 0xe580
je 0x2aa5
movl $0x0, 0xbad6(%rip)      # 0xe574
movb $0x0, 0xbadb(%rip)      # 0xe580
testq %r10, %r10
je 0x2b23
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 0xbaaa(%rip), %rdi      # 0xe580
movl $0x3f, %esi
movq %r10, %rdx
callq 0x20a0
movb $0x0, 0xbad5(%rip)      # 0xe5bf
cmpl $0x3, 0xb69f(%rip)      # 0xe190
jl 0x2b23
movl $0x1, %edi
callq 0x28a3
leaq 0x6673(%rip), %rsi      # 0x9177
leaq 0xba75(%rip), %rdx      # 0xe580
movl $0x3, %edi
xorl %eax, %eax
callq 0x2909
incl 0xba43(%rip)            # 0xe560
incl 0xba51(%rip)            # 0xe574
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
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 0x2b8b
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, 0xb5fe(%rip)      # 0xe190
jl 0x2c80
cmpq $0x0, 0xb9c8(%rip)      # 0xe568
je 0x2c80
cmpl $0x0, 0xba13(%rip)      # 0xe5c0
je 0x2c80
movq %rdi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x4f0(%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)
movq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
testq %rax, %rax
je 0x2c5f
movq %rax, %r14
leaq 0xd0(%rsp), %rbx
leaq 0x6571(%rip), %r15      # 0x918f
cmpb $0x1, 0xb95b(%rip)      # 0xe580
movl $0x3, %edi
sbbl $0x0, %edi
callq 0x28a3
movl %r14d, %esi
subl %ebx, %esi
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2100
movq %r14, %rbx
incq %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movq %rax, %r14
testq %rax, %rax
jne 0x2c1e
cmpb $0x0, (%rbx)
je 0x2c80
cmpb $0x1, 0xb915(%rip)      # 0xe580
movl $0x3, %edi
sbbl $0x0, %edi
callq 0x28a3
movq %rbx, %rdi
callq 0x2080
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %r13d
movq %rsp, %r12
leaq 0xf(%r13), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movl %edx, -0x2c(%rbp)
testl %edx, %edx
jle 0x3cee
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2130
movq %r14, %rdi
callq 0x5f7e
xorl %edi, %edi
cmpl -0x2c(%rbp), %eax
sete %dil
leaq 0x57dd(%rip), %rsi      # 0x94e3
leaq 0x59b1(%rip), %rcx      # 0x96be
leaq 0x57e5(%rip), %r8       # 0x94f9
movl $0x30, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3de2
movq %r14, %rdi
callq 0x61d9
testq %rax, %rax
je 0x3dcc
movq %rax, %rbx
movq %r14, -0x38(%rbp)
movq %r14, %rdi
movq %r12, %r14
movq %rbx, %rsi
callq 0x6265
movl $0x0, %r12d
movl $0x0, %edi
cmpl $0x0, -0x2c(%rbp)
jle 0x3d81
movl (%rax), %eax
xorl %r12d, %r12d
cmpl %eax, (%r15,%r12,4)
je 0x3d79
incq %r12
cmpq %r12, %r13
jne 0x3d64
movl %r13d, %r12d
xorl %edi, %edi
jmp 0x3d81
movzbl (%r14,%r12), %edi
xorl $0x1, %edi
leaq 0x575b(%rip), %rsi      # 0x94e3
movl $0x38, %edx
leaq 0x592a(%rip), %rcx      # 0x96be
leaq 0x5778(%rip), %r8       # 0x9513
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3de2
movl %r12d, %eax
movq %r14, %r12
movb $0x1, (%r14,%rax)
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6222
movq %rax, %rbx
testq %rax, %rax
jne 0x3d40
movq %r14, %rdi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6158
callq 0x2e49
// File: /workspace/github_c_makefile_star2_O3/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 0x4b3a
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52cd
movq %rax, %rbx
movq %rax, %rdi
callq 0x5f7e
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x56cd(%rip), %rsi      # 0x94e3
leaq 0x58a1(%rip), %rcx      # 0x96be
leaq 0x5709(%rip), %r8       # 0x952d
movl $0x45, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3e44
movq %rbx, %rdi
callq 0x6158
xorl %eax, %eax
popq %rbx
jmp 0x4bfd
callq 0x2e49
// File: /workspace/github_c_makefile_star2_O3/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 0x4b3a
movl 0xa65c(%rip), %eax      # 0xe4c0
movq %rsp, %rbx
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
subq %rcx, %rbx
movq %rbx, %rsp
testl %eax, %eax
jle 0x3f24
leaq 0xa318(%rip), %r14      # 0xe1a0
leaq 0x5654(%rip), %r15      # 0x94e3
leaq 0x5828(%rip), %r12      # 0x96be
xorl %r13d, %r13d
movl (%r14), %eax
movl %eax, (%rbx,%r13,4)
movq %r14, %rdi
callq 0x4e36
xorb $0x1, %al
movzbl %al, %edi
movq %r15, %rsi
movl $0x54, %edx
movq %r12, %rcx
leaq 0x5683(%rip), %r8       # 0x9542
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f39
movq %r14, %rdi
callq 0x4e36
movzbl %al, %edi
movq %r15, %rsi
movl $0x55, %edx
movq %r12, %rcx
leaq 0x565c(%rip), %r8       # 0x9543
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f39
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52cd
incq %r13
movq %rax, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x3caf
movslq 0xa5a9(%rip), %rax      # 0xe4c0
addq $0x28, %r14
cmpq %rax, %r13
jl 0x3e99
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4bfd
callq 0x2e49
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
xorl %eax, %eax
callq 0x4b3a
movl 0xa567(%rip), %eax      # 0xe4c0
movq %rsp, %rbx
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
subq %rcx, %rbx
movq %rbx, %rsp
testl %eax, %eax
jle 0x4064
leaq 0xa223(%rip), %r14      # 0xe1a0
xorl %r15d, %r15d
movl (%r14), %eax
movl %eax, (%rbx,%r15,4)
movq %r14, %rdi
callq 0x4e36
incq %r15
movslq 0xa527(%rip), %rax      # 0xe4c0
addq $0x28, %r14
cmpq %rax, %r15
jl 0x3f80
testl %eax, %eax
jle 0x4064
addq $0x4, %rbx
leaq 0xa1eb(%rip), %r12      # 0xe1a0
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movl (%r12), %edi
callq 0x50b2
movzbl %al, %edi
leaq 0x5512(%rip), %r15      # 0x94e3
movq %r15, %rsi
movl $0x6b, %edx
leaq 0x56de(%rip), %rcx      # 0x96be
leaq 0x557b(%rip), %r8       # 0x9562
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x4079
movl (%r12), %edi
callq 0x50b2
xorb $0x1, %al
movzbl %al, %edi
movq %r15, %rsi
movl $0x6c, %edx
leaq 0x56ab(%rip), %rcx      # 0x96be
leaq 0x5547(%rip), %r8       # 0x9561
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x4079
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52cd
incq %r14
movl 0xa485(%rip), %edx      # 0xe4c0
addl %r13d, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3caf
movslq 0xa470(%rip), %rax      # 0xe4c0
addq $0x28, %r12
decl %r13d
addq $0x4, %rbx
cmpq %rax, %r14
jl 0x3fbe
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4bfd
callq 0x2e49
// File: /workspace/github_c_makefile_star2_O3/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 0x52cd
movq %rax, %r13
movq %rax, %rdi
callq 0x5f7e
movl %eax, %ebp
movq %r13, %rdi
callq 0x6158
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5510
xorl %edi, %edi
cmpl %ebp, %eax
sete %dil
leaq 0x529c(%rip), %rsi      # 0x94e3
leaq 0x5470(%rip), %rcx      # 0x96be
leaq 0x5338(%rip), %r8       # 0x958d
movl $0xa4, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x4274
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e49
// File: /workspace/github_c_makefile_star2_O3/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 %eax, %eax
callq 0x4b3a
cmpl $0x0, 0xa235(%rip)      # 0xe4c0
jle 0x42b2
leaq 0x9f0c(%rip), %rbx      # 0xe1a0
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x4e36
incq %r14
movslq 0xa217(%rip), %rax      # 0xe4c0
addq $0x28, %rbx
cmpq %rax, %r14
jl 0x4297
leaq 0x513f(%rip), %rbx      # 0x93f8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x41f6
leaq 0x50cd(%rip), %r14      # 0x939b
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x41f6
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x41f6
leaq 0x50b3(%rip), %rbx      # 0x93a5
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x41f6
leaq 0x527b(%rip), %rcx      # 0x9582
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x41f6
leaq 0x5078(%rip), %rdi      # 0x9391
leaq 0x5116(%rip), %r14      # 0x9436
leaq 0x5170(%rip), %rcx      # 0x9497
xorl %esi, %esi
movq %r14, %rdx
callq 0x41f6
leaq 0x507e(%rip), %rsi      # 0x93b6
xorl %edi, %edi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x41f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4bfd
// File: /workspace/github_c_makefile_star2_O3/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 0x5c62
movq %rax, %r14
movq %rax, %rdi
callq 0x5f7e
xorl %edi, %edi
cmpl %ebp, %eax
sete %dil
leaq 0x5161(%rip), %rsi      # 0x94e3
leaq 0x5335(%rip), %rcx      # 0x96be
leaq 0x523d(%rip), %r8       # 0x95cd
movl $0xbf, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x4434
movq %r14, %rdi
callq 0x61d9
testq %rax, %rax
je 0x441e
movq %rax, %r15
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
leaq 0x5223(%rip), %rbp      # 0x95e4
movq %r14, %rdi
movq %r15, %rsi
callq 0x6265
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5510
movl %eax, %r12d
xorl %edi, %edi
cmpl %r13d, %eax
setle %dil
leaq 0x50f5(%rip), %rsi      # 0x94e3
movl $0xc4, %edx
leaq 0x52c4(%rip), %rcx      # 0x96be
movq %rbp, %r8
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x4434
movq %r14, %rdi
movq %r15, %rsi
callq 0x6222
movq %rax, %r15
movl %r12d, %r13d
testq %rax, %rax
jne 0x43c1
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6158
callq 0x2e49
// File: /workspace/github_c_makefile_star2_O3/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 %eax, %eax
callq 0x4b3a
cmpl $0x0, 0xa075(%rip)      # 0xe4c0
jle 0x4472
leaq 0x9d4c(%rip), %rbx      # 0xe1a0
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x4e36
incq %r14
movslq 0xa057(%rip), %rax      # 0xe4c0
addq $0x28, %rbx
cmpq %rax, %r14
jl 0x4457
movl $0x1, %ebx
leaq 0x4f61(%rip), %r14      # 0x93df
movl %ebx, %edi
movq %r14, %rsi
callq 0x4353
incl %ebx
cmpl $0x3, %ebx
jne 0x447e
movl $0x1, %ebx
leaq 0x4f00(%rip), %r14      # 0x939b
movl %ebx, %edi
movq %r14, %rsi
callq 0x4353
incl %ebx
cmpl $0x4, %ebx
jne 0x449b
movl $0x1, %ebx
movl %ebx, %edi
xorl %esi, %esi
callq 0x4353
incl %ebx
cmpl $0x7, %ebx
jne 0x44b1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4bfd
// File: /workspace/github_c_makefile_star2_O3/giannisdravilas[P]Disease-Monitor/tests/../include/acutest.h
// Function: test_timer_print_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:
cvtsi2sdq 0xa228(%rip), %xmm1 # 0xe700
movsd 0x4b28(%rip), %xmm2     # 0x9008
mulsd %xmm2, %xmm1
cvtsi2sdq 0xa21b(%rip), %xmm0 # 0xe708
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0xa1f3(%rip), %xmm1 # 0xe6f0
cvtsi2sdq 0xa1f2(%rip), %xmm3 # 0xe6f8
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm3
subsd %xmm3, %xmm0
divsd %xmm2, %xmm0
leaq 0x5165(%rip), %rdi      # 0x9682
movb $0x1, %al
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x473b
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, 0x9a4e(%rip)      # 0xe190
jl 0x47b7
movq %rdi, %rbx
movl $0x1, %edi
callq 0x28a3
cmpl $0x3, 0x9a38(%rip)      # 0xe190
jl 0x476d
leaq 0x5269(%rip), %rsi      # 0x99ca
movl $0x5, %edi
xorl %eax, %eax
callq 0x2909
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 0x21e0
movl $0xa, %edi
callq 0x2030
cmpl $0x3, 0x99e5(%rip)      # 0xe190
jl 0x47b7
movl $0xa, %edi
callq 0x2030
addq $0xd0, %rsp
popq %rbx
retq