LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: counter_fn
void *
counter_fn(void *arg)
{
	counter_thread_control *ctc = (counter_thread_control *) arg;
	
	uint64_t last_t = 0;
	
	while (ctc->death == 0) {
		
		sleep(1);
		
		int keys = atomic_int_get(ctc->keys);
		int tps = keys - last_t;
		last_t = keys;
		
		if ((ctc->gen_errs == 0) || (atomic_int_get(ctc->gen_errs) == 0) ) 
			fprintf(stderr, "%s: %d (tps %d)\n",ctc->msg,keys,tps);
		else
			fprintf(stderr, "%s: %d (tps %d) gen-errs %d\n",ctc->msg,keys,tps,atomic_int_get(ctc->gen_errs));
	}
	return(0);
}

// Assembly:
cmpl $0x0, 0x18(%rdi)
jne 0x315c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %ebp, %ebp
movl $0x1, %edi
movl %ebp, %r15d
callq 0x2150
movq 0x8(%rbx), %r13
leaq 0x8(%r13), %r12
movq %r12, %rdi
callq 0x23c0
movl (%r13), %ebp
movq %r12, %rdi
callq 0x2160
movl %ebp, %r12d
subl %r15d, %r12d
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x3112
leaq 0x8(%r15), %r13
movq %r13, %rdi
callq 0x23c0
movl (%r15), %r15d
movq %r13, %rdi
callq 0x2160
testl %r15d, %r15d
jne 0x3134
movq 0x16ec7(%rip), %rax     # 0x19fe0
movq (%rbx), %rdx
leaq 0xf025(%rip), %rsi      # 0x12148
movl %ebp, %ecx
movl %r12d, %r8d
movq (%rax), %rdi
xorl %eax, %eax
callq 0x2390
jmp 0x3144
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x287d
cmpl $0x0, 0x18(%rbx)
je 0x30be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: start_counter_thread
void *
start_counter_thread(char *msg, atomic_int *keys, atomic_int *gen_errs)
{
	counter_thread_control *ctc = (counter_thread_control *) malloc(sizeof(counter_thread_control));
	ctc->keys = keys;
	ctc->gen_errs = gen_errs;
	ctc->msg = strdup(msg);

	ctc->death = 0;
	pthread_create(&ctc->th, 0, counter_fn, ctc);
	return(ctc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x28, %edi
movq %rdx, %rbx
movq %rsi, %r14
callq 0x22f0
movq %r15, %rdi
movq %r14, 0x8(%rax)
movq %rax, %r12
movq %rbx, 0x10(%rax)
callq 0x2500
leaq 0x20(%r12), %rdi
leaq -0xf9(%rip), %rdx       # 0x30a0
xorl %esi, %esi
movq %r12, %rcx
movq %rax, (%r12)
movl $0x0, 0x18(%r12)
callq 0x24f0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: rand_64
uint64_t
rand_64()
{
	pthread_mutex_lock(&rand_buf_lock);
	if (rand_buf_off < sizeof(uint64_t) ) {
		if (seeded == 0) {
			int rfd = open("/dev/urandom",	O_RDONLY);
			int rsz = read(rfd, rand_buf, SEED_SZ);
			if (rsz < SEED_SZ) {
				fprintf(stderr, "warning! can't seed random number generator");
				return(0);
			}
			close(rfd);
			RAND_seed(rand_buf, rsz);
			seeded = 1;
		}
		if (1 != RAND_bytes(rand_buf, sizeof(rand_buf))) {
			fprintf(stderr, "RAND_bytes not so happy.\n");
			pthread_mutex_unlock(&rand_buf_lock);
			return(0);
		}
		rand_buf_off = sizeof(rand_buf);
	}
	
	rand_buf_off -= sizeof(uint64_t);
	uint64_t r = *(uint64_t *) (&rand_buf[rand_buf_off]);
	pthread_mutex_unlock(&rand_buf_lock);
	return(r);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x17117(%rip), %rdi     # 0x1a300
callq 0x23c0
movl 0x17134(%rip), %ebx     # 0x1a328
cmpl $0x7, %ebx
ja 0x3268
cmpb $0x0, 0x1712c(%rip)     # 0x1a32c
jne 0x324d
leaq 0xef6d(%rip), %rdi      # 0x12176
xorl %esi, %esi
xorl %eax, %eax
callq 0x24c0
leaq 0x17117(%rip), %rsi     # 0x1a330
movl $0x40, %edx
movl %eax, %edi
movl %eax, %ebx
callq 0x23a0
movq %rax, %r14
cmpl $0x40, %r14d
jl 0x329a
movl %ebx, %edi
callq 0x2560
leaq 0x170f2(%rip), %rdi     # 0x1a330
movl %r14d, %esi
callq 0x24b0
movb $0x1, 0x170df(%rip)     # 0x1a32c
leaq 0x170dc(%rip), %rdi     # 0x1a330
movl $0x2000, %esi           # imm = 0x2000
movl $0x2000, %ebx           # imm = 0x2000
callq 0x23e0
cmpl $0x1, %eax
jne 0x3293
addl $-0x8, %ebx
leaq 0x170be(%rip), %rax     # 0x1a330
leaq 0x17087(%rip), %rdi     # 0x1a300
movl %ebx, 0x170a9(%rip)     # 0x1a328
movq (%rbx,%rax), %rbx
callq 0x2160
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x28fa
jmp 0x329f
callq 0x28de
xorl %ebx, %ebx
jmp 0x3288
// File: /workspace/github_c_makefile_star2_O3/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 0x1441d(%rip), %rax     # 0x19fc0
movq %rdi, %rbx
movb $0x0, (%rsp)
movq %rsi, %rdx
leaq 0xd45c(%rip), %rsi      # 0x13010
movq (%rax), %rdi
movq (%rbx), %rcx
xorl %eax, %eax
callq 0x2390
movl $0x3f, %ebp
movl %ebp, %eax
cmpq $0x0, 0x8(%rbx,%rax,8)
jne 0x5bda
addl $-0x1, %ebp
jb 0x5bc6
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpq $0x0, 0x8(%rbx,%rax,8)
jne 0x5bf2
incq %rax
cmpq $0x40, %rax
jne 0x5bdc
movl $0x40, %eax
cmpl %ebp, %eax
jg 0x5cb3
movl %eax, %r14d
incl %ebp
leaq 0xd41a(%rip), %r15      # 0x13020
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq $0x0, 0x8(%rbx,%r14,8)
je 0x5c69
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 0x5c93
movl %r12d, %ecx
andl $0x80000003, %ecx       # imm = 0x80000003
cmpl $0x3, %ecx
jne 0x5c63
movq 0x1437a(%rip), %rax     # 0x19fc0
leaq 0xce87(%rip), %rsi      # 0x12ad4
movq %rsp, %rdx
xorl %r13d, %r13d
movq (%rax), %rdi
xorl %eax, %eax
callq 0x2390
movb $0x0, (%rsp)
jmp 0x5c66
addl %eax, %r13d
incl %r12d
incq %r14
cmpq %r14, %rbp
jne 0x5c0c
testl %r13d, %r13d
jle 0x5cb3
movq 0x14343(%rip), %rax     # 0x19fc0
leaq 0xce50(%rip), %rsi      # 0x12ad4
movq %rsp, %rdx
movq (%rax), %rdi
xorl %eax, %eax
callq 0x2390
jmp 0x5cb3
movq 0x14326(%rip), %rax     # 0x19fc0
leaq 0xd390(%rip), %rdi      # 0x13031
movl $0x1a, %esi
movl $0x1, %edx
movq (%rax), %rcx
callq 0x2550
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/tests/key_c/src/../../../include/citrusleaf/cf_atomic.h
// Function: histogram_insert_data_point
static inline int64_t
cf_atomic64_add(cf_atomic64 *a, int64_t b)
{
	int64_t i = b;

#ifndef CF_WINDOWS
	__asm__ __volatile__ ("lock; xaddq %0, %1" : "+r" (b), "+m" (*a) : : "memory");
#else
	b = _InterlockedExchangeAdd64((LONGLONG *)a, b);
#endif

	return(b + i);
}

// Assembly:
movl $0x1, %eax
lock
xaddq %rax, (%rdi)
movq %rsi, %rax
shrq $0x20, %rax
jne 0x5cf7
cmpq $0x10000, %rsi          # imm = 0x10000
jae 0x5d19
cmpq $0x100, %rsi            # imm = 0x100
jae 0x5d52
leaq 0xd222(%rip), %rax      # 0x12f10
movsbl (%rsi,%rax), %eax
jmp 0x5d9e
movq %rsi, %rcx
shrq $0x30, %rcx
jne 0x5d39
movq %rsi, %rcx
shrq $0x28, %rcx
jne 0x5d69
leaq 0xd200(%rip), %rcx      # 0x12f10
movsbl (%rax,%rcx), %eax
jmp 0x5d9b
movq %rsi, %rax
cmpq $0x1000000, %rsi        # imm = 0x1000000
jae 0x5d79
shrq $0x10, %rax
leaq 0xd1e0(%rip), %rcx      # 0x12f10
movsbl (%rax,%rcx), %eax
addl $0x10, %eax
jmp 0x5d9e
movq %rsi, %rax
shrq $0x38, %rax
jne 0x5d8d
leaq 0xd1c7(%rip), %rax      # 0x12f10
movsbl (%rcx,%rax), %eax
addl $0x10, %eax
jmp 0x5d9b
movq %rsi, %rax
leaq 0xd1b4(%rip), %rcx      # 0x12f10
shrq $0x8, %rax
movsbl (%rax,%rcx), %eax
addl $0x8, %eax
jmp 0x5d9e
leaq 0xd1a0(%rip), %rax      # 0x12f10
movsbl (%rcx,%rax), %eax
addl $0x8, %eax
jmp 0x5d9b
shrq $0x18, %rax
leaq 0xd18c(%rip), %rcx      # 0x12f10
movsbl (%rax,%rcx), %eax
addl $0x18, %eax
jmp 0x5d9e
leaq 0xd17c(%rip), %rcx      # 0x12f10
movsbl (%rax,%rcx), %eax
addl $0x18, %eax
addl $0x20, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
testq %rsi, %rsi
cmovnsq %rax, %rcx
movl $0x1, %eax
lock
xaddq %rax, 0x8(%rdi,%rcx,8)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xed0a
testb $0x4, %al
jne 0xed69
movl (%rbx), %ebp
jmp 0xed83
cmpl $0x0, 0x18(%rbx)
je 0xed81
xorl %r15d, %r15d
xorl %ebp, %ebp
leaq (%r15,%r15,4), %r14
shlq $0x3, %r14
addq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x23c0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xed54
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %edx
leaq 0x10(%rcx,%rdx), %rcx
imulq %r15, %rcx
addq %rcx, %rax
cmpb $0x0, 0x8(%rax)
je 0xed54
movq (%rax), %rax
incl %ebp
testq %rax, %rax
jne 0xed44
movq %r14, %rdi
callq 0x2160
movl 0x18(%rbx), %eax
incq %r15
cmpq %rax, %r15
jb 0xed15
jmp 0xed83
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x23c0
movl (%rbx), %ebp
movq %r14, %rdi
callq 0x2160
jmp 0xed83
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
callq *0x10(%r12)
xorl %edx, %edx
divl 0x18(%r12)
movl 0xc(%r12), %eax
testb $0x4, %al
movl %edx, %ebx
jne 0xf055
movb $0x1, %cl
testb $0x8, %al
je 0xf068
movq 0x50(%r12), %rax
testq %rax, %rax
je 0xf068
leaq (%rbx,%rbx,4), %rcx
leaq (%rax,%rcx,8), %rdi
jmp 0xf05a
leaq 0x28(%r12), %rdi
movq %rdi, 0x8(%rsp)
callq 0x23c0
xorl %ecx, %ecx
jmp 0xf071
movq $0x0, 0x8(%rsp)
movq 0x20(%r12), %r15
movl 0x4(%r12), %r13d
movl 0x8(%r12), %r12d
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
leaq 0x10(%r13,%r12), %rax
imulq %rax, %rbx
cmpb $0x0, 0x8(%r15,%rbx)
je 0xf0db
addq %rbx, %r15
movl %ecx, 0x4(%rsp)
leaq 0x9(%r15), %rbx
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rdi
callq 0x2240
testl %eax, %eax
je 0xf0bd
movq (%r15), %r15
testq %r15, %r15
jne 0xf09d
jmp 0xf0d7
movq 0x10(%rsp), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0xf0d7
addq %r13, %rbx
movq %r12, %rdx
movq %rbx, %rsi
callq 0x2180
movl 0x4(%rsp), %ecx
testb %cl, %cl
jne 0xf0e9
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_O3/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 0xf146
testb $0x8, %al
je 0xf15c
movq 0x50(%r13), %rax
testq %rax, %rax
je 0xf15c
leaq (%rbx,%rbx,4), %rcx
leaq (%rax,%rcx,8), %r12
jmp 0xf14a
leaq 0x28(%r13), %r12
movq %r12, %rdi
callq 0x23c0
movl $0x0, 0x4(%rsp)
jmp 0xf165
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 0xf1a3
addq %rbx, %r14
leaq 0x9(%r14), %r13
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rdi
callq 0x2240
testl %eax, %eax
je 0xf1c3
movq (%r14), %r14
testq %r14, %r14
jne 0xf185
cmpb $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rbx
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jne 0xf1dc
movq %r12, %rdi
callq 0x2160
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0xf1e1
movq 0x10(%rsp), %rax
addq %rbp, %r13
movq 0x8(%rsp), %rbx
movq %r13, (%rax)
xorl %eax, %eax
cmpb $0x0, 0x4(%rsp)
je 0xf1e4
testq %rbx, %rbx
je 0xf1e7
xorl %r12d, %r12d
movq %r12, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x18(%rdi), %eax
movq %rdi, %rbx
testl %eax, %eax
je 0xf7f5
movq 0x20(%rbx), %r14
xorl %ebp, %ebp
movq (%r14), %rdi
testq %rdi, %rdi
je 0xf7e1
movq (%rdi), %r15
callq 0x22a0
testq %r15, %r15
movq %r15, %rdi
jne 0xf7ce
movl 0x18(%rbx), %eax
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %edx
incl %ebp
addq %rcx, %rdx
cmpl %eax, %ebp
leaq 0x10(%r14,%rdx), %r14
jb 0xf7c6
movl 0xc(%rbx), %eax
testb $0x4, %al
je 0xf808
leaq 0x28(%rbx), %rdi
callq 0x2290
movl 0xc(%rbx), %eax
testb $0x8, %al
je 0xf83c
cmpl $0x0, 0x18(%rbx)
je 0xf833
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x50(%rbx), %rdi
addq %r14, %rdi
callq 0x2290
movl 0x18(%rbx), %eax
incq %r15
addq $0x28, %r14
cmpq %rax, %r15
jb 0xf818
movq 0x50(%rbx), %rdi
callq 0x22a0
movq 0x20(%rbx), %rdi
callq 0x22a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suftaborder.c
// Function: showcomparisonfailure
static void showcomparisonfailure(const char *filename,
                                  int line,
                                  const char *where,
                                  const GtEncseq *encseq,
                                  GtReadmode readmode,
                                  const GtSuffixsortspace *suffixsortspace,
                                  GtUword subbucketleft,
                                  GtUword depth,
                                  GtUword idx1,
                                  GtUword idx2,
                                  int cmp,
                                  GtUword maxlcp)
{
  GtUword pos1, pos2;

  pos1 = gt_suffixsortspace_get(suffixsortspace,subbucketleft,idx1);
  pos2 = gt_suffixsortspace_get(suffixsortspace,subbucketleft,idx2);
  fprintf(stderr,"ERROR: file \"%s\", line %d: ",filename,line);
  fprintf(stderr,"%s("GT_WU" vs "GT_WU""
                 " "GT_WU"=\"",
                       where,
                       idx1,
                       idx2,
                       pos1);
  gt_encseq_showatstartposwithdepth(stderr,encseq,readmode,pos1,depth);
  fprintf(stderr,"\",\"");
  gt_encseq_showatstartposwithdepth(stderr,encseq,readmode,pos2,depth);
  fprintf(stderr,"\"="GT_WU")=%d with maxlcp "GT_WU",depth="GT_WU"\n",pos2,cmp,
          maxlcp,depth);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r13
movl %r8d, 0x10(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, 0x18(%rsp)
movl 0x90(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rsp), %r15
movq 0x88(%rsp), %rbx
movq 0x70(%rsp), %r12
movq 0x80(%rsp), %rbp
movq %r9, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1fc965
movq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1fc965
movq %rax, %r13
movq 0x43a999(%rip), %r12    # 0x4b8f80
movq (%r12), %rdi
leaq 0x2db8fc(%rip), %rsi    # 0x359eee
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
xorl %eax, %eax
callq 0x17ab0
movq (%r12), %rdi
leaq 0x2db8fd(%rip), %rsi    # 0x359f0a
movq 0x20(%rsp), %rdx
movq %rbp, %rcx
movq %rbx, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x17ab0
movq (%r12), %rdi
movq 0x28(%rsp), %rbp
movq %rbp, %rsi
movl 0x10(%rsp), %ebx
movl %ebx, %edx
movq %r14, %rcx
movq %r15, %r8
callq 0xed8f5
movq (%r12), %rcx
leaq 0x2db8d4(%rip), %rdi    # 0x359f1e
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x17fa0
movq (%r12), %rdi
movq %rbp, %rsi
movl %ebx, %edx
movq %r13, %rcx
movq %r15, %r8
callq 0xed8f5
movq (%r12), %rdi
leaq 0x33d17a(%rip), %rsi    # 0x3bb7ee
movq %r13, %rdx
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %r8
movq %r15, %r9
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17ab0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/twobits2kmers.c
// Function: showdifferentkmers
static void showdifferentkmers(int line,GtUword pos,GtCodetype kmer1,
                               GtCodetype kmer2)
{
  char buffer[2*GT_INTWORDSIZE+1];

  fprintf(stderr,"line %d: pos="GT_WU"\n",line,pos);
  gt_bitsequence_tostring_units(buffer,(GtBitsequence) kmer1,2U);
  fprintf(stderr,"kmer1=%s\n",buffer);
  gt_bitsequence_tostring_units(buffer,(GtBitsequence) kmer2,2U);
  fprintf(stderr,"kmer2=%s\n",buffer);
  fprintf(stderr,"kmer1="GT_WU" != "GT_WU"= kmer2\n",kmer1,kmer2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rcx
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
movq 0x439ae8(%rip), %r15    # 0x4b8f80
movq (%r15), %rdi
leaq 0x33d2e7(%rip), %rsi    # 0x3bc789
xorl %r13d, %r13d
movl $0xe8, %edx
xorl %eax, %eax
callq 0x17ab0
pushq $0x1
popq %rax
movq %r12, %rcx
testq %r14, %rcx
sete %sil
xorb $0x31, %sil
leal 0x1(%r13), %edx
movl %r13d, %edi
movb %sil, (%rsp,%rdi)
testb $0x1, %al
jne 0x7f4dd
addl $0x2, %r13d
movl %edx, %edx
movb $0x20, (%rsp,%rdx)
jmp 0x7f4e0
movl %edx, %r13d
incl %eax
shrq %rcx
cmpl $0x41, %eax
jne 0x7f4b7
movl %r13d, %eax
movb $0x0, (%rsp,%rax)
movq (%r15), %rdi
leaq 0x33d2a0(%rip), %rsi    # 0x3bc79b
xorl %r13d, %r13d
movq %rsp, %rdx
xorl %eax, %eax
callq 0x17ab0
pushq $0x1
popq %rax
testq %rbx, %r12
sete %dl
xorb $0x31, %dl
leal 0x1(%r13), %ecx
movl %r13d, %esi
movb %dl, (%rsp,%rsi)
testb $0x1, %al
jne 0x7f52e
addl $0x2, %r13d
movl %ecx, %ecx
movb $0x20, (%rsp,%rcx)
jmp 0x7f531
movl %ecx, %r13d
incl %eax
shrq %r12
cmpl $0x41, %eax
jne 0x7f50b
movl %r13d, %eax
movb $0x0, (%rsp,%rax)
movq (%r15), %rdi
leaq 0x33d259(%rip), %rsi    # 0x3bc7a5
movq %rsp, %rdx
xorl %eax, %eax
callq 0x17ab0
movq (%r15), %rdi
leaq 0x33d24f(%rip), %rsi    # 0x3bc7af
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17ab0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebp
callq 0x102778
callq 0xfcb4c
movq %rax, %rbx
movq (%r15), %rsi
movq %rax, %rdi
callq 0xfcc72
movq %rbx, %rdi
callq 0x97b08
testq %rax, %rax
je 0x97aea
movq %rax, %r14
movq %rax, %rdi
callq 0x980bc
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %rbx, %r8
callq 0x97daf
cmpl $0x2, %eax
je 0x97aa7
cmpl $0x1, %eax
je 0x97a9d
testl %eax, %eax
jne 0x97aaf
movslq 0x4(%rsp), %rax
subl %eax, %ebp
leaq (%r15,%rax,8), %rdx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
callq 0x980f0
movl %eax, 0x4(%rsp)
jmp 0x97aaf
movl $0x1, 0x4(%rsp)
jmp 0x97aaf
movl $0x0, 0x4(%rsp)
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x97af9
movq %r14, %rdi
callq 0x9890b
movq %rbx, %rdi
callq 0xfcccd
callq 0x1029a3
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x97adf
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x18090
movl $0x1, %eax
jmp 0x97adf
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x18010
jmp 0x97abb
// File: /workspace/github_c_makefile_star2_O3/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 0x97dd6
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x97e1a
testq %r12, %r12
je 0x97e15
movq %r12, %rdi
callq 0x97e1f
movq %rax, %r12
leaq 0x8781f(%rip), %r8      # 0x11f60c
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x10875d
movl %eax, %ebx
movq %r12, %rdi
callq 0x10a0b4
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1810f
callq 0x180d6
// File: /workspace/github_c_makefile_star2_O3/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 0x980eb
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x11df02
callq 0x98b1c
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x10109b
callq 0x9926e
movq %rax, 0x28(%rbx)
popq %rbx
retq
callq 0x18148
// File: /workspace/github_c_makefile_star2_O3/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 0x9897f
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0xfd018
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x30(%rbx), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11df02
movq 0x28(%rbx), %rdi
callq 0x10109b
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x98961
callq 0x226b39
movq 0x48(%rbx), %rdi
callq 0x22190c
leaq 0x2ac7d4(%rip), %rsi    # 0x345145
movq %rbx, %rdi
movl $0x224, %edx            # imm = 0x224
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11dd9e
testl %eax, %eax
je 0x9899b
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 0x14c8c4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtr.c
// Function: create_manpage
static int create_manpage(const char *outdir, const char *toolname,
                          GtOptionParser *option_parser, GtError *err)
{
  GtFile *outfile = NULL;
  GtStr *man, *pathbuf;
  char *utoolname;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(outdir && toolname && option_parser);
  man = gt_str_new();
  pathbuf = gt_str_new_cstr(outdir);
  utoolname = gt_cstr_dup(toolname);
  gt_cstr_rep(utoolname, ' ', '_');
  if (!gt_file_exists(gt_str_get(pathbuf)))
    gt_xmkdir(gt_str_get(pathbuf));
  gt_str_append_char(pathbuf, GT_PATH_SEPARATOR);
  gt_str_append_cstr(pathbuf, utoolname);
  gt_str_append_cstr(pathbuf, ".mansrc");
  gt_free(utoolname);
  if (!(outfile = gt_file_new(gt_str_get(pathbuf), "w+", err)))
    had_err = -1;
  if (!had_err)
    had_err = gt_option_parser_manpage(option_parser, toolname, man, err);
  if (!had_err)
    gt_file_xprintf(outfile, "%s", gt_str_get(man));
  gt_file_delete(outfile);
  gt_str_delete(pathbuf);
  gt_str_delete(man);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x989db
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x98b15
testq %r14, %r14
je 0x98b10
testq %r12, %r12
je 0x98b10
testq %r13, %r13
je 0x98b10
callq 0x11ac6c
movq %rax, %rbx
movq %r14, %rdi
callq 0x11acc9
movq %rax, %r14
movq %r12, %rdi
callq 0xe4290
movq %rax, %rbp
movq %rax, %rdi
movl $0x20, %esi
movl $0x5f, %edx
callq 0xe431c
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff28c
testb %al, %al
jne 0x98a4a
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0x11fb9f
movq %r14, %rdi
movl $0x2f, %esi
callq 0x11af23
movq %r14, %rdi
movq %rbp, %rsi
callq 0x11acf3
leaq 0x2acbf8(%rip), %rsi    # 0x345661
movq %r14, %rdi
callq 0x11acf3
leaq 0x2ac6cd(%rip), %rsi    # 0x345145
movq %rbp, %rdi
movl $0x138, %edx            # imm = 0x138
callq 0x1045eb
movq %r14, %rdi
callq 0x11b0a1
leaq 0x2acbd5(%rip), %rsi    # 0x345669
movq %rax, %rdi
movq %r15, %rdx
callq 0xfea8a
movq %rax, %rbp
testq %rax, %rax
je 0x98ae0
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x107e71
movl %eax, %r15d
testl %eax, %eax
jne 0x98ae6
movq %rbx, %rdi
callq 0x11b0a1
leaq 0x32ffdb(%rip), %rsi    # 0x3c8aa9
xorl %r15d, %r15d
movq %rbp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
jmp 0x98ae6
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %rbp, %rdi
callq 0xff22c
movq %r14, %rdi
callq 0x11bdbf
movq %rbx, %rdi
callq 0x11bdbf
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x18382
callq 0x18349
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2ac289(%rip), %rax    # 0x345f11
leaq 0x2ac28a(%rip), %rdx    # 0x345f19
testl %esi, %esi
cmovneq %rax, %rdx
leaq 0x31687d(%rip), %rax    # 0x3b0519
leaq 0x2ac27f(%rip), %r15    # 0x345f22
cmovneq %rax, %r15
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x224a06
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
testq %rax, %rax
cmovneq %rax, %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2235b9
movq 0x41f1fa(%rip), %r12    # 0x4b8ed8
movq (%r12), %rsi
movq %r15, %rdi
callq 0x178c0
movq (%r12), %rdi
callq 0x178f0
movq 0x41f226(%rip), %rax    # 0x4b8f20
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x17c30
testq %rax, %rax
je 0x99d5c
movq %rsp, %rdi
callq 0x172f0
testq %rax, %rax
je 0x99d28
cmpb $0xa, -0x1(%rsp,%rax)
jne 0x99d28
movb $0x0, -0x1(%rsp,%rax)
testb %bpl, %bpl
je 0x99d4b
cmpb $0x3d, (%rsp)
jne 0x99d4b
leaq 0x1(%rsp), %rdx
leaq 0x2ac1c8(%rip), %rsi    # 0x345f07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x224708
jmp 0x99d56
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2243ba
movl $0x1, %r14d
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_O3/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 %rbx
movq %rdi, %rbx
leaq 0x2ac1b4(%rip), %rdx    # 0x345f2e
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x224a06
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x223a4b
cmpl $0x5, %eax
jne 0x99dea
leaq 0x3422a5(%rip), %rdx    # 0x3dc042
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224a06
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x223a4b
cmpl $0x6, %eax
jne 0x99df4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x223a2b
movl $0x2, %esi
movq %rbx, %rdi
callq 0x2241dd
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x2252cf
jmp 0x99e01
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
jmp 0x99dfc
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x2235b9
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ac0e5(%rip), %rdx    # 0x345f60
movl $0x1, %edi
movl $0x28, %esi
movl $0x25, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x10ad60
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x99f04
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xff22c
movq 0x18(%rbx), %rdi
callq 0x10b00c
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0x11bdbf
leaq 0x2ac06a(%rip), %rsi    # 0x345f60
movq %rbx, %rdi
movl $0x36, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ac068(%rip), %rdi    # 0x345f7b
leaq 0x2ac06c(%rip), %rsi    # 0x345f86
callq 0x107bfe
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2e40fb(%rip), %rdi    # 0x37e027
leaq 0x2ac07a(%rip), %rsi    # 0x345fad
leaq 0x2ac093(%rip), %rcx    # 0x345fcd
callq 0x10a770
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x8(%r14), %rdx
leaq 0x2ac084(%rip), %rdi    # 0x345fd9
leaq 0x2ac087(%rip), %rsi    # 0x345fe3
leaq 0x2ac0a6(%rip), %rcx    # 0x346009
callq 0x10a770
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdx
leaq 0x2ac09d(%rip), %rdi    # 0x34601b
leaq 0x2ac0a0(%rip), %rsi    # 0x346025
leaq 0x2ac0b7(%rip), %rcx    # 0x346043
callq 0x10a770
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x18(%r14), %rdi
addq $0x20, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ad87
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10873c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x99fee
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9a071
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0x1266de
movq %rax, %r15
movq (%r14), %rdi
callq 0x11b0a1
movq %r15, %rdi
movq %rax, %rsi
callq 0x126749
movq 0x8(%r14), %rdi
callq 0x11b0a1
movq %r15, %rdi
movq %rax, %rsi
callq 0x126762
movq 0x10(%r14), %rdi
callq 0x11b0a1
movq %r15, %rdi
movq %rax, %rsi
callq 0x12677b
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x146fc0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162f5d
movl %eax, %ebx
movq %r14, %rdi
callq 0x162dee
movq %r15, %rdi
callq 0x162dee
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1845f
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2abfc0(%rip), %rdx    # 0x346063
movl $0x1, %edi
movl $0x20, %esi
movl $0x2d, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x172c40
movq %rax, 0x8(%rbx)
callq 0x10ad60
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a10a
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
movq 0x8(%rbx), %rdi
callq 0x172c87
leaq 0x2abf67(%rip), %rsi    # 0x346063
movq %rbx, %rdi
movl $0x3a, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_cds.c
// Function: gt_cds_runner
static int gt_cds_runner(GT_UNUSED int argc, const char **argv, int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtNodeStream *gff3_in_stream, *cds_stream = NULL, *gff3_out_stream = NULL;
  CDSArguments *arguments = tool_arguments;
  GtRegionMapping *region_mapping;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  /* create gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);

  /* create region mapping */
  region_mapping = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
  if (!region_mapping)
    had_err = -1;

  if (!had_err) {
    /* create CDS stream */
    cds_stream = gt_cds_stream_new(gff3_in_stream, region_mapping,
                                   arguments->minorflen, GT_CDS_SOURCE_TAG,
                                   arguments->start_codon,
                                   arguments->final_stop_codon,
                                   arguments->generic_start_codons);

    /* create gff3 output stream */
    gff3_out_stream = gt_gff3_out_stream_new(cds_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(cds_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
testq %r8, %r8
je 0x9a260
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9a31e
testq %r15, %r15
je 0x9a319
movslq %ebp, %rax
movq (%rbx,%rax,8), %rdi
callq 0x145d7c
movq %rax, %rbx
cmpb $0x1, 0x7(%r15)
jne 0x9a28e
cmpq $0x0, 0x18(%r15)
je 0x9a28e
movq %rbx, %rdi
callq 0x145b36
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x172fdd
testq %rax, %rax
je 0x9a2e7
movl (%r15), %edx
movzbl 0x4(%r15), %r8d
movzbl 0x5(%r15), %r9d
movzbl 0x6(%r15), %ecx
movl %ecx, (%rsp)
leaq 0x2abf64(%rip), %rcx    # 0x34621f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x128104
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x146fc0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x162f5d
movl %eax, %ebp
jmp 0x9a2f2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x162dee
movq %r12, %rdi
callq 0x162dee
movq %rbx, %rdi
callq 0x162dee
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x18504
callq 0x184cd
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x18e30e
movq %rax, %r12
movq (%rbx), %r13
movq %r14, %rdi
callq 0x18e309
leaq 0x2abec6(%rip), %rdi    # 0x346230
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x17070
testl %ebp, %ebp
jne 0x9a408
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
callq 0x18e313
testb %al, %al
je 0x9a3cb
testq %r12, %r12
je 0x9a403
decq %r12
leaq 0x10(%rsp), %r13
movq 0x41eb31(%rip), %rbx    # 0x4b8ed8
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x18e317
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x18e367
addq $-0x1, %r12
jb 0x9a3a7
jmp 0x9a403
testq %r12, %r12
je 0x9a403
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
movq 0x41eaf9(%rip), %rbx    # 0x4b8ed8
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x18e317
movq (%rbx), %rdi
movq %rbp, %rsi
callq 0x18e367
incq %r13
cmpq %r13, %r12
jne 0x9a3df
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_O3/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 0x9a4c5
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11c144
movq 0x28(%rbx), %rdi
callq 0x11c144
movq 0x30(%rbx), %rdi
callq 0x10a16a
movq 0x38(%rbx), %rdi
callq 0x10a16a
movq 0x40(%rbx), %rdi
callq 0x10a16a
movq 0x48(%rbx), %rdi
callq 0x10a16a
leaq 0x2abd9c(%rip), %rsi    # 0x346253
movq %rbx, %rdi
movl $0x2c, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a9d8
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
callq 0x10b00c
leaq 0x2abf0d(%rip), %rsi    # 0x3468d7
movq %rbx, %rdi
movl $0x35, %edx
popq %rbx
jmp 0x1045eb
retq