LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_enqueue
int QUEUE_enqueue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_full(pQ) == TRUE) {
		printf("Queue is full!\n");
		return QUEUE_FULL;
	}
	
	memcpy((char *)pQ->data + pQ->tail*pQ->itemSize,item,pQ->itemSize);
	pQ->tail++;
	pQ->tail %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1341
movq %rdi, %rbx
movl (%rdi), %eax
movslq 0x4(%rdi), %rdi
cmpl %edi, %eax
jne 0x1320
cmpl 0x10(%rbx), %eax
jne 0x1320
leaq 0xd4b(%rip), %rdi       # 0x205f
callq 0x1060
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x1367
movslq 0x14(%rbx), %rdx
imulq %rdx, %rdi
addq 0x8(%rbx), %rdi
callq 0x1040
movl 0x4(%rbx), %eax
incl %eax
cltd
idivl 0x10(%rbx)
movl %edx, 0x4(%rbx)
xorl %eax, %eax
jmp 0x1367
leaq 0xcc4(%rip), %rdi       # 0x200c
leaq 0xcd3(%rip), %rsi       # 0x2022
leaq 0xced(%rip), %rdx       # 0x2043
movl $0x36, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_dequeue
int QUEUE_dequeue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_empty(pQ) == TRUE) {
		return QUEUE_EMPTY;
	}

	memcpy(item,(char *)pQ->data + pQ->head*pQ->itemSize,pQ->itemSize);
	pQ->head++;
	pQ->head %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x13a4
movq %rdi, %rbx
movslq (%rdi), %rcx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl 0x4(%rdi), %ecx
je 0x13ca
movslq 0x14(%rbx), %rdx
imulq %rdx, %rcx
addq 0x8(%rbx), %rcx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x1040
movl (%rbx), %eax
incl %eax
cltd
idivl 0x10(%rbx)
movl %edx, (%rbx)
xorl %eax, %eax
jmp 0x13ca
leaq 0xc61(%rip), %rdi       # 0x200c
leaq 0xc70(%rip), %rsi       # 0x2022
leaq 0xc98(%rip), %rdx       # 0x2051
movl $0x46, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/init.c
// Function: gt_lib_clean
int gt_lib_clean(void)
{
  int fa_fptr_rval, fa_mmap_rval, gt_rval;
  if (spacepeak) {
    gt_ma_show_space_peak(stdout);
    gt_fa_show_space_peak(stdout);
    gt_spacepeak_show_space_peak(stdout);
    gt_ma_disable_global_spacepeak();
  }
  fa_fptr_rval = gt_fa_check_fptr_leak();
  fa_mmap_rval = gt_fa_check_mmap_leak();
  gt_fa_clean();
  gt_symbol_clean();
  gt_class_alloc_clean();
  gt_class_alloc_lock_clean();
  gt_ya_rand_clean();
  gt_log_clean();
  gt_spacepeak_clean();
  gt_combinatorics_clean();
  gt_rval = gt_ma_check_space_leak();
  gt_ma_clean();
#ifdef HAVE_MYSQL
  mysql_library_end();
#endif
  return fa_fptr_rval || fa_mmap_rval || gt_rval;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x11d6e7(%rip)    # 0x1529e1
jne 0x35320
movq 0x11bc55(%rip), %rbx    # 0x150f58
movq (%rbx), %rdi
callq 0x35d59
movq (%rbx), %rdi
callq 0x753e3
movq (%rbx), %rdi
callq 0x39ec7
callq 0x35d14
callq 0x752cc
movl %eax, %ebx
callq 0x75335
movl %eax, %ebp
callq 0x7542b
callq 0x3cda7
callq 0x722d5
callq 0x7235b
callq 0x3d56c
callq 0x35470
callq 0x39f0f
callq 0x724f8
callq 0x35da5
movl %eax, %r14d
callq 0x35f16
orl %ebx, %ebp
xorl %eax, %eax
orl %r14d, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_new
GtLogger* gt_logger_new(bool enabled, const char *prefix, FILE *target)
{
  GtLogger *l;
  gt_assert(target);
  l = (GtLogger*) gt_calloc((size_t) 1, sizeof (GtLogger));
  l->target = target;
  l->prefix = gt_cstr_dup(prefix);
  l->enabled = enabled;
  return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x354d3
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
leaq 0xabefd(%rip), %rdx     # 0xe1395
movl $0x1, %edi
movl $0x18, %esi
movl $0x24, %ecx
callq 0x359a6
movq %rax, %r12
movq %r15, (%rax)
movq %r14, %rdi
callq 0x728c0
movq %rax, 0x8(%r12)
movb %bl, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xbea1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_force
void gt_logger_log_force(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va_force(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x35580
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x355b4
testq %rsi, %rsi
je 0x355bc
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x355c1
addq $0xd8, %rsp
retq
callq 0xbfeb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va_force
void gt_logger_log_va_force(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x35612
movq %rsi, %r15
testq %rsi, %rsi
je 0x35618
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x35618
movq %rdx, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x355f2
callq 0xb730
movq (%rbx), %rsi
movq %rsi, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb820
movq (%rbx), %rsi
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xbc90
popq %rbx
popq %r14
popq %r15
retq
callq 0xc022
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log
void gt_logger_log(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x35673
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x356ad
cmpb $0x1, 0x10(%rdi)
jne 0x356ad
testq %rsi, %rsi
je 0x356b5
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x356ba
addq $0xd8, %rsp
retq
callq 0xc059
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va
void gt_logger_log_va(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x35711
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x35711
movq %rsi, %r15
testq %rsi, %rsi
je 0x35717
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x35717
movq %rdx, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x356f1
callq 0xb730
movq (%rbx), %rsi
movq %rsi, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb820
movq (%rbx), %rsi
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xbc90
popq %rbx
popq %r14
popq %r15
retq
callq 0xc090
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_init
void gt_ma_init(bool bookkeeping)
{
  gt_assert(!ma);
  ma = xcalloc(1, sizeof (MA), 0, __FILE__, __LINE__);
  gt_assert(!ma->bookkeeping);
  ma->allocated_pointer = gt_hashmap_new_no_ma(GT_HASH_DIRECT, NULL,
                                               (GtFree) ma_info_free);
  /* MA is ready to use */
  ma->bookkeeping = bookkeeping;
  bookkeeping_lock = gt_mutex_new();
  ma->global_space_peak = false;
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x11d28f(%rip)    # 0x1529f0
jne 0x357c6
movl %edi, %ebx
leaq 0xabd4b(%rip), %rcx     # 0xe14b7
movl $0x1, %edi
movl $0x28, %esi
xorl %edx, %edx
movl $0x6b, %r8d
callq 0x357d0
movq %rax, 0x11d266(%rip)    # 0x1529f0
cmpb $0x1, 0x8(%rax)
je 0x357cb
leaq 0xc6(%rip), %rdx        # 0x3585d
xorl %edi, %edi
xorl %esi, %esi
callq 0x77520
movq 0x11d249(%rip), %rcx    # 0x1529f0
movq %rax, (%rcx)
movb %bl, 0x8(%rcx)
callq 0x3cff6
movq %rax, 0x11d23f(%rip)    # 0x1529f8
movq 0x11d230(%rip), %rax    # 0x1529f0
movb $0x0, 0x9(%rax)
popq %rbx
retq
callq 0xc0c7
callq 0xc0fe
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: xcalloc
static void* xcalloc(size_t nmemb, size_t size, GtUword current_size,
                     const char *src_file, int src_line)
{
  void *p;
  if ((p = calloc(nmemb, size)) == NULL) {
    fprintf(stderr, "cannot calloc("GT_ZU", "GT_ZU") memory\n", nmemb, size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
           src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0xb410
testq %rax, %rax
je 0x35803
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11b7b6(%rip), %r13    # 0x150fc0
movq (%r13), %rdi
leaq 0xabe72(%rip), %rsi     # 0xe1687
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xb8d0
movq (%r13), %rdi
leaq 0xabcfa(%rip), %rsi     # 0xe1527
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8d0
testq %rbx, %rbx
je 0x35853
movq (%r13), %rdi
leaq 0xabe5e(%rip), %rsi     # 0xe16a7
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8d0
movl $0x1, %edi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_malloc_mem
void* gt_malloc_mem(size_t size, const char *src_file, int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xmalloc(size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xmalloc(size, ma->current_size, src_file, src_line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x11d180(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x35933
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rax)
jne 0x3591b
movq 0x11d166(%rip), %rdi    # 0x1529f8
callq 0x3d043
movq 0x11d152(%rip), %rax    # 0x1529f0
incq 0x10(%rax)
movq 0x18(%rax), %rsi
movl $0x18, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35938
movq %rax, %r15
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x11d127(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35938
movq %rax, %r14
movq 0x11d10c(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x77628
movq 0x11d0f7(%rip), %rdi    # 0x1529f0
movq %rbx, %rsi
callq 0x3596f
movq 0x11d0f0(%rip), %rdi    # 0x1529f8
callq 0x3d05e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35938
callq 0xc135
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: add_size
static void add_size(MA* ma, GtUword size)
{
  gt_assert(ma);
  ma->current_size += size;
  if (ma->global_space_peak)
    gt_spacepeak_add(size);
  if (ma->current_size > ma->max_size)
    ma->max_size = ma->current_size;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x359a1
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq %rsi, %rax
movq %rax, 0x18(%rdi)
cmpb $0x1, 0x9(%rdi)
jne 0x35995
movq %rsi, %rdi
callq 0x39e3a
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
jbe 0x3599f
movq %rax, 0x20(%rbx)
popq %rbx
retq
callq 0xc1cf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_calloc_mem
void* gt_calloc_mem(size_t nmemb, size_t size, const char *src_file,
                    int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = nmemb * size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xcalloc(nmemb, size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, nmemb * size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xcalloc(nmemb, size, ma->current_size, src_file, src_line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x11d038(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x35a98
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x1, 0x8(%rax)
jne 0x35a75
movq 0x11d01b(%rip), %rdi    # 0x1529f8
callq 0x3d043
movq 0x11d007(%rip), %rax    # 0x1529f0
incq 0x10(%rax)
movq 0x18(%rax), %rsi
movl $0x18, %edi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x35938
movq %rax, %r13
movq %r15, %rbp
imulq %r12, %rbp
movq %rbp, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x11cfd5(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
movl %ebx, %r8d
callq 0x357d0
movq %rax, %rbx
movq 0x11cfb6(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x77628
movq 0x11cfa1(%rip), %rdi    # 0x1529f0
movq %rbp, %rsi
callq 0x3596f
movq 0x11cf9a(%rip), %rdi    # 0x1529f8
callq 0x3d05e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x357d0
callq 0xc206
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_realloc_mem
void* gt_realloc_mem(void *ptr, size_t size, const char *src_file, int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    if (ptr) {
      mainfo = gt_hashmap_get(ma->allocated_pointer, ptr);
      gt_assert(mainfo);
      subtract_size(ma, mainfo->size);
      gt_hashmap_remove(ma->allocated_pointer, ptr);
    }
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xrealloc(ptr, size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xrealloc(ptr, size, ma->current_size, src_file, src_line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x11cf44(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x35bb7
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x1, 0x8(%rax)
jne 0x35b9d
movq 0x11cf27(%rip), %rdi    # 0x1529f8
callq 0x3d043
movq 0x11cf13(%rip), %rax    # 0x1529f0
incq 0x10(%rax)
testq %r15, %r15
je 0x35b22
movq (%rax), %rdi
movq %r15, %rsi
callq 0x775ed
testq %rax, %rax
je 0x35bbc
movq 0x11ceef(%rip), %rdi    # 0x1529f0
movq (%rax), %rsi
callq 0x35bc1
movq 0x11cee0(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %r15, %rsi
callq 0x77666
movq 0x11cece(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rsi
movl $0x18, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35938
movq %rax, %r12
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x11cea7(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
movl %ebp, %r8d
callq 0x35bef
movq %rax, %r14
movq 0x11ce88(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x77628
movq 0x11ce73(%rip), %rdi    # 0x1529f0
movq %rbx, %rsi
callq 0x3596f
movq 0x11ce6c(%rip), %rdi    # 0x1529f8
callq 0x3d05e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
movl %ebp, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x35bef
callq 0xc278
callq 0xc23f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: subtract_size
static void subtract_size(MA *ma, GtUword size)
{
  gt_assert(ma);
  gt_assert(ma->current_size >= size);
  ma->current_size -= size;
  if (ma->global_space_peak)
    gt_spacepeak_free(size);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x35be5
movq 0x18(%rdi), %rax
subq %rsi, %rax
jb 0x35bea
movq %rax, 0x18(%rdi)
cmpb $0x1, 0x9(%rdi)
jne 0x35be3
movq %rsi, %rdi
popq %rax
jmp 0x39e79
popq %rax
retq
callq 0xc2ea
callq 0xc2b1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_free_mem
void gt_free_mem(void *ptr, GT_UNUSED const char *src_file,
                 GT_UNUSED int src_line)
{
  MAInfo *mainfo;
  gt_assert(ma);
  if (ptr == NULL) return;
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
#ifndef NDEBUG
    if (!gt_hashmap_get(ma->allocated_pointer, ptr)) {
      fprintf(stderr, "bug: double free() attempted on line %d in file "
              "\"%s\"\n", src_line, src_file);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    mainfo = gt_hashmap_get(ma->allocated_pointer, ptr);
    gt_assert(mainfo);
    subtract_size(ma, mainfo->size);
    gt_hashmap_remove(ma->allocated_pointer, ptr);
    free(ptr);
    gt_mutex_unlock(bookkeeping_lock);
  }
  else {
    free(ptr);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x11cdbe(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x35cd2
movq %rdi, %rbx
testq %rdi, %rdi
je 0x35cc1
cmpb $0x1, 0x8(%rax)
jne 0x35cc6
movl %edx, %ebp
movq %rsi, %r14
movq 0x11cda3(%rip), %rdi    # 0x1529f8
callq 0x3d043
movq 0x11cd8f(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x35cd7
movq 0x11cd78(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x35ce1
movq 0x11cd61(%rip), %rdi    # 0x1529f0
movq (%rax), %rsi
callq 0x35bc1
movq 0x11cd52(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x77666
movq %rbx, %rdi
callq 0xb790
movq 0x11cd40(%rip), %rdi    # 0x1529f8
popq %rbx
popq %r14
popq %rbp
jmp 0x3d05e
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb790
callq 0xc3e3
movl %ebp, %edi
movq %r14, %rsi
callq 0xc3bd
callq 0xc384
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_show_space_peak
void gt_ma_show_space_peak(FILE *fp)
{
  gt_assert(ma);
  fprintf(fp, "# space peak in megabytes: %.2f (in "GT_LLU" events)\n",
          GT_MEGABYTES(ma->max_size),
          ma->mallocevents);
}

// Assembly:
movq 0x11cc90(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x35d9f
movsd 0x20(%rax), %xmm1
unpcklps 0xab70f(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xab717(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0xab713(%rip), %xmm0    # 0xe14a0
movq 0x10(%rax), %rdx
leaq 0xab832(%rip), %rsi     # 0xe15ca
movb $0x1, %al
jmp 0xb8d0
pushq %rax
callq 0xc500
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_check_space_leak
int gt_ma_check_space_leak(void)
{
  CheckSpaceLeakInfo info;
  GT_UNUSED int had_err;
  gt_assert(ma);
  gt_mutex_lock(bookkeeping_lock);
  info.has_leak = false;
  had_err = gt_hashmap_foreach(ma->allocated_pointer, check_space_leak, &info,
                               NULL);
  gt_assert(!had_err); /* cannot happen, check_space_leak() is sane */
  gt_mutex_unlock(bookkeeping_lock);
  if (info.has_leak)
    return -1;
  return 0;
}

// Assembly:
pushq %rax
cmpq $0x0, 0x11cc42(%rip)    # 0x1529f0
je 0x35df5
movq 0x11cc41(%rip), %rdi    # 0x1529f8
callq 0x3d043
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x11cc25(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
leaq 0x2a(%rip), %rsi        # 0x35dff
xorl %ecx, %ecx
callq 0x776d9
testl %eax, %eax
jne 0x35dfa
movq 0x11cc11(%rip), %rdi    # 0x1529f8
callq 0x3d05e
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
callq 0xc572
callq 0xc539
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: check_space_leak
static int check_space_leak(GT_UNUSED void *key, void *value, void *data,
                            GT_UNUSED GtError *err)
{
  CheckSpaceLeakInfo *info = (CheckSpaceLeakInfo*) data;
  MAInfo *mainfo = (MAInfo*) value;
  gt_error_check(err);
  gt_assert(key && value && data);
  /* report only the first leak */
  if (!info->has_leak) {
    fprintf(stderr, "bug: "GT_ZU" bytes memory leaked (allocated on line %d in "
            "file \"%s\")\n", mainfo->size, mainfo->src_line, mainfo->src_file);
    info->has_leak = true;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x35e1e
movq %rcx, %rdi
callq 0x34fea
testb %al, %al
jne 0x35e4c
testq %r15, %r15
je 0x35e47
testq %r14, %r14
je 0x35e47
testq %rbx, %rbx
je 0x35e47
cmpb $0x0, (%rbx)
je 0x35e3a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc61d
jmp 0x35e32
callq 0xc5e4
callq 0xc5ab
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_show_allocations
void gt_ma_show_allocations(FILE *outfp)
{
  GT_UNUSED int had_err;
  gt_assert(ma);
  gt_mutex_lock(bookkeeping_lock);
  had_err = gt_hashmap_foreach(ma->allocated_pointer, print_allocation,
                               outfp, NULL);
  gt_mutex_unlock(bookkeeping_lock);
  gt_assert(!had_err); /* cannot happen, print_allocation() is sane */
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x11cb80(%rip)    # 0x1529f0
je 0x35eb0
movq %rdi, %rbx
movq 0x11cb7c(%rip), %rdi    # 0x1529f8
callq 0x3d043
movq 0x11cb68(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
leaq 0x28(%rip), %rsi        # 0x35eba
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x776d9
movl %eax, %ebx
movq 0x11cb53(%rip), %rdi    # 0x1529f8
callq 0x3d05e
testl %ebx, %ebx
jne 0x35eb5
popq %rbx
retq
callq 0xc6bd
callq 0xc684
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: print_allocation
static int print_allocation(GT_UNUSED void *key, void *value,
                            void *data, GT_UNUSED GtError *err)
{
  MAInfo *mainfo = (MAInfo*) value;
  FILE *outfp = (FILE*) data;
  gt_error_check(err);
  gt_assert(outfp && key && value);
  fprintf(outfp, ""GT_ZU" bytes memory allocated on line %d in file \"%s\")\n",
          mainfo->size, mainfo->src_line, mainfo->src_file);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x35ed9
movq %rcx, %rdi
callq 0x34fea
testb %al, %al
jne 0x35f11
testq %r14, %r14
je 0x35f0c
testq %r15, %r15
je 0x35f0c
testq %rbx, %rbx
je 0x35f0c
movl 0x10(%r14), %ecx
movq (%r14), %rdx
movq 0x8(%r14), %r8
leaq 0xab8b7(%rip), %rsi     # 0xe17b1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb8d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xc72f
callq 0xc6f6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_clean
void gt_ma_clean(void)
{
  gt_assert(ma);
  gt_mutex_lock(bookkeeping_lock);
  ma->bookkeeping = false;
  gt_hashmap_delete(ma->allocated_pointer);
  gt_mutex_unlock(bookkeeping_lock);
  gt_mutex_delete(bookkeeping_lock);
  free(ma);
  ma = NULL;
}

// Assembly:
pushq %rax
cmpq $0x0, 0x11cad1(%rip)    # 0x1529f0
je 0x35f71
movq 0x11cad0(%rip), %rdi    # 0x1529f8
callq 0x3d043
movq 0x11cabc(%rip), %rax    # 0x1529f0
movb $0x0, 0x8(%rax)
movq (%rax), %rdi
callq 0x77bab
movq 0x11cab1(%rip), %rdi    # 0x1529f8
callq 0x3d05e
movq 0x11caa5(%rip), %rdi    # 0x1529f8
callq 0x3d021
movq 0x11ca91(%rip), %rdi    # 0x1529f0
callq 0xb790
movq $0x0, 0x11ca81(%rip) # 0x1529f0
popq %rax
retq
callq 0xc768
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_unit_test
int gt_ma_unit_test(GtError *err)
{
  int had_err;
  gt_error_check(err);
  had_err = gt_multithread(test_malloc, NULL, err);
  if (!had_err)
    had_err = gt_multithread(test_calloc, NULL, err);
  if (!had_err)
    had_err = gt_multithread(test_realloc, NULL, err);
  return had_err;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x35f8b
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x35fc9
leaq 0x3c(%rip), %rdi        # 0x35fce
xorl %esi, %esi
movq %rbx, %rdx
callq 0x361b4
testl %eax, %eax
jne 0x35fb5
leaq 0xbe(%rip), %rdi        # 0x36065
xorl %esi, %esi
movq %rbx, %rdx
callq 0x361b4
testl %eax, %eax
je 0x35fb7
popq %rbx
retq
leaq 0x143(%rip), %rdi       # 0x36101
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x361b4
callq 0xc7a1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: test_malloc
static void* test_malloc(GT_UNUSED void *data)
{
  GtArray *chunks;
  unsigned int i;
  void *mem;
  chunks = gt_array_new(sizeof (void*));
  for (i = 0; i < NUMBER_OF_ALLOCS; i++) {
    mem = gt_malloc(SIZE_OF_ALLOCS);
    gt_array_add(chunks, mem);
  }
  for (i = 0; i < NUMBER_OF_ALLOCS; i++) {
    mem = *(void**) gt_array_get(chunks, i);
    gt_free(mem);
  }
  gt_array_delete(chunks);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xab4c9(%rip), %r14     # 0xe14b7
movq %rsp, %r15
movl $0x40, %edi
movq %r14, %rsi
movl $0x162, %edx            # imm = 0x162
callq 0x35862
movq %rax, (%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f240
decl %ebp
jne 0x35ff1
xorl %r14d, %r14d
leaq 0xab492(%rip), %r15     # 0xe14b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x167, %edx            # imm = 0x167
callq 0x35c27
incq %r14
cmpq $0x186a0, %r14          # imm = 0x186A0
jne 0x36025
movq %rbx, %rdi
callq 0x6f768
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: test_calloc
static void* test_calloc(GT_UNUSED void *data)
{
  GtArray *chunks;
  unsigned int i;
  void *mem;
  chunks = gt_array_new(sizeof (void*));
  for (i = 0; i < NUMBER_OF_ALLOCS; i++) {
    mem = gt_calloc(1, SIZE_OF_ALLOCS);
    gt_array_add(chunks, mem);
  }
  for (i = 0; i < NUMBER_OF_ALLOCS; i++) {
    mem = *(void**) gt_array_get(chunks, i);
    gt_free(mem);
  }
  gt_array_delete(chunks);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xab432(%rip), %r14     # 0xe14b7
movq %rsp, %r15
movl $0x1, %edi
movl $0x40, %esi
movq %r14, %rdx
movl $0x174, %ecx            # imm = 0x174
callq 0x359a6
movq %rax, (%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f240
decl %ebp
jne 0x36088
xorl %r14d, %r14d
leaq 0xab3f6(%rip), %r15     # 0xe14b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x179, %edx            # imm = 0x179
callq 0x35c27
incq %r14
cmpq $0x186a0, %r14          # imm = 0x186A0
jne 0x360c1
movq %rbx, %rdi
callq 0x6f768
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/ma.c
// Function: test_realloc
static void* test_realloc(GT_UNUSED void *data)
{
  GtArray *chunks;
  unsigned int i;
  void *mem;
  chunks = gt_array_new(sizeof (void*));
  for (i = 0; i < NUMBER_OF_ALLOCS; i++) {
    mem = gt_realloc(NULL, SIZE_OF_ALLOCS / 2);
    mem = gt_realloc(mem, SIZE_OF_ALLOCS / 2);
    gt_array_add(chunks, mem);
  }
  for (i = 0; i < NUMBER_OF_ALLOCS; i++) {
    mem = *(void**) gt_array_get(chunks, i);
    gt_free(mem);
  }
  gt_array_delete(chunks);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xab396(%rip), %r14     # 0xe14b7
movq %rsp, %r15
movl $0x20, %esi
xorl %edi, %edi
movq %r14, %rdx
movl $0x186, %ecx            # imm = 0x186
callq 0x35a9d
movq %rax, (%rsp)
movl $0x20, %esi
movq %rax, %rdi
movq %r14, %rdx
movl $0x187, %ecx            # imm = 0x187
callq 0x35a9d
movq %rax, (%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f240
decl %ebp
jne 0x36124
xorl %r14d, %r14d
leaq 0xab344(%rip), %r15     # 0xe14b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x18c, %edx            # imm = 0x18C
callq 0x35c27
incq %r14
cmpq $0x186a0, %r14          # imm = 0x186A0
jne 0x36173
movq %rbx, %rdi
callq 0x6f768
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/multithread.c
// Function: gt_multithread
int gt_multithread(GtThreadFunc function, void *data, GtError *err)
{
  GtArray *threads;
  GtThread *thread;
  unsigned int i, j;

  gt_error_check(err);
  gt_assert(function);

  threads = gt_array_new(sizeof (GtThread*));

  /* start all other threads and store them */
  for (i = 1; i < gt_jobs; i++) {
    if (!(thread = gt_thread_new(function, data, err))) {
      for (j = 0; j < gt_array_size(threads); j++)
        gt_thread_delete(*(GtThread**) gt_array_get(threads, j));
      gt_array_delete(threads);
      return -1;
    }
    gt_array_add(threads, thread);
  }

  function(data); /* execute function in main thread, too */

  /* wait until all other threads are finished */
  for (i = 0; i < gt_array_size(threads); i++) {
    thread = *(GtThread**) gt_array_get(threads, i);
    gt_thread_join(thread);
    gt_thread_delete(thread);
  }
  gt_array_delete(threads);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x361dd
movq %r12, %rdi
callq 0x34fea
testb %al, %al
jne 0x362ec
testq %r14, %r14
je 0x362e7
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %rbx
leaq 0x11b4ea(%rip), %rbp    # 0x1516e4
cmpl $0x2, (%rbp)
jb 0x36236
movl $0x1, %r13d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3ce74
movq %rax, (%rsp)
testq %rax, %rax
je 0x3628d
movl $0x8, %edx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x6f240
incl %r13d
cmpl (%rbp), %r13d
jb 0x36206
movq %r15, %rdi
callq *%r14
movq %rbx, %rdi
callq 0x6f310
testq %rax, %rax
je 0x36288
movl $0x1, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %rdi, (%rsp)
callq 0x3cf13
movq (%rsp), %rdi
callq 0x3d079
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x6f310
incl %ebp
cmpq %r15, %rax
ja 0x36254
jmp 0x362cd
xorl %r14d, %r14d
jmp 0x362cd
movq %rbx, %rdi
callq 0x6f310
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x362cd
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x3d079
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x6f310
incl %ebp
cmpq %r15, %rax
ja 0x362a8
movq %rbx, %rdi
callq 0x6f768
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xc811
callq 0xc7da
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_parser_new
GtOptionParser* gt_option_parser_new(const char *synopsis,
                                     const char *one_liner)
{
  GtOptionParser *op;
  gt_assert(synopsis && one_liner);
  gt_assert("one_liner must have upper case letter at start and '.' at end" &&
            strlen(one_liner) && isupper((int) one_liner[0]));
  gt_assert(one_liner[strlen(one_liner)-1] == '.');
  op = gt_calloc(1, sizeof *op);
  op->synopsis = gt_cstr_dup(synopsis);
  op->one_liner = gt_cstr_dup(one_liner);
  op->options = gt_array_new(sizeof (GtOption*));
  op->min_additional_arguments = GT_UNDEF_UINT;
  op->max_additional_arguments = GT_UNDEF_UINT;
  op->optionindex = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x363be
movq %rsi, %rbx
testq %rsi, %rsi
je 0x363be
movq %rdi, %r14
movq %rbx, %rdi
callq 0xb260
testq %rax, %rax
je 0x363b9
movq %rax, %r15
callq 0xb6e0
movq (%rax), %rax
movsbq (%rbx), %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0x363b9
cmpb $0x2e, -0x1(%rbx,%r15)
jne 0x363c3
leaq 0xab5ad(%rip), %rdx     # 0xe1906
movl $0x1, %edi
movl $0x60, %esi
movl $0xdb, %ecx
callq 0x359a6
movq %rax, %r15
movq %r14, %rdi
callq 0x728c0
movq %rax, 0x8(%r15)
movq %rbx, %rdi
callq 0x728c0
movq %rax, 0x10(%r15)
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x18(%r15)
movq $-0x1, 0x50(%r15)
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7740c
movq %rax, 0x58(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xc8f3
callq 0xc881
callq 0xc8ba
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_parser_register_hook
void gt_option_parser_register_hook(GtOptionParser *op,
                                    GtOptionParserHookFunc hook,
                                    void *data)
{
  HookInfo hookinfo;
  gt_assert(op && hook);
  if (!op->hooks)
    op->hooks = gt_array_new(sizeof (HookInfo));
  hookinfo.hook = hook;
  hookinfo.data = data;
  gt_array_add(op->hooks, hookinfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x364c2
movq %rsi, %r14
testq %rsi, %rsi
je 0x364c2
movq %rdx, %rbx
movq %rdi, %r15
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x364a4
movl $0x10, %edi
callq 0x6ef7c
movq %rax, %rdi
movq %rax, 0x20(%r15)
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, 0x8(%rsi)
movl $0x10, %edx
callq 0x6f240
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xca49
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_parser_reset
void gt_option_parser_reset(GtOptionParser *op)
{
  GT_UNUSED int rval;
  gt_assert(op);
  rval = gt_hashmap_foreach(op->optionindex, reset_option, NULL, NULL);
  gt_assert(!rval); /* reset_option() is sane */
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x364e7
movq 0x58(%rdi), %rdi
leaq 0x19(%rip), %rsi        # 0x364f1
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x776d9
testl %eax, %eax
jne 0x364ec
popq %rax
retq
callq 0xcabb
callq 0xca82
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: add_common_options
static void add_common_options(GtOptionParser *op)
{
  bool has_extended_options;
  GtOption *option;
  gt_assert(op);
  has_extended_options = has_extended_option(op->options);
  option = gt_option_new_help(has_extended_options);
  gt_option_parser_add_option(op, option);
  if (has_extended_options) {
    option = gt_option_new_helpplus();
    gt_option_parser_add_option(op, option);
  }
  option = gt_option_new_helpdev();
  gt_option_parser_add_option(op, option);
  option = gt_option_new_version();
  gt_option_parser_add_option(op, option);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x36d6d
movq %rdi, %rbx
movq %r14, %rdi
callq 0x6f310
testq %rax, %rax
je 0x36ca0
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rax
cmpb $0x0, 0x4d(%rax)
jne 0x36cbd
incq %r15
movq %r14, %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x36c7c
leaq 0xab9b3(%rip), %rdi     # 0xe265a
leaq 0xab85a(%rip), %rsi     # 0xe2508
xorl %edx, %edx
callq 0x389d7
movl $0x4, (%rax)
jmp 0x36d02
leaq 0xab996(%rip), %rdi     # 0xe265a
leaq 0xab815(%rip), %rsi     # 0xe24e0
xorl %edx, %edx
callq 0x389d7
movl $0x4, (%rax)
movb $0x0, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xab830(%rip), %rdi     # 0xe251e
leaq 0xab82f(%rip), %rsi     # 0xe2524
xorl %edx, %edx
callq 0x389d7
movl $0x5, (%rax)
xorl %r14d, %r14d
movb %r14b, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xab82f(%rip), %rdi     # 0xe254a
leaq 0xab830(%rip), %rsi     # 0xe2552
xorl %edx, %edx
callq 0x389d7
movl $0x6, (%rax)
movb %r14b, 0x20(%rax)
movb $0x1, 0x4e(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xc1d00(%rip), %rdi     # 0xf8a49
leaq 0xab830(%rip), %rsi     # 0xe2580
xorl %edx, %edx
callq 0x389d7
movl $0xe, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x363c8
callq 0xcc26
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: print_toolname
static void print_toolname(const char *toolname, GtStr *outstr, bool upper) {
  GtUword i;
  for (i = 0; i < strlen(toolname); i++) {
    char c = toolname[i];
    if (c == ' ')
      gt_str_append_char(outstr, '-');
    else {
      if (upper)
        gt_str_append_char(outstr, toupper(c));
      else
        gt_str_append_char(outstr, c);
    }
  }
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x36dd7
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movsbq (%r15,%r12), %r13
cmpq $0x20, %r13
setne %cl
movl $0x2d, %eax
cmovnel %r13d, %eax
andb %bl, %cl
cmpb $0x1, %cl
jne 0x36db3
callq 0xb0b0
movq (%rax), %rax
movb (%rax,%r13,4), %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x3b9df
incq %r12
movq %r15, %rdi
callq 0xb260
cmpq %rax, %r12
jb 0x36d8b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: print_asciidoc_header
static void print_asciidoc_header(const char *hdr, GtStr *outstr) {
  GtUword i;
  gt_str_append_cstr(outstr, hdr);
  gt_str_append_char(outstr, '\n');
  for (i = 0; i < strlen(hdr); i++)
    gt_str_append_char(outstr, '-');
  gt_str_append_cstr(outstr, "\n\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3b7af
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3b9df
cmpb $0x0, (%r14)
je 0x36e21
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x3b9df
incq %r15
movq %r14, %rdi
callq 0xb260
cmpq %rax, %r15
jb 0x36e04
leaq 0xc09ea(%rip), %rsi     # 0xf7812
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3b7af
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: optional_arg
static bool optional_arg(GtOption *o, int argnum, int argc, const char **argv)
{
  gt_assert(o);
  if (o->argument_is_optional &&
      (argnum + 1 >= argc || argv[argnum + 1][0] == '-' ||
       !strcmp(argv[argnum + 1], "--"))) {
    return true;
  }
  return false;
}

// Assembly:
testq %rdi, %rdi
je 0x3818d
cmpb $0x1, 0x4f(%rdi)
jne 0x3818a
incl %esi
movb $0x1, %al
cmpl %edx, %esi
jge 0x3818c
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
cmpb $0x2d, (%rcx)
je 0x3818c
xorl %eax, %eax
retq
pushq %rax
callq 0xcf7d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: check_missing_argument_and_minus_sign
static int check_missing_argument_and_minus_sign(int argnum, int argc,
                                                 GtStr *option,
                                                 const char **argv,
                                                 GtError *err)
{
  gt_error_check(err);
  if (argnum + 1 >= argc || (argv[argnum+1][0] == '-'
                               && argv[argnum+1][1] != '\0')) {
    gt_error_set(err, "missing argument to option \"-%s\"", gt_str_get(option));
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %r12d
movl %edi, %ebp
testq %r8, %r8
je 0x381ba
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x381ff
incl %ebp
cmpl %r12d, %ebp
jge 0x381d5
movslq %ebp, %rax
movq (%r15,%rax,8), %rcx
xorl %eax, %eax
cmpb $0x2d, (%rcx)
jne 0x381f6
cmpb $0x0, 0x1(%rcx)
je 0x381f6
movq %r14, %rdi
callq 0x3bb5d
leaq 0xa9f13(%rip), %rsi     # 0xe20f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xcfb6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: check_missing_argument
static int check_missing_argument(int argnum, int argc, GtStr *option,
                                  GtError *err)
{
  gt_error_check(err);
  if (argnum + 1 >= argc) {
    gt_error_set(err, "missing argument to option \"-%s\"", gt_str_get(option));
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
testq %rcx, %rcx
je 0x38227
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x3825d
incl %r15d
xorl %eax, %eax
cmpl %ebp, %r15d
jl 0x38252
movq %r14, %rdi
callq 0x3bb5d
leaq 0xa9eb7(%rip), %rsi     # 0xe20f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xcfef
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_parser_delete
void gt_option_parser_delete(GtOptionParser *op)
{
  GtUword i;
  if (!op) return;
  gt_free(op->progname);
  gt_free(op->synopsis);
  gt_free(op->one_liner);
  for (i = 0; i < gt_array_size(op->options); i++)
    gt_option_delete(*(GtOption**) gt_array_get(op->options, i));
  gt_array_delete(op->options);
  gt_array_delete(op->hooks);
  gt_hashmap_delete(op->optionindex);
  gt_free(op);
}

// Assembly:
testq %rdi, %rdi
je 0x38871
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xa9130(%rip), %r14     # 0xe1906
movq %r14, %rsi
movl $0x5c9, %edx            # imm = 0x5C9
callq 0x35c27
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x5ca, %edx            # imm = 0x5CA
callq 0x35c27
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x5cb, %edx            # imm = 0x5CB
callq 0x35c27
movq 0x18(%rbx), %rdi
callq 0x6f310
testq %rax, %rax
je 0x3883b
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x38872
incq %r14
movq 0x18(%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x38816
movq 0x18(%rbx), %rdi
callq 0x6f768
movq 0x20(%rbx), %rdi
callq 0x6f768
movq 0x58(%rbx), %rdi
callq 0x77bab
leaq 0xa90a9(%rip), %rsi     # 0xe1906
movq %rbx, %rdi
movl $0x5d1, %edx            # imm = 0x5D1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_delete
void gt_option_delete(GtOption *o)
{
  GtUword i;
  if (!o) return;
  if (o->reference_count) {
    o->reference_count--;
    return;
  }
  gt_str_delete(o->option_str);
  gt_str_delete(o->description);
  for (i = 0; i < gt_array_size(o->implications); i++)
    gt_array_delete(*(GtArray**) gt_array_get(o->implications, i));
  gt_array_delete(o->implications);
  gt_array_delete(o->exclusions);
  gt_array_delete(o->mandatory_either_options);
  gt_free(o);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3888a
movq %rdi, %rbx
movl 0x68(%rdi), %eax
testl %eax, %eax
je 0x38892
decl %eax
movl %eax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
callq 0x3c87b
movq 0x10(%rbx), %rdi
callq 0x3c87b
movq 0x50(%rbx), %rdi
callq 0x6f310
testq %rax, %rax
je 0x388da
xorl %r14d, %r14d
movq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x6f768
incq %r14
movq 0x50(%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x388b5
movq 0x50(%rbx), %rdi
callq 0x6f768
movq 0x58(%rbx), %rdi
callq 0x6f768
movq 0x60(%rbx), %rdi
callq 0x6f768
leaq 0xa900a(%rip), %rsi     # 0xe1906
movq %rbx, %rdi
movl $0x7c1, %edx            # imm = 0x7C1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_debug
GtOption* gt_option_new_debug(bool *value)
{
  GtOption *o = gt_option_new_bool("debug", "enable debugging output", value,
                                   false);
  o->is_development_option = true;
  return o;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa9874(%rip), %rdi     # 0xe218f
leaq 0xa9873(%rip), %rsi     # 0xe2195
movq %rbx, %rdx
callq 0x389d7
movl $0x0, (%rax)
xorl %ecx, %ecx
movb %cl, 0x20(%rax)
movb %cl, (%rbx)
movb $0x1, 0x4e(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_bool
GtOption* gt_option_new_bool(const char *option_str, const char *description,
                             bool *value, bool default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_BOOL;
  o->default_value.b = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x389d7
movl $0x0, (%rax)
movb %bl, 0x20(%rax)
movb %bl, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uword
GtOption* gt_option_new_uword(const char *option_str, const char *description,
                              GtUword *value, GtUword default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_ULONG;
  o->default_value.ul = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
callq 0x389d7
movl $0xa, (%rax)
movq %rbx, 0x20(%rax)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/option.c
// Function: gt_option_new
static GtOption *gt_option_new(const char *option_str, const char *description,
                               void *value)
{
  GtOption *o = gt_calloc(1, sizeof (GtOption));
  gt_assert(option_str && strlen(option_str));
  gt_assert("an option string should not start with '-', this is added "
            "automatically"  && option_str[0] != '-');
  o->option_str = gt_str_new_cstr(option_str);
  o->description = gt_str_new_cstr(description);
  o->value = value;
  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0xa8f17(%rip), %rdx     # 0xe1906
movl $0x1, %edi
movl $0x70, %esi
movl $0x7d, %ecx
callq 0x359a6
testq %r12, %r12
je 0x38a44
movq %rax, %r15
movzbl (%r12), %eax
cmpl $0x2d, %eax
je 0x38a49
testl %eax, %eax
je 0x38a44
movq %r12, %rdi
callq 0x3b785
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x3b785
movq %rax, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xd17e
callq 0xd145