LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x8040
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x2cc7
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8310
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2d34
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8040
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x8280
movq (%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x8280
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2d71
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x2d4d
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x8080
movq 0x8(%rsp), %rdi
callq 0x7890
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: finish_jobs
local void finish_jobs(void) {
    struct job job;
    // only do this once
    if (compress_have == NULL)
        return;

    // command all of the extant compress threads to return
    possess(compress_have);
    job.seq = -1;
    job.next = NULL;
    job.next1 = NULL;
    compress_head = &job;
    compress_tail = &(job.next);
    twist(compress_have, BY, +1);       // will wake them all up
    // join all of the compress threads, verify they all came back
    join_all();
    // free the resources
    merge_stat(&in_pool);
    free_pool(&in_pool);
    free_lock(write_first);
    free_lock(compress_have);
    if (g.outraw) free_lock(write_first_raw);
    compress_have = NULL;
    gzclose(g.gzfp1);
    if (g.single_or_pair) gzclose(g.gzfp2);
    fclose(g.fpout1);
    if (g.single_or_pair) fclose(g.fpout2);
    if (g.outraw){
    	fclose(g.fpout1_raw);
	    if (g.single_or_pair) fclose(g.fpout2_raw);
    }
}

// Assembly:
subq $0x78, %rsp
cmpq $0x0, 0x9d94(%rip)      # 0xd2f0
jne 0x3563
jmp 0x367f
movq 0x9d86(%rip), %rdi      # 0xd2f0
callq 0x8040
movq $-0x1, 0x8(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x9d62(%rip)      # 0xd2f8
leaq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x9d6a(%rip)      # 0xd310
movq 0x9d43(%rip), %rdi      # 0xd2f0
movl $0x1, %esi
movl $0x1, %edx
callq 0x8280
callq 0x85b0
leaq 0x9d10(%rip), %rdi      # 0xd2d8
callq 0x4ec0
leaq 0x9d04(%rip), %rdi      # 0xd2d8
callq 0x51c0
movq 0x9ce8(%rip), %rdi      # 0xd2c8
callq 0x7fe0
movq 0x9d04(%rip), %rdi      # 0xd2f0
callq 0x7fe0
cmpb $0x0, 0x9c1c(%rip)      # 0xd214
je 0x3606
movq 0x9cff(%rip), %rdi      # 0xd300
callq 0x7fe0
movq $0x0, 0x9cdf(%rip) # 0xd2f0
movq 0x9c78(%rip), %rdi      # 0xd290
callq 0x2030
cmpb $0x0, 0x9bb4(%rip)      # 0xd1d8
je 0x3632
movq 0x9c6b(%rip), %rdi      # 0xd298
callq 0x2030
movq 0x9c67(%rip), %rdi      # 0xd2a0
callq 0x20b0
cmpb $0x0, 0x9b93(%rip)      # 0xd1d8
je 0x3653
movq 0x9c5a(%rip), %rdi      # 0xd2a8
callq 0x20b0
cmpb $0x0, 0x9bba(%rip)      # 0xd214
je 0x367f
movq 0x9c4d(%rip), %rdi      # 0xd2b0
callq 0x20b0
cmpb $0x0, 0x9b69(%rip)      # 0xd1d8
je 0x367d
movq 0x9c40(%rip), %rdi      # 0xd2b8
callq 0x20b0
jmp 0x367f
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: new_pool
local void new_pool(pool* pool, int limit){
	pool->have = new_lock(0);
	pool->head = NULL;
	pool->limit = limit;
	pool->term = 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x7f60
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x14(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x3d85
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2110
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq $0x1d, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x3e0b
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movq 0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0xa, %eax
je 0x3dfc
jmp 0x3dbb
jmp 0x3dfe
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3dac
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x20c0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x58(%rax)
cmpb $0x0, 0x93a6(%rip)      # 0xd1d8
je 0x3f14
movq 0x28(%rsp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x3e6f
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2110
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1d, %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x3ef4
movl $0x0, 0x10(%rsp)
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0xa, %eax
je 0x3ee5
jmp 0x3ea5
jmp 0x3ee7
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3e96
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x20c0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x68(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: substr_
local inline void substr_(const char* line, char* str){
	while(*line++ != '\n'){
		*str = *line;
		str++;
	}
	*str = '\0';
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x3f61
movq -0x8(%rsp), %rax
movb (%rax), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x3f2a
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
addq $0x1d, %rax
addq $0xc00, %rax            # imm = 0xC00
movq %rax, -0x28(%rsp)
movl -0xc(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x3ffb
movq -0x28(%rsp), %rax
movslq -0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl 0x923f(%rip), %eax      # 0xd20c
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl 0x9219(%rip), %eax      # 0xd1f4
jl 0x3fee
movq -0x20(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x3fac
cmpb $0x0, 0x91d6(%rip)      # 0xd1d8
je 0x407f
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x30(%rsp), %rax
addq $0x1d, %rax
addq $0xc00, %rax            # imm = 0xC00
movq %rax, -0x28(%rsp)
movl -0xc(%rsp), %eax
movq -0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x407d
movq -0x28(%rsp), %rax
movslq -0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl 0x91bd(%rip), %eax      # 0xd20c
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl 0x9197(%rip), %eax      # 0xd1f4
jl 0x4070
movq -0x20(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x402e
jmp 0x407f
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x1d, %rdi
addq $0x400, %rdi            # imm = 0x400
movq 0x8(%rsp), %rsi
addq $0x1d, %rsi
addq $0x400, %rsi            # imm = 0x400
movslq 0x9123(%rip), %rax      # 0xd1e0
addq %rax, %rsi
movslq 0x9115(%rip), %rdx      # 0xd1dc
callq 0x2160
movq 0x8(%rsp), %rax
movslq 0x9104(%rip), %rcx      # 0xd1dc
movb $0xa, 0x41d(%rax,%rcx)
movq 0x8(%rsp), %rax
movslq 0x90f0(%rip), %rcx      # 0xd1dc
movb $0x0, 0x41e(%rax,%rcx)
movq 0x8(%rsp), %rdi
addq $0x1d, %rdi
addq $0xc00, %rdi            # imm = 0xC00
movq 0x8(%rsp), %rsi
addq $0x1d, %rsi
addq $0xc00, %rsi            # imm = 0xC00
movslq 0x90c5(%rip), %rax      # 0xd1e0
addq %rax, %rsi
movslq 0x90b7(%rip), %rdx      # 0xd1dc
callq 0x2160
movq 0x8(%rsp), %rax
movslq 0x90a6(%rip), %rcx      # 0xd1dc
movb $0xa, 0xc1d(%rax,%rcx)
movq 0x8(%rsp), %rax
movslq 0x9092(%rip), %rcx      # 0xd1dc
movb $0x0, 0xc1e(%rax,%rcx)
cmpb $0x0, 0x907f(%rip)      # 0xd1d8
je 0x420c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x1d, %rdi
addq $0x400, %rdi            # imm = 0x400
movq (%rsp), %rsi
addq $0x1d, %rsi
addq $0x400, %rsi            # imm = 0x400
movslq 0x904b(%rip), %rdx      # 0xd1dc
callq 0x2160
movq (%rsp), %rax
movslq 0x903b(%rip), %rcx      # 0xd1dc
movb $0xa, 0x41d(%rax,%rcx)
movq (%rsp), %rax
movslq 0x9028(%rip), %rcx      # 0xd1dc
movb $0x0, 0x41e(%rax,%rcx)
movq (%rsp), %rdi
addq $0x1d, %rdi
addq $0xc00, %rdi            # imm = 0xC00
movq (%rsp), %rsi
addq $0x1d, %rsi
addq $0xc00, %rsi            # imm = 0xC00
movslq 0x8ffb(%rip), %rdx      # 0xd1dc
callq 0x2160
movq (%rsp), %rax
movslq 0x8feb(%rip), %rcx      # 0xd1dc
movb $0xa, 0xc1d(%rax,%rcx)
movq (%rsp), %rax
movslq 0x8fd8(%rip), %rcx      # 0xd1dc
movb $0x0, 0xc1e(%rax,%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movb $0x1, 0x1e(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x1420(%rax)
je 0x429a
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movq 0x1420(%rax), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rcx
addq $0x1d, %rcx
addq $0x400, %rcx            # imm = 0x400
movq 0x10(%rsp), %rax
movq 0x1420(%rax), %rax
movq %rcx, 0x220(%rax)
movq 0x10(%rsp), %rax
movq 0x1420(%rax), %rdi
callq 0x8b20
movb %al, 0x1f(%rsp)
jmp 0x42b6
movq 0x8f9f(%rip), %rdi      # 0xd240
movq 0x10(%rsp), %rsi
addq $0x101d, %rsi           # imm = 0x101D
callq 0x8a00
movb %al, 0x1f(%rsp)
cmpb $0x0, 0x8f1b(%rip)      # 0xd1d8
je 0x434e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1420(%rax)
je 0x4330
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movq 0x8(%rsp), %rax
movq 0x1420(%rax), %rax
movl %ecx, 0x14(%rax)
movq 0x8(%rsp), %rcx
addq $0x1d, %rcx
addq $0x400, %rcx            # imm = 0x400
movq 0x8(%rsp), %rax
movq 0x1420(%rax), %rax
movq %rcx, 0x220(%rax)
movq 0x8(%rsp), %rax
movq 0x1420(%rax), %rdi
callq 0x8b20
movb %al, 0x1e(%rsp)
jmp 0x434c
movq 0x8f11(%rip), %rdi      # 0xd248
movq 0x8(%rsp), %rsi
addq $0x101d, %rsi           # imm = 0x101D
callq 0x8a00
movb %al, 0x1e(%rsp)
jmp 0x434e
movsbl 0x1f(%rsp), %eax
movsbl 0x1e(%rsp), %ecx
imull %ecx, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x4873
movq 0x18(%rsp), %rdi
callq 0x20c0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
je 0x47d0
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x54, %eax
jne 0x47d8
movl $0x1, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x4871
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
je 0x4814
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x54, %eax
jne 0x4859
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4857
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x14(%rsp), %eax
jne 0x4855
movb $0x1, 0x27(%rsp)
jmp 0x4878
jmp 0x4861
jmp 0x4859
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x47e0
jmp 0x4873
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x4d40
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq $0x1d, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x4dc6
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movq 0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0xa, %eax
je 0x4db7
jmp 0x4d76
jmp 0x4db9
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4d67
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x20c0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x38(%rax)
cmpb $0x0, 0x83eb(%rip)      # 0xd1d8
je 0x4eba
movq 0x28(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x4e15
movl $0x1000, %edi           # imm = 0x1000
callq 0x21b0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1d, %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x4e9a
movl $0x0, 0x10(%rsp)
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0xa, %eax
je 0x4e8b
jmp 0x4e4b
jmp 0x4e8d
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e3c
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x20c0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x48(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x8040
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x529e
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x7fe0
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x1420(%rax), %rdi
callq 0x2040
cmpb $0x0, 0x7f97(%rip)      # 0xd1d8
je 0x525b
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x1420(%rax), %rdi
callq 0x2040
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2040
cmpb $0x0, 0x7f66(%rip)      # 0xd1d8
je 0x5285
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x51de
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x8080
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x7fe0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: readadapter
local void readadapter(void){
	gzFile* gzfp=gzopen(g.adapter1,"r");
	if (gzfp==NULL){
		perror("adapter1 ");
		exit(0);
	}
	char line[1024];
	char* cur;
	while (gzgets(gzfp,line,1024)!=NULL){
		if (strlen(line)==1 && strcmp(line,"\n")==0){
			continue;
		}
		cur = (char*)memchr(line,'\t',1024);
		if (cur){
			*cur = '\n';
			cur++;
			*cur = '\0';
			insert_keyvalue(&g.table1,line,1);
		}
	}
	gzclose(gzfp);
	if (g.single_or_pair){
		gzfp=gzopen(g.adapter2,"r");
		if (gzfp==NULL){
			perror("adapter2 ");
			exit(0);
		}
		while (gzgets(gzfp,line,1024)!=NULL){
			if (strlen(line)==1 && strcmp(line,"\n")==0){
				continue;
			}
			cur = (char*)memchr(line,'\t',1024);
			if (cur!=NULL){
				*cur = '\n';
				cur++;
				*cur = '\0';
				insert_keyvalue(&g.table2,line,1);
			}
		}
		gzclose(gzfp);
	}
}

// Assembly:
subq $0x418, %rsp            # imm = 0x418
movq 0x6942(%rip), %rdi      # 0xd280
leaq 0x3a3a(%rip), %rsi      # 0xa37f
callq 0x2200
movq %rax, 0x410(%rsp)
cmpq $0x0, 0x410(%rsp)
jne 0x6970
leaq 0x454e(%rip), %rdi      # 0xaeb2
callq 0x2260
xorl %edi, %edi
callq 0x22a0
jmp 0x6972
movq 0x410(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
cmpq $0x0, %rax
je 0x6a19
leaq 0x10(%rsp), %rdi
callq 0x20c0
cmpq $0x1, %rax
jne 0x69bb
leaq 0x10(%rsp), %rdi
leaq 0x4888(%rip), %rsi      # 0xb237
callq 0x2140
cmpl $0x0, %eax
jne 0x69bb
jmp 0x6972
leaq 0x10(%rsp), %rdi
movl $0x9, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2120
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6a14
movq 0x8(%rsp), %rax
movb $0xa, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rsi
leaq 0x67d2(%rip), %rdi      # 0xd1d8
addq $0x68, %rdi
movl $0x1, %edx
callq 0x8900
jmp 0x6972
movq 0x410(%rsp), %rdi
callq 0x2030
cmpb $0x0, 0x67ab(%rip)      # 0xd1d8
je 0x6b22
movq 0x684e(%rip), %rdi      # 0xd288
leaq 0x393e(%rip), %rsi      # 0xa37f
callq 0x2200
movq %rax, 0x410(%rsp)
cmpq $0x0, 0x410(%rsp)
jne 0x6a6c
leaq 0x445c(%rip), %rdi      # 0xaebc
callq 0x2260
xorl %edi, %edi
callq 0x22a0
jmp 0x6a6e
movq 0x410(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2080
cmpq $0x0, %rax
je 0x6b15
leaq 0x10(%rsp), %rdi
callq 0x20c0
cmpq $0x1, %rax
jne 0x6ab7
leaq 0x10(%rsp), %rdi
leaq 0x478c(%rip), %rsi      # 0xb237
callq 0x2140
cmpl $0x0, %eax
jne 0x6ab7
jmp 0x6a6e
leaq 0x10(%rsp), %rdi
movl $0x9, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2120
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6b10
movq 0x8(%rsp), %rax
movb $0xa, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rsi
leaq 0x66d6(%rip), %rdi      # 0xd1d8
addq $0x70, %rdi
movl $0x1, %edx
callq 0x8900
jmp 0x6a6e
movq 0x410(%rsp), %rdi
callq 0x2030
addq $0x418, %rsp            # imm = 0x418
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/fqtools.c
// Function: push_job_raw
local void push_job_raw(struct job* job){
	struct job *here, **prior;
	possess(write_first_raw);
	prior = &(write_head_raw);
	while((here = *prior) != NULL){
		if (here->seq > job->seq){
			break;
		}
		prior = &(here->next1);
	}
	job->next1 = here;
	*prior = job;
	twist(write_first_raw,TO,write_head_raw->seq);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x5890(%rip), %rdi      # 0xd300
callq 0x8040
leaq 0x588c(%rip), %rax      # 0xd308
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7ab5
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jle 0x7aa6
jmp 0x7ab5
movq 0x8(%rsp), %rax
addq $0x28, %rax
movq %rax, (%rsp)
jmp 0x7a80
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x582a(%rip), %rdi      # 0xd300
movq 0x582b(%rip), %rax      # 0xd308
movq (%rax), %rdx
xorl %esi, %esi
callq 0x8280
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x57c8(%rip), %rdi      # 0xd2c8
callq 0x8040
leaq 0x57c4(%rip), %rax      # 0xd2d0
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7b45
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jle 0x7b36
jmp 0x7b45
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
jmp 0x7b10
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x5762(%rip), %rdi      # 0xd2c8
movq 0x5763(%rip), %rax      # 0xd2d0
movq (%rax), %rdx
xorl %esi, %esi
callq 0x8280
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x60, %edi
callq 0x21b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2300
cmpl $0x0, %eax
jne 0x7fa2
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2180
cmpl $0x0, %eax
je 0x7fc1
movq 0x504f(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3279(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x802d
movq (%rsp), %rdi
addq $0x28, %rdi
callq 0x2240
cmpl $0x0, %eax
jne 0x800c
movq (%rsp), %rdi
callq 0x20f0
cmpl $0x0, %eax
je 0x802b
movq 0x4fe5(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x320f(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
jmp 0x802d
movq (%rsp), %rdi
callq 0x2040
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x732bb(%rip), %rdi     # 0x7b390
callq 0x8040
movl $0x10, %edi
callq 0x21b0
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, 0x38(%rsp)
movq %rsp, %rdi
callq 0x2130
cmpl $0x0, %eax
jne 0x815a
movq %rsp, %rdi
xorl %esi, %esi
callq 0x2190
cmpl $0x0, %eax
jne 0x815a
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rcx
movq %rsp, %rsi
leaq 0x7d(%rip), %rdx        # 0x81c0
callq 0x21e0
cmpl $0x0, %eax
jne 0x815a
movq %rsp, %rdi
callq 0x2270
cmpl $0x0, %eax
je 0x8179
movq 0x4e97(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x30c1(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
movq 0x38(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x73264(%rip), %rcx     # 0x7b3f0
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x7324f(%rip)     # 0x7b3f0
leaq 0x731e8(%rip), %rdi     # 0x7b390
callq 0x8080
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x50a(%rip), %rax       # 0x86f0
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x22e0
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq $0x0, %rax
je 0x8225
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
callq *%rax
leaq 0x20(%rsp), %rdi
callq 0x21c0
leaq 0x20(%rsp), %rdi
callq 0x22c0
movq 0x88(%rsp), %rax
movq (%rax), %rax
movq 0x88(%rsp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq 0x88(%rsp), %rdi
callq 0x2040
jmp 0x8257
jmp 0x8259
leaq 0x20(%rsp), %rdi
callq 0x2100
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
callq *%rax
addq $0x98, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x82a7
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
jmp 0x82c1
cmpl $0x1, 0xc(%rsp)
jne 0x82bf
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
jmp 0x82c1
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x2060
cmpl $0x0, %eax
jne 0x82e3
movq 0x10(%rsp), %rdi
callq 0x21a0
cmpl $0x0, %eax
je 0x8302
movq 0x4d0e(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2f38(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x84a8
movq 0x8(%rsp), %rax
leaq 0x2edb(%rip), %rcx      # 0xb21c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x834c
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
cmpq 0x10(%rsp), %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8365
jmp 0x839e
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
callq 0x20a0
cmpl $0x0, %eax
je 0x839c
movq 0x4c74(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2e9e(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
jmp 0x834c
jmp 0x84a8
jmp 0x83a5
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
cmpq 0x10(%rsp), %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x83be
jmp 0x83f7
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
callq 0x20a0
cmpl $0x0, %eax
je 0x83f5
movq 0x4c1b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2e45(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
jmp 0x83a5
jmp 0x84a8
jmp 0x83fe
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
cmpq 0x10(%rsp), %rax
setge %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8417
jmp 0x8450
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
callq 0x20a0
cmpl $0x0, %eax
je 0x844e
movq 0x4bc2(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2dec(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
jmp 0x83fe
jmp 0x84a8
jmp 0x8454
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
cmpq 0x10(%rsp), %rax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x846d
jmp 0x84a6
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
callq 0x20a0
cmpl $0x0, %eax
je 0x84a4
movq 0x4b6c(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2d96(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
jmp 0x8454
jmp 0x84a8
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22d0
cmpl $0x0, %eax
je 0x84ee
movq 0x4b22(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2d4c(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
leaq 0x72e9b(%rip), %rdi     # 0x7b390
callq 0x8040
leaq 0x72eef(%rip), %rax     # 0x7b3f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8534
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x8525
jmp 0x8534
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
jmp 0x8505
cmpq $0x0, 0x8(%rsp)
jne 0x855b
movq 0x4ab5(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2cdf(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x8578
movq 0x72e7b(%rip), %rax     # 0x7b3e8
addq $-0x1, %rax
movq %rax, 0x72e70(%rip)     # 0x7b3e8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
leaq 0x72e01(%rip), %rdi     # 0x7b390
callq 0x8080
movq 0x10(%rsp), %rdi
callq 0x2040
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
leaq 0x72dd5(%rip), %rdi     # 0x7b390
callq 0x8040
cmpq $0x0, 0x72e28(%rip)     # 0x7b3f0
je 0x8686
leaq 0x72dbb(%rip), %rdi     # 0x7b390
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8310
leaq 0x72e06(%rip), %rax     # 0x7b3f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x861f
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x860f
jmp 0x861f
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x85ef
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22d0
cmpl $0x0, %eax
je 0x8654
movq 0x49bc(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2be6(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
movq 0x72d8d(%rip), %rax     # 0x7b3e8
addq $-0x1, %rax
movq %rax, 0x72d82(%rip)     # 0x7b3e8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x2040
jmp 0x85c0
leaq 0x72d03(%rip), %rdi     # 0x7b390
callq 0x8080
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
callq 0x2210
movq %rax, 0x10(%rsp)
leaq 0x72c8b(%rip), %rdi     # 0x7b390
callq 0x8040
leaq 0x72cdf(%rip), %rax     # 0x7b3f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x874f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x21f0
cmpl $0x0, %eax
je 0x8740
jmp 0x874f
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
jmp 0x8715
cmpq $0x0, 0x8(%rsp)
jne 0x8776
movq 0x489a(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2ac4(%rip), %rsi      # 0xb22c
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x22a0
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq 0x72c62(%rip), %rax     # 0x7b3f0
je 0x87bc
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x72c49(%rip), %rcx     # 0x7b3f0
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x72c34(%rip)     # 0x7b3f0
leaq 0x72bcd(%rip), %rdi     # 0x7b390
movl $0x1, %esi
movl $0x1, %edx
callq 0x8280
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0x1505, -0x18(%rsp)    # imm = 0x1505
movq -0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x884e
movq -0x18(%rsp), %rax
shlq $0x5, %rax
movq -0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movsbl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movslq -0xc(%rsp), %rcx
cmpq %rcx, %rax
jb 0x884c
movq -0x18(%rsp), %rax
movslq -0xc(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rsp)
jmp 0x87f2
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x18, %edi
callq 0x21b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x100000, (%rax)       # imm = 0x100000
movq 0x10(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x21b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x21b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x88f0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x88c0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl (%rax), %esi
callq 0x87e0
movl %eax, 0x10(%rsp)
movl $0x18, %edi
callq 0x21b0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x21b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2050
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x20c0
movq %rax, %rcx
movq (%rsp), %rax
movb $0x0, (%rax,%rcx)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x10(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x10(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0x87e0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x8a6a
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2140
cmpl $0x0, %eax
jne 0x8a5c
movb $0x0, 0x27(%rsp)
jmp 0x8a6f
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x8a38
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x228, %edi            # imm = 0x228
callq 0x21b0
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq (%rsp), %rdi
addq $0x1c, %rdi
movq 0x10(%rsp), %rsi
callq 0x2050
movq 0x10(%rsp), %rdi
callq 0x20c0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x220(%rax)
movq (%rsp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
cltq
imulq $0xc, %rax, %rdi
callq 0x21b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/cutadapt.c
// Function: match
char match(adapter_* adapter){
	alignread(adapter);
	if (adapter->result->stop1 - adapter->result->start1 < adapter->min_overlap){
		return(1);
	}
	//printf("%d\t%d\t%d\t%d\t%d\t%d\n",adapter->result->start1,adapter->result->stop1,adapter->result->start2,adapter->result->stop2,adapter->result->matches,adapter->result->errors);	
	return(0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x8b70
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
subl (%rcx), %eax
movq 0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x8b5b
movb $0x1, 0x17(%rsp)
jmp 0x8b60
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/cutadapt.c
// Function: cutadapt_main
void cutadapt_main(char* fq1, char* adapter_seq, int min_overlap){
	gzFile* gzfp1 = gzopen(fq1,"rb");
	if (gzfp1 == NULL){
		fprintf(stderr, "%s not open\n",fq1 );
		exit(1);
	}
	adaptline_* adaptline1 = (adaptline_*)malloc(sizeof(adaptline_));
	adaptline1->adapter = initalign(adapter_seq,min_overlap);
	adaptline1->adapter->s2 = (char*)malloc(sizeof(char)*1024);
	adaptline1->id = (char*)malloc(sizeof(char)*1024);
	adaptline1->gzfp = gzfp1;
	func(adaptline1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1d4d(%rip), %rsi      # 0xaf0b
callq 0x2200
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x91f7
movq 0x3e21(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x2062(%rip), %rsi      # 0xb248
movb $0x0, %al
callq 0x2150
movl $0x1, %edi
callq 0x22a0
movl $0x18, %edi
callq 0x21b0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x8a80
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl $0x400, %edi            # imm = 0x400
callq 0x21b0
movq %rax, %rcx
movq (%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x220(%rax)
movl $0x400, %edi            # imm = 0x400
callq 0x21b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rdi
callq 0x9270
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/annoroad[P]fqtools_plus/cutadapt.c
// Function: func
static void func(adaptline_* adaptline){
	while(1){
		if (readfq(adaptline))break;
		if (match(adaptline->adapter)==0){
			printmatch(adaptline);
		}
	}
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x92b0
cmpb $0x0, %al
je 0x9284
jmp 0x92a3
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8b20
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x92a1
movq (%rsp), %rdi
callq 0x9490
jmp 0x9275
popq %rax
retq
nopw %cs:(%rax,%rax)