LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x17394
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x17392
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x18(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x23e0
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x20(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
movl 0x18(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x17378
movq 0x8(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1735e
jmp 0x17378
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x17342
movq 0x10(%rsp), %rdi
callq 0x2190
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x172dd
jmp 0x173da
movq 0x20(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x173cd
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x23e0
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x2190
jmp 0x173d8
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x173da
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rdi
callq *%rax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %ecx
movl 0x18(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x178dc
movq 0x30(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
jmp 0x17907
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x17905
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x18(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x17907
cmpq $0x0, 0x10(%rsp)
je 0x17919
movq 0x10(%rsp), %rdi
callq 0x23e0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x30(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
movl 0x18(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17965
movl $0xfffffffd, 0x1c(%rsp) # imm = 0xFFFFFFFD
jmp 0x179e1
jmp 0x17967
movq 0x8(%rsp), %rdi
addq $0x9, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x2100
cmpl $0x0, %eax
jne 0x179c4
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
je 0x179ba
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x9, %rsi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
addq %rax, %rsi
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x21b0
movl $0x0, 0x1c(%rsp)
jmp 0x179e1
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17967
movl $0xfffffffd, 0x1c(%rsp) # imm = 0xFFFFFFFD
cmpq $0x0, 0x10(%rsp)
je 0x179f3
movq 0x10(%rsp), %rdi
callq 0x2190
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rdi
callq *%rax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %ecx
movl 0x10(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x17a71
movq 0x30(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
jmp 0x17a9c
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x17a9a
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x10(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x17a9c
cmpq $0x0, 0x8(%rsp)
je 0x17aae
movq 0x8(%rsp), %rdi
callq 0x23e0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x30(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
movl 0x10(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x17af8
movl $0xfffffffd, 0x14(%rsp) # imm = 0xFFFFFFFD
jmp 0x17b5a
jmp 0x17afa
movq (%rsp), %rdi
addq $0x9, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x2100
cmpl $0x0, %eax
jne 0x17b40
movq (%rsp), %rcx
addq $0x9, %rcx
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x14(%rsp)
jmp 0x17b5a
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x17afa
movl $0xfffffffd, 0x14(%rsp) # imm = 0xFFFFFFFD
cmpq $0x0, 0x8(%rsp)
je 0x17b90
cmpl $0x0, 0x14(%rsp)
jne 0x17b78
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x17b8e
movq 0x8(%rsp), %rdi
callq 0x2190
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
jmp 0x17ba6
cmpq $0x0, 0x18(%rsp)
je 0x17ba4
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
jmp 0x17ba6
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x185e6
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x185b2
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x185b0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22c0
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x18585
jmp 0x185b2
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x30(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1855f
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x18604
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x22b0
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1865e
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x18650
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movl 0xc(%rsp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x22b0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1861c
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x22c0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x22c0
movq 0x30(%rsp), %rdi
callq 0x22c0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1a66c
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1a634
jmp 0x1a66c
movq 0x621965(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4fb9ce(%rip), %rsi    # 0x516013
leaq 0x4fbb73(%rip), %rdx    # 0x5161bf
leaq 0x4fbb8a(%rip), %rcx    # 0x5161dd
leaq 0x4fbaeb(%rip), %r8     # 0x516145
movl $0xef, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a66e
jmp 0x1a670
cmpq $0x0, 0x30(%rsp)
jne 0x1a6b0
movq 0x621921(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4fb98a(%rip), %rsi    # 0x516013
leaq 0x4fbb57(%rip), %rdx    # 0x5161e7
leaq 0x4fbb46(%rip), %rcx    # 0x5161dd
leaq 0x4fbaa7(%rip), %r8     # 0x516145
movl $0xf0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6b2
movq 0x30(%rsp), %rdi
callq 0x1a700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r9
leaq 0x10c050(%rip), %r8     # 0x126730
callq 0xf2ab0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf5cf0
movl 0x4(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1aad4
movq 0x6214fd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4fb566(%rip), %rsi    # 0x516013
leaq 0x4fb733(%rip), %rdx    # 0x5161e7
leaq 0x4fb730(%rip), %rcx    # 0x5161eb
leaq 0x4fb683(%rip), %r8     # 0x516145
movl $0xfa, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1aad6
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x123de0
callq 0x1beb0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xe1770
callq 0x1cc30
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtr.c
// Function: enable_logging
static void enable_logging(const char *debugfp, FILE **logfp)
{
  gt_log_enable();
  if (!strcmp(debugfp, "stdout"))
    gt_log_set_fp(stdout);
  else if (!strcmp(debugfp, "stderr"))
    gt_log_set_fp(stderr);
  else {
    *logfp = gt_fa_xfopen(debugfp, "w");
    gt_log_set_fp(*logfp);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0xe7710
movq 0x10(%rsp), %rdi
leaq 0x576d0c(%rip), %rsi    # 0x5920cb
callq 0x19980
cmpl $0x0, %eax
jne 0x1b3da
movq 0x620b68(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
callq 0xe7840
jmp 0x1b438
movq 0x10(%rsp), %rdi
leaq 0x4fb105(%rip), %rsi    # 0x5164eb
callq 0x19980
cmpl $0x0, %eax
jne 0x1b401
movq 0x620ba9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
callq 0xe7840
jmp 0x1b436
movq 0x10(%rsp), %rdi
leaq 0x54aab8(%rip), %rsi    # 0x565ec5
leaq 0x4fad31(%rip), %rdx    # 0x516145
movl $0x1a7, %ecx            # imm = 0x1A7
callq 0xd91d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xe7840
jmp 0x1b438
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1bb81
jmp 0x1bc16
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0xd9390
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x123de0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xe1770
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1bbf4
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x339e40
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x330d10
movq (%rsp), %rdi
leaq 0x4fa539(%rip), %rsi    # 0x516145
movl $0x224, %edx            # imm = 0x224
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1239a0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1bc69
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x181ce0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/interactive.c
// Function: dotty
static void dotty(lua_State *L) {
  int status;
  while ((status = loadline(L)) != -1) {
    if (status == 0) status = docall(L, 0, 0);
    report(L, status);
    if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
      lua_getglobal(L, "print");
      lua_insert(L, 1);
      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0) {
        fprintf(stderr, "%s\n", lua_pushfstring(L,
                               "error calling " LUA_QL("print") " (%s)",
                               lua_tostring(L, -1)));
        fflush(stderr);
      }
    }
  }
  lua_settop(L, 0);  /* clear stack */
  fputs("\n", stdout);
  fflush(stdout);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1d5d0
movl %eax, 0x1c(%rsp)
cmpl $-0x1, %eax
je 0x1d592
cmpl $0x0, 0x1c(%rsp)
jne 0x1d4a9
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1d6d0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x1d790
cmpl $0x0, 0x1c(%rsp)
jne 0x1d58d
movq 0x20(%rsp), %rdi
callq 0x333eb0
cmpl $0x0, %eax
jle 0x1d58d
movq 0x20(%rsp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x511c62(%rip), %rdx    # 0x52f148
callq 0x336410
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3341a0
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x333eb0
movq 0x10(%rsp), %rdi
movl %eax, %esi
subl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3375c0
cmpl $0x0, %eax
je 0x1d58b
movq 0x61ea73(%rip), %rax    # 0x63bfa0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x4f999f(%rip), %rsi    # 0x516efe
movb $0x0, %al
callq 0x335df0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x509977(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0x199f0
movq 0x61ea1d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
callq 0x19840
jmp 0x1d58d
jmp 0x1d479
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x333ed0
movq 0x61e993(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
leaq 0x575cc4(%rip), %rdi    # 0x593273
callq 0x19810
movq 0x61e97d(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
callq 0x19840
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/interactive.c
// Function: loadline
static int loadline(lua_State *L) {
  int status;
  lua_settop(L, 0);
  if (!pushline(L, true))
    return -1;  /* no input */
  for (;;) {  /* repeat until gets a complete line */
    status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
    if (!incomplete(L, status)) break;  /* cannot try to add lines? */
    if (!pushline(L, false))  /* no more input? */
      return -1;
    lua_pushliteral(L, "\n");  /* add a new line... */
    lua_insert(L, -2);  /* ...between the two lines */
    lua_concat(L, 3);  /* join them */
  }
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x333ed0
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x1d830
cmpl $0x0, %eax
jne 0x1d606
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1d6c5
jmp 0x1d608
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x3350d0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x4f98ce(%rip), %rcx    # 0x516f19
callq 0x33ba40
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1d980
cmpl $0x0, %eax
jne 0x1d669
jmp 0x1d6bd
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1d830
cmpl $0x0, %eax
jne 0x1d684
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1d6c5
movq 0x18(%rsp), %rdi
leaq 0x575be3(%rip), %rsi    # 0x593273
movl $0x1, %edx
callq 0x335540
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x3341a0
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x338280
jmp 0x1d608
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/interactive.c
// Function: report
static int report(lua_State *L, int status) {
  if (status && !lua_isnil(L, -1)) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "(error object is not a string)";
    fprintf(stderr, "%s\n", msg);
    fflush(stderr);
    lua_pop(L, 1);
  }
  return status;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1d81b
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
cmpl $0x0, %eax
je 0x1d81b
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1d7e1
leaq 0x4f977d(%rip), %rax    # 0x516f5a
movq %rax, (%rsp)
movq 0x61e7b8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x5096f6(%rip), %rsi    # 0x526eec
movb $0x0, %al
callq 0x199f0
movq 0x61e79c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
callq 0x19840
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2038, %rsp           # imm = 0x2038
movb %sil, %al
movq %rdi, 0x2028(%rsp)
andb $0x1, %al
movb %al, 0x2027(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x2028(%rsp), %rdi
movb 0x2027(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1da10
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x61e6af(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
callq 0x19810
movq 0x61e6a0(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
callq 0x19840
movq 0x18(%rsp), %rdi
movq 0x61e6b4(%rip), %rax    # 0x63bf60
movq (%rax), %rdx
movl $0x2000, %esi           # imm = 0x2000
callq 0x19b60
cmpq $0x0, %rax
jne 0x1d8cf
movl $0x0, 0x2034(%rsp)
jmp 0x1d964
movq 0x18(%rsp), %rdi
callq 0x192b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x1d90f
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1d90f
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
testb $0x1, 0x2027(%rsp)
je 0x1d947
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x1d947
movq 0x2028(%rsp), %rdi
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
leaq 0x4f95e2(%rip), %rsi    # 0x516f20
movb $0x0, %al
callq 0x335df0
jmp 0x1d959
movq 0x2028(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x335740
movl $0x1, 0x2034(%rsp)
movl 0x2034(%rsp), %eax
addq $0x2038, %rsp           # imm = 0x2038
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/interactive.c
// Function: incomplete
static int incomplete(lua_State *L, int status) {
  if (status == LUA_ERRSYNTAX) {
    size_t lmsg;
    const char *msg = lua_tolstring(L, -1, &lmsg);
    const char *tp = msg + lmsg - (sizeof (LUA_QL("<eof>")) - 1);
    if (strstr(msg, LUA_QL("<eof>")) == tp) {
      lua_pop(L, 1);
      return 1;
    }
  }
  return 0;  /* else... */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
cmpl $0x3, 0x24(%rsp)
jne 0x1d9f3
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %rdx
callq 0x334f50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq 0x18(%rsp), %rax
addq $-0x7, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4f9573(%rip), %rsi    # 0x516f3f
callq 0x19130
cmpq 0x8(%rsp), %rax
jne 0x1d9f1
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
movl $0x1, 0x34(%rsp)
jmp 0x1d9fb
jmp 0x1d9f3
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/interactive.c
// Function: get_prompt
static const char* get_prompt(lua_State *L, bool firstline) {
  const char *p;
  lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
  p = lua_tostring(L, -1);
  if (p == NULL) p = (firstline ? "> " : ">> ");
  lua_pop(L, 1);  /* remove global */
  return p;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %cl
leaq 0x4f9500(%rip), %rdx    # 0x516f32
leaq 0x4f94f1(%rip), %rax    # 0x516f2a
testb $0x1, %cl
cmovneq %rax, %rdx
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x336410
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x334f50
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1da85
movb 0xf(%rsp), %dl
leaq 0x4f94c8(%rip), %rax    # 0x516f3b
leaq 0x565858(%rip), %rcx    # 0x5832d2
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x4f948d(%rip), %rdx    # 0x516f47
callq 0x336410
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
cmpl $0x5, %eax
je 0x1daec
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x333ed0
movl $0x1, 0x14(%rsp)
jmp 0x1db69
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x593905(%rip), %rdx    # 0x5b1402
callq 0x336410
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3345d0
cmpl $0x6, %eax
je 0x1db2f
movq 0x8(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x333ed0
movl $0x1, 0x14(%rsp)
jmp 0x1db69
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x334560
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3354f0
movq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x337460
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x28, %esi
leaq 0x4f9337(%rip), %rdx    # 0x516f79
movl $0x25, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1dcbd
jmp 0x1dd18
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4f926b(%rip), %rsi    # 0x516f79
movl $0x36, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x4f925a(%rip), %rdi    # 0x516f94
leaq 0x4f925e(%rip), %rsi    # 0x516f9f
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0x53286d(%rip), %rdi    # 0x5505c7
leaq 0x4f9265(%rip), %rsi    # 0x516fc6
leaq 0x4f927e(%rip), %rcx    # 0x516fe6
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x4f9261(%rip), %rdi    # 0x516ff2
leaq 0x4f9264(%rip), %rsi    # 0x516ffc
leaq 0x4f9283(%rip), %rcx    # 0x517022
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x4f926c(%rip), %rdi    # 0x517034
leaq 0x4f926f(%rip), %rsi    # 0x51703e
leaq 0x4f9286(%rip), %rcx    # 0x51705c
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x20, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf29e0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x1deb7
movq 0x40(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1de7f
jmp 0x1deb7
movq 0x61e11a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4f8183(%rip), %rsi    # 0x516013
leaq 0x4f8328(%rip), %rdx    # 0x5161bf
leaq 0x4f91c8(%rip), %rcx    # 0x517066
leaq 0x4f90d4(%rip), %r8     # 0x516f79
movl $0x5f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1deb9
movq 0x58(%rsp), %rax
movslq 0x54(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x134680
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x134710
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11dee0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x134780
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11dee0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x1347f0
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x176d50
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1b1cb0
movq 0x38(%rsp), %rdi
callq 0x1b1cb0
movl 0x24(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x20, %esi
leaq 0x4f90aa(%rip), %rdx    # 0x51707c
movl $0x2d, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x1d43b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1e02d
jmp 0x1e06d
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1d4420
movq 0x8(%rsp), %rdi
leaq 0x4f9019(%rip), %rsi    # 0x51707c
movl $0x3a, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
callq 0x209260
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x209250
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x4f8d6e(%rip), %rdi    # 0x517248
movb $0x0, %al
callq 0x19070
testb $0x1, 0x77(%rsp)
jne 0x1e5a7
movq 0x58(%rsp), %rdi
callq 0x209270
testb $0x1, %al
jne 0x1e4fc
jmp 0x1e551
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jbe 0x1e54f
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
subq $0x1, %rcx
leaq 0x18(%rsp), %rdi
callq 0x209280
movq 0x61da06(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x209390
movq 0x50(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x1e506
jmp 0x1e5a5
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x1e5a3
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
leaq 0x18(%rsp), %rdi
callq 0x209280
movq 0x61d9b2(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x209390
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x1e55a
jmp 0x1e5a5
jmp 0x1e5a7
movq 0x40(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1e65d
jmp 0x1e6d5
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rdi
leaq 0x4f8ba0(%rip), %rsi    # 0x51726b
movl $0x2c, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1ef8d
jmp 0x1efbf
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4f893a(%rip), %rsi    # 0x5178ef
movl $0x35, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1f023
movq 0x61cfae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4f7017(%rip), %rsi    # 0x516013
leaq 0x55bb5c(%rip), %rdx    # 0x57ab5f
leaq 0x4f88fd(%rip), %rcx    # 0x517907
leaq 0x4f88de(%rip), %r8     # 0x5178ef
movl $0x3d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1f025
leaq 0x4f88f9(%rip), %rdi    # 0x517925
leaq 0x4f8918(%rip), %rsi    # 0x51794b
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x55c0c1(%rip), %rdi    # 0x57b10a
leaq 0x4f8937(%rip), %rsi    # 0x517987
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
callq 0xf5f90
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
leaq 0x162c2b(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0xf2a40
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq $0x0, (%rsp)
je 0x1f348
movq (%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1f310
jmp 0x1f348
movq 0x61cc89(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4f6cf2(%rip), %rsi    # 0x516013
leaq 0x4f6e97(%rip), %rdx    # 0x5161bf
leaq 0x4f86df(%rip), %rcx    # 0x517a0e
leaq 0x4f86e8(%rip), %r8     # 0x517a1e
movl $0x46, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1f34a
leaq 0x4f86e2(%rip), %rdi    # 0x517a33
callq 0x1f3a0
leaq 0x4f86db(%rip), %rdi    # 0x517a38
callq 0x1f3a0
leaq 0x4f86d4(%rip), %rdi    # 0x517a3d
callq 0x1f3a0
leaq 0x4f86cd(%rip), %rdi    # 0x517a42
callq 0x1f3a0
leaq 0x4f86c6(%rip), %rdi    # 0x517a47
callq 0x1f3a0
leaq 0x4f86bf(%rip), %rdi    # 0x517a4c
callq 0x1f3a0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x4f86a1(%rip), %rdi    # 0x517a51
callq 0x11d510
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x11d550
movq 0x50(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
movl $0x10, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8(%rsp), %rcx
callq 0x127520
cmpq $0x0, 0x8(%rsp)
je 0x1f450
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x11dee0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x19980
cmpl $0x0, %eax
je 0x1f44e
jmp 0x1f424
movq 0x58(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1f44c
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0x127980
movq 0x58(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x58(%rsp)
jmp 0x1f424
jmp 0x1f44e
jmp 0x1f450
leaq 0x8(%rsp), %rdi
callq 0x194c0
movq 0x50(%rsp), %rdi
callq 0x11f560
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
callq 0x1235b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
callq 0x21050
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x4f856c(%rip), %rsi    # 0x517aa6
callq 0x1235f0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x21980
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f8555(%rip), %rsi    # 0x517ab2
callq 0x1235f0
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x1f8e0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f8537(%rip), %rsi    # 0x517ab7
callq 0x1235f0
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x205c0
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f8512(%rip), %rsi    # 0x517ab5
callq 0x1235f0
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)