LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_bgzf
int bgzf_check_bgzf(const char *fn)
{
    BGZF *fp;
    uint8_t buf[10],magic[10]="\037\213\010\4\0\0\0\0\0\377";
    int n;

    if ((fp = bgzf_open(fn, "r")) == 0) 
    {
        fprintf(stderr, "[bgzf_check_bgzf] failed to open the file: %s\n",fn);
        return -1;
    }

#ifdef _USE_KNETFILE
    n = knet_read(fp->x.fpr, buf, 10);
#else
    n = fread(buf, 1, 10, fp->file);
#endif
    bgzf_close(fp);

    if ( n!=10 ) 
        return -1;

    if ( !memcmp(magic, buf, 10) ) return 1;
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x258e0(%rip), %rsi     # 0x363ec9
callq 0x33e66b
testq %rax, %rax
je 0x33e649
movq %rax, %r14
movq 0x10(%rax), %rcx
leaq 0xe(%rsp), %rdi
movl $0x1, %esi
movl $0xa, %edx
callq 0x17b40
movq %rax, %rbx
movq %r14, %rdi
callq 0x33e78d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xa, %ebx
jne 0x33e641
movl $0x4088b1f, %ecx        # imm = 0x4088B1F
xorq 0xe(%rsp), %rcx
movzwl 0x16(%rsp), %edx
xorq $0xff00, %rdx           # imm = 0xFF00
xorl %eax, %eax
orq %rcx, %rdx
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x185930(%rip), %rax    # 0x4c3f80
movq (%rax), %rdi
leaq 0xb2526(%rip), %rsi     # 0x3f0b80
movq %rbx, %rdx
xorl %eax, %eax
callq 0x17ab0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x33e641
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_open
BGZF*
bgzf_open(const char* __restrict path, const char* __restrict mode)
{
    BGZF* fp = NULL;
    if (strchr(mode, 'r') || strchr(mode, 'R')) { /* The reading mode is preferred. */
#ifdef _USE_KNETFILE
		knetFile *file = knet_open(path, mode);
		if (file == 0) return 0;
		fp = bgzf_read_init();
		fp->file_descriptor = -1;
		fp->open_mode = 'r';
		fp->x.fpr = file;
#else
		int fd, oflag = O_RDONLY;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag);
		if (fd == -1) return 0;
        fp = open_read(fd);
#endif
    } else if (strchr(mode, 'w') || strchr(mode, 'W')) {
		int fd, compress_level = -1, oflag = O_WRONLY | O_CREAT | O_TRUNC;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag, 0666);
		if (fd == -1) return 0;
		{ // set compress_level
			int i;
			for (i = 0; mode[i]; ++i)
				if (mode[i] >= '0' && mode[i] <= '9') break;
			if (mode[i]) compress_level = (int)mode[i] - '0';
			if (strchr(mode, 'u')) compress_level = 0;
		}
        fp = open_write(fd, compress_level);
    }
    if (fp != NULL) fp->owned_file = 1;
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
movl $0x72, %esi
callq 0x17280
testq %rax, %rax
jne 0x33e69c
movq %rbx, %rdi
movl $0x52, %esi
callq 0x17280
testq %rax, %rax
je 0x33e6da
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x17d60
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x33e6bc
movl %ebx, %edi
callq 0x33e8b4
movq %rax, %r14
cmpl $-0x1, %ebx
je 0x33e774
testq %r14, %r14
je 0x33e777
movw $0x1, 0x6(%r14)
jmp 0x33e777
movq %rbx, %rdi
movl $0x77, %esi
callq 0x17280
testq %rax, %rax
jne 0x33e702
movq %rbx, %rdi
movl $0x57, %esi
callq 0x17280
testq %rax, %rax
je 0x33e785
xorl %r14d, %r14d
movq %r15, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x17d60
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x33e76b
movq %rbx, %rcx
movzbl (%rcx), %eax
testl %eax, %eax
je 0x33e735
leal -0x30(%rax), %edx
incq %rcx
cmpb $0x9, %dl
ja 0x33e723
leal -0x30(%rax), %ecx
xorl %r15d, %r15d
cmpl $0x1, %eax
movl $0x0, %r14d
sbbl %r14d, %r14d
orl %ecx, %r14d
movq %rbx, %rdi
movl $0x75, %esi
callq 0x17280
testq %rax, %rax
cmovnel %r15d, %r14d
movl %ebp, %edi
movl %r14d, %esi
callq 0x33e945
movq %rax, %r14
cmpl $-0x1, %ebp
jne 0x33e6c5
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x33e6c5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_read
static
BGZF*
open_read(int fd)
{
#ifdef _USE_KNETFILE
    knetFile *file = knet_dopen(fd, "r");
#else
    FILE* file = fdopen(fd, "r");
#endif
    BGZF* fp;
	if (file == 0) return 0;
	fp = bgzf_read_init();
    fp->file_descriptor = fd;
    fp->open_mode = 'r';
#ifdef _USE_KNETFILE
    fp->x.fpr = file;
#else
    fp->file = file;
#endif
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x25605(%rip), %rsi     # 0x363ec9
callq 0x17860
testq %rax, %rax
je 0x33e934
movq %rax, %r14
movl $0x1, %edi
movl $0x58, %esi
callq 0x174e0
movq %rax, %r15
movl $0x10000, %ebp          # imm = 0x10000
movl %ebp, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17ff0
movq %rax, 0x20(%r15)
movl %ebp, 0x1c(%r15)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17ff0
movq %rax, 0x28(%r15)
movl $0x0, 0x40(%r15)
movl $0x1, %edi
movl $0x28, %esi
callq 0x174e0
movq %rax, 0x50(%r15)
movl %ebx, (%r15)
movb $0x72, 0x4(%r15)
movq %r14, 0x10(%r15)
jmp 0x33e937
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_write
static
BGZF*
open_write(int fd, int compress_level) // compress_level==-1 for the default level
{
    FILE* file = fdopen(fd, "w");
    BGZF* fp;
	if (file == 0) return 0;
	fp = malloc(sizeof(BGZF));
    fp->file_descriptor = fd;
    fp->open_mode = 'w';
    fp->owned_file = 0;
	fp->compress_level = compress_level < 0? Z_DEFAULT_COMPRESSION : compress_level; // Z_DEFAULT_COMPRESSION==-1
	if (fp->compress_level > 9) fp->compress_level = Z_DEFAULT_COMPRESSION;
#ifdef _USE_KNETFILE
    fp->x.fpw = file;
#else
    fp->file = file;
#endif
    fp->uncompressed_block_size = DEFAULT_BLOCK_SIZE;
    fp->uncompressed_block = NULL;
    fp->compressed_block_size = MAX_BLOCK_SIZE;
    fp->compressed_block = malloc(MAX_BLOCK_SIZE);
    fp->block_address = 0;
    fp->block_offset = 0;
    fp->block_length = 0;
    fp->error = NULL;
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r15d
leaq 0x5e0d9(%rip), %rsi     # 0x39ca31
callq 0x17860
testq %rax, %rax
je 0x33e9cd
movq %rax, %r14
movl $0x58, %edi
callq 0x17ff0
movq %rax, %rbx
movl %r15d, (%rax)
movb $0x77, 0x4(%rax)
movw $0x0, 0x6(%rax)
testl %ebp, %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
cmpw $0xa, %ax
movl $0xffff, %ecx           # imm = 0xFFFF
cmovll %eax, %ecx
movw %cx, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movabsq $0x1000000010000, %rax  # imm = 0x1000000010000
movq %rax, 0x18(%rbx)
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17ff0
movq %rax, 0x28(%rbx)
movq %r14, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
jmp 0x33e9cf
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_fdopen
BGZF*
bgzf_fdopen(int fd, const char * __restrict mode)
{
	if (fd == -1) return 0;
    if (mode[0] == 'r' || mode[0] == 'R') {
        return open_read(fd);
    } else if (mode[0] == 'w' || mode[0] == 'W') {
		int i, compress_level = -1;
		for (i = 0; mode[i]; ++i)
			if (mode[i] >= '0' && mode[i] <= '9') break;
		if (mode[i]) compress_level = (int)mode[i] - '0';
		if (strchr(mode, 'u')) compress_level = 0;
        return open_write(fd, compress_level);
    } else {
        return NULL;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x33e9fd
movl %edi, %ebx
movzbl (%rsi), %ecx
cmpl $0x71, %ecx
jg 0x33ea04
cmpl $0x52, %ecx
je 0x33ea56
movq %rsi, %rax
cmpl $0x57, %ecx
je 0x33ea11
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x72, %ecx
je 0x33ea56
movq %rsi, %rax
cmpl $0x77, %ecx
jne 0x33e9fd
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x33ea23
leal -0x30(%rcx), %edx
incq %rax
cmpb $0x9, %dl
ja 0x33ea11
leal -0x30(%rcx), %eax
xorl %r14d, %r14d
cmpl $0x1, %ecx
movl $0x0, %ebp
sbbl %ebp, %ebp
orl %eax, %ebp
movq %rsi, %rdi
movl $0x75, %esi
callq 0x17280
testq %rax, %rax
cmovnel %r14d, %ebp
movl %ebx, %edi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x33e945
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x33e8b4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_read
int
bgzf_read(BGZF* fp, void* data, int length)
{
    if (length <= 0) {
        return 0;
    }
    if (fp->open_mode != 'r') {
        report_error(fp, "file not open for reading");
        return -1;
    }

    int bytes_read = 0;
    bgzf_byte_t* output = data;
    while (bytes_read < length) {
        int copy_length, available = fp->block_length - fp->block_offset;
		bgzf_byte_t *buffer;
        if (available <= 0) {
            if (bgzf_read_block(fp) != 0) {
                return -1;
            }
            available = fp->block_length - fp->block_offset;
            if (available <= 0) {
                break;
            }
        }
        copy_length = bgzf_min(length-bytes_read, available);
        buffer = fp->uncompressed_block;
        memcpy(output, buffer + fp->block_offset, copy_length);
        fp->block_offset += copy_length;
        output += copy_length;
        bytes_read += copy_length;
    }
    if (fp->block_offset == fp->block_length) {
#ifdef _USE_KNETFILE
        fp->block_address = knet_tell(fp->x.fpr);
#else
        fp->block_address = ftello(fp->file);
#endif
        fp->block_offset = 0;
        fp->block_length = 0;
    }
    return bytes_read;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edx, %edx
jle 0x33efd1
movq %rdi, %r14
cmpb $0x72, 0x4(%rdi)
jne 0x33efd5
movl %edx, %ebp
movq %rsi, %r15
xorl %ebx, %ebx
movl %ebp, %r12d
subl %ebx, %r12d
jle 0x33efe7
movl 0x38(%r14), %eax
subl 0x3c(%r14), %eax
jle 0x33efa9
cmpl %eax, %r12d
cmovll %r12d, %eax
movslq 0x3c(%r14), %rsi
addq 0x20(%r14), %rsi
movslq %eax, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x17660
addl %r12d, 0x3c(%r14)
addq %r12, %r15
addl %r12d, %ebx
xorl %ecx, %ecx
jmp 0x33efba
movq %r14, %rdi
callq 0x33ea61
movl $0x1, %ecx
testl %eax, %eax
je 0x33efc0
testl %ecx, %ecx
je 0x33ef6c
jmp 0x33efe2
movl 0x38(%r14), %eax
subl 0x3c(%r14), %eax
jg 0x33ef7e
movl $0x3, %ecx
jmp 0x33efba
xorl %ebx, %ebx
jmp 0x33f00d
leaq 0xb1bf4(%rip), %rax     # 0x3f0bd0
movq %rax, 0x48(%r14)
jmp 0x33f008
cmpl $0x3, %ecx
jne 0x33f008
movl 0x3c(%r14), %eax
cmpl 0x38(%r14), %eax
jne 0x33f00d
movq 0x10(%r14), %rdi
callq 0x17bc0
movq %rax, 0x30(%r14)
movq $0x0, 0x38(%r14)
jmp 0x33f00d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_flush
int bgzf_flush(BGZF* fp)
{
    while (fp->block_offset > 0) {
        int count, block_length;
		block_length = deflate_block(fp, fp->block_offset);
        if (block_length < 0) return -1;
#ifdef _USE_KNETFILE
        count = fwrite(fp->compressed_block, 1, block_length, fp->x.fpw);
#else
        count = fwrite(fp->compressed_block, 1, block_length, fp->file);
#endif
        if (count != block_length) {
            report_error(fp, "write failed");
            return -1;
        }
        fp->block_address += block_length;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x3c(%rdi), %esi
testl %esi, %esi
jle 0x33f065
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x33f081
testl %eax, %eax
js 0x33f074
movl %eax, %r14d
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdi
movl %eax, %r15d
movl $0x1, %esi
movq %r15, %rdx
callq 0x17fa0
cmpl %eax, %r14d
jne 0x33f069
addq %r15, 0x30(%rbx)
movl 0x3c(%rbx), %esi
testl %esi, %esi
jg 0x33f02e
xorl %ebp, %ebp
jmp 0x33f074
leaq 0xb1b7a(%rip), %rax     # 0x3f0bea
movq %rax, 0x48(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_write
int bgzf_write(BGZF* fp, const void* data, int length)
{
	const bgzf_byte_t *input = data;
	int block_length, bytes_written;
    if (fp->open_mode != 'w') {
        report_error(fp, "file not open for writing");
        return -1;
    }

    if (fp->uncompressed_block == NULL)
        fp->uncompressed_block = malloc(fp->uncompressed_block_size);

    input = data;
    block_length = fp->uncompressed_block_size;
    bytes_written = 0;
    while (bytes_written < length) {
        int copy_length = bgzf_min(block_length - fp->block_offset, length - bytes_written);
        bgzf_byte_t* buffer = fp->uncompressed_block;
        memcpy(buffer + fp->block_offset, input, copy_length);
        fp->block_offset += copy_length;
        input += copy_length;
        bytes_written += copy_length;
        if (fp->block_offset == block_length) {
            if (bgzf_flush(fp) != 0) {
                break;
            }
        }
    }
    return bytes_written;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x77, 0x4(%rdi)
jne 0x33f37a
movl %edx, %ebp
movq %rsi, %r14
cmpq $0x0, 0x20(%rbx)
jne 0x33f323
movslq 0x18(%rbx), %rdi
callq 0x17ff0
movq %rax, 0x20(%rbx)
testl %ebp, %ebp
jle 0x33f38d
movl 0x18(%rbx), %r13d
xorl %r15d, %r15d
movslq 0x3c(%rbx), %rdi
movl %r13d, %eax
subl %edi, %eax
movl %ebp, %ecx
subl %r15d, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
addq 0x20(%rbx), %rdi
movslq %ecx, %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x17660
movl 0x3c(%rbx), %eax
addl %r12d, %eax
movl %eax, 0x3c(%rbx)
addq %r12, %r14
addl %r12d, %r15d
cmpl %r13d, %eax
jne 0x33f373
movq %rbx, %rdi
callq 0x33f018
testl %eax, %eax
jne 0x33f390
cmpl %ebp, %r15d
jl 0x33f32e
jmp 0x33f390
leaq 0xb1876(%rip), %rax     # 0x3f0bf7
movq %rax, 0x48(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x33f390
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_EOF
int bgzf_check_EOF(BGZF *fp)
{
	static uint8_t magic[28] = "\037\213\010\4\0\0\0\0\0\377\6\0\102\103\2\0\033\0\3\0\0\0\0\0\0\0\0\0";
	uint8_t buf[28];
	off_t offset;
#ifdef _USE_KNETFILE
	offset = knet_tell(fp->x.fpr);
	if (knet_seek(fp->x.fpr, -28, SEEK_END) != 0) return -1;
	knet_read(fp->x.fpr, buf, 28);
	knet_seek(fp->x.fpr, offset, SEEK_SET);
#else
	offset = ftello(fp->file);
	if (fseeko(fp->file, -28, SEEK_END) != 0) return -1;
	fread(buf, 1, 28, fp->file);
	fseeko(fp->file, offset, SEEK_SET);
#endif
	return (memcmp(magic, buf, 28) == 0)? 1 : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x17bc0
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq $-0x1c, %rsi
movl $0x2, %edx
callq 0x17cf0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x33f43c
movq 0x10(%rbx), %rcx
movq %rsp, %r15
movl $0x1, %esi
movl $0x1c, %edx
movq %r15, %rdi
callq 0x17b40
movq 0x10(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x17cf0
movdqa 0x18942e(%rip), %xmm0   # 0x4c8840
movdqu 0x189432(%rip), %xmm1   # 0x4c884c
movdqu 0xc(%r15), %xmm2
pcmpeqb %xmm1, %xmm2
pcmpeqb (%r15), %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %ecx
xorl %eax, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
sete %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x348a23
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xd4a9a
cmpq %r14, %rax
jbe 0x348a1b
movq (%r15), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
testq %rdi, %rdi
je 0x348a1b
movq %rbx, %rsi
callq 0xeb3f9
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x348a1d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x98e44
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
testq %rdi, %rdi
je 0x348adc
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq 0xd4a9a
cmpq %r15, %rax
ja 0x348a90
movq (%r12), %rdi
callq 0xd4a9a
leaq 0x1(%r15), %rbp
subq %rax, %rbp
je 0x348a90
cmpq $0x1, %rbp
adcq $0x0, %rbp
movq %rsp, %r13
callq 0xeb310
movq %rax, (%rsp)
movq (%r12), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0xd49ce
decq %rbp
jne 0x348a71
movq (%r12), %rdi
movq %r15, %rsi
callq 0xd47ba
movq (%rax), %rdi
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x348ae1
movq %r14, %rsi
testb %bl, %bl
je 0x348ab6
callq 0xeb32b
jmp 0x348abb
callq 0xeb3d0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3489d8
cmpb %bl, %al
jne 0x348ae6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x98ee9
callq 0x98eb2
callq 0x98e7b
// File: /workspace/github_c_makefile_star2_O1/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 0x348b35
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xd4a9a
cmpq %rbx, %rax
jbe 0x348b26
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xd47ba
movq (%rax), %rdi
testq %rdi, %rdi
je 0x348b26
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeb424
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x98f20
// File: /workspace/github_c_makefile_star2_O1/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 0x348b84
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xd4a9a
cmpq %rbx, %rax
jbe 0x348b75
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xd47ba
movq (%rax), %rdi
testq %rdi, %rdi
je 0x348b75
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeb46c
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x98f57
// File: /workspace/github_c_makefile_star2_O1/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 0x348bd6
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xd4a9a
cmpq %r14, %rax
jbe 0x348bc9
movq (%r15), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
testq %rdi, %rdi
je 0x348bc9
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xeb47c
movq $-0x1, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x98f8e
// File: /workspace/github_c_makefile_star2_O1/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 0x348c3d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x348c1a
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0xebab4
incq %r14
movq (%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x348bf7
movq (%rbx), %rdi
callq 0xd4ef4
leaq 0xaa997(%rip), %rsi     # 0x3f35c0
movq %rbx, %rdi
movl $0x79, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x349481
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x3493cc
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x3499dc
incq %r14
movq 0x8(%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x3493a7
movq 0x8(%rbx), %rdi
callq 0xd4ef4
movq (%rbx), %r14
testq %r14, %r14
je 0x349464
movq (%r14), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x349448
xorl %r15d, %r15d
leaq 0xaa2ad(%rip), %r12     # 0x3f36a5
movq (%r14), %rdi
movq %r15, %rsi
callq 0xd47ba
movq (%rax), %r13
movq 0x8(%r13), %rdi
movq %r12, %rsi
movl $0x38, %edx
callq 0x109670
movq (%r13), %rdi
movq %r12, %rsi
movl $0x39, %edx
callq 0x109670
movq %r13, %rdi
movq %r12, %rsi
movl $0x3a, %edx
callq 0x109670
incq %r15
movq (%r14), %rdi
callq 0xd4a9a
cmpq %rax, %r15
jb 0x3493f8
movq (%r14), %rdi
callq 0xd4ef4
leaq 0xaa24e(%rip), %rsi     # 0x3f36a5
movq %r14, %rdi
movl $0x3d, %edx
callq 0x109670
leaq 0xaa23a(%rip), %rsi     # 0x3f36a5
movq %rbx, %rdi
movl $0x1bf, %edx            # imm = 0x1BF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x34949a
movq 0x8(%rdi), %rdi
callq 0xd47ba
movq (%rax), %rdi
popq %rax
jmp 0x349aad
callq 0x9934d
// File: /workspace/github_c_makefile_star2_O1/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 0x3494bf
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0xd47ba
movq (%rax), %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x349abc
callq 0x99386
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x349514
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x3495d2
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq 0x108cae
movl %eax, %r15d
testl %r15d, %r15d
jne 0x3495c4
movq %r14, %rdi
callq 0x108c0e
movzbl %al, %eax
cmpl $0x20, %eax
jg 0x34956e
cmpl $0xa, %eax
je 0x34958f
cmpl $0xd, %eax
jne 0x34959f
movq %r14, %rdi
callq 0x108c47
movq %r14, %rdi
callq 0x108c0e
movl $0x5, %r12d
cmpb $0xa, %al
jne 0x3495b5
movq %r14, %rdi
callq 0x108c47
jmp 0x3495b5
cmpl $0xff, %eax
je 0x34958f
cmpl $0x21, %eax
jne 0x34959f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3495d7
movl %eax, %ebp
movl $0x1, %r12d
jmp 0x3495b5
movq %r14, %rdi
callq 0x108c47
movl $0x5, %r12d
jmp 0x3495b5
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq 0x108cae
movl %eax, %r15d
xorl %r12d, %r12d
testl %r12d, %r12d
je 0x349527
cmpl $0x5, %r12d
jne 0x3495c7
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x99431
// File: /workspace/github_c_makefile_star2_O1/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 0x3495f2
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x349653
movq %rbx, %rdi
movl $0x21, %esi
movq %r14, %rdx
callq 0x108cae
movl %eax, %ebp
testl %eax, %eax
je 0x34962a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movzbl %al, %eax
cmpl $0xff, %eax
je 0x349608
movq %rbx, %rdi
cmpl $0xd, %eax
je 0x349638
callq 0x108c47
testl %ebp, %ebp
jne 0x349608
movq %rbx, %rdi
callq 0x108c0e
cmpb $0xa, %al
jne 0x34960f
jmp 0x349649
callq 0x108c47
movq %rbx, %rdi
callq 0x108c0e
cmpb $0xa, %al
jne 0x349608
movq %rbx, %rdi
callq 0x108c47
jmp 0x349608
callq 0x9946a
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x349681
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x349761
testq %r12, %r12
je 0x34975c
testq %r15, %r15
je 0x34975c
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3497bb
testl %eax, %eax
jne 0x3496c9
movq %r14, %rdi
xorl %esi, %esi
callq 0x349766
testb %al, %al
jne 0x349693
movq %r14, %rdi
movl $0x3a, %esi
movq %rbx, %rdx
callq 0x108cae
movl %eax, %ebp
jmp 0x3496ce
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %ebp, %ebp
jne 0x349719
movq %r14, %rdi
callq 0x108c0e
cmpb $0x20, %al
jne 0x3496f9
movq %r14, %rdi
callq 0x108c47
jmp 0x3496ce
movq %r14, %rdi
movl $0x1, %esi
callq 0x349766
testb %al, %al
je 0x349717
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3497bb
testl %eax, %eax
je 0x3496e8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x349719
xorl %ebp, %ebp
testl %ebp, %ebp
je 0x349728
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x108c0e
movq %r14, %rdi
cmpb $0x21, %al
jne 0x349747
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3495d7
movl $0xa, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x108cae
callq 0x994dc
callq 0x994a3
// File: /workspace/github_c_makefile_star2_O1/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 0x3497e3
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x3498c8
testq %r15, %r15
je 0x3498c3
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x349766
testb %al, %al
je 0x349813
movq %r14, %rdi
callq 0x108c47
movsbl %al, %esi
movq %r15, %rdi
callq 0x120ba5
xorl %eax, %eax
jmp 0x34987f
movq %r14, %rdi
callq 0x108c0e
movq %r14, %rdi
cmpb $-0x1, %al
je 0x349853
callq 0x108c0e
cmpb $0xd, %al
je 0x349837
movq %r14, %rdi
callq 0x108c0e
cmpb $0xa, %al
jne 0x349888
movq %r14, %rdi
callq 0x108c81
movq %rax, %r15
movq %r14, %rdi
callq 0x108c71
leaq 0x5cb15(%rip), %rsi     # 0x3a6366
jmp 0x34986a
callq 0x108c81
movq %rax, %r15
movq %r14, %rdi
callq 0x108c71
leaq 0x5cad0(%rip), %rsi     # 0x3a633a
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x108c81
movq %rax, %r15
movq %r14, %rdi
callq 0x108c71
movq %rax, %r12
movq %r14, %rdi
callq 0x108c0e
movsbl %al, %r8d
leaq 0x5cadd(%rip), %rsi     # 0x3a638e
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1019cf
jmp 0x34987a
callq 0x9954e
callq 0x99515
// File: /workspace/github_c_makefile_star2_O1/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 0x3498f0
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x349962
testq %r15, %r15
je 0x34995d
testq %rbx, %rbx
je 0x34995d
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x349abc
testq %rax, %rax
jne 0x349950
movq %r15, %rdi
callq 0x349aad
movq %rax, %r12
movq %r15, %rdi
callq 0x349b22
movq %rax, %r13
movq %r15, %rdi
callq 0x349b0e
leaq 0xa9fd0(%rip), %rsi     # 0x3f3904
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x995be
callq 0x99587
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa9fc8(%rip), %rsi     # 0x3f3948
movl $0x20, %edi
movl $0x23, %edx
callq 0x1092b2
movq %rax, %r12
movq %r15, %rdi
callq 0xe8760
movq %rax, (%r12)
leaq -0x240276(%rip), %rsi   # 0x10972f
leaq -0x227b21(%rip), %rdx   # 0x121e8b
movl $0x1, %edi
callq 0x105830
movq %rax, 0x8(%r12)
movq %r14, 0x10(%r12)
movq %rbx, %rdi
callq 0x120e79
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_O1/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 0x349a28
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x105f7d
movq (%rbx), %rdi
leaq 0xa9f44(%rip), %r14     # 0x3f3948
movq %r14, %rsi
movl $0x31, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x32, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x349aa8
movq %rsi, %rbx
testq %rsi, %rsi
je 0x349aa8
movq %rdx, %r14
testq %rdx, %rdx
je 0x349aa8
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
callq 0x105a11
testq %rax, %rax
je 0x349a70
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x121c30
callq 0x121b54
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x121c30
movq 0x8(%r15), %r14
movq %rbx, %rdi
callq 0xe8760
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x105a4c
callq 0x995f5
// File: /workspace/github_c_makefile_star2_O1/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 0x349ae3
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x105a11
testq %rax, %rax
je 0x349adf
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x121cfa
xorl %eax, %eax
popq %rbx
retq
callq 0x99663
// File: /workspace/github_c_makefile_star2_O1/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 0x349b09
movq 0x8(%rdi), %rdi
callq 0x105a11
testq %rax, %rax
je 0x349b05
movq %rax, %rdi
popq %rax
jmp 0x121e78
xorl %eax, %eax
popq %rcx
retq
callq 0x9969a
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa9ead(%rip), %r15     # 0x3f39fb
movl $0x38, %edi
movq %r15, %rsi
movl $0x1f, %edx
callq 0x1092b2
movq %rax, %r12
xorl %r13d, %r13d
movq %r13, 0x18(%rax)
callq 0x1208f8
movq %rax, 0x20(%r12)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
movl $0x23, %ecx
callq 0x1021c2
movq %rax, 0x30(%r12)
movq %r13, 0x8(%r12)
movq $0x400, 0x10(%r12)      # imm = 0x400
movq %rbx, %rdi
callq 0x120955
movq %rax, 0x28(%r12)
movq 0x10(%r12), %rdi
shlq $0x2, %rdi
movq %r15, %rsi
movl $0x28, %edx
callq 0x1092b2
movq %rax, (%r12)
movq 0x10(%r12), %rax
shlq $0x2, %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl $0x2a, %esi
movq %r15, %rdx
movl $0x1, %ecx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x320ca8
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x4, %esi
callq 0x125658
movq 0x8(%rbx), %rax
addq %rax, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-psbuf.c
// Function: gt_leftborderbuffer_delete
GtStr *gt_leftborderbuffer_delete(GtLeftborderOutbuffer *lbbuf,
                                  GtFirstcodesspacelog *fcsl,
                                  GT_UNUSED GtUword expectedwritten)
{
  GtStr *outfilename;

  gt_assert(lbbuf != NULL);
  gt_leftborderbuffer_flush(lbbuf);
  gt_fa_fclose(lbbuf->fp);
  lbbuf->fp = NULL;
  gt_log_log("write %s to file %s ("GT_WU" units of size %u)",
             gt_str_get(lbbuf->name),
             gt_str_get(lbbuf->outfilename),
             lbbuf->totalwrite,(unsigned int) sizeof (*lbbuf->spaceuint32_t));
  gt_assert(lbbuf->spaceuint32_t != NULL);
  gt_free(lbbuf->spaceuint32_t);
  GT_FCI_SUBTRACTWORKSPACE(fcsl,gt_str_get(lbbuf->name));
  gt_assert(lbbuf->totalwrite == expectedwritten);
  outfilename = lbbuf->outfilename;
  gt_str_delete(lbbuf->name);
  gt_free(lbbuf);
  return outfilename;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x349d23
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rdx
movq 0x30(%rbx), %rcx
movl $0x4, %esi
callq 0x125658
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rdi
addq %rax, 0x18(%rbx)
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
callq 0x101e80
movq %r12, 0x30(%rbx)
movq 0x28(%rbx), %rdi
callq 0x120d23
movq %rax, %r12
movq 0x20(%rbx), %rdi
callq 0x120d23
movq 0x18(%rbx), %rcx
leaq 0xa9daf(%rip), %rdi     # 0x3f3a41
movq %r12, %rsi
movq %rax, %rdx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x108e02
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x349d28
leaq 0xa9d47(%rip), %r12     # 0x3f39fb
movq %r12, %rsi
movl $0x47, %edx
callq 0x109670
movq 0x28(%rbx), %rdi
callq 0x120d23
movq $0x0, (%rsp)
movq %r15, %rdi
movl $0x48, %esi
movq %r12, %rdx
xorl %ecx, %ecx
movq %rax, %r8
movl $0x1, %r9d
callq 0x320ca8
cmpq %r14, 0x18(%rbx)
jne 0x349d2d
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %rdi
callq 0x121b03
leaq 0xa9cf4(%rip), %rsi     # 0x3f39fb
movq %rbx, %rdi
movl $0x4c, %edx
callq 0x109670
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x997ad
callq 0x99776
callq 0x9973f
nop
// File: /workspace/github_c_makefile_star2_O1/lacework-dev[P]strace_lab_PUBLIC/./src/example_4.c
// Function: main
int main(int argc, char *argv[])
{

	int fd = open("/tmp/follow_twitter_lacework_labs", O_CREAT|O_WRONLY, 0777);

	// ptrace reference: https://stackoverflow.com/questions/33646089/using-ptrace-to-detect-debugger
	if (ptrace(PTRACE_TRACEME, 0,1,0) == -1) 
	{
		printf("[!] Oh no! Error!");
		return 1;
	} 

	if (fd == 31337){
		printf("[*] Achievement unlocked!\n");
	} else {
		printf("[!] Achievement still locked!\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xe8a(%rip), %rdi       # 0x2004
movl $0x41, %esi
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x1060
movl %eax, %r14d
movl $0x1, %ebx
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1050
cmpq $-0x1, %rax
je 0x11bd
cmpl $0x7a69, %r14d          # imm = 0x7A69
jne 0x11cd
leaq 0xe9b(%rip), %rdi       # 0x2056
jmp 0x11d4
leaq 0xe62(%rip), %rdi       # 0x2026
xorl %eax, %eax
callq 0x1040
jmp 0x11db
leaq 0xe64(%rip), %rdi       # 0x2038
callq 0x1030
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: s_iconv
static nkf_char
s_iconv(ARG_UNUSED nkf_char c2, nkf_char c1, ARG_UNUSED nkf_char c0)
{
    if (c2 == JIS_X_0201_1976_K || (0xA1 <= c2 && c2 <= 0xDF)) {
	if (iso2022jp_f && !x0201_f) {
	    c2 = GETA1; c1 = GETA2;
	} else {
	    c1 &= 0x7f;
	}
    } else if ((c2 == EOF) || (c2 == 0) || c2 < SP) {
	/* NOP */
    } else if (!x0213_f && 0xF0 <= c2 && c2 <= 0xF9 && 0x40 <= c1 && c1 <= 0xFC) {
	/* CP932 UDC */
	if(c1 == 0x7F) return 0;
	c1 = nkf_char_unicode_new((c2 - 0xF0) * 188 + (c1 - 0x40 - (0x7E < c1)) + 0xE000);
	c2 = 0;
    } else {
	nkf_char ret = s2e_conv(c2, c1, &c2, &c1);
	if (ret) return ret;
    }
    (*oconv)(c2, c1);
    return 0;
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
cmpl $0x1013, %edi           # imm = 0x1013
setne %al
leal -0xa1(%rdi), %ecx
cmpl $0x3f, %ecx
setae %cl
testb %cl, %al
jne 0xcbb6
cmpb $0x1, 0x48866(%rip)     # 0x55400
jne 0xcc0a
cmpl $0x0, 0x4070d(%rip)     # 0x4d2b0
jne 0xcc0a
movl $0x22, 0x4(%rsp)
movl $0x2e, (%rsp)
jmp 0xcc10
cmpl $0x20, %edi
jl 0xcc10
leal -0x40(%rsi), %ecx
cmpl $0xbc, %ecx
ja 0xcc21
leal -0xf0(%rdi), %eax
cmpl $0x9, %eax
ja 0xcc21
testb $0x1, 0x407e4(%rip)     # 0x4d3bc
jne 0xcc21
xorl %eax, %eax
cmpl $0x7f, %esi
je 0xcc1f
imull $0xbc, %edi, %eax
xorl %edx, %edx
cmpl $0x7f, %esi
setge %dl
addl %ecx, %eax
subl %edx, %eax
addl $0x2fc0, %eax           # imm = 0x2FC0
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, (%rsp)
movl $0x0, 0x4(%rsp)
jmp 0xcc10
andl $0x7f, %esi
movl %esi, (%rsp)
movl 0x4(%rsp), %edi
movl (%rsp), %esi
callq *0x4069b(%rip)          # 0x4d2b8
xorl %eax, %eax
popq %rcx
retq
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
callq 0x110a3
testl %eax, %eax
jne 0xcc1f
jmp 0xcc10