LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_open_w
static RAZF* razf_open_w(int fd){
	RAZF *rz;
#ifdef _WIN32
	setmode(fd, O_BINARY);
#endif
	rz = calloc(1, sizeof(RAZF));
	rz->mode = 'w';
#ifdef _USE_KNETFILE
    rz->x.fpw = fd;
#else
	rz->filedes = fd;
#endif
	rz->stream = calloc(sizeof(z_stream), 1);
	rz->inbuf  = malloc(RZ_BUFFER_SIZE);
	rz->outbuf = malloc(RZ_BUFFER_SIZE);
	rz->index = calloc(sizeof(ZBlockIndex), 1);
	deflateInit2(rz->stream, RZ_COMPRESS_LEVEL, Z_DEFLATED, WINDOW_BITS + 16, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
	rz->stream->avail_out = RZ_BUFFER_SIZE;
	rz->stream->next_out  = rz->outbuf;
	rz->header = calloc(sizeof(gz_header), 1);
	rz->header->os    = 0x03; //Unix
	rz->header->text  = 0;
	rz->header->time  = 0;
	rz->header->extra = malloc(7);
	strncpy((char*)rz->header->extra, "RAZF", 4);
	rz->header->extra[4] = 1; // obsolete field
	// block size = RZ_BLOCK_SIZE, Big-Endian
	rz->header->extra[5] = RZ_BLOCK_SIZE >> 8;
	rz->header->extra[6] = RZ_BLOCK_SIZE & 0xFF;
	rz->header->extra_len = 7;
	rz->header->name = rz->header->comment  = 0;
	rz->header->hcrc = 0;
	deflateSetHeader(rz->stream, rz->header);
	rz->block_pos = rz->block_off = 0;
	return rz;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
pushq $0x1
popq %r15
movl $0x98, %esi
movq %r15, %rdi
callq 0x174c0
movq %rax, %rbx
movb $0x77, (%rax)
movl %ebp, 0x8(%rax)
pushq $0x70
popq %rdi
movq %r15, %rsi
callq 0x174c0
movq %rax, %r14
movq %rax, 0x10(%rbx)
movl $0x1000, %edi           # imm = 0x1000
callq 0x17f50
movq %rax, 0x60(%rbx)
movl $0x1000, %edi           # imm = 0x1000
callq 0x17f50
movq %rax, %r12
movq %rax, 0x68(%rbx)
pushq $0x18
popq %rdi
movq %r15, %rsi
callq 0x174c0
movq %rax, 0x18(%rbx)
leaq 0x963b2(%rip), %rax     # 0x36ebf4
pushq $0x6
popq %rsi
pushq $0x1f
popq %rcx
pushq $0x8
popq %rdx
movq %r14, %rdi
movl %edx, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x21766a
popq %rcx
popq %rdx
movl $0x1000, 0x20(%r14)     # imm = 0x1000
movq %r12, 0x18(%r14)
pushq $0x50
popq %rdi
movq %r15, %rsi
callq 0x174c0
movq %rax, %r15
movq %rax, 0x78(%rbx)
movl $0x3, 0x14(%rax)
pushq $0x7
popq %rdi
callq 0x17f50
movq %rax, 0x18(%r15)
movl $0x465a4152, (%rax)     # imm = 0x465A4152
movw $0x8001, 0x4(%rax)      # imm = 0x8001
movb $0x0, 0x6(%rax)
movl $0x7, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x217f9e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_open
static inline RAZF* _razf_open(const char *filename, const char *mode, int _load_index){
	int fd;
	RAZF *rz;
	if(strstr(mode, "r")){
#ifdef _USE_KNETFILE
        knetFile *fd = knet_open(filename, "r");
        if (fd == 0) {
            fprintf(stderr, "[_razf_open] fail to open %s\n", filename);
            return NULL;
        }
#else
#ifdef _WIN32
		fd = open(filename, O_RDONLY | O_BINARY);
#else
		fd = open(filename, O_RDONLY);
#endif
#endif
		if(fd < 0) return NULL;
		rz = razf_open_r(fd, _load_index);
	} else if(strstr(mode, "w")){
#ifdef _WIN32
		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
#else
		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
#endif
		if(fd < 0) return NULL;
		rz = razf_open_w(fd);
	} else return NULL;
	return rz;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x72
popq %rsi
movq %r14, %rdi
callq 0x17260
testq %rax, %rax
je 0x2d894d
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x17ce0
testl %eax, %eax
js 0x2d8980
movl %eax, %edi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2d839f
pushq $0x77
popq %rsi
movq %r14, %rdi
callq 0x17260
testq %rax, %rax
je 0x2d8980
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x17ce0
testl %eax, %eax
js 0x2d8980
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2d87d7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_get_data_size
int razf_get_data_size(RAZF *rz, int64_t *u_size, int64_t *c_size){
	int64_t n;
	if(rz->mode != 'r' && rz->mode != 'R') return 0;
	switch(rz->file_type){
		case FILE_TYPE_PLAIN:
			if(rz->end == 0x7fffffffffffffffLL){
#ifdef _USE_KNETFILE
				if(knet_seek(rz->x.fpr, 0, SEEK_CUR) == -1) return 0;
                n = knet_tell(rz->x.fpr);
				knet_seek(rz->x.fpr, 0, SEEK_END);
                rz->end = knet_tell(rz->x.fpr);
				knet_seek(rz->x.fpr, n, SEEK_SET);
#else
				if((n = lseek(rz->filedes, 0, SEEK_CUR)) == -1) return 0;
				rz->end = lseek(rz->filedes, 0, SEEK_END);
				lseek(rz->filedes, n, SEEK_SET);
#endif                
			}
			*u_size = *c_size = rz->end;
			return 1;
		case FILE_TYPE_GZ:
			return 0;
		case FILE_TYPE_RZ:
			if(rz->src_end == rz->end) return 0;
			*u_size = rz->src_end;
			*c_size = rz->end;
			return 1;
		default:
			return 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movzbl (%rdi), %eax
xorl %r12d, %r12d
orl $0x20, %eax
cmpl $0x72, %eax
jne 0x2d8a2d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rdi), %eax
cmpl $0x1, %eax
je 0x2d8a15
cmpl $0x2, %eax
jne 0x2d8a2d
movq 0x30(%r15), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0x2d8a0d
movl 0x8(%r15), %edi
xorl %r12d, %r12d
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x17680
cmpq $-0x1, %rax
je 0x2d8a2d
movq %rax, %r13
movl 0x8(%r15), %edi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x17680
movq %rax, 0x30(%r15)
movl 0x8(%r15), %edi
movq %r13, %rsi
xorl %edx, %edx
callq 0x17680
movq 0x30(%r15), %rax
movq %rax, (%rbx)
movq %rax, (%r14)
jmp 0x2d8a29
movq 0x38(%r15), %rax
cmpq 0x30(%r15), %rax
je 0x2d8a2d
movq %rax, (%r14)
movq 0x30(%r15), %rax
movq %rax, (%rbx)
pushq $0x1
popq %r12
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_read
int razf_read(RAZF *rz, void *data, int size){
	int ori_size, i;
	ori_size = size;
	while(size > 0){
		if(rz->buf_len){
			if(size < rz->buf_len){
				for(i=0;i<size;i++) ((char*)data)[i] = ((char*)rz->outbuf + rz->buf_off)[i];
				rz->buf_off += size;
				rz->buf_len -= size;
				data += size;
				rz->block_off += size;
				size = 0;
				break;
			} else {
				for(i=0;i<rz->buf_len;i++) ((char*)data)[i] = ((char*)rz->outbuf + rz->buf_off)[i];
				data += rz->buf_len;
				size -= rz->buf_len;
				rz->block_off += rz->buf_len;
				rz->buf_off = 0;
				rz->buf_len = 0;
				if(rz->buf_flush){
					rz->block_pos = rz->next_block_pos;
					rz->block_off = 0;
					rz->buf_flush = 0;
				}
			}
		} else if(rz->buf_flush){
			rz->block_pos = rz->next_block_pos;
			rz->block_off = 0;
			rz->buf_flush = 0;
		}
		if(rz->buf_flush) continue;
		rz->buf_len = _razf_read(rz, rz->outbuf, RZ_BUFFER_SIZE);
		if(rz->z_eof && rz->buf_len == 0) break;
	}
	rz->out += ori_size - size;
	return ori_size - size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %ebp
testl %ebp, %ebp
jle 0x2d8b1b
movl 0x84(%r14), %ecx
testl %ecx, %ecx
je 0x2d8a9f
cmpl %ecx, %ebp
jl 0x2d8ae7
xorl %eax, %eax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x2d8a8e
movslq 0x80(%r14), %rcx
addq 0x68(%r14), %rcx
movb (%rax,%rcx), %cl
movb %cl, (%r15,%rax)
incq %rax
movl 0x84(%r14), %ecx
jmp 0x2d8a68
addq %rcx, 0x50(%r14)
andq $0x0, 0x80(%r14)
addq %rcx, %r15
subl %ecx, %ebp
cmpl $0x0, 0x40(%r14)
je 0x2d8ab8
movq 0x58(%r14), %rax
movq %rax, 0x48(%r14)
andq $0x0, 0x50(%r14)
andl $0x0, 0x40(%r14)
movq 0x68(%r14), %rsi
movq %r14, %rdi
callq 0x2d8b2f
movl %eax, 0x84(%r14)
cmpl $0x0, 0x8c(%r14)
setne %cl
testl %eax, %eax
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x2d8a4b
jmp 0x2d8b1b
movl %ebp, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2d8b07
movslq 0x80(%r14), %rdx
addq 0x68(%r14), %rdx
movb (%rcx,%rdx), %dl
movb %dl, (%r15,%rcx)
incq %rcx
jmp 0x2d8aeb
addl %ebp, 0x80(%r14)
subl %ebp, 0x84(%r14)
addq %rax, 0x50(%r14)
xorl %ebp, %ebp
subl %ebp, %ebx
movslq %ebx, %rax
addq %rax, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_skip
int razf_skip(RAZF* rz, int size){
	int ori_size;
	ori_size = size;
	while(size > 0){
		if(rz->buf_len){
			if(size < rz->buf_len){
				rz->buf_off += size;
				rz->buf_len -= size;
				rz->block_off += size;
				size = 0;
				break;
			} else {
				size -= rz->buf_len;
				rz->buf_off = 0;
				rz->buf_len = 0;
				rz->block_off += rz->buf_len;
				if(rz->buf_flush){
					rz->block_pos = rz->next_block_pos;
					rz->block_off = 0;
					rz->buf_flush = 0;
				}
			}
		} else if(rz->buf_flush){
			rz->block_pos = rz->next_block_pos;
			rz->block_off = 0;
			rz->buf_flush = 0;
		}
		if(rz->buf_flush) continue;
		rz->buf_len = _razf_read(rz, rz->outbuf, RZ_BUFFER_SIZE);
		if(rz->z_eof || rz->z_err) break;
	}
	rz->out += ori_size - size;
	return ori_size - size;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
testl %esi, %esi
jle 0x2d8d25
movl 0x84(%rbx), %eax
movl %ebp, %ecx
testl %eax, %eax
je 0x2d8d03
movl %ecx, %r14d
subl %eax, %r14d
jl 0x2d8d0e
andq $0x0, 0x80(%rbx)
cmpl $0x0, 0x40(%rbx)
je 0x2d8cd5
movq 0x58(%rbx), %rax
movq %rax, 0x48(%rbx)
andq $0x0, 0x50(%rbx)
andl $0x0, 0x40(%rbx)
movq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq 0x2d8b2f
movl %eax, 0x84(%rbx)
cmpl $0x0, 0x8c(%rbx)
jne 0x2d8d25
cmpl $0x0, 0x88(%rbx)
jne 0x2d8d25
movl %r14d, %ecx
testl %r14d, %r14d
jg 0x2d8caa
jmp 0x2d8d25
cmpl $0x0, 0x40(%rbx)
movl %ecx, %r14d
jne 0x2d8cc4
jmp 0x2d8cd5
addl %ecx, 0x80(%rbx)
subl %ecx, %eax
movl %eax, 0x84(%rbx)
movl %ecx, %eax
addq %rax, 0x50(%rbx)
xorl %r14d, %r14d
subl %r14d, %ebp
movslq %ebp, %rax
addq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_jump
int64_t razf_jump(RAZF *rz, int64_t block_start, int block_offset){
	int64_t pos;
	rz->z_eof = 0;
	if(rz->file_type == FILE_TYPE_PLAIN){
		rz->buf_off = rz->buf_len = 0;
		pos = block_start + block_offset;
#ifdef _USE_KNETFILE
		knet_seek(rz->x.fpr, pos, SEEK_SET);
        pos = knet_tell(rz->x.fpr);
#else
		pos = lseek(rz->filedes, pos, SEEK_SET);
#endif
		rz->out = rz->in = pos;
		return pos;
	}
	if(block_start == rz->block_pos && block_offset >= rz->block_off) {
		block_offset -= rz->block_off;
		goto SKIP; // Needn't reset inflate
	}
	if(block_start  == 0) block_start = rz->header_size; // Automaticly revist wrong block_start
	_razf_reset_read(rz, block_start, 0);
	SKIP:
	if(block_offset) razf_skip(rz, block_offset);
	return rz->block_off;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x8c(%rdi)
movl %edx, %ebp
cmpl $0x2, 0x4(%rdi)
jne 0x2d8d6e
andq $0x0, 0x80(%rbx)
movslq %ebp, %rax
addq %rsi, %rax
movl 0x8(%rbx), %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x17680
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
jmp 0x2d8da9
cmpq %rsi, 0x48(%rbx)
jne 0x2d8d80
movslq %ebp, %rcx
movq 0x50(%rbx), %rax
cmpq %rcx, %rax
jle 0x2d8d95
testq %rsi, %rsi
jne 0x2d8d89
movslq 0x70(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d8db0
jmp 0x2d8d97
subl %eax, %ebp
testl %ebp, %ebp
je 0x2d8da5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2d8c8e
movq 0x50(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_reset_read
static void _razf_reset_read(RAZF *rz, int64_t in, int64_t out){
#ifdef _USE_KNETFILE
	knet_seek(rz->x.fpr, in, SEEK_SET);
#else
	lseek(rz->filedes, in, SEEK_SET);
#endif
	rz->in  = in;
	rz->out = out;
	rz->block_pos = in;
	rz->next_block_pos = in;
	rz->block_off = 0;
	rz->buf_flush = 0;
	rz->z_eof = rz->z_err = 0;
	inflateReset(rz->stream);
	rz->stream->avail_in = 0;
	rz->buf_off = rz->buf_len = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %edi
xorl %edx, %edx
callq 0x17680
movq %r14, 0x20(%r15)
movq %rbx, 0x28(%r15)
movq %r14, 0x48(%r15)
movq %r14, 0x58(%r15)
andq $0x0, 0x50(%r15)
andl $0x0, 0x40(%r15)
andq $0x0, 0x88(%r15)
movq 0x10(%r15), %rdi
callq 0x21bf26
movq 0x10(%r15), %rax
andl $0x0, 0x8(%rax)
andq $0x0, 0x80(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_seek
int64_t razf_seek(RAZF* rz, int64_t pos, int where){
	int64_t idx;
	int64_t seek_pos, new_out;
	rz->z_eof = 0;
	if (where == SEEK_CUR) pos += rz->out;
	else if (where == SEEK_END) pos += rz->src_end;
	if(rz->file_type == FILE_TYPE_PLAIN){
#ifdef _USE_KNETFILE
		knet_seek(rz->x.fpr, pos, SEEK_SET);
        seek_pos = knet_tell(rz->x.fpr);
#else
		seek_pos = lseek(rz->filedes, pos, SEEK_SET);
#endif
		rz->buf_off = rz->buf_len = 0;
		rz->out = rz->in = seek_pos;
		return seek_pos;
	} else if(rz->file_type == FILE_TYPE_GZ){
		if(pos >= rz->out) goto SKIP;
		return rz->out;
	}
	if(pos == rz->out) return pos;
	if(pos > rz->src_end) return rz->out;
	if(!rz->seekable || !rz->load_index){
		if(pos >= rz->out) goto SKIP;
	}
	idx = pos / RZ_BLOCK_SIZE - 1;
	seek_pos = (idx < 0)? rz->header_size:(rz->index->cell_offsets[idx] + rz->index->bin_offsets[idx / RZ_BIN_SIZE]);
	new_out  = (idx + 1) * RZ_BLOCK_SIZE;
	if(pos > rz->out && new_out <= rz->out) goto SKIP;
	_razf_reset_read(rz, seek_pos, new_out);
	SKIP:
	razf_skip(rz, (int)(pos - rz->out));
	return rz->out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andl $0x0, 0x8c(%rdi)
cmpl $0x1, %edx
je 0x2d8e28
cmpl $0x2, %edx
jne 0x2d8e2f
pushq $0x38
jmp 0x2d8e2a
pushq $0x28
popq %rax
addq (%rbx,%rax), %r14
movl 0x4(%rbx), %eax
cmpl $0x3, %eax
je 0x2d8e5e
cmpl $0x2, %eax
jne 0x2d8e7b
movl 0x8(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x17680
andq $0x0, 0x80(%rbx)
movq %rax, %rcx
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
jmp 0x2d8e8f
movq 0x28(%rbx), %rcx
cmpq %rcx, %r14
jl 0x2d8e8f
subl %ecx, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2d8c8e
movq 0x28(%rbx), %rcx
jmp 0x2d8e8f
movq 0x28(%rbx), %rcx
cmpq %rcx, %r14
jne 0x2d8e89
movq %r14, %rcx
jmp 0x2d8e8f
cmpq 0x38(%rbx), %r14
jle 0x2d8e9a
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, 0x90(%rbx)
je 0x2d8eac
cmpl $0x0, 0x94(%rbx)
jne 0x2d8eb1
cmpq %rcx, %r14
jge 0x2d8e67
movl $0x8000, %esi           # imm = 0x8000
movq %r14, %rax
cqto
idivq %rsi
cmpq $0x7fff, %r14           # imm = 0x7FFF
jg 0x2d8ecd
movslq 0x70(%rbx), %rsi
jmp 0x2d8ee8
leaq -0x1(%rax), %rdx
movq 0x18(%rbx), %rsi
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
movl -0x4(%rdi,%rax,4), %esi
shrq $0x11, %rdx
addq (%r8,%rdx,8), %rsi
shlq $0xf, %rax
cmpq %rcx, %r14
setle %dl
cmpq %rcx, %rax
setg %dil
orb %dl, %dil
cmpb $0x1, %dil
jne 0x2d8e67
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2d8db0
movq 0x28(%rbx), %rcx
jmp 0x2d8e67
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_write
static void _razf_write(RAZF* rz, const void *data, int size){
	int tout;
	rz->stream->avail_in = size;
	rz->stream->next_in  = (void*)data;
	while(1){
		tout = rz->stream->avail_out;
		deflate(rz->stream, Z_NO_FLUSH);
		rz->out += tout - rz->stream->avail_out;
		if(rz->stream->avail_out) break;
#ifdef _USE_KNETFILE
		write(rz->x.fpw, rz->outbuf, RZ_BUFFER_SIZE - rz->stream->avail_out);
#else
		write(rz->filedes, rz->outbuf, RZ_BUFFER_SIZE - rz->stream->avail_out);
#endif
		rz->stream->avail_out = RZ_BUFFER_SIZE;
		rz->stream->next_out  = rz->outbuf;
		if(rz->stream->avail_in == 0) break;
	};
	rz->in += size - rz->stream->avail_in;
	rz->block_off += size - rz->stream->avail_in;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, 0x8(%rdi)
movq %rsi, (%rdi)
movl 0x20(%rdi), %r15d
xorl %esi, %esi
callq 0x21822a
movq 0x10(%r14), %rax
movl 0x20(%rax), %ecx
subl %ecx, %r15d
addq %r15, 0x28(%r14)
testl %ecx, %ecx
jne 0x2d91b5
movl 0x8(%r14), %edi
movq 0x68(%r14), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x17250
movq 0x10(%r14), %rdi
movl $0x1000, 0x20(%rdi)     # imm = 0x1000
movq 0x68(%r14), %rax
movq %rax, 0x18(%rdi)
movl $0x1000, %r15d          # imm = 0x1000
cmpl $0x0, 0x8(%rdi)
jne 0x2d9167
xorl %eax, %eax
jmp 0x2d91b8
movl 0x8(%rax), %eax
subl %eax, %ebx
addq %rbx, 0x20(%r14)
addq %rbx, 0x50(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get
bool gt_bool_matrix_get(GtBoolMatrix *bm, GtUword firstdim,
                        GtUword seconddim)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim);
    if (bt && gt_dyn_bittab_bit_is_set(bt, seconddim))
      return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2de45d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x586a4
cmpq %r14, %rax
jbe 0x2de455
movq (%r15), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2de455
movq %rbx, %rsi
callq 0x6f846
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2de457
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x159b04(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x6ba5(%rip), %rsi      # 0x2e5013
leaq 0xabbf2(%rip), %rdx     # 0x38a067
leaq 0xabbee(%rip), %rcx     # 0x38a06a
leaq 0xabbcd(%rip), %r8      # 0x38a050
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_set
void gt_bool_matrix_set(GtBoolMatrix *bm, GtUword firstdim,
                        GtUword seconddim, bool b)
{
  GtDynBittab *bt;
  GtUword i, elems_to_add;

  gt_assert(bm);
  /* make sure first dimension is large enough */
  if (firstdim >= gt_array_size(bm->dyn_bittabs)) {
    elems_to_add = firstdim - gt_array_size(bm->dyn_bittabs) + 1;
    for (i = 0; i < elems_to_add; i++) {
      bt = gt_dyn_bittab_new();
      gt_array_add(bm->dyn_bittabs, bt);
    }
  }

  /* set bit, if necessary */
  bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim);
  gt_assert(bt);
  if (b)
    gt_dyn_bittab_set_bit(bt, seconddim);
  else
    gt_dyn_bittab_unset_bit(bt, seconddim);

  /* value has been set */
  gt_assert(gt_bool_matrix_get(bm, firstdim, seconddim) == b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
testq %rdi, %rdi
je 0x2de556
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x586a4
cmpq %rbx, %rax
jbe 0x2de4f4
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x581aa
movq (%rax), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x2de580
movl 0xc(%rsp), %ebp
movq %r14, %rsi
testb %bpl, %bpl
je 0x2de52f
callq 0x6f715
jmp 0x2de534
movq (%r12), %rdi
callq 0x586a4
movq %rbx, %r15
subq %rax, %r15
incq %r15
leaq 0x10(%rsp), %r13
pushq $0x8
popq %rbp
subq $0x1, %r15
jb 0x2de4c4
callq 0x6f700
movq %rax, 0x10(%rsp)
movq (%r12), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x5851d
jmp 0x2de50e
callq 0x6f7f0
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2de412
cmpb %bpl, %al
jne 0x2de5aa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x159a0b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x6aac(%rip), %rsi      # 0x2e5013
leaq 0xabaf9(%rip), %rdx     # 0x38a067
leaq 0xabb08(%rip), %rcx     # 0x38a07d
leaq 0xabad4(%rip), %r8      # 0x38a050
pushq $0x37
jmp 0x2de5d2
movq 0x1599e1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x6a82(%rip), %rsi      # 0x2e5013
leaq 0x6b707(%rip), %rdx     # 0x349c9f
leaq 0xabade(%rip), %rcx     # 0x38a07d
leaq 0xabaaa(%rip), %r8      # 0x38a050
pushq $0x43
jmp 0x2de5d2
movq 0x1599b7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x6a58(%rip), %rsi      # 0x2e5013
leaq 0xabace(%rip), %rdx     # 0x38a090
leaq 0xabab4(%rip), %rcx     # 0x38a07d
leaq 0xaba80(%rip), %r8      # 0x38a050
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get_first_column
GtUword gt_bool_matrix_get_first_column(const GtBoolMatrix *bm,
                                              GtUword firstdim)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    if ((bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim)))
      return gt_dyn_bittab_get_first_bitnum(bt);
  }
  return GT_UNDEF_UWORD;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2de626
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x586a4
cmpq %rbx, %rax
jbe 0x2de61b
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x581aa
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2de61b
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f8a2
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x15993b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x69dc(%rip), %rsi      # 0x2e5013
leaq 0xaba29(%rip), %rdx     # 0x38a067
leaq 0xaba7c(%rip), %rcx     # 0x38a0c1
leaq 0xaba04(%rip), %r8      # 0x38a050
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get_last_column
GtUword gt_bool_matrix_get_last_column(const GtBoolMatrix *bm,
                                             GtUword firstdim)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    if ((bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim)))
      return gt_dyn_bittab_get_last_bitnum(bt);
  }
  return GT_UNDEF_UWORD;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2de6a2
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x586a4
cmpq %rbx, %rax
jbe 0x2de697
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x581aa
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2de697
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f90f
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1598bf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x6960(%rip), %rsi      # 0x2e5013
leaq 0xab9ad(%rip), %rdx     # 0x38a067
leaq 0xaba20(%rip), %rcx     # 0x38a0e1
leaq 0xab988(%rip), %r8      # 0x38a050
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_get_next_column
GtUword gt_bool_matrix_get_next_column(const GtBoolMatrix *bm,
                                             GtUword firstdim,
                                             GtUword i)
{
  GtDynBittab *bt;
  gt_assert(bm);
  if (firstdim < gt_array_size(bm->dyn_bittabs)) {
    if ((bt = *(GtDynBittab**) gt_array_get(bm->dyn_bittabs, firstdim)))
      return gt_dyn_bittab_get_next_bitnum(bt, i);
  }
  return GT_UNDEF_UWORD;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2de721
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x586a4
cmpq %r14, %rax
jbe 0x2de718
movq (%r15), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2de718
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6f950
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x159840(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x68e1(%rip), %rsi      # 0x2e5013
leaq 0xab92e(%rip), %rdx     # 0x38a067
leaq 0xab9c0(%rip), %rcx     # 0x38a100
leaq 0xab909(%rip), %r8      # 0x38a050
pushq $0x6a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bool_matrix.c
// Function: gt_bool_matrix_delete
void gt_bool_matrix_delete(GtBoolMatrix *bm)
{
  GtUword i;
  if (!bm) return;
  for (i = 0; i < gt_array_size(bm->dyn_bittabs); i++)
    gt_dyn_bittab_delete(*(GtDynBittab**) gt_array_get(bm->dyn_bittabs, i));
  gt_array_delete(bm->dyn_bittabs);
  gt_free(bm);
}

// Assembly:
testq %rdi, %rdi
je 0x2de7a9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x586a4
movq (%rbx), %rdi
cmpq %rax, %r14
jae 0x2de78b
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0x6ff36
incq %r14
jmp 0x2de766
callq 0x58eb9
leaq 0xab8b9(%rip), %rsi     # 0x38a050
pushq $0x79
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: gt_obo_parse_tree_delete
void gt_obo_parse_tree_delete(GtOBOParseTree *obo_parse_tree)
{
  GtUword i;
  if (!obo_parse_tree) return;
  for (i = 0; i < gt_array_size(obo_parse_tree->stanzas); i++) {
    gt_obo_stanza_delete(*(GtOBOStanza**)
                         gt_array_get(obo_parse_tree->stanzas, i));
  }
  gt_array_delete(obo_parse_tree->stanzas);
  obo_header_delete(obo_parse_tree->obo_header);
  gt_free(obo_parse_tree);
}

// Assembly:
testq %rdi, %rdi
je 0x2df1b0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
callq 0x586a4
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jae 0x2df112
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0x2df8e6
incq %r14
jmp 0x2df0eb
callq 0x58eb9
movq (%rbx), %r14
testq %r14, %r14
je 0x2df18e
xorl %r15d, %r15d
leaq 0xab00c(%rip), %r12     # 0x38a135
pushq $0x3a
popq %rbp
movq (%r14), %rdi
callq 0x586a4
movq (%r14), %rdi
cmpq %rax, %r15
jae 0x2df177
movq %r15, %rsi
callq 0x581aa
movq (%rax), %r13
movq 0x8(%r13), %rdi
movq %r12, %rsi
pushq $0x38
popq %rdx
callq 0x936f9
movq (%r13), %rdi
movq %r12, %rsi
pushq $0x39
popq %rdx
callq 0x936f9
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x936f9
incq %r15
jmp 0x2df12c
callq 0x58eb9
leaq 0xaafb2(%rip), %rsi     # 0x38a135
pushq $0x3d
popq %rdx
movq %r14, %rdi
callq 0x936f9
leaq 0xaafa0(%rip), %rsi     # 0x38a135
movq %rbx, %rdi
movl $0x1bf, %edx            # imm = 0x1BF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: gt_obo_parse_tree_get_stanza_type
const char* gt_obo_parse_tree_get_stanza_type(const GtOBOParseTree
                                              *obo_parse_tree,
                                              GtUword stanza_num)
{
  gt_assert(obo_parse_tree);
  return gt_obo_stanza_get_type(*(GtOBOStanza**)
                                gt_array_get(obo_parse_tree->stanzas,
                                             stanza_num));
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2df1c9
movq 0x8(%rdi), %rdi
callq 0x581aa
movq (%rax), %rdi
popq %rax
jmp 0x2df9e4
movq 0x158d98(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5e39(%rip), %rsi      # 0x2e5013
leaq 0xaaf72(%rip), %rdx     # 0x38a153
leaq 0xaaf7a(%rip), %rcx     # 0x38a162
leaq 0xaaf46(%rip), %r8      # 0x38a135
movl $0x1c6, %r9d            # imm = 0x1C6
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: gt_obo_parse_tree_get_stanza_value
const char* gt_obo_parse_tree_get_stanza_value(const GtOBOParseTree
                                               *obo_parse_tree,
                                               GtUword stanza_num,
                                               const char *stanza_key)
{
  gt_assert(obo_parse_tree);
  return gt_obo_stanza_get_value(*(GtOBOStanza**)
                                 gt_array_get(obo_parse_tree->stanzas,
                                              stanza_num), stanza_key, 0);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2df221
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x581aa
movq (%rax), %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x2dfa24
movq 0x158d40(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5de1(%rip), %rsi      # 0x2e5013
leaq 0xaaf1a(%rip), %rdx     # 0x38a153
leaq 0xaaf44(%rip), %rcx     # 0x38a184
leaq 0xaaeee(%rip), %r8      # 0x38a135
movl $0x1d1, %r9d            # imm = 0x1D1
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: blank_line
static int blank_line(GtIO *obo_file, GtError *err)
{
  int had_err;
  gt_error_check(err);
  had_err = gt_io_expect(obo_file, OBO_BLANK_CHAR, err);
  while (!had_err) {
    char cc = gt_io_peek(obo_file);
    if (cc == OBO_COMMENT_CHAR)
      return comment_line(obo_file, err);
    else if (cc == GT_CARRIAGE_RETURN) {
      gt_io_next(obo_file);
      if (gt_io_peek(obo_file) == GT_END_OF_LINE)
        gt_io_next(obo_file);
      break;
    }
    else if ((cc == GT_END_OF_LINE) || (cc == GT_END_OF_FILE)) {
      gt_io_next(obo_file);
      break;
    }
    else
      had_err = gt_io_expect(obo_file, OBO_BLANK_CHAR, err);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2df307
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2df37a
pushq $0x20
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x928fc
testl %eax, %eax
jne 0x2df351
movq %rbx, %rdi
callq 0x92771
cmpb $0xa, %al
je 0x2df345
movzbl %al, %eax
cmpl $0xd, %eax
je 0x2df355
cmpl $0xff, %eax
je 0x2df345
cmpl $0x21, %eax
jne 0x2df307
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2df3b2
movq %rbx, %rdi
callq 0x927d7
xorl %ebp, %ebp
jmp 0x2df373
movl %eax, %ebp
jmp 0x2df373
movq %rbx, %rdi
callq 0x927d7
movq %rbx, %rdi
callq 0x92771
xorl %ebp, %ebp
cmpb $0xa, %al
jne 0x2df373
movq %rbx, %rdi
callq 0x927d7
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x158be7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5c88(%rip), %rsi      # 0x2e5013
leaq 0x5e2d(%rip), %rdx      # 0x2e51bf
leaq 0x5dcd7(%rip), %rcx     # 0x33d070
leaq 0xaad95(%rip), %r8      # 0x38a135
movl $0xda, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: comment_line
static int comment_line(GtIO *obo_file, GtError *err)
{
  int had_err;
  gt_error_check(err);
  had_err = gt_io_expect(obo_file, OBO_COMMENT_CHAR, err);
  while (!had_err) {
    switch (gt_io_peek(obo_file)) {
      case GT_CARRIAGE_RETURN:
        gt_io_next(obo_file);
        if (gt_io_peek(obo_file) == GT_END_OF_LINE)
          gt_io_next(obo_file);
        return had_err;
      case GT_END_OF_LINE:
        gt_io_next(obo_file);
        /*@fallthrough@*/
      case GT_END_OF_FILE:
        return had_err;
      default:
        gt_io_next(obo_file);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2df3cd
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2df428
pushq $0x21
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x928fc
movl %eax, %ebp
testl %eax, %eax
jne 0x2df421
jmp 0x2df3fa
movzbl %al, %eax
cmpl $0xff, %eax
je 0x2df421
movq %rbx, %rdi
cmpl $0xd, %eax
je 0x2df408
callq 0x927d7
movq %rbx, %rdi
callq 0x92771
cmpb $0xa, %al
jne 0x2df3e3
jmp 0x2df419
callq 0x927d7
movq %rbx, %rdi
callq 0x92771
cmpb $0xa, %al
jne 0x2df421
movq %rbx, %rdi
callq 0x927d7
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x158b39(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5bda(%rip), %rsi      # 0x2e5013
leaq 0x5d7f(%rip), %rdx      # 0x2e51bf
leaq 0x5dc51(%rip), %rcx     # 0x33d098
leaq 0xaace7(%rip), %r8      # 0x38a135
movl $0xc2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: tag_line
static int tag_line(GtIO *obo_file, GtStr *tag, GtStr *value, GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_assert(obo_file && tag && value);
  do {
    had_err = proc_any_char(obo_file, tag, false, err);
  } while (!had_err && any_char(obo_file, false));
  if (!had_err)
    had_err = gt_io_expect(obo_file, OBO_SEPARATOR_CHAR, err);
  while (!had_err && gt_io_peek(obo_file) == OBO_BLANK_CHAR)
    gt_io_next(obo_file);
  if (!had_err) {
    do {
      had_err = proc_any_char(obo_file, value, true, err);
    } while (!had_err && any_char(obo_file, true));
  }
  if (!had_err) {
    if (gt_io_peek(obo_file) == OBO_COMMENT_CHAR)
      had_err = comment_line(obo_file, err);
    else
      had_err = gt_io_expect(obo_file, GT_END_OF_LINE, err);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x2df48c
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2df596
testq %r12, %r12
je 0x2df568
testq %r15, %r15
je 0x2df568
pushq $-0x1
popq %r13
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2df61a
testl %eax, %eax
jne 0x2df53a
movq %r14, %rdi
xorl %esi, %esi
callq 0x2df5ce
testb %al, %al
jne 0x2df4a2
pushq $0x3a
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x928fc
testl %eax, %eax
jne 0x2df53d
jmp 0x2df4e4
movq %r14, %rdi
callq 0x927d7
movq %r14, %rdi
callq 0x92771
cmpb $0x20, %al
je 0x2df4dc
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x2df61a
testl %eax, %eax
jne 0x2df53a
movq %r14, %rdi
movl %ebp, %esi
callq 0x2df5ce
testb %al, %al
jne 0x2df4f3
movq %r14, %rdi
callq 0x92771
cmpb $0x21, %al
jne 0x2df54c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2df3b2
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0xa
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x928fc
movq 0x1589f9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5a9a(%rip), %rsi      # 0x2e5013
leaq 0xaac8f(%rip), %rdx     # 0x38a20f
leaq 0x5db99(%rip), %rcx     # 0x33d120
leaq 0xaaba7(%rip), %r8      # 0x38a135
movl $0x116, %r9d            # imm = 0x116
jmp 0x2df5c2
movq 0x1589cb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5a6c(%rip), %rsi      # 0x2e5013
leaq 0x5c11(%rip), %rdx      # 0x2e51bf
leaq 0x5db6b(%rip), %rcx     # 0x33d120
leaq 0xaab79(%rip), %r8      # 0x38a135
movl $0x115, %r9d            # imm = 0x115
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: proc_any_char
static int proc_any_char(GtIO *obo_file, GtStr *capture, bool be_permissive,
                         GtError *err)
{
  gt_error_check(err);
  gt_assert(obo_file && capture);
  if (!any_char(obo_file, be_permissive)) {
    if (gt_io_peek(obo_file) == GT_END_OF_FILE) {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected end-of-file",
                gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file));
    }
    else if ((gt_io_peek(obo_file) == GT_CARRIAGE_RETURN) ||
             (gt_io_peek(obo_file) == GT_END_OF_LINE)) {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected newline",
                gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file));
    }
    else {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected character '%c'",
                gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file),
                gt_io_peek(obo_file));
    }
    return -1;
  }
  gt_str_append_char(capture, gt_io_next(obo_file));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x2df642
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2df74e
testq %r15, %r15
je 0x2df720
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x2df5ce
testb %al, %al
je 0x2df672
movq %r14, %rdi
callq 0x927d7
movsbl %al, %esi
movq %r15, %rdi
callq 0xaced9
xorl %eax, %eax
jmp 0x2df6dc
movq %r14, %rdi
callq 0x92771
movq %r14, %rdi
cmpb $-0x1, %al
je 0x2df6b2
callq 0x92771
cmpb $0xd, %al
je 0x2df696
movq %r14, %rdi
callq 0x92771
cmpb $0xa, %al
jne 0x2df6e5
movq %r14, %rdi
callq 0x9286d
movq %rax, %r15
movq %r14, %rdi
callq 0x9282c
leaq 0x5db3b(%rip), %rsi     # 0x33d1eb
jmp 0x2df6c9
callq 0x9286d
movq %rax, %r15
movq %r14, %rdi
callq 0x9282c
leaq 0x5daf6(%rip), %rsi     # 0x33d1bf
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x9286d
movq %rax, %r15
movq %r14, %rdi
callq 0x9282c
movq %rax, %r12
movq %r14, %rdi
callq 0x92771
movsbl %al, %r8d
leaq 0x5db05(%rip), %rsi     # 0x33d213
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x89dbb
jmp 0x2df6d9
movq 0x158841(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x58e2(%rip), %rsi      # 0x2e5013
leaq 0xaaaf0(%rip), %rdx     # 0x38a228
leaq 0x5da59(%rip), %rcx     # 0x33d198
leaq 0xaa9ef(%rip), %r8      # 0x38a135
movl $0xfc, %r9d
jmp 0x2df77a
movq 0x158813(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x58b4(%rip), %rsi      # 0x2e5013
leaq 0x5a59(%rip), %rdx      # 0x2e51bf
leaq 0x5da2b(%rip), %rcx     # 0x33d198
leaq 0xaa9c1(%rip), %r8      # 0x38a135
movl $0xfb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: validate_value
static int validate_value(const GtOBOStanza *obo_stanza, const char *value,
                          GtError *err)
{
  gt_error_check(err);
  gt_assert(obo_stanza && value);
  if (!gt_obo_stanza_get_value(obo_stanza, value, 0)) {
    gt_error_set(err, "%s stanza starting on line "GT_WU" in file \"%s\" lacks "
                 "required \"%s\" tag", gt_obo_stanza_get_type(obo_stanza),
                 gt_obo_stanza_line(obo_stanza),
                 gt_obo_stanza_filename(obo_stanza), value);
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x2df7ad
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2df842
testq %r15, %r15
je 0x2df818
testq %rbx, %rbx
je 0x2df818
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2dfa24
testq %rax, %rax
jne 0x2df80b
movq %r15, %rdi
callq 0x2df9e4
movq %rax, %r12
movq %r15, %rdi
callq 0x2dfb1d
movq %rax, %r13
movq %r15, %rdi
callq 0x2dfad8
leaq 0xaaba3(%rip), %rsi     # 0x38a394
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r12
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x158749(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x57ea(%rip), %rsi      # 0x2e5013
leaq 0xaab50(%rip), %rdx     # 0x38a380
leaq 0xaab3a(%rip), %rcx     # 0x38a371
leaq 0xaa8f7(%rip), %r8      # 0x38a135
pushq $0x76
jmp 0x2df86a
movq 0x15871f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x57c0(%rip), %rsi      # 0x2e5013
leaq 0x5965(%rip), %rdx      # 0x2e51bf
leaq 0xaab10(%rip), %rcx     # 0x38a371
leaq 0xaa8cd(%rip), %r8      # 0x38a135
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_new
GtOBOStanza* gt_obo_stanza_new(const char *type, GtUword line,
                               GtStr *filename)
{
  GtOBOStanza *obo_stanza = gt_malloc(sizeof *obo_stanza);
  obo_stanza->type = gt_cstr_dup(type);
  obo_stanza->content = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                       (GtFree) gt_str_array_delete);
  obo_stanza->line = line;
  obo_stanza->filename = gt_str_ref(filename);
  return obo_stanza;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xaab48(%rip), %rsi     # 0x38a3d8
pushq $0x20
popq %rdi
pushq $0x23
popq %rdx
callq 0x93160
movq %rax, %r12
movq %r15, %rdi
callq 0x6c2be
movq %rax, (%r12)
leaq -0x24c072(%rip), %rsi   # 0x9383f
leaq -0x231256(%rip), %rdx   # 0xae662
pushq $0x1
popq %rdi
callq 0x8f330
movq %rax, 0x8(%r12)
movq %r14, 0x10(%r12)
movq %rbx, %rdi
callq 0xad4d2
movq %rax, 0x18(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_delete
void gt_obo_stanza_delete(GtOBOStanza *obo_stanza)
{
  if (!obo_stanza) return;
  gt_str_delete(obo_stanza->filename);
  gt_hashmap_delete(obo_stanza->content);
  gt_free(obo_stanza->type);
  gt_free(obo_stanza);
}

// Assembly:
testq %rdi, %rdi
je 0x2df92e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0x8f933
movq (%rbx), %rdi
leaq 0xaaaca(%rip), %r14     # 0x38a3d8
pushq $0x31
popq %rdx
movq %r14, %rsi
callq 0x936f9
pushq $0x32
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_add
void gt_obo_stanza_add(GtOBOStanza *obo_stanza, const char *tag,
                       const char *value)
{
  GtStrArray *sa;
  gt_assert(obo_stanza && tag && value);
  if (!(sa = gt_hashmap_get(obo_stanza->content, tag))) {
    sa = gt_str_array_new();
    gt_str_array_add_cstr(sa, value);
    gt_hashmap_add(obo_stanza->content, gt_cstr_dup(tag), sa);
  }
  else
    gt_str_array_add_cstr(sa, value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2df9ae
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2df9ae
movq %rdx, %r14
testq %rdx, %rdx
je 0x2df9ae
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
callq 0x8f482
testq %rax, %rax
je 0x2df976
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xae22f
callq 0xae154
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0xae22f
movq 0x8(%r15), %r14
movq %rbx, %rdi
callq 0x6c2be
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8f4bd
movq 0x1585b3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5654(%rip), %rsi      # 0x2e5013
leaq 0xaaa2c(%rip), %rdx     # 0x38a3f2
leaq 0xaaa40(%rip), %rcx     # 0x38a40d
leaq 0xaaa04(%rip), %r8      # 0x38a3d8
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_get_value
const char* gt_obo_stanza_get_value(const GtOBOStanza *obo_stanza,
                                    const char *stanza_key,
                                    GtUword num)
{
  GtStrArray *sa;
  gt_assert(obo_stanza);
  if ((sa = gt_hashmap_get(obo_stanza->content, stanza_key)))
    return gt_str_array_get(sa, num);
  return NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2dfa4b
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x8f482
testq %rax, %rax
je 0x2dfa47
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xae386
xorl %eax, %eax
popq %rbx
retq
movq 0x158516(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x55b7(%rip), %rsi      # 0x2e5013
leaq 0xaa8a6(%rip), %rdx     # 0x38a309
leaq 0xaa9cc(%rip), %rcx     # 0x38a436
leaq 0xaa967(%rip), %r8      # 0x38a3d8
pushq $0x4e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_size
GtUword gt_obo_stanza_size(const GtOBOStanza *obo_stanza,
                                 const char *stanza_key)
{
  GtStrArray *sa;
  gt_assert(obo_stanza);
  if ((sa = gt_hashmap_get(obo_stanza->content, stanza_key)))
    return gt_str_array_size(sa);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2dfaa2
movq 0x8(%rdi), %rdi
callq 0x8f482
testq %rax, %rax
je 0x2dfa9e
movq %rax, %rdi
popq %rax
jmp 0xae61c
xorl %eax, %eax
popq %rcx
retq
movq 0x1584bf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x5560(%rip), %rsi      # 0x2e5013
leaq 0xaa84f(%rip), %rdx     # 0x38a309
leaq 0xaa98d(%rip), %rcx     # 0x38a44e
leaq 0xaa910(%rip), %r8      # 0x38a3d8
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/firstcodes-psbuf.c
// Function: gt_leftborderbuffer_new
GtLeftborderOutbuffer *gt_leftborderbuffer_new(const char *name,
                                               GtFirstcodesspacelog *fcsl)
{
  GtLeftborderOutbuffer *lbbuf = gt_malloc(sizeof (*lbbuf));

  lbbuf->totalwrite = 0;
  lbbuf->outfilename = gt_str_new();
  lbbuf->fp = gt_xtmpfp(lbbuf->outfilename);
  lbbuf->nextfree = 0;
  lbbuf->allocated = 1024UL;
  lbbuf->name = gt_str_new_cstr(name);
  lbbuf->spaceuint32_t = gt_malloc(sizeof (*lbbuf->spaceuint32_t) *
                                   lbbuf->allocated);
  GT_FCI_ADDWORKSPACE(fcsl,name,
                      sizeof (*lbbuf->spaceuint32_t) * lbbuf->allocated);
  return lbbuf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaa916(%rip), %r15     # 0x38a48b
pushq $0x38
popq %rdi
pushq $0x1f
popq %rdx
movq %r15, %rsi
callq 0x93160
movq %rax, %r12
andq $0x0, 0x18(%rax)
callq 0xacb84
movq %rax, 0x20(%r12)
pushq $0x23
popq %rcx
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x8abea
movq %rax, 0x30(%r12)
andq $0x0, 0x8(%r12)
movq $0x400, 0x10(%r12)      # imm = 0x400
movq %rbx, %rdi
callq 0xacbd1
movq %rax, 0x28(%r12)
movq 0x10(%r12), %rdi
shlq $0x2, %rdi
pushq $0x28
popq %rdx
movq %r15, %rsi
callq 0x93160
movq %rax, (%r12)
movq 0x10(%r12), %rax
shlq $0x2, %rax
movq %rax, (%rsp)
pushq $0x2a
popq %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %r8
movl %ecx, %r9d
callq 0x2b613a
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/firstcodes-psbuf.c
// Function: gt_leftborderbuffer_flush
void gt_leftborderbuffer_flush(GtLeftborderOutbuffer *leftborderbuffer)
{
  gt_xfwrite(leftborderbuffer->spaceuint32_t,
             sizeof (*leftborderbuffer->spaceuint32_t),
             (size_t) leftborderbuffer->nextfree,
             leftborderbuffer->fp);
  leftborderbuffer->totalwrite += leftborderbuffer->nextfree;
  leftborderbuffer->nextfree = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rdx
movq 0x30(%rbx), %rcx
pushq $0x4
popq %rsi
callq 0xb302c
movq 0x8(%rbx), %rax
addq %rax, 0x18(%rbx)
andq $0x0, 0x8(%rbx)
popq %rbx
retq