LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/annoroad[P]fqtools_plus/fqtools.c
// Function: get_space
local space* get_space(struct pool* pool){
	struct space* space;
	possess(pool->have);
	
	if (pool->limit == 0){
		wait_for(pool->have, NOT_TO_BE, 0);
	}
	
	if (pool->head != NULL){
		space = pool->head;
		possess(space->use);
		pool->head = space->next;
		twist(pool->have,BY,-1);
		twist(space->use,TO,1);
		return(space);
	}
	if (pool->limit > 0){
		pool->limit--;
	}
	release(pool->have);
	space = new_space(pool);
	return(space);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x837e(%rip), %rdi      # 0xb2c0
callq 0x6275
cmpl $0x0, 0x8382(%rip)      # 0xb2d0
jne 0x2f63
movq 0x8369(%rip), %rdi      # 0xb2c0
movl $0x1, %esi
xorl %edx, %edx
callq 0x63db
movq 0x835e(%rip), %rbx      # 0xb2c8
testq %rbx, %rbx
je 0x2fb4
movq (%rbx), %rdi
callq 0x6275
movq 0x10(%rbx), %rax
movq %rax, 0x8346(%rip)      # 0xb2c8
movq 0x8337(%rip), %rdi      # 0xb2c0
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x63a4
movq (%rbx), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x63a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8316(%rip), %eax      # 0xb2d0
testl %eax, %eax
jle 0x2fc6
decl %eax
movl %eax, 0x830a(%rip)      # 0xb2d0
leaq 0x82f3(%rip), %r14      # 0xb2c0
movq 0x82ec(%rip), %rdi      # 0xb2c0
callq 0x6286
movl $0x20, %edi
callq 0x21b0
movq %rax, %rbx
movl $0x1, %edi
callq 0x6200
movq %rax, (%rbx)
movq %r14, 0x18(%rbx)
movq $0x0, 0x10(%rbx)
movl $0x18, %edi
callq 0x21b0
movq %rax, %r14
movq %rax, 0x8(%rbx)
movl $0x6e078, %edi          # imm = 0x6E078
callq 0x21b0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rax, 0x10(%r14)
movl $0x6e078, %edx          # imm = 0x6E078
movq %rax, %rdi
xorl %esi, %esi
callq 0x2100
movl $0x1428, %edi           # imm = 0x1428
callq 0x21b0
movq %rax, (%r14)
movl $0x1428, %edx           # imm = 0x1428
movq %rax, %rdi
xorl %esi, %esi
callq 0x2100
movq 0x81b9(%rip), %rdi      # 0xb210
cmpb $0x0, (%rdi)
je 0x3071
movl 0x81be(%rip), %esi      # 0xb220
callq 0x6838
movq (%r14), %rcx
movq %rax, 0x1420(%rcx)
cmpb $0x0, 0x8148(%rip)      # 0xb1c0
je 0x2fa9
movl $0x1428, %edi           # imm = 0x1428
callq 0x21b0
movq %rax, 0x8(%r14)
movl $0x1428, %edx           # imm = 0x1428
movq %rax, %rdi
xorl %esi, %esi
callq 0x2100
movq 0x8176(%rip), %rdi      # 0xb218
cmpb $0x0, (%rdi)
je 0x2fa9
movl 0x816f(%rip), %esi      # 0xb220
callq 0x6838
movq 0x8(%r14), %rcx
movq %rax, 0x1420(%rcx)
jmp 0x2fa9
// File: /workspace/github_c_makefile_star2_O1/annoroad[P]fqtools_plus/fqtools.c
// Function: readn
local int readn(struct space* space){
	if (!space->pool->term) return(0);
	readline* read1 = space->readclass->read1;
	if (!gzgets(g.gzfp1,read1->reads[0],1024)) return(0);
	else g.read1Count++;
	if (!gzgets(g.gzfp1,read1->reads[1],1024))	return(0);
	if (!gzgets(g.gzfp1,read1->reads[2],1024))	return(0);
	if (!gzgets(g.gzfp1,read1->reads[3],1024))	return(0);

	if (g.single_or_pair){
		readline* read2 = space->readclass->read2;
		if (!gzgets(g.gzfp2,read2->reads[0],1024)) return(0);
		else g.read2Count++;
		if (!gzgets(g.gzfp2,read2->reads[1],1024))	return(0);
		if (!gzgets(g.gzfp2,read2->reads[2],1024))	return(0);
		if (!gzgets(g.gzfp2,read2->reads[3],1024))	return(0);
	}
	return(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
xorl %ebx, %ebx
cmpb $0x0, 0x14(%rax)
je 0x3205
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax), %r15
movq 0x818c(%rip), %rdi      # 0xb278
leaq 0x1d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
incq 0x80f6(%rip)            # 0xb200
movq 0x8167(%rip), %rdi      # 0xb278
leaq 0x41d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
movq 0x8146(%rip), %rdi      # 0xb278
leaq 0x81d(%r15), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
movq 0x8125(%rip), %rdi      # 0xb278
addq $0xc1d, %r15            # imm = 0xC1D
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
cmpb $0x0, 0x8049(%rip)      # 0xb1c0
je 0x3200
movq 0x8(%r14), %rax
movq 0x8(%rax), %r14
movq 0x80f4(%rip), %rdi      # 0xb280
leaq 0x1d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
incq 0x8062(%rip)            # 0xb208
movq 0x80d3(%rip), %rdi      # 0xb280
leaq 0x41d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
movq 0x80b6(%rip), %rdi      # 0xb280
leaq 0x81d(%r14), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
movq 0x8099(%rip), %rdi      # 0xb280
addq $0xc1d, %r14            # imm = 0xC1D
movq %r14, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
testq %rax, %rax
je 0x3205
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/annoroad[P]fqtools_plus/fqtools.c
// Function: to_buffer_raw
local void to_buffer_raw(struct readclass* readclass, struct job* job){
	if (job->buffer1_raw == NULL) {job->buffer1_raw = malloc(1024*4);memset(job->buffer1_raw,0,1024*4);}
	char* cur1 = job->buffer1_raw;
	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_r = strlen(job->buffer1_raw);
	if (g.single_or_pair){
		if (job->buffer2_raw == NULL) {job->buffer2_raw = malloc(1024*4);memset(job->buffer2_raw,0,1024*4);}
		char* cur2 = job->buffer2_raw;
		char (*reads2)[1024] = readclass->read2->reads;
		for (i=0;i<4;i++){
			j=0;
			while( (*cur2++ = reads2[i][j++]) != '\n' ){}
		}
		*cur2 = '\0';
		job->l2_r = strlen(job->buffer2_raw);
	}
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x50(%rsi)
jne 0x3b5c
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, 0x50(%rbx)
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rdi
xorl %esi, %esi
callq 0x2100
movq 0x50(%rbx), %rax
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 0x3b6c
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x3b69
movb $0x0, (%rax)
movq 0x50(%rbx), %rdi
callq 0x20c0
movl %eax, 0x58(%rbx)
cmpb $0x0, 0x761c(%rip)      # 0xb1c0
je 0x3c0c
cmpq $0x0, 0x60(%rbx)
jne 0x3bca
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, 0x60(%rbx)
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rdi
xorl %esi, %esi
callq 0x2100
movq 0x60(%rbx), %rax
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 0x3bdb
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x3bd8
movb $0x0, (%rax)
movq 0x60(%rbx), %rdi
callq 0x20c0
movl %eax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/annoroad[P]fqtools_plus/fqtools.c
// Function: raw_Q30
local void raw_Q30(struct readclass* readclass){
	int i=0;
	int curqual;
	readline* read1 = readclass->read1;
	
	STAT* stat = readclass->stat;
	char* qual=(read1->reads)[3];
	while (i < read1->seqlen){
		curqual=(int)*(qual + i) - g.ASCII;
		if (curqual >= g.HIGHQ){
			stat->raw_Q30_bases++;
		}
		i++;
	}
	if (g.single_or_pair){
		readline* read2 = readclass->read2;
		i = 0;
		qual=(read2->reads)[3];
		while (i < read2->seqlen){
			curqual=(int)*(qual + i) - g.ASCII;
			if (curqual >= g.HIGHQ){
				stat->raw_Q30_bases++;
			}
			i++;
		}
	}
		
	
}

// Assembly:
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x3c50
movl 0x75cb(%rip), %esi      # 0xb1f4
movl 0x75ac(%rip), %r8d      # 0xb1dc
xorl %r9d, %r9d
movsbl 0xc1d(%rcx,%r9), %r10d
subl %esi, %r10d
cmpl %r8d, %r10d
jl 0x3c48
incq 0x40(%rax)
incq %r9
cmpq %r9, %rdx
jne 0x3c33
cmpb $0x0, 0x7569(%rip)      # 0xb1c0
je 0x3c91
movq 0x8(%rdi), %rcx
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x3c91
movl 0x7589(%rip), %esi      # 0xb1f4
movl 0x756b(%rip), %edi      # 0xb1dc
xorl %r8d, %r8d
movsbl 0xc1d(%rcx,%r8), %r9d
subl %esi, %r9d
cmpl %edi, %r9d
jl 0x3c89
incq 0x40(%rax)
incq %r8
cmpq %r8, %rdx
jne 0x3c74
retq
// File: /workspace/github_c_makefile_star2_O1/annoroad[P]fqtools_plus/fqtools.c
// Function: cutseq
local void cutseq(struct readclass* readclass){
	readline* read1 = readclass->read1;
	memcpy((read1->reads)[1],(read1->reads)[1] + g.start,g.CUT);
	*((read1->reads)[1] + g.CUT) = '\n';
	*((read1->reads)[1] + g.CUT + 1) = '\0';
	memcpy((read1->reads)[3],(read1->reads)[3] + g.start,g.CUT);
	*((read1->reads)[3] + g.CUT) = '\n';
	*((read1->reads)[3] + g.CUT + 1) = '\0';
	if (g.single_or_pair){
		readline* read2 = readclass->read2;
		memcpy((read2->reads)[1],(read2->reads)[1],g.CUT);
		*((read2->reads)[1] + g.CUT) = '\n';
		*((read2->reads)[1] + g.CUT + 1) = '\0';
		memcpy((read2->reads)[3],(read2->reads)[3],g.CUT);
		*((read2->reads)[3] + g.CUT) = '\n';
		*((read2->reads)[3] + g.CUT + 1) = '\0';
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x41d(%r15), %rdi
movslq 0x751a(%rip), %rax      # 0xb1c8
leaq (%r15,%rax), %rsi
addq $0x41d, %rsi            # imm = 0x41D
movslq 0x7504(%rip), %r14      # 0xb1c4
movq %r14, %rdx
callq 0x2160
movb $0xa, %bpl
movb %bpl, 0x41d(%r15,%r14)
movslq 0x74ea(%rip), %rax      # 0xb1c4
xorl %r12d, %r12d
movb %r12b, 0x41e(%r15,%rax)
leaq 0xc1d(%r15), %rdi
movslq 0x74d5(%rip), %rax      # 0xb1c8
leaq (%r15,%rax), %rsi
addq $0xc1d, %rsi            # imm = 0xC1D
movslq 0x74bf(%rip), %r14      # 0xb1c4
movq %r14, %rdx
callq 0x2160
movb %bpl, 0xc1d(%r15,%r14)
movslq 0x74a8(%rip), %rax      # 0xb1c4
movb %r12b, 0xc1e(%r15,%rax)
cmpb %r12b, 0x7495(%rip)     # 0xb1c0
je 0x3d6d
movq 0x8(%rbx), %rax
movslq 0x748c(%rip), %rcx      # 0xb1c4
movb %bpl, 0x41d(%rax,%rcx)
movslq 0x747d(%rip), %rcx      # 0xb1c4
xorl %edx, %edx
movb %dl, 0x41e(%rax,%rcx)
movslq 0x746d(%rip), %rcx      # 0xb1c4
movb %bpl, 0xc1d(%rax,%rcx)
movslq 0x745e(%rip), %rcx      # 0xb1c4
movb %dl, 0xc1e(%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/annoroad[P]fqtools_plus/fqtools.c
// Function: checkadapter
local char checkadapter(struct readclass* readclass){
	char a,b;
	b = 1;
	readline* read1 = readclass->read1;
	if (read1->adapter){
		read1->adapter->n = read1->seqlen;
		read1->adapter->s2 = (read1->reads)[1];
		a = match(read1->adapter);
	}else{
		a= get_index(g.table1, read1->id);
	}

	if (g.single_or_pair){
		readline* read2 = readclass->read2;
		if (read2->adapter){
			read2->adapter->n = read2->seqlen;
			read2->adapter->s2 = (read2->reads)[1];
			b = match(read2->adapter);
		}else{
			b= get_index(g.table2, read2->id);
		}
	}
	return(a * b);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rsi
movq 0x1420(%rsi), %rdi
testq %rdi, %rdi
je 0x3da6
movl (%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x41d, %rsi            # imm = 0x41D
movq %rsi, 0x220(%rdi)
callq 0x689d
jmp 0x3db9
movq 0x747b(%rip), %rdi      # 0xb228
addq $0x101d, %rsi           # imm = 0x101D
callq 0x67bf
movl %eax, %ebx
cmpb $0x0, 0x73fe(%rip)      # 0xb1c0
je 0x3dee
movq 0x8(%r14), %rsi
movq 0x1420(%rsi), %rdi
testq %rdi, %rdi
je 0x3df2
movl (%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x41d, %rsi            # imm = 0x41D
movq %rsi, 0x220(%rdi)
callq 0x689d
jmp 0x3e05
movb $0x1, %al
jmp 0x3e05
movq 0x7437(%rip), %rdi      # 0xb230
addq $0x101d, %rsi           # imm = 0x101D
callq 0x67bf
mulb %bl
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x4069
movl %esi, %ebx
movq %rdi, %r14
callq 0x20c0
cmpl $0x2, %eax
setge %cl
jl 0x4069
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1, %edx
subq %rax, %rdx
movl $0x1, %edi
movl $0x2, %esi
movzbl -0x1(%r14,%rsi), %r9d
xorl %r8d, %r8d
cmpl $0x54, %r9d
je 0x4040
cmpl $0x41, %r9d
jne 0x4050
cmpb -0x2(%r14,%rsi), %r9b
jne 0x4050
incl %edi
movl %edi, %r8d
cmpl %ebx, %edi
je 0x4073
cmpq %rax, %rsi
setb %cl
leaq (%rdx,%rsi), %r9
incq %r9
incq %rsi
movl %r8d, %edi
cmpq $0x2, %r9
jne 0x402b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
testb $0x1, %cl
je 0x4069
jmp 0x406b
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x30(%rsi)
jne 0x42ac
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, 0x30(%rbx)
movq 0x30(%rbx), %rax
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 0x42bc
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x42b9
movb $0x0, (%rax)
movq 0x30(%rbx), %rdi
callq 0x20c0
movl %eax, 0x38(%rbx)
cmpb $0x0, 0x6ecc(%rip)      # 0xb1c0
je 0x434d
cmpq $0x0, 0x40(%rbx)
jne 0x430b
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, 0x40(%rbx)
movq 0x40(%rbx), %rax
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 0x431c
incq %rdx
addq $0x400, %rcx            # imm = 0x400
cmpq $0x4, %rdx
jne 0x4319
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_O1/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 0x6d20(%rip), %rdi      # 0xb2c0
callq 0x6275
movq 0x6d1c(%rip), %rbx      # 0xb2c8
testq %rbx, %rbx
je 0x4630
movq 0x10(%rbx), %rax
movq %rax, 0x6d0c(%rip)      # 0xb2c8
movq (%rbx), %rdi
callq 0x6245
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, 0x6bd5(%rip)      # 0xb1c0
je 0x4601
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, 0x6bac(%rip)      # 0xb1c0
je 0x4623
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2040
jmp 0x45a5
movq 0x6c89(%rip), %rdi      # 0xb2c0
callq 0x6286
movq 0x6c7d(%rip), %rdi      # 0xb2c0
popq %rbx
jmp 0x6245
// File: /workspace/github_c_makefile_star2_O1/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 0x190c(%rip), %rsi      # 0x70da
movq %r12, %rdi
callq 0x2140
testl %eax, %eax
je 0x5822
leaq 0x194f(%rip), %rsi      # 0x7130
movq %r12, %rdi
callq 0x2140
testl %eax, %eax
je 0x5861
leaq 0x19ba(%rip), %rsi      # 0x71ae
movq %r12, %rdi
callq 0x2140
testl %eax, %eax
je 0x58dc
leaq 0x18f5(%rip), %rsi      # 0x7100
movq %r12, %rdi
callq 0x2140
testl %eax, %eax
je 0x58e9
xorl %eax, %eax
jmp 0x5925
testl %r15d, %r15d
jle 0x5852
callq 0x2340
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 0x5925
incq %rdx
cmpq %rdx, %r15
jne 0x583a
movq %r14, %rdi
callq 0x2280
movl %eax, (%rbx)
jmp 0x5920
movq %rbx, 0x8(%rsp)
testl %r15d, %r15d
jle 0x58c5
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 0x58be
callq 0x2340
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r12,2)
je 0x581b
incq %rbx
incl %r13d
cmpq 0x10(%rsp), %rbx
jl 0x5888
jmp 0x58c5
xorl %ebp, %ebp
cmpl %r15d, %r13d
jl 0x587e
movq %r14, %rdi
callq 0x2090
cvtsd2ss %xmm0, %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
jmp 0x5920
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2050
jmp 0x5920
testl %r15d, %r15d
jle 0x5915
callq 0x2340
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 0x5925
incq %rdx
cmpq %rdx, %r15
jne 0x5901
movq %r14, %rdi
callq 0x2230
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_O1/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 0x5108(%rip), %rdi      # 0xb2b0
callq 0x6275
movq 0x5104(%rip), %rax      # 0xb2b8
leaq 0x50fd(%rip), %rcx      # 0xb2b8
testq %rax, %rax
je 0x61dd
movq (%rbx), %rdx
cmpq %rdx, (%rax)
jg 0x61dd
movq %rax, %rcx
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x61d9
cmpq %rdx, (%rax)
jle 0x61c8
addq $0x20, %rcx
movq %rax, 0x20(%rbx)
movq %rbx, (%rcx)
movq 0x50c5(%rip), %rdi      # 0xb2b0
movq 0x50c6(%rip), %rax      # 0xb2b8
movq (%rax), %rdx
xorl %esi, %esi
popq %rbx
jmp 0x63a4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x21b0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x2300
testl %eax, %eax
jne 0x6240
leaq 0x28(%r14), %rdi
xorl %esi, %esi
callq 0x2180
testl %eax, %eax
jne 0x6240
movq %rbx, 0x58(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2592
// File: /workspace/github_c_makefile_star2_O1/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 0x6267
leaq 0x28(%rbx), %rdi
callq 0x2240
testl %eax, %eax
jne 0x6270
movq %rbx, %rdi
callq 0x20e0
testl %eax, %eax
jne 0x6270
movq %rbx, %rdi
popq %rbx
jmp 0x2040
callq 0x25b6
// File: /workspace/github_c_makefile_star2_O1/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 0x730cb(%rip), %rdi     # 0x79378
callq 0x6275
movl $0x10, %edi
callq 0x21b0
movq %rax, %r14
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2130
testl %eax, %eax
jne 0x634c
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2190
testl %eax, %eax
jne 0x634c
leaq 0x59(%rip), %rdx        # 0x6351
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x21e0
testl %eax, %eax
jne 0x634c
leaq 0x8(%rsp), %rdi
callq 0x2270
testl %eax, %eax
jne 0x634c
movl $0x0, 0x10(%rbx)
movq 0x730b0(%rip), %rax     # 0x793d8
movq %rax, 0x8(%rbx)
movq %rbx, 0x730a5(%rip)     # 0x793d8
leaq 0x7303e(%rip), %rdi     # 0x79378
callq 0x6286
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x2622
// File: /workspace/github_c_makefile_star2_O1/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 0x22e0
testl %eax, %eax
jne 0x6397
movq %rsp, %r14
movq %r14, %rdi
callq 0x22c0
movq 0x8(%rbx), %rdi
callq *(%rbx)
movq %rbx, %rdi
callq 0x2040
movq %r14, %rdi
callq 0x20f0
callq 0x65cb
addq $0x68, %rsp
popq %rbx
popq %r14
retq
callq 0x65cb
movq %rsp, %rdi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O1/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 0x63b7
testl %esi, %esi
jne 0x63bb
movq %rdx, 0x58(%rbx)
jmp 0x63bb
addq %rdx, 0x58(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x2060
testl %eax, %eax
jne 0x63d6
movq %rbx, %rdi
callq 0x21a0
testl %eax, %eax
jne 0x63d6
popq %rbx
retq
callq 0x2646
// File: /workspace/github_c_makefile_star2_O1/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 0x6479
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %eax
leaq 0x1b70(%rip), %rcx      # 0x7f68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
je 0x6479
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x6405
callq 0x26d6
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jge 0x6479
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x6423
callq 0x268e
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jle 0x6479
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x6441
callq 0x266a
leaq 0x28(%r14), %r15
cmpq %rbx, 0x58(%r14)
jne 0x6479
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
testl %eax, %eax
je 0x645f
callq 0x26b2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22d0
testl %eax, %eax
jne 0x64e6
leaq 0x72ee0(%rip), %rdi     # 0x79378
callq 0x6275
leaq 0x72f34(%rip), %rdx     # 0x793d8
movq %rdx, %rax
movq (%rdx), %rcx
testq %rcx, %rcx
je 0x64b8
leaq 0x8(%rcx), %rdx
cmpq %rbx, %rcx
jne 0x64a4
testq %rcx, %rcx
je 0x64eb
cmpl $0x0, 0x10(%rcx)
je 0x64ca
decq 0x72f06(%rip)           # 0x793d0
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
leaq 0x72ea0(%rip), %rdi     # 0x79378
callq 0x6286
movq %rbx, %rdi
popq %rbx
jmp 0x2040
callq 0x26fa
callq 0x271e
// File: /workspace/github_c_makefile_star2_O1/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 0x72e79(%rip), %rdi     # 0x79378
callq 0x6275
cmpq $0x0, 0x72ecc(%rip)     # 0x793d8
je 0x658c
leaq 0x72e63(%rip), %rbx     # 0x79378
leaq 0x72ebc(%rip), %r15     # 0x793d8
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x63db
movq 0x72ea6(%rip), %r14     # 0x793d8
testq %r14, %r14
je 0x655a
cmpl $0x0, 0x10(%r14)
movq %r15, %r12
jne 0x655d
movq %r14, %r12
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x6554
cmpl $0x0, 0x10(%r14)
je 0x6541
addq $0x8, %r12
jmp 0x655d
movq %r15, %r12
movq (%r14), %rdi
xorl %esi, %esi
callq 0x22d0
testl %eax, %eax
jne 0x65a3
decq 0x72e5e(%rip)           # 0x793d0
movq 0x8(%r14), %rax
movq %rax, (%r12)
movq %r14, %rdi
callq 0x2040
cmpq $0x0, 0x72e4e(%rip)     # 0x793d8
jne 0x651c
leaq 0x72de5(%rip), %rdi     # 0x79378
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6286
callq 0x2742
// File: /workspace/github_c_makefile_star2_O1/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 0x2210
movq %rax, %rbx
leaq 0x72d99(%rip), %rdi     # 0x79378
callq 0x6275
movq 0x72ded(%rip), %r14     # 0x793d8
testq %r14, %r14
je 0x666c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21f0
testl %eax, %eax
je 0x6608
leaq 0x72dd2(%rip), %r15     # 0x793d8
jmp 0x6627
movq %r14, %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x666c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21f0
testl %eax, %eax
je 0x6608
addq $0x8, %r15
movl $0x1, 0x10(%r14)
cmpq 0x72da2(%rip), %r14     # 0x793d8
je 0x6651
movq 0x8(%r14), %rax
movq %rax, (%r15)
movq 0x72d92(%rip), %rax     # 0x793d8
movq %rax, 0x8(%r14)
movq %r14, 0x72d87(%rip)     # 0x793d8
leaq 0x72d20(%rip), %rdi     # 0x79378
movl $0x1, %edx
movl $0x1, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x63a4
callq 0x278a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x66ad
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 0x66a3
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x6685
retq
movl $0x1505, %eax           # imm = 0x1505
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21b0
movq %rax, %rbx
movl $0x100000, (%rax)       # imm = 0x100000
movl $0x400000, %edi         # imm = 0x400000
callq 0x21b0
movq %rax, 0x8(%rbx)
movl $0x800000, %edi         # imm = 0x800000
callq 0x21b0
movq %rax, 0x10(%rbx)
movl $0x800000, %edx         # imm = 0x800000
movq %rax, %rdi
xorl %esi, %esi
callq 0x2100
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r13
movb (%rsi), %dl
testb %dl, %dl
je 0x674d
movslq (%r13), %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 0x6740
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x6722
movl %eax, %ebp
jmp 0x6752
movl $0x1505, %ebp           # imm = 0x1505
movl $0x18, %edi
callq 0x21b0
movq %rax, %r15
movq %r14, %rdi
callq 0x20c0
leaq 0x1(%rax), %rdi
callq 0x21b0
movq %rax, %r12
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movq %r14, %rdi
callq 0x20c0
movb $0x0, (%r12,%rax)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%r15)
movq 0x10(%r13), %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 $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6803
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 0x67f6
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x67d8
movl %eax, %eax
jmp 0x6808
movl $0x1505, %eax           # imm = 0x1505
movq 0x10(%rdi), %rcx
movq (%rcx,%rax,8), %r14
movb $0x1, %bpl
testq %r14, %r14
je 0x682f
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2140
testl %eax, %eax
je 0x682d
movq 0x10(%r14), %r14
jmp 0x6813
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x21b0
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 0x21b0
movq %rax, (%rbx)
movl $0x18, %edi
callq 0x21b0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movl $0x18, %edi
callq 0x10f0
andb $-0x10, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x47b2
leaq 0xafa(%rip), %rsi       # 0x523a
callq 0x1140
testq %rax, %rax
je 0x47b2
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 0x9db(%rip), %rdi       # 0x5181
movq %r14, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x47b5
xorl %r14d, %r14d
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x279c
movq %rax, %r14
movq 0x2822(%rip), %rax      # 0x6ff0
movq (%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x198b
movl $0xa, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x2ada
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ba1
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xbef9(%rip)      # 0xe6c0
jne 0x2817
testl %ebx, %ebx
leaq 0x6e84(%rip), %rax      # 0x9656
leaq 0x6e79(%rip), %rsi      # 0x9652
cmoveq %rax, %rsi
movl 0xbf05(%rip), %edx      # 0xe6e8
incl %edx
movq 0xbd7c(%rip), %rax      # 0xe568
movq (%rax), %rcx
leaq 0x6e63(%rip), %rdi      # 0x9659
xorl %eax, %eax
callq 0x2100
testl %ebx, %ebx
jne 0x288a
cmpl $0x0, 0xbee0(%rip)      # 0xe6ec
je 0x288a
leaq 0x6e50(%rip), %rdi      # 0x9665
jmp 0x2870
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
leaq 0x6e4c(%rip), %rax      # 0x9672
leaq 0x6e48(%rip), %r14      # 0x9675
cmoveq %rax, %r14
xorl $0x5, %ebp
leaq 0x6e41(%rip), %rdi      # 0x967c
xorl %eax, %eax
callq 0x2100
movl %ebp, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x28f5
leaq 0x6e2a(%rip), %rdi      # 0x967f
xorl %eax, %eax
callq 0x2100
testl %ebx, %ebx
jne 0x287c
cmpl $0x0, 0xbe85(%rip)      # 0xe6ec
je 0x287c
leaq 0x6934(%rip), %rdi      # 0x91a4
xorl %eax, %eax
callq 0x2100
callq 0x45fe
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xbe21(%rip)      # 0xe6c0
jne 0x28ad
decl %ebx
movl $0x23, %edi
callq 0x2030
cmpl $0x11, %ebx
jl 0x28d9
leaq 0x6e08(%rip), %r14      # 0x96c1
leaq 0x6810(%rip), %r15      # 0x90d0
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
leal -0x10(%rbx), %esi
cmpl $0x20, %ebx
movl %esi, %ebx
jg 0x28c0
jmp 0x28db
movl %ebx, %esi
leaq 0x6dab(%rip), %rdi      # 0x968d
leaq 0x67e7(%rip), %rdx      # 0x90d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x2a67
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, 0xb722(%rip)      # 0xe190
jl 0x2b0f
movq %rdi, %r10
cmpb $0x0, 0xbb02(%rip)      # 0xe580
je 0x2a91
movl $0x0, 0xbaea(%rip)      # 0xe574
movb $0x0, 0xbaef(%rip)      # 0xe580
testq %r10, %r10
je 0x2b0f
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 0xbabe(%rip), %rdi      # 0xe580
movl $0x3f, %esi
movq %r10, %rdx
callq 0x20a0
movb $0x0, 0xbae9(%rip)      # 0xe5bf
cmpl $0x3, 0xb6b3(%rip)      # 0xe190
jl 0x2b0f
movl $0x1, %edi
callq 0x288f
leaq 0x6687(%rip), %rsi      # 0x9177
leaq 0xba89(%rip), %rdx      # 0xe580
movl $0x3, %edi
xorl %eax, %eax
callq 0x28f5
incl 0xba57(%rip)            # 0xe560
incl 0xba65(%rip)            # 0xe574
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b77
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, 0xb612(%rip)      # 0xe190
jl 0x2c6c
cmpq $0x0, 0xb9dc(%rip)      # 0xe568
je 0x2c6c
cmpl $0x0, 0xba27(%rip)      # 0xe5c0
je 0x2c6c
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 0x2c4b
movq %rax, %r14
leaq 0xd0(%rsp), %rbx
leaq 0x6585(%rip), %r15      # 0x918f
cmpb $0x1, 0xb96f(%rip)      # 0xe580
movl $0x3, %edi
sbbl $0x0, %edi
callq 0x288f
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 0x2c0a
cmpb $0x0, (%rbx)
je 0x2c6c
cmpb $0x1, 0xb929(%rip)      # 0xe580
movl $0x3, %edi
sbbl $0x0, %edi
callq 0x288f
movq %rbx, %rdi
callq 0x2080
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e15
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2130
movq %r14, %rdi
callq 0x60ce
xorl %edi, %edi
cmpl -0x2c(%rbp), %eax
sete %dil
leaq 0x56b6(%rip), %rsi      # 0x94e3
leaq 0x588d(%rip), %rcx      # 0x96c1
leaq 0x56be(%rip), %r8       # 0x94f9
movl $0x30, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f09
movq %r14, %rdi
callq 0x6329
testq %rax, %rax
je 0x3ef3
movq %rax, %rbx
movq %r14, -0x38(%rbp)
movq %r14, %rdi
movq %r12, %r14
movq %rbx, %rsi
callq 0x63b5
movl $0x0, %r12d
movl $0x0, %edi
cmpl $0x0, -0x2c(%rbp)
jle 0x3ea8
movl (%rax), %eax
xorl %r12d, %r12d
cmpl %eax, (%r15,%r12,4)
je 0x3ea0
incq %r12
cmpq %r12, %r13
jne 0x3e8b
movl %r13d, %r12d
xorl %edi, %edi
jmp 0x3ea8
movzbl (%r14,%r12), %edi
xorl $0x1, %edi
leaq 0x5634(%rip), %rsi      # 0x94e3
movl $0x38, %edx
leaq 0x5806(%rip), %rcx      # 0x96c1
leaq 0x5651(%rip), %r8       # 0x9513
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f09
movl %r12d, %eax
movq %r14, %r12
movb $0x1, (%r14,%rax)
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6372
movq %rax, %rbx
testq %rax, %rax
jne 0x3e67
movq %r14, %rdi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62a8
callq 0x2e32
// File: /workspace/github_c_makefile_star2_O1/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 0x4c6e
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x541d
movq %rax, %rbx
movq %rax, %rdi
callq 0x60ce
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x55a6(%rip), %rsi      # 0x94e3
leaq 0x577d(%rip), %rcx      # 0x96c1
leaq 0x55e2(%rip), %r8       # 0x952d
movl $0x45, %edx
xorl %eax, %eax
callq 0x25fc
testl %eax, %eax
je 0x3f6b
movq %rbx, %rdi
callq 0x62a8
xorl %eax, %eax
popq %rbx
jmp 0x4d31
callq 0x2e32