LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: histogram_dump
void histogram_dump(histogram* h, const char* p_tag) {
	char printbuf[100];
	int pos = 0; // location to print from
	printbuf[0] = '\0';

	fprintf(stdout, "%s (%zu total)\n", p_tag, h->n_counts);

	int i, j;
	int k = 0;

	for (j = N_COUNTS-1 ; j >= 0 ; j--) {
		if (h->count[j]) break;
	}

	for (i = 0; i < N_COUNTS; i++) {
		if (h->count[i]) break;
	}

	for (; i <= j; i++) {
		if (h->count[i] > 0) { // print only non zero columns
			int bytes = sprintf(
				(char*)(printbuf + pos), " (%02d: %010zu) ", i, h->count[i]);

			if (bytes <= 0) {
				fprintf(stdout, "ERROR: printing histogram\n");
				return;
			}

			pos += bytes;

		    if (k % 4 == 3) {
		    	 fprintf(stdout, "%s\n", (char*)printbuf);
		    	 pos = 0;
		    	 printbuf[0] = '\0';
		    }

		    k++;
		}
	}

	if (pos > 0) {
	    fprintf(stdout, "%s\n", (char*)printbuf);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x12b3d(%rip), %rax     # 0x17fc0
movq %rdi, %rbx
movb $0x0, (%rsp)
movq %rsi, %rdx
leaq 0xbb7c(%rip), %rsi      # 0x11010
movq (%rax), %rdi
movq (%rbx), %rcx
xorl %eax, %eax
callq 0x2390
pushq $0x3f
popq %rcx
pushq $-0x1
popq %rax
testl %ecx, %ecx
js 0x54bb
movl %ecx, %edx
cmpq $0x0, 0x8(%rbx,%rdx,8)
jne 0x54b9
decl %ecx
jmp 0x54a7
movl %ecx, %eax
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x54d1
cmpq $0x0, 0x8(%rbx,%r14,8)
jne 0x54d1
incq %r14
jmp 0x54be
movslq %eax, %rbp
leaq 0xbb45(%rip), %r15      # 0x11020
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %rbp, %r14
jg 0x5548
cmpq $0x0, 0x8(%rbx,%r14,8)
je 0x5543
movq 0x8(%rbx,%r14,8), %rcx
movl %r13d, %eax
movq %r15, %rsi
movl %r14d, %edx
leaq (%rsp,%rax), %rdi
xorl %eax, %eax
callq 0x2070
testl %eax, %eax
jle 0x556a
movl %r12d, %ecx
andl $0x80000003, %ecx       # imm = 0x80000003
cmpl $0x3, %ecx
jne 0x553d
movq 0x12aa0(%rip), %rax     # 0x17fc0
leaq 0xb5ad(%rip), %rsi      # 0x10ad4
movq %rsp, %rdx
xorl %r13d, %r13d
movq (%rax), %rdi
xorl %eax, %eax
callq 0x2390
movb $0x0, (%rsp)
jmp 0x5540
addl %eax, %r13d
incl %r12d
incq %r14
jmp 0x54e1
testl %r13d, %r13d
jle 0x5586
movq 0x12a6c(%rip), %rax     # 0x17fc0
leaq 0xb579(%rip), %rsi      # 0x10ad4
movq %rsp, %rdx
movq (%rax), %rdi
xorl %eax, %eax
callq 0x2390
jmp 0x5586
movq 0x12a4f(%rip), %rax     # 0x17fc0
leaq 0xbab9(%rip), %rdi      # 0x11031
movq (%rax), %rcx
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2550
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: histogram_insert_data_point
void histogram_insert_data_point(histogram* h, uint64_t delta_ms) {
	cf_atomic_int_incr(&h->n_counts);

	int index = bits_find_last_set_64(delta_ms);

	if (index < 0) {
		index = 0;
	}

	if ((int64_t)delta_ms < 0) {
	    // Need to investigate why in some cases start is a couple of ms greater than end
		// Could it be rounding error (usually the difference is 1 but sometimes I have seen 2
	    // fprintf(stdout, "start = %"PRIu64" > end = %"PRIu64"", start, end);
		index = 0;
	}

	cf_atomic_int_incr(&h->count[index]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rax
lock
xaddq %rax, (%rdi)
movq %rsi, %rdi
shrq $0x20, %rdi
jne 0x55ba
movl %r14d, %edi
callq 0x55e2
jmp 0x55c2
callq 0x55e2
addl $0x20, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
testq %r14, %r14
cmovnsq %rax, %rcx
pushq $0x1
popq %rax
lock
xaddq %rax, 0x8(%rbx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: bits_find_last_set
static int bits_find_last_set(uint32_t v) {
	int r;
	uint32_t t, tt;

	if ((tt = v >> 16) != 0) {
		r = (t = tt >> 8) ? (24 + LogTable256[t]) : (16 + LogTable256[tt]);
	}
	else {
		r = (t = v >> 8) ? (8 + LogTable256[t]) : LogTable256[v];
	}

	return (r);
}

// Assembly:
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x5600
cmpl $0x100, %edi            # imm = 0x100
jae 0x561a
movl %edi, %eax
leaq 0xb915(%rip), %rcx      # 0x10f10
movsbl (%rax,%rcx), %eax
retq
cmpl $0x1000000, %edi        # imm = 0x1000000
jae 0x562c
shrl $0x10, %edi
leaq 0xb8fe(%rip), %rax      # 0x10f10
movsbl (%rdi,%rax), %eax
addl $0x10, %eax
retq
shrl $0x8, %edi
leaq 0xb8ec(%rip), %rax      # 0x10f10
movsbl (%rdi,%rax), %eax
addl $0x8, %eax
retq
shrl $0x18, %edi
leaq 0xb8da(%rip), %rax      # 0x10f10
movsbl (%rdi,%rax), %eax
addl $0x18, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cf_shash.c
// Function: shash_create
int
shash_create(shash **h_r, shash_hash_fn h_fn, uint32_t key_len, uint32_t value_len, uint32_t sz, unsigned int flags)
{
	shash *h;

	h = (shash*)malloc(sizeof(shash));
	if (!h)	return(SHASH_ERR);

	h->elements = 0;
	h->table_len = sz;
	h->key_len = key_len;
	h->value_len = value_len;
	h->flags = flags;
	h->h_fn = h_fn;

	if ((flags & SHASH_CR_MT_BIGLOCK) && (flags & SHASH_CR_MT_MANYLOCK)) {
		*h_r = 0;
		return(SHASH_ERR);
	}
	
	h->table = malloc(sz * SHASH_ELEM_SZ(h));
	if (!h->table) {
		free(h);
		*h_r = 0;
		return(SHASH_ERR);
	}
	
	shash_elem *table = (shash_elem*)h->table;
	for (unsigned int i=0;i<sz;i++) {
		table->in_use = false;
		table->next = 0;
		// next element in head table
		table = (shash_elem *) (((uint8_t *)table) + SHASH_ELEM_SZ(h));
	}
	
	if (flags & SHASH_CR_MT_BIGLOCK) {
		if (0 != pthread_mutex_init ( &h->biglock, 0) ) {
			free(h->table); free(h);
			return(SHASH_ERR);
		}
	}
	else
		memset( (void*)&h->biglock, 0, sizeof( h->biglock ) );
	
	if (flags & SHASH_CR_MT_MANYLOCK) {
		h->lock_table = (pthread_mutex_t*)malloc( sizeof(pthread_mutex_t) * sz);
		if (! h->lock_table) {
			free(h);
			*h_r = 0;
			return(SHASH_ERR);
		}
		for (unsigned int i=0;i<sz;i++) {
			pthread_mutex_init( &(h->lock_table[i]), 0 );
		}
	}
	else
		h->lock_table = 0;
	

	*h_r = h;

	return(SHASH_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebx
movq %rsi, %rbp
movq %rdi, (%rsp)
pushq $0x58
popq %rdi
callq 0x22f0
pushq $-0x1
popq %rcx
testq %rax, %rax
je 0xdcc7
andl $0x0, (%rax)
movl %r12d, 0x18(%rax)
movl %ebx, 0x4(%rax)
movl %r13d, 0x8(%rax)
movl %r15d, 0xc(%rax)
movq %rax, %r14
movq %rbp, 0x10(%rax)
movl %r15d, %eax
notl %eax
testb $0xc, %al
jne 0xdbec
movq (%rsp), %rax
andq $0x0, (%rax)
jmp 0xdcc7
movl %ebx, %eax
movl %r13d, %ecx
movl %r12d, %ebp
leaq 0x10(%rax,%rcx), %rbx
movq %rbx, %rdi
imulq %rbp, %rdi
callq 0x22f0
testq %rax, %rax
movq %rax, 0x20(%r14)
je 0xdcb4
addq $0x8, %rax
subl $0x1, %r12d
jb 0xdc29
movb $0x0, (%rax)
andq $0x0, -0x8(%rax)
addq %rbx, %rax
jmp 0xdc16
movq %r14, %rdi
addq $0x28, %rdi
testb $0x4, %r15b
jne 0xdc50
andq $0x0, 0x20(%rdi)
andq $0x0, 0x18(%rdi)
andq $0x0, 0x10(%rdi)
andq $0x0, 0x8(%rdi)
andq $0x0, (%rdi)
jmp 0xdc6e
xorl %esi, %esi
callq 0x2410
testl %eax, %eax
je 0xdc6e
movq 0x20(%r14), %rdi
callq 0x22a0
movq %r14, %rdi
callq 0x22a0
jmp 0xdcc4
testb $0x8, %r15b
jne 0xdc84
andq $0x0, 0x50(%r14)
movq (%rsp), %rax
xorl %ecx, %ecx
movq %r14, (%rax)
jmp 0xdcc7
imulq $0x28, %rbp, %r15
movq %r15, %rdi
callq 0x22f0
testq %rax, %rax
movq %rax, 0x50(%r14)
je 0xdcb4
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0xdc79
movq 0x50(%r14), %rdi
xorl %esi, %esi
addq %rbx, %rdi
callq 0x2410
addq $0x28, %rbx
jmp 0xdc9b
movq %r14, %rdi
callq 0x22a0
movq (%rsp), %rax
andq $0x0, (%rax)
pushq $-0x1
popq %rcx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cf_shash.c
// Function: shash_get_size
uint32_t
shash_get_size(shash *h)
{

    uint32_t elements = 0;
	
	if (h->flags & SHASH_CR_MT_MANYLOCK) {


        
        for (unsigned int i=0; i<h->table_len ; i++) {
            
            pthread_mutex_t *l = &(h->lock_table[i]);
            pthread_mutex_lock( l );
            
            shash_elem *list_he = (shash_elem *) ( ((uint8_t *)h->table) + (SHASH_ELEM_SZ(h) * i));
            while (list_he) {
                
                // not in use is common at head pointer - unused bucket
                if (list_he->in_use == false) 
                    break;
                
                elements++;
                
                list_he = list_he->next;
            };
    
            pthread_mutex_unlock(l);
    
        }

    }
    
    else if (h->flags & SHASH_CR_MT_BIGLOCK) {
    	pthread_mutex_lock(&h->biglock);
    	elements = h->elements;
    	pthread_mutex_unlock(&h->biglock);
    }
    else {
    	elements = h->elements;
    }
    
	return(elements);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0xc(%rdi), %eax
movq %rdi, %rbx
testb $0x8, %al
jne 0xdcf1
testb $0x4, %al
jne 0xdd40
movl (%rbx), %ebp
jmp 0xdd56
xorl %r15d, %r15d
xorl %ebp, %ebp
movl 0x18(%rbx), %eax
cmpq %rax, %r15
jae 0xdd56
imulq $0x28, %r15, %r14
addq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x23c0
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %ecx
leaq 0x10(%rax,%rcx), %rax
imulq %r15, %rax
addq 0x20(%rbx), %rax
testq %rax, %rax
je 0xdd33
cmpb $0x0, 0x8(%rax)
je 0xdd33
movq (%rax), %rax
incl %ebp
jmp 0xdd21
movq %r14, %rdi
callq 0x2160
incq %r15
jmp 0xdcf6
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x23c0
movl (%rbx), %ebp
movq %r14, %rdi
callq 0x2160
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cf_shash.c
// Function: shash_get
int
shash_get(shash *h, void *key, void *value)
{
	int rv = SHASH_ERR;
	
	unsigned int hash = h->h_fn(key);
	hash %= h->table_len;

	pthread_mutex_t		*l = 0;
	if (h->flags & SHASH_CR_MT_BIGLOCK) {
		l = &h->biglock;
	}
	else if (h->flags & SHASH_CR_MT_MANYLOCK) {
		l = & (h->lock_table[hash]);
	}
	if (l)     pthread_mutex_lock( l );
	
	shash_elem *e = (shash_elem *) ( ((byte *)h->table) + (SHASH_ELEM_SZ(h) * hash));	

	if (e->in_use == false) {
		rv = SHASH_ERR_NOTFOUND;
		goto Out;
	}
	
	do {
		if ( memcmp(SHASH_ELEM_KEY_PTR(h, e), key, h->key_len) == 0) {
            if (NULL != value)
			    memcpy(value, SHASH_ELEM_VALUE_PTR(h, e), h->value_len);
			rv = SHASH_OK; 
			goto Out;
		}
		e = e->next;
	} while (e);
	rv = SHASH_ERR_NOTFOUND;
	
Out:
	if (l) pthread_mutex_unlock(l);

	return(rv);
					
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq %rsi, %rdi
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
callq *0x10(%r12)
xorl %edx, %edx
divl 0x18(%r12)
movl 0xc(%r12), %eax
testb $0x4, %al
movl %edx, %ebx
jne 0xe01f
movb $0x1, %cl
testb $0x8, %al
je 0xe032
movq 0x50(%r12), %rdi
testq %rdi, %rdi
je 0xe032
imulq $0x28, %rbx, %rax
addq %rax, %rdi
jmp 0xe024
leaq 0x28(%r12), %rdi
movq %rdi, 0x8(%rsp)
callq 0x23c0
xorl %ecx, %ecx
jmp 0xe03b
movq $0x0, 0x8(%rsp)
movq 0x20(%r12), %r14
movl 0x4(%r12), %r13d
movl 0x8(%r12), %r12d
leaq 0x10(%r13,%r12), %rax
imulq %rax, %rbx
pushq $-0x3
popq %rbp
cmpb $0x0, 0x8(%r14,%rbx)
je 0xe0a3
addq %rbx, %r14
movl %ecx, 0x4(%rsp)
leaq 0x9(%r14), %rbx
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rdi
callq 0x2240
testl %eax, %eax
je 0xe085
movq (%r14), %r14
testq %r14, %r14
jne 0xe065
jmp 0xe09f
movq 0x10(%rsp), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0xe09f
addq %r13, %rbx
movq %r12, %rdx
movq %rbx, %rsi
callq 0x2180
movl 0x4(%rsp), %ecx
testb %cl, %cl
jne 0xe0b1
movq 0x8(%rsp), %rdi
callq 0x2160
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cf_shash.c
// Function: shash_get_vlock
int
shash_get_vlock(shash *h, void *key, void **value, pthread_mutex_t **vlock)
{
	int rv = SHASH_ERR;
	
	unsigned int hash = h->h_fn(key);
	hash %= h->table_len;

	pthread_mutex_t		*l = 0;
	if (h->flags & SHASH_CR_MT_BIGLOCK) {
		l = &h->biglock;
	}
	else if (h->flags & SHASH_CR_MT_MANYLOCK) {
		l = & (h->lock_table[hash]);
	}
	if (l)     pthread_mutex_lock( l );
	
	shash_elem *e = (shash_elem *) ( ((byte *)h->table) + (SHASH_ELEM_SZ(h) * hash));	

	if (e->in_use == false) {
		rv = SHASH_ERR_NOTFOUND;
		goto Out;
	}
	
	do {
		if ( memcmp(SHASH_ELEM_KEY_PTR(h, e), key, h->key_len) == 0) {
			*value = SHASH_ELEM_VALUE_PTR(h, e);
			rv = SHASH_OK; 
			goto Out;
		}
		e = e->next;
	} while (e);
	
	rv = SHASH_ERR_NOTFOUND;
	
Out:
	if (l) {
		if (rv == SHASH_OK) {
			*vlock = l;
		}
		else {
			pthread_mutex_unlock( l );
			*vlock = 0;
		}
	}
	else {
		// for safety sake
		if (vlock) *vlock = 0;
	}

	return(rv);
					
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
movq %rsi, %rdi
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
callq *0x10(%r13)
xorl %edx, %edx
divl 0x18(%r13)
movl 0xc(%r13), %eax
testb $0x4, %al
movl %edx, %ebx
jne 0xe10d
testb $0x8, %al
je 0xe123
movq 0x50(%r13), %r12
testq %r12, %r12
je 0xe123
imulq $0x28, %rbx, %rax
addq %rax, %r12
jmp 0xe111
leaq 0x28(%r13), %r12
movq %r12, %rdi
callq 0x23c0
movl $0x0, 0x4(%rsp)
jmp 0xe12c
movb $0x1, %al
xorl %r12d, %r12d
movl %eax, 0x4(%rsp)
movl 0x4(%r13), %ebp
movl 0x8(%r13), %eax
movq 0x20(%r13), %r14
leaq 0x10(%rbp,%rax), %rax
imulq %rax, %rbx
cmpb $0x0, 0x8(%r14,%rbx)
je 0xe16a
addq %rbx, %r14
leaq 0x9(%r14), %r13
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rdi
callq 0x2240
testl %eax, %eax
je 0xe18d
movq (%r14), %r14
testq %r14, %r14
jne 0xe14c
cmpb $0x0, 0x4(%rsp)
je 0xe17b
pushq $-0x3
popq %rax
movq 0x8(%rsp), %rcx
jmp 0xe1a6
movq %r12, %rdi
callq 0x2160
pushq $-0x3
popq %rax
movq 0x8(%rsp), %rcx
jmp 0xe1ab
movq 0x10(%rsp), %rax
addq %rbp, %r13
movq 0x8(%rsp), %rcx
movq %r13, (%rax)
xorl %eax, %eax
cmpb $0x0, 0x4(%rsp)
je 0xe1ae
testq %rcx, %rcx
je 0xe1b1
xorl %r12d, %r12d
movq %r12, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cf_shash.c
// Function: shash_destroy
void
shash_destroy(shash *h)
{
	shash_elem *e_table = (shash_elem*)h->table;
	for (unsigned int i=0;i<h->table_len;i++) {
		if (e_table->next) {
			shash_elem *e = e_table->next;
			shash_elem *t;
			while (e) {
				t = e->next;
				free(e);
				e = t;
			}
		}
		e_table = (shash_elem *) (((uint8_t *)e_table) + SHASH_ELEM_SZ(h));
	}

	if (h->flags & SHASH_CR_MT_BIGLOCK) {
		pthread_mutex_destroy(&h->biglock);
	}
	if (h->flags & SHASH_CR_MT_MANYLOCK) {
		for (unsigned int i=0;i<h->table_len;i++) {
			pthread_mutex_destroy(&(h->lock_table[i]));
		}
		free(h->lock_table);
	}

	free(h->table);
	free(h);	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r14
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl 0x18(%rbx), %ebp
jae 0xe72a
movq (%r14), %rdi
testq %rdi, %rdi
jne 0xe713
jmp 0xe718
movq (%rdi), %r15
callq 0x22a0
movq %r15, %rdi
testq %rdi, %rdi
jne 0xe708
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %ecx
incl %ebp
addq %rax, %rcx
leaq 0x10(%r14,%rcx), %r14
jmp 0xe6f9
movl 0xc(%rbx), %eax
testb $0x4, %al
je 0xe73d
leaq 0x28(%rbx), %rdi
callq 0x2290
movl 0xc(%rbx), %eax
testb $0x8, %al
je 0xe769
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0x18(%rbx), %eax
movq 0x50(%rbx), %rdi
cmpq %rax, %r15
jae 0xe764
addq %r14, %rdi
callq 0x2290
incq %r15
addq $0x28, %r14
jmp 0xe747
callq 0x22a0
movq 0x20(%rbx), %rdi
callq 0x22a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gt.c
// Function: main
int main(int argc, char *argv[])
{
  GtError *err;
  GtR *gtr;
  int rval;
  gt_lib_init();
  err = gt_error_new();
  gt_error_set_progname(err, argv[0]);
  if (!(gtr = gtr_new(err))) {
    fprintf(stderr, "%s: error: %s\n", gt_error_get_progname(err),
            gt_error_get(err));
    gt_error_delete(err);
    return EXIT_FAILURE;
  }
  gtr_register_components(gtr);
  switch (gtr_parse(gtr, &rval, argc, (const char**) argv, err)) {
    case GT_OPTION_PARSER_OK:
      argc -= rval;
      argv += rval;
      rval = gtr_run(gtr, argc, (const char**) argv, err);
      break;
    case GT_OPTION_PARSER_ERROR:
      rval = EXIT_FAILURE; /* user error */
      break;
    case GT_OPTION_PARSER_REQUESTS_EXIT:
      rval = EXIT_SUCCESS; /* everything went fine */
  }
  if (gt_error_is_set(err)) {
    fprintf(stderr, "%s: error: %s\n", gt_error_get_progname(err),
            gt_error_get(err));
    gt_assert(rval);
  }
  gtr_delete(gtr);
  gt_error_delete(err);
  if (gt_lib_clean())
    return GT_EXIT_PROGRAMMING_ERROR; /* programmer error */
  return rval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebp
callq 0x9114c
callq 0x89da4
movq %rax, %rbx
movq (%r15), %rsi
movq %rax, %rdi
callq 0x89f8a
movq %rbx, %rdi
callq 0x181e0
testq %rax, %rax
je 0x1812d
movq %rax, %r14
movq %rax, %rdi
callq 0x187d0
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1846c
cmpl $0x2, %eax
je 0x180eb
cmpl $0x1, %eax
je 0x180e1
testl %eax, %eax
jne 0x180f0
movslq 0x4(%rsp), %rax
subl %eax, %ebp
leaq (%r15,%rax,8), %rdx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
callq 0x18837
movl %eax, 0x4(%rsp)
jmp 0x180f0
movl $0x1, 0x4(%rsp)
jmp 0x180f0
andl $0x0, 0x4(%rsp)
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1816d
movq %r14, %rdi
callq 0x1915e
movq %rbx, %rdi
callq 0x8a045
callq 0x91393
testl %eax, %eax
jne 0x1811b
movl 0x4(%rsp), %eax
jmp 0x1811e
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x41fe34(%rip), %rax    # 0x437f68
movq (%rax), %r14
movq %rbx, %rdi
callq 0x8a001
movq %rax, %r15
movq %rbx, %rdi
callq 0x89f41
leaq 0x2cceb3(%rip), %rsi    # 0x2e5004
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x17a50
movq %rbx, %rdi
callq 0x8a045
pushq $0x1
jmp 0x1811d
movq 0x41fdf4(%rip), %r13    # 0x437f68
movq (%r13), %r15
movq %rbx, %rdi
callq 0x8a001
movq %rax, %r12
movq %rbx, %rdi
callq 0x89f41
leaq 0x2cce72(%rip), %rsi    # 0x2e5004
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x17a50
cmpl $0x0, 0x4(%rsp)
jne 0x180fc
movq (%r13), %rdi
leaq 0x2cce5b(%rip), %rsi    # 0x2e5013
leaq 0x2eadd9(%rip), %rdx    # 0x302f98
leaq 0x2e2d59(%rip), %rcx    # 0x2faf1f
leaq 0x2ccf6f(%rip), %r8     # 0x2e513c
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtr.c
// Function: gtr_parse
GtOPrval gtr_parse(GtR *gtr, int *parsed_args, int argc, const char **argv,
                   GtError *err)
{
  GtOptionParser *op;
  GtOPrval oprval;
  gt_error_check(err);
  gt_assert(gtr);
  op = gtr_option_parser_new(gtr);
  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);
  gt_option_parser_delete(op);
  return oprval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
testq %r8, %r8
je 0x18493
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x18500
testq %r12, %r12
je 0x184d2
movq %r12, %rdi
callq 0x18538
movq %rax, %r12
leaq 0x9a7a6(%rip), %r8      # 0xb2c50
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x98cb0
movl %eax, %ebx
movq %r12, %rdi
callq 0x9a844
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x41fa8f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2ccb30(%rip), %rsi    # 0x2e5013
leaq 0x2cccfd(%rip), %rdx    # 0x2e51e7
leaq 0x2cccec(%rip), %rcx    # 0x2e51dd
leaq 0x2ccc4d(%rip), %r8     # 0x2e5145
movl $0xf0, %r9d
jmp 0x1852c
movq 0x41fa61(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2ccb02(%rip), %rsi    # 0x2e5013
leaq 0x2ccca7(%rip), %rdx    # 0x2e51bf
leaq 0x2cccbe(%rip), %rcx    # 0x2e51dd
leaq 0x2ccc1f(%rip), %r8     # 0x2e5145
movl $0xef, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtr.c
// Function: gtr_register_components
void gtr_register_components(GtR *gtr)
{
  gt_assert(gtr);
  /* add tools */
  gt_toolbox_delete(gtr->tools);
  gtr->tools = gtt_tools();
  /* add unit tests */
  gt_hashmap_delete(gtr->unit_tests);
  gtr->unit_tests = gtt_unit_tests();
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x187ff
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xb1193
callq 0x193c4
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x8f933
callq 0x19b16
movq %rax, 0x28(%rbx)
popq %rbx
retq
movq 0x41f762(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2cc803(%rip), %rsi    # 0x2e5013
leaq 0x2cc9d0(%rip), %rdx    # 0x2e51e7
leaq 0x2cc9cd(%rip), %rcx    # 0x2e51eb
leaq 0x2cc920(%rip), %r8     # 0x2e5145
movl $0xfa, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtr.c
// Function: gtr_delete
void gtr_delete(GtR *gtr)
{
  if (!gtr) return;
  gt_fa_fclose(gtr->logfp);
  gt_str_delete(gtr->testspacepeak);
  gt_str_delete(gtr->debugfp);
  gt_str_delete(gtr->test_only);
  gt_str_delete(gtr->manoutdir);
  gt_toolbox_delete(gtr->tools);
  gt_hashmap_delete(gtr->unit_tests);
  if (gtr->L) lua_close(gtr->L);
#ifndef WITHOUT_CAIRO
  gt_style_delete_without_state(gtr->style);
#endif
  gt_free(gtr);
}

// Assembly:
testq %rdi, %rdi
je 0x191d2
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0x8a4fd
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x30(%rbx), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xb1193
movq 0x28(%rbx), %rdi
callq 0x8f933
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x191b4
callq 0x1de4cb
movq 0x48(%rbx), %rdi
callq 0x1d9434
leaq 0x2cbf81(%rip), %rsi    # 0x2e5145
movq %rbx, %rdi
movl $0x224, %edx            # imm = 0x224
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtr.c
// Function: show_gtr_help
static int show_gtr_help(const char *progname, void *data, GtError *err)
{
  int had_err;
  had_err = gt_toolbox_show(progname, data, err);
  if (!had_err)
    had_err = gt_gtdata_show_help(progname, NULL, err);
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0xb0e98
testl %eax, %eax
je 0x191ee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe74ec
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/interactive.c
// Function: pushline
static int pushline(lua_State *L, bool firstline) {
  char buffer[BUFSIZ];
  char *b = buffer;
  size_t l;
  const char *prmt = get_prompt(L, firstline);
  b = buffer; /* use static buffer */
  fputs(prmt, stdout); fflush(stdout);/* show prompt */
  if (!fgets(b, BUFSIZ, stdin))  /* get line */
    return 0; /* no input */
  l = strlen(b);
  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
    b[l-1] = '\0';  /* remove it */
  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
  else
    lua_pushstring(L, b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2cb97a(%rip), %rax    # 0x2e5f11
leaq 0x2cb97b(%rip), %rdx    # 0x2e5f19
testl %esi, %esi
cmovneq %rax, %rdx
leaq 0x3363b6(%rip), %rax    # 0x350961
leaq 0x2cb970(%rip), %r15    # 0x2e5f22
cmovneq %rax, %r15
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x1dc63b
xorl %r14d, %r14d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1dbb73
testq %rax, %rax
cmovneq %rax, %r15
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x1db3d2
movq 0x41d8c7(%rip), %r12    # 0x437eb0
movq (%r12), %rsi
movq %r15, %rdi
callq 0x17870
movq (%r12), %rdi
callq 0x178a0
movq 0x41d8f3(%rip), %rax    # 0x437ef8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x17bc0
testq %rax, %rax
je 0x1a665
movq %rsp, %rdi
callq 0x172d0
testq %rax, %rax
je 0x1a633
cmpb $0xa, -0x1(%rsp,%rax)
jne 0x1a633
movb $0x0, -0x1(%rsp,%rax)
testb %bpl, %bpl
je 0x1a656
cmpb $0x3d, (%rsp)
jne 0x1a656
leaq 0x1(%rsp), %rdx
leaq 0x2cb8bd(%rip), %rsi    # 0x2e5f07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1dc33c
jmp 0x1a661
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1dc009
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/interactive.c
// Function: traceback
static int traceback(lua_State *L) {
  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
  if (!lua_istable(L, -1)) {
    lua_pop(L, 1);
    return 1;
  }
  lua_getfield(L, -1, "traceback");
  if (!lua_isfunction(L, -1)) {
    lua_pop(L, 2);
    return 1;
  }
  lua_pushvalue(L, 1);  /* pass error message */
  lua_pushinteger(L, 2);  /* skip this function and traceback */
  lua_call(L, 2, 1);  /* call debug.traceback */
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2cb8a9(%rip), %rdx    # 0x2e5f2e
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x1dc63b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x1db731
cmpl $0x5, %eax
jne 0x1a6e9
leaq 0x361d6c(%rip), %rdx    # 0x37c412
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1dc63b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1db731
cmpl $0x6, %eax
jne 0x1a6ed
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1db711
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1dbe48
pushq $0x2
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1dce3a
jmp 0x1a6f8
pushq $-0x2
jmp 0x1a6ef
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x1db3d2
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_arguments_new
static void *gt_bed_to_gff3_arguments_new(void)
{
  BEDToGFF3Arguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->feature_type = gt_str_new();
  arguments->thick_feature_type = gt_str_new();
  arguments->block_type = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2cb7ed(%rip), %rdx    # 0x2e5f60
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x25
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0x9b6b4
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_arguments_delete
static void gt_bed_to_gff3_arguments_delete(void *tool_arguments)
{
  BEDToGFF3Arguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->block_type);
  gt_str_delete(arguments->thick_feature_type);
  gt_str_delete(arguments->feature_type);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1a7f4
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x8da06
movq 0x18(%rbx), %rdi
callq 0x9ba24
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0xae103
leaq 0x2cb778(%rip), %rsi    # 0x2e5f60
pushq $0x36
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_option_parser_new
static GtOptionParser* gt_bed_to_gff3_option_parser_new(void *tool_arguments)
{
  BEDToGFF3Arguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *o;

  op = gt_option_parser_new("[BED_file]",
                            "Parse BED file and convert it to GFF3.");

  o = gt_option_new_string("featuretype", "Set type of parsed BED features",
                           arguments->feature_type, BED_FEATURE_TYPE);
  gt_option_parser_add_option(op, o);

  o = gt_option_new_string("thicktype", "Set type of parsed thick BED features",
                           arguments->thick_feature_type,
                           BED_THICK_FEATURE_TYPE);
  gt_option_parser_add_option(op, o);

  o = gt_option_new_string("blocktype", "Set type of parsed BED blocks",
                           arguments->block_type, BED_BLOCK_TYPE);
  gt_option_parser_add_option(op, o);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  gt_option_parser_set_max_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2cb778(%rip), %rdi    # 0x2e5f7b
leaq 0x2cb77c(%rip), %rsi    # 0x2e5f86
callq 0x97df5
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x303c13(%rip), %rdi    # 0x31e42f
leaq 0x2cb78a(%rip), %rsi    # 0x2e5fad
leaq 0x2cb7a3(%rip), %rcx    # 0x2e5fcd
callq 0x9ad12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%r14), %rdx
leaq 0x2cb794(%rip), %rdi    # 0x2e5fd9
leaq 0x2cb797(%rip), %rsi    # 0x2e5fe3
leaq 0x2cb7b6(%rip), %rcx    # 0x2e6009
callq 0x9ad12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%r14), %rdx
leaq 0x2cb7ad(%rip), %rdi    # 0x2e601b
leaq 0x2cb7b0(%rip), %rsi    # 0x2e6025
leaq 0x2cb7c7(%rip), %rcx    # 0x2e6043
callq 0x9ad12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x18(%r14), %rdi
addq $0x20, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9b6d7
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x98c29
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_bed_to_gff3.c
// Function: gt_bed_to_gff3_runner
static int gt_bed_to_gff3_runner(GT_UNUSED int argc, const char **argv,
                                 int parsed_args, void *tool_arguments,
                                 GtError *err)
{
  GtNodeStream *bed_in_stream = NULL, *gff3_out_stream = NULL;
  BEDToGFF3Arguments *arguments = tool_arguments;
  int had_err;

  gt_error_check(err);

  /* create a BED input stream */
  bed_in_stream = gt_bed_in_stream_new(argv[parsed_args]);
  gt_bed_in_stream_set_feature_type((GtBEDInStream*) bed_in_stream,
                                    gt_str_get(arguments->feature_type));
  gt_bed_in_stream_set_thick_feature_type((GtBEDInStream*) bed_in_stream,
                                          gt_str_get(arguments
                                                     ->thick_feature_type));
  gt_bed_in_stream_set_block_type((GtBEDInStream*) bed_in_stream,
                                  gt_str_get(arguments->block_type));

  /* create a GFF3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(bed_in_stream, arguments->outfp);

  /* pull the features through the stream and free them afterwards */
  had_err = gt_node_stream_pull(gff3_out_stream, err);

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(bed_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0x1a8dc
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1a95f
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0xbb771
movq %rax, %r15
movq (%r14), %rdi
callq 0xad1fa
movq %r15, %rdi
movq %rax, %rsi
callq 0xbb7dc
movq 0x8(%r14), %rdi
callq 0xad1fa
movq %r15, %rdi
movq %rax, %rsi
callq 0xbb826
movq 0x10(%r14), %rdi
callq 0xad1fa
movq %r15, %rdi
movq %rax, %rsi
callq 0xbb870
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0xe07df
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x41d602(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2ca6a3(%rip), %rsi    # 0x2e5013
leaq 0x2ca848(%rip), %rdx    # 0x2e51bf
leaq 0x2cb6cf(%rip), %rcx    # 0x2e604d
leaq 0x2cb5db(%rip), %r8     # 0x2e5f60
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_cds.c
// Function: gt_cds_arguments_new
static void* gt_cds_arguments_new(void)
{
  CDSArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2cb6a0(%rip), %rdx    # 0x2e6063
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x2d
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x116724
movq %rax, 0x8(%rbx)
callq 0x9b6b4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_cds.c
// Function: gt_cds_arguments_delete
static void gt_cds_arguments_delete(void *tool_arguments)
{
  CDSArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1aa22
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0x116765
leaq 0x2cb64d(%rip), %rsi    # 0x2e6063
pushq $0x3a
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_chain2dim.c
// Function: gt_outputformatchaingeneric
static void gt_outputformatchaingeneric(
                                bool silent,
                                void *data,
                                const GtChain2Dimmatchtable *matchtable,
                                const GtChain2Dim *chain)
{
  GtUword idx, chainlength;
  Counter *counter = (Counter *) data;

  chainlength = gt_chain_chainlength(chain);
  printf("# chain "GT_WU": length "GT_WU" score "GT_WD"\n",
         counter->chaincounter,chainlength,gt_chain_chainscore(chain));
  if (!silent)
  {
    GtChain2Dimmatchvalues value;

    if (gt_chain_storedinreverseorder(chain))
    {
      for (idx=chainlength; idx > 0; idx--)
      {
        gt_chain_extractchainelem(&value, matchtable, chain, idx - 1);
        gt_chain_printchainelem(stdout,&value);
      }
    } else
    {
      for (idx=0; idx < chainlength; idx++)
      {
        gt_chain_extractchainelem(&value, matchtable, chain, idx);
        gt_chain_printchainelem(stdout,&value);
      }
    }
  }
  counter->chaincounter++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
movq %rcx, %rdi
callq 0x13777f
movq %rax, %r12
movq (%rbx), %r13
movq %r14, %rdi
callq 0x13777a
leaq 0x2cb528(%rip), %rdi    # 0x2e6230
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x17070
testl %ebp, %ebp
jne 0x1ada1
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
callq 0x137784
testb %al, %al
je 0x1ad67
decq %r12
leaq 0x10(%rsp), %r13
movq 0x41d170(%rip), %rbx    # 0x437eb0
cmpq $-0x1, %r12
je 0x1ad9c
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x137788
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x137807
decq %r12
jmp 0x1ad40
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
movq 0x41d13a(%rip), %rbx    # 0x437eb0
cmpq %r13, %r12
je 0x1ad9c
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x137788
movq (%rbx), %rdi
movq %rbp, %rsi
callq 0x137807
incq %r13
jmp 0x1ad76
movq 0x8(%rsp), %rbx
incq (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_chain2dim.c
// Function: gt_chain2dim_arguments_delete
static void gt_chain2dim_arguments_delete (void *tool_arguments)
{
  GtChain2dimoptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete (arguments->matchfile);
  gt_str_array_delete (arguments->globalargs);
  gt_str_array_delete (arguments->localargs);
  gt_option_delete (arguments->refoptionmaxgap);
  gt_option_delete (arguments->refoptionweightfactor);
  gt_option_delete (arguments->refoptionglobal);
  gt_option_delete (arguments->refoptionlocal);
  gt_free (arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1ae58
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae662
movq 0x28(%rbx), %rdi
callq 0xae662
movq 0x30(%rbx), %rdi
callq 0x9a8ea
movq 0x38(%rbx), %rdi
callq 0x9a8ea
movq 0x40(%rbx), %rdi
callq 0x9a8ea
movq 0x48(%rbx), %rdi
callq 0x9a8ea
leaq 0x2cb407(%rip), %rsi    # 0x2e6253
pushq $0x2c
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_chseqids.c
// Function: gt_chseqids_arguments_delete
static void gt_chseqids_arguments_delete(void *tool_arguments)
{
  ChseqidsArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1b460
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8da06
movq 0x8(%rbx), %rdi
callq 0x9ba24
leaq 0x2cb483(%rip), %rsi    # 0x2e68d7
pushq $0x35
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_chseqids.c
// Function: gt_chseqids_option_parser_new
static GtOptionParser* gt_chseqids_option_parser_new(void *tool_arguments)
{
  ChseqidsArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] mapping_file [GFF3_file]",
                         "Change sequence ids by the mapping given in a "
                         "mapping file.");

  /* -sort */
  option = gt_option_new_bool("sort",
                              "sort the GFF3 features after changing the "
                              "sequence ids\n(memory consumption is "
                              "proportional to the input file size)",
                              &arguments->sort, false);
  gt_option_parser_add_option(op, option);

  /* -v */
  option = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, option);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  /* parse options */
  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_min_max_args(op, 1, 2);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b4fb
movq %rdi, %r14
leaq 0x2cb495(%rip), %rdi    # 0x2e690d
leaq 0x2cb4b4(%rip), %rsi    # 0x2e6933
callq 0x97df5
movq %rax, %rbx
leaq 0x32d719(%rip), %rdi    # 0x348ba7
leaq 0x2cb4da(%rip), %rsi    # 0x2e696f
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x1(%r14), %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%r14), %rdi
addq $0x10, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9b6d7
leaq 0xcc014(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x98c6b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x41ca66(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c9b07(%rip), %rsi    # 0x2e5013
leaq 0x32d140(%rip), %rdx    # 0x348653
leaq 0x2cb3d5(%rip), %rcx    # 0x2e68ef
leaq 0x2cb3b6(%rip), %r8     # 0x2e68d7
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_clean.c
// Function: gt_clean_runner
int gt_clean_runner(GT_UNUSED int argc, GT_UNUSED const char **argv,
                    GT_UNUSED int parsed_args, GT_UNUSED void *tool_arguments,
                    GT_UNUSED GtError *err)
{
  gt_error_check(err);

#ifndef _WIN32
  remove_pattern_in_current_dir(GT_ENCSEQFILESUFFIX);
  remove_pattern_in_current_dir(GT_SSPTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_DESTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_SDSTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_OISTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_MD5TABFILESUFFIX);
#else
  /* XXX */
  gt_error_set(err, "gt_clean_runner() not implemented");
  return -1;
#endif

  return 0;
}

// Assembly:
pushq %rax
testq %r8, %r8
je 0x1b6a6
movq %r8, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1b6f2
leaq 0x2cb36e(%rip), %rdi    # 0x2e6a1b
callq 0x1b728
leaq 0x2cb367(%rip), %rdi    # 0x2e6a20
callq 0x1b728
leaq 0x2cb360(%rip), %rdi    # 0x2e6a25
callq 0x1b728
leaq 0x2cb359(%rip), %rdi    # 0x2e6a2a
callq 0x1b728
leaq 0x2cb352(%rip), %rdi    # 0x2e6a2f
callq 0x1b728
leaq 0x2cb34b(%rip), %rdi    # 0x2e6a34
callq 0x1b728
xorl %eax, %eax
popq %rcx
retq
movq 0x41c86f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c9910(%rip), %rsi    # 0x2e5013
leaq 0x2c9ab5(%rip), %rdx    # 0x2e51bf
leaq 0x2cb2e5(%rip), %rcx    # 0x2e69f6
leaq 0x2cb2ee(%rip), %r8     # 0x2e6a06
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_clean.c
// Function: remove_pattern_in_current_dir
static void remove_pattern_in_current_dir(const char *pattern)
{
  char **files_to_remove;
  GtStr *path;
  glob_t g;

  path = gt_str_new_cstr("./*");
  gt_str_append_cstr(path, pattern);
  gt_xglob(gt_str_get(path), GLOB_NOCHECK, NULL, &g);

  /* remove found files */
  if (g.gl_pathc) {
    files_to_remove = g.gl_pathv;
    if (strcmp(*files_to_remove, gt_str_get(path))) {
      while (*files_to_remove) {
        gt_xunlink(*files_to_remove);
        files_to_remove++;
      }
    }
  }

  /* free */
  globfree(&g);
  gt_str_delete(path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x2cb2fe(%rip), %rdi    # 0x2e6a39
callq 0xacbd1
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xacbfb
movq %rbx, %rdi
callq 0xad1fa
pushq $0x10
popq %rsi
leaq 0x8(%rsp), %r14
movq %rax, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb3489
cmpq $0x0, (%r14)
je 0x1b7a3
movq 0x10(%rsp), %r15
movq (%r15), %r14
movq %rbx, %rdi
callq 0xad1fa
movq %r14, %rdi
movq %rax, %rsi
callq 0x179e0
testl %eax, %eax
jne 0x1b79b
jmp 0x1b7a3
callq 0xb3704
addq $0x8, %r15
movq (%r15), %rdi
testq %rdi, %rdi
jne 0x1b792
leaq 0x8(%rsp), %rdi
callq 0x174e0
movq %rbx, %rdi
callq 0xae103
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_arguments_new
static void* gt_compreads_arguments_new(void)
{
  GtToolbox *compreads_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(compreads_toolbox,
      "refcompress", gt_compreads_refcompress());
  gt_toolbox_add_tool(compreads_toolbox,
      "refdecompress", gt_compreads_refdecompress());
  gt_toolbox_add_tool(compreads_toolbox,
      "compress", gt_compreads_compress());
  gt_toolbox_add_tool(compreads_toolbox,
      "decompress", gt_compreads_decompress());
  return compreads_toolbox;
}

// Assembly:
pushq %rbx
callq 0xb0c26
movq %rax, %rbx
callq 0x1c914
leaq 0x2cb236(%rip), %rsi    # 0x2e6a8e
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x1cea4
leaq 0x2cb22b(%rip), %rsi    # 0x2e6a9a
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x1bac4
leaq 0x2cb219(%rip), %rsi    # 0x2e6a9f
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x1c1d4
leaq 0x2cb200(%rip), %rsi    # 0x2e6a9d
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_option_parser_new
static GtOptionParser* gt_compreads_option_parser_new(void *tool_arguments)
{
  GtToolbox *compreads_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(compreads_toolbox);
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                            "Call a fastq file compression tool.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, compreads_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b901
movq %rdi, %rbx
leaq 0x2cb228(%rip), %rdi    # 0x2e6af2
leaq 0x2cb242(%rip), %rsi    # 0x2e6b13
callq 0x97df5
movq %rax, %r14
leaq 0x955b8(%rip), %rsi     # 0xb0e98
movq %rax, %rdi
movq %rbx, %rdx
callq 0x98045
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x41c660(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c9701(%rip), %rsi    # 0x2e5013
leaq 0x2cb18f(%rip), %rdx    # 0x2e6aa8
leaq 0x2cb19a(%rip), %rcx    # 0x2e6aba
leaq 0x2cb1b2(%rip), %r8     # 0x2e6ad9
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_compreads_compress.c
// Function: gt_compreads_compress_arguments_new
static void* gt_compreads_compress_arguments_new(void)
{
  GtCsrHcrEncodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->smap = gt_str_new();
  arguments->name = gt_str_new();
  arguments->files = gt_str_array_new();
  arguments->qrng.start = GT_UNDEF_UINT;
  arguments->qrng.end = GT_UNDEF_UINT;
  arguments->arg_range.start = GT_UNDEF_UWORD;
  arguments->arg_range.end = GT_UNDEF_UWORD;
  arguments->method = gt_str_new();
  arguments->pagewise = false;
  arguments->regular = false;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2cb098(%rip), %rdx    # 0x2e6b8c
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
pushq $0x34
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xae154
movq %rax, 0x20(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%rbx)
orq $-0x1, 0x40(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
andw $0x0, 0x1(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_compreads_compress.c
// Function: gt_compreads_compress_arguments_delete
static void gt_compreads_compress_arguments_delete(void *tool_arguments)
{
  GtCsrHcrEncodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->name);
  gt_str_array_delete(arguments->files);
  gt_str_delete(arguments->smap);
  gt_str_delete(arguments->method);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1bb81
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae662
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
leaq 0x2cb017(%rip), %rsi    # 0x2e6b8c
pushq $0x4a
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_compreads_decompress.c
// Function: gt_compreads_decompress_arguments_new
static void* gt_compreads_decompress_arguments_new(void)
{
  GtCsrHcrDecodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->file = gt_str_new();
  arguments->smap = gt_str_new();
  arguments->name = gt_str_new();
  arguments->rng.start = GT_UNDEF_UWORD;
  arguments->rng.end = GT_UNDEF_UWORD;
  arguments->bench = 0;

  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2cae5f(%rip), %rdx    # 0x2e705e
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
pushq $0x32
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x30(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x38(%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_compreads_decompress.c
// Function: gt_compreads_decompress_arguments_delete
static void gt_compreads_decompress_arguments_delete(void *tool_arguments)
{
  GtCsrHcrDecodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->file);
  gt_str_delete(arguments->name);
  gt_str_delete(arguments->smap);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x1c275
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xae103
movq 0x30(%rbx), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae103
leaq 0x2cadf5(%rip), %rsi    # 0x2e705e
pushq $0x44
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq