LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x11c9bf(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x36111
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x1, 0x8(%rax)
jne 0x360ee
movq 0x11c9a2(%rip), %rdi    # 0x1529f8
callq 0x3d9b7
movq 0x11c98e(%rip), %rax    # 0x1529f0
incq 0x10(%rax)
movq 0x18(%rax), %rsi
movl $0x18, %edi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x35fb8
movq %rax, %r13
movq %r15, %rbp
imulq %r12, %rbp
movq %rbp, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x11c95c(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
movl %ebx, %r8d
callq 0x35e50
movq %rax, %rbx
movq 0x11c93d(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x77144
movq 0x11c928(%rip), %rdi    # 0x1529f0
movq %rbp, %rsi
callq 0x35fef
movq 0x11c921(%rip), %rdi    # 0x1529f8
callq 0x3d9d2
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 0x35e50
callq 0xc206
// File: /workspace/github_c_makefile_star2_O1/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 0x11c8cb(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x36230
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x1, 0x8(%rax)
jne 0x36216
movq 0x11c8ae(%rip), %rdi    # 0x1529f8
callq 0x3d9b7
movq 0x11c89a(%rip), %rax    # 0x1529f0
incq 0x10(%rax)
testq %r15, %r15
je 0x36194
movq (%rax), %rdi
movq %r15, %rsi
callq 0x77109
testq %rax, %rax
je 0x36235
movq 0x11c876(%rip), %rdi    # 0x1529f0
movq (%rax), %rsi
callq 0x3623a
movq 0x11c867(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %r15, %rsi
callq 0x77182
movq 0x11c855(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rsi
movl $0x18, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35fb8
movq %rax, %r12
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x11c82e(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
movl %ebp, %r8d
callq 0x36268
movq %rax, %r14
movq 0x11c80f(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x77144
movq 0x11c7fa(%rip), %rdi    # 0x1529f0
movq %rbx, %rsi
callq 0x35fef
movq 0x11c7f3(%rip), %rdi    # 0x1529f8
callq 0x3d9d2
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 0x36268
callq 0xc278
callq 0xc23f
// File: /workspace/github_c_makefile_star2_O1/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 0x3625e
movq 0x18(%rdi), %rax
subq %rsi, %rax
jb 0x36263
movq %rax, 0x18(%rdi)
cmpb $0x1, 0x9(%rdi)
jne 0x3625c
movq %rsi, %rdi
popq %rax
jmp 0x3a6d9
popq %rax
retq
callq 0xc2ea
callq 0xc2b1
// File: /workspace/github_c_makefile_star2_O1/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 0x11c745(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x3634b
movq %rdi, %rbx
testq %rdi, %rdi
je 0x3633a
cmpb $0x1, 0x8(%rax)
jne 0x3633f
movl %edx, %ebp
movq %rsi, %r14
movq 0x11c72a(%rip), %rdi    # 0x1529f8
callq 0x3d9b7
movq 0x11c716(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x36350
movq 0x11c6ff(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x3635a
movq 0x11c6e8(%rip), %rdi    # 0x1529f0
movq (%rax), %rsi
callq 0x3623a
movq 0x11c6d9(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x77182
movq %rbx, %rdi
callq 0xb790
movq 0x11c6c7(%rip), %rdi    # 0x1529f8
popq %rbx
popq %r14
popq %rbp
jmp 0x3d9d2
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_O1/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 0x11c617(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x36418
movsd 0x20(%rax), %xmm1
unpcklps 0xab096(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xab09e(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0xab09a(%rip), %xmm0    # 0xe14a0
movq 0x10(%rax), %rdx
leaq 0xab1b9(%rip), %rsi     # 0xe15ca
movb $0x1, %al
jmp 0xb8d0
pushq %rax
callq 0xc500
// File: /workspace/github_c_makefile_star2_O1/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, 0x11c5c9(%rip)    # 0x1529f0
je 0x3646e
movq 0x11c5c8(%rip), %rdi    # 0x1529f8
callq 0x3d9b7
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x11c5ac(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
leaq 0x2a(%rip), %rsi        # 0x36478
xorl %ecx, %ecx
callq 0x771f5
testl %eax, %eax
jne 0x36473
movq 0x11c598(%rip), %rdi    # 0x1529f8
callq 0x3d9d2
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
callq 0xc572
callq 0xc539
// File: /workspace/github_c_makefile_star2_O1/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 0x36497
movq %rcx, %rdi
callq 0x3566a
testb %al, %al
jne 0x364c5
testq %r15, %r15
je 0x364c0
testq %r14, %r14
je 0x364c0
testq %rbx, %rbx
je 0x364c0
cmpb $0x0, (%rbx)
je 0x364b3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc61d
jmp 0x364ab
callq 0xc5e4
callq 0xc5ab
// File: /workspace/github_c_makefile_star2_O1/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, 0x11c507(%rip)    # 0x1529f0
je 0x36529
movq %rdi, %rbx
movq 0x11c503(%rip), %rdi    # 0x1529f8
callq 0x3d9b7
movq 0x11c4ef(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
leaq 0x28(%rip), %rsi        # 0x36533
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x771f5
movl %eax, %ebx
movq 0x11c4da(%rip), %rdi    # 0x1529f8
callq 0x3d9d2
testl %ebx, %ebx
jne 0x3652e
popq %rbx
retq
callq 0xc6bd
callq 0xc684
// File: /workspace/github_c_makefile_star2_O1/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 0x36552
movq %rcx, %rdi
callq 0x3566a
testb %al, %al
jne 0x3658a
testq %r14, %r14
je 0x36585
testq %r15, %r15
je 0x36585
testq %rbx, %rbx
je 0x36585
movl 0x10(%r14), %ecx
movq (%r14), %rdx
movq 0x8(%r14), %r8
leaq 0xab23e(%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_O1/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, 0x11c458(%rip)    # 0x1529f0
je 0x365ea
movq 0x11c457(%rip), %rdi    # 0x1529f8
callq 0x3d9b7
movq 0x11c443(%rip), %rax    # 0x1529f0
movb $0x0, 0x8(%rax)
movq (%rax), %rdi
callq 0x77675
movq 0x11c438(%rip), %rdi    # 0x1529f8
callq 0x3d9d2
movq 0x11c42c(%rip), %rdi    # 0x1529f8
callq 0x3d995
movq 0x11c418(%rip), %rdi    # 0x1529f0
callq 0xb790
movq $0x0, 0x11c408(%rip) # 0x1529f0
popq %rax
retq
callq 0xc768
// File: /workspace/github_c_makefile_star2_O1/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 0x36604
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x36642
leaq 0x3c(%rip), %rdi        # 0x36647
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3682c
testl %eax, %eax
jne 0x3662a
leaq 0xbe(%rip), %rdi        # 0x366de
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3682c
testl %eax, %eax
je 0x36630
popq %rbx
retq
leaq 0x143(%rip), %rdi       # 0x3677a
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x3682c
callq 0xc7a1
// File: /workspace/github_c_makefile_star2_O1/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 0x6e93c
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xaae50(%rip), %r14     # 0xe14b7
movq %rsp, %r15
movl $0x40, %edi
movq %r14, %rsi
movl $0x162, %edx            # imm = 0x162
callq 0x35ee2
movq %rax, (%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ec0e
decl %ebp
jne 0x3666a
xorl %r14d, %r14d
leaq 0xaae19(%rip), %r15     # 0xe14b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x167, %edx            # imm = 0x167
callq 0x362a0
incq %r14
cmpq $0x186a0, %r14          # imm = 0x186A0
jne 0x3669e
movq %rbx, %rdi
callq 0x6f134
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6e93c
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xaadb9(%rip), %r14     # 0xe14b7
movq %rsp, %r15
movl $0x1, %edi
movl $0x40, %esi
movq %r14, %rdx
movl $0x174, %ecx            # imm = 0x174
callq 0x3601f
movq %rax, (%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ec0e
decl %ebp
jne 0x36701
xorl %r14d, %r14d
leaq 0xaad7d(%rip), %r15     # 0xe14b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x179, %edx            # imm = 0x179
callq 0x362a0
incq %r14
cmpq $0x186a0, %r14          # imm = 0x186A0
jne 0x3673a
movq %rbx, %rdi
callq 0x6f134
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6e93c
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xaad1d(%rip), %r14     # 0xe14b7
movq %rsp, %r15
movl $0x20, %esi
xorl %edi, %edi
movq %r14, %rdx
movl $0x186, %ecx            # imm = 0x186
callq 0x36116
movq %rax, (%rsp)
movl $0x20, %esi
movq %rax, %rdi
movq %r14, %rdx
movl $0x187, %ecx            # imm = 0x187
callq 0x36116
movq %rax, (%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ec0e
decl %ebp
jne 0x3679d
xorl %r14d, %r14d
leaq 0xaaccb(%rip), %r15     # 0xe14b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x18c, %edx            # imm = 0x18C
callq 0x362a0
incq %r14
cmpq $0x186a0, %r14          # imm = 0x186A0
jne 0x367ec
movq %rbx, %rdi
callq 0x6f134
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x36855
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0x36964
testq %r14, %r14
je 0x3695f
movl $0x8, %edi
callq 0x6e93c
movq %rax, %rbx
leaq 0x11ae72(%rip), %rbp    # 0x1516e4
cmpl $0x2, (%rbp)
jb 0x368ae
movl $0x1, %r13d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3d7e8
movq %rax, (%rsp)
testq %rax, %rax
je 0x36905
movl $0x8, %edx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x6ec0e
incl %r13d
cmpl (%rbp), %r13d
jb 0x3687e
movq %r15, %rdi
callq *%r14
movq %rbx, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x36900
movl $0x1, %ebp
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %rdi, (%rsp)
callq 0x3d887
movq (%rsp), %rdi
callq 0x3d9ed
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x6ecda
incl %ebp
cmpq %r15, %rax
ja 0x368cc
jmp 0x36945
xorl %r14d, %r14d
jmp 0x36945
movq %rbx, %rdi
callq 0x6ecda
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x36945
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x3d9ed
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x6ecda
incl %ebp
cmpq %r15, %rax
ja 0x36920
movq %rbx, %rdi
callq 0x6f134
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_O1/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 0x36a36
movq %rsi, %rbx
testq %rsi, %rsi
je 0x36a36
movq %rdi, %r14
movq %rbx, %rdi
callq 0xb260
testq %rax, %rax
je 0x36a31
movq %rax, %r15
callq 0xb6e0
movq (%rax), %rax
movsbq (%rbx), %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0x36a31
cmpb $0x2e, -0x1(%rbx,%r15)
jne 0x36a3b
leaq 0xaaf35(%rip), %rdx     # 0xe1906
movl $0x1, %edi
movl $0x60, %esi
movl $0xdb, %ecx
callq 0x3601f
movq %rax, %r15
movq %r14, %rdi
callq 0x722dc
movq %rax, 0x8(%r15)
movq %rbx, %rdi
callq 0x722dc
movq %rax, 0x10(%r15)
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x18(%r15)
movq $-0x1, 0x50(%r15)
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x76f28
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_O1/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 0x36b39
movq %rsi, %r15
testq %rsi, %rsi
je 0x36b39
movq %rdx, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0x36b17
movl $0x10, %edi
callq 0x6e93c
movq %rax, 0x20(%r14)
movq %rsp, %rsi
movq %r15, (%rsi)
movq %rbx, 0x8(%rsi)
movq 0x20(%r14), %rdi
movl $0x10, %edx
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xca49
// File: /workspace/github_c_makefile_star2_O1/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 0x36b5e
movq 0x58(%rdi), %rdi
leaq 0x19(%rip), %rsi        # 0x36b68
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x771f5
testl %eax, %eax
jne 0x36b63
popq %rax
retq
callq 0xcabb
callq 0xca82
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x373ce
movq %rdi, %rbx
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
setne %bpl
je 0x37309
movq %r14, %rdi
xorl %esi, %esi
callq 0x6e9fa
movq (%rax), %rax
cmpb $0x0, 0x4d(%rax)
jne 0x37309
movl $0x1, %r15d
movq %r14, %rdi
callq 0x6ecda
cmpq %rax, %r15
setb %bpl
jae 0x37309
movq %r14, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rax
incq %r15
cmpb $0x1, 0x4d(%rax)
jne 0x372e1
leaq 0xab1d0(%rip), %rax     # 0xe24e0
leaq 0xab1f1(%rip), %rsi     # 0xe2508
testb %bpl, %bpl
cmovneq %rax, %rsi
leaq 0xab335(%rip), %rdi     # 0xe265a
xorl %edx, %edx
callq 0x3921b
movl $0x4, (%rax)
movb $0x0, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
testb %bpl, %bpl
je 0x37370
leaq 0xab1d1(%rip), %rdi     # 0xe251e
leaq 0xab1d0(%rip), %rsi     # 0xe2524
xorl %edx, %edx
callq 0x3921b
movl $0x5, (%rax)
movb $0x0, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0xab1d3(%rip), %rdi     # 0xe254a
leaq 0xab1d4(%rip), %rsi     # 0xe2552
xorl %edx, %edx
callq 0x3921b
movl $0x6, (%rax)
movb $0x0, 0x20(%rax)
movb $0x1, 0x4e(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0xc1734(%rip), %rdi     # 0xf8ad9
leaq 0xab1d4(%rip), %rsi     # 0xe2580
xorl %edx, %edx
callq 0x3921b
movl $0xe, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36a40
callq 0xcc26
// File: /workspace/github_c_makefile_star2_O1/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 0x37438
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 0x37414
callq 0xb0b0
movq (%rax), %rax
movb (%rax,%r13,4), %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x3c28d
incq %r12
movq %r15, %rdi
callq 0xb260
cmpq %rax, %r12
jb 0x373ec
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c067
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3c28d
cmpb $0x0, (%r14)
je 0x37482
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x3c28d
incq %r15
movq %r14, %rdi
callq 0xb260
cmpq %rax, %r15
jb 0x37465
leaq 0xc041f(%rip), %rsi     # 0xf78a8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c067
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
testq %rdi, %rdi
je 0x389ae
cmpb $0x1, 0x4f(%rdi)
jne 0x389a8
incl %esi
movb $0x1, %bl
cmpl %edx, %esi
jge 0x389aa
movslq %esi, %rax
movq (%rcx,%rax,8), %rdi
cmpb $0x2d, (%rdi)
je 0x389aa
leaq 0xd2234(%rip), %rsi     # 0x10abd3
callq 0xb890
testl %eax, %eax
je 0x389aa
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
callq 0xcf7d
// File: /workspace/github_c_makefile_star2_O1/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 0x389da
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x38a1f
incl %ebp
cmpl %r12d, %ebp
jge 0x389f5
movslq %ebp, %rax
movq (%r15,%rax,8), %rcx
xorl %eax, %eax
cmpb $0x2d, (%rcx)
jne 0x38a16
cmpb $0x0, 0x1(%rcx)
je 0x38a16
movq %r14, %rdi
callq 0x3c40b
leaq 0xa96f3(%rip), %rsi     # 0xe20f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xcfb6
// File: /workspace/github_c_makefile_star2_O1/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 0x38a47
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x38a7d
incl %r15d
xorl %eax, %eax
cmpl %ebp, %r15d
jl 0x38a72
movq %r14, %rdi
callq 0x3c40b
leaq 0xa9697(%rip), %rsi     # 0xe20f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3559f
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_O1/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 0x390b5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xa88ec(%rip), %r14     # 0xe1906
movq %r14, %rsi
movl $0x5c9, %edx            # imm = 0x5C9
callq 0x362a0
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x5ca, %edx            # imm = 0x5CA
callq 0x362a0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x5cb, %edx            # imm = 0x5CB
callq 0x362a0
movq 0x18(%rbx), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x3907f
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x390b6
incq %r14
movq 0x18(%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r14
jb 0x3905a
movq 0x18(%rbx), %rdi
callq 0x6f134
movq 0x20(%rbx), %rdi
callq 0x6f134
movq 0x58(%rbx), %rdi
callq 0x77675
leaq 0xa8865(%rip), %rsi     # 0xe1906
movq %rbx, %rdi
movl $0x5d1, %edx            # imm = 0x5D1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x390ce
movq %rdi, %rbx
movl 0x68(%rdi), %eax
testl %eax, %eax
je 0x390d6
decl %eax
movl %eax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
callq 0x3d1eb
movq 0x10(%rbx), %rdi
callq 0x3d1eb
movq 0x50(%rbx), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x3911e
xorl %r14d, %r14d
movq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x6f134
incq %r14
movq 0x50(%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r14
jb 0x390f9
movq 0x50(%rbx), %rdi
callq 0x6f134
movq 0x58(%rbx), %rdi
callq 0x6f134
movq 0x60(%rbx), %rdi
callq 0x6f134
leaq 0xa87c6(%rip), %rsi     # 0xe1906
movq %rbx, %rdi
movl $0x7c1, %edx            # imm = 0x7C1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/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 0xa9030(%rip), %rdi     # 0xe218f
leaq 0xa902f(%rip), %rsi     # 0xe2195
movq %rbx, %rdx
callq 0x3921b
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_O1/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 0x3921b
movl $0x0, (%rax)
movb %bl, 0x20(%rax)
movb %bl, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3921b
movl $0xa, (%rax)
movq %rbx, 0x20(%rax)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa86d3(%rip), %rdx     # 0xe1906
movl $0x1, %edi
movl $0x70, %esi
movl $0x7d, %ecx
callq 0x3601f
testq %r12, %r12
je 0x39288
movq %rax, %r15
movzbl (%r12), %eax
cmpl $0x2d, %eax
je 0x3928d
testl %eax, %eax
je 0x39288
movq %r12, %rdi
callq 0x3c03d
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x3c03d
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
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_double
GtOption* gt_option_new_double(const char *option_str, const char *description,
                               double *value, double default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_DOUBLE;
  o->default_value.d = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
callq 0x3921b
movl $0x2, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_double_min
GtOption *gt_option_new_double_min(const char *option_str,
                                   const char *description,
                                   double *value, double default_value,
                                   double min_value)
{
  GtOption *o = gt_option_new_double(option_str, description, value,
                                     default_value);
  o->min_value_set = true;
  o->min_value.d = min_value;
  return o;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
callq 0x3921b
movl $0x2, (%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd %xmm0, (%rbx)
movb $0x1, 0x4b(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x38(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_double_min_max
GtOption *gt_option_new_double_min_max(const char *option_str,
                                       const char *description, double *value,
                                       double default_value, double min_value,
                                       double max_value)
{
  GtOption *o = gt_option_new_double(option_str, description, value,
                                     default_value);
  o->min_value_set = true;
  o->min_value.d = min_value;
  o->max_value_set = true;
  o->max_value.d = max_value;
  return o;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
callq 0x3921b
movl $0x2, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd %xmm0, (%rbx)
movw $0x101, 0x4b(%rax)      # imm = 0x101
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x38(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x40(%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int
GtOption* gt_option_new_int(const char *option_str, const char *description,
                            int *value, int default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_INT;
  o->default_value.i = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x3921b
movl $0x7, (%rax)
movl %ebx, 0x20(%rax)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int_min
GtOption* gt_option_new_int_min(const char *option_str, const char *description,
                                int *value, int default_value, int min_value)
{
  GtOption *o = gt_option_new_int(option_str, description, value,
                                  default_value);
  o->min_value_set = true;
  o->min_value.i = min_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x3921b
movl $0x7, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4b(%rax)
movl %ebx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int_max
GtOption* gt_option_new_int_max(const char *option_str, const char *description,
                                int *value, int default_value, int max_value)
{
  GtOption *o = gt_option_new_int(option_str, description, value,
                                  default_value);
  o->max_value_set = true;
  o->max_value.i = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x3921b
movl $0x7, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4c(%rax)
movl %ebx, 0x40(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_int_min_max
GtOption* gt_option_new_int_min_max(const char *option_str,
                                    const char *description,
                                    int *value, int default_value,
                                    int min_value, int max_value)
{
  GtOption *o = gt_option_new_int(option_str, description, value,
                                  default_value);
  o->min_value_set = true;
  o->min_value.i = min_value;
  o->max_value_set = true;
  o->max_value.i = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
callq 0x3921b
movl $0x7, (%rax)
movl %r14d, 0x20(%rax)
movl %r14d, (%r15)
movw $0x101, 0x4b(%rax)      # imm = 0x101
movl %ebp, 0x38(%rax)
movl %ebx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint
GtOption* gt_option_new_uint(const char *option_str, const char *description,
                             unsigned int *value, unsigned int default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_UINT;
  o->default_value.ui = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x3921b
movl $0x8, (%rax)
movl %ebx, 0x20(%rax)
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint_min
GtOption* gt_option_new_uint_min(const char *option_str,
                                 const char *description,
                                 unsigned int *value,
                                 unsigned int default_value,
                                 unsigned int min_value)
{
  GtOption *o = gt_option_new_uint(option_str, description, value,
                                   default_value);
  o->min_value_set = true;
  o->min_value.ui = min_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x3921b
movl $0x8, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4b(%rax)
movl %ebx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint_max
GtOption* gt_option_new_uint_max(const char *option_str,
                                 const char *description,
                                 unsigned int *value,
                                 unsigned int default_value,
                                 unsigned int max_value)
{
  GtOption *o = gt_option_new_uint(option_str, description, value,
                                   default_value);
  o->max_value_set = true;
  o->max_value.ui = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
callq 0x3921b
movl $0x8, (%rax)
movl %ebp, 0x20(%rax)
movl %ebp, (%r14)
movb $0x1, 0x4c(%rax)
movl %ebx, 0x40(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uint_min_max
GtOption *gt_option_new_uint_min_max(const char *option_str,
                                     const char *description,
                                     unsigned int *value,
                                     unsigned int default_value,
                                     unsigned int min_value,
                                     unsigned int max_value)
{
  GtOption *o = gt_option_new_uint(option_str, description, value,
                                   default_value);
  o->min_value_set = true;
  o->min_value.i = min_value;
  o->max_value_set = true;
  o->max_value.i = max_value;
  return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
callq 0x3921b
movl $0x8, (%rax)
movl %r14d, 0x20(%rax)
movl %r14d, (%r15)
movw $0x101, 0x4b(%rax)      # imm = 0x101
movl %ebp, 0x38(%rax)
movl %ebx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_word
GtOption* gt_option_new_word(const char *option_str, const char *description,
                             GtWord *value, GtWord default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_LONG;
  o->default_value.l = default_value;
  *value = default_value;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
callq 0x3921b
movl $0x9, (%rax)
movq %rbx, 0x20(%rax)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uword_min
GtOption* gt_option_new_uword_min(const char *option_str,
                                  const char *description,
                                  GtUword *value,
                                  GtUword default_value,
                                  GtUword min_value)
{
  GtOption *o = gt_option_new_uword(option_str, description, value,
                                    default_value);
  o->min_value_set = true;
  o->min_value.ul = min_value;
  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
callq 0x3921b
movl $0xa, (%rax)
movq %r14, 0x20(%rax)
movq %r14, (%r15)
movb $0x1, 0x4b(%rax)
movq %rbx, 0x38(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_uword_min_max
GtOption *gt_option_new_uword_min_max(const char *option_str,
                                      const char *description,
                                      GtUword *value,
                                      GtUword default_value,
                                      GtUword min_value,
                                      GtUword max_value)
{
  GtOption *o = gt_option_new_uword(option_str, description, value,
                                    default_value);
  o->min_value_set = true;
  o->min_value.ul = min_value;
  o->max_value_set = true;
  o->max_value.ul = max_value;
  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
callq 0x3921b
movl $0xa, (%rax)
movq %r15, 0x20(%rax)
movq %r15, (%r12)
movw $0x101, 0x4b(%rax)      # imm = 0x101
movq %r14, 0x38(%rax)
movq %rbx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/option.c
// Function: gt_option_new_range
GtOption* gt_option_new_range(const char *option_str, const char *description,
                              GtRange *value, GtRange *default_value)
{
  GtOption *o = gt_option_new(option_str, description, value);
  o->option_type = OPTION_RANGE;
  o->default_value.r.start = default_value ? default_value->start
                                           : GT_UNDEF_UWORD;
  o->default_value.r.end   = default_value ? default_value->end
                                           : GT_UNDEF_UWORD;
  value->start = o->default_value.r.start;
  value->end   = o->default_value.r.end;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
callq 0x3921b
movl $0xb, (%rax)
movq $-0x1, %rcx
movq $-0x1, %rdx
testq %r14, %r14
je 0x3966e
movq (%r14), %rdx
movq %rdx, 0x20(%rax)
testq %r14, %r14
je 0x3967b
movq 0x8(%r14), %rcx
movq %rcx, 0x28(%rax)
movq %rdx, (%rbx)
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq