LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpq $0x0, 0x1a8806(%rip)    # 0x1b62d0
jne 0xdb04
movq 0x1a6505(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150589(%rip), %rsi    # 0x15e066
leaq 0x1509bd(%rip), %rdx    # 0x15e4a1
leaq 0x150a15(%rip), %rcx    # 0x15e500
leaq 0x1509bd(%rip), %r8     # 0x15e4af
movl $0xd2, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdb06
cmpq $0x0, 0x20(%rsp)
jne 0xdb13
jmp 0xdc1a
movq 0x1a87b6(%rip), %rax    # 0x1b62d0
testb $0x1, 0x8(%rax)
je 0xdc10
movq 0x1a87ad(%rip), %rdi    # 0x1b62d8
callq 0x1c340
movq 0x1a8799(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x86470
cmpq $0x0, %rax
jne 0xdb75
movq 0x1a6487(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
leaq 0x1509a8(%rip), %rsi    # 0x15e50c
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
movq 0x1a8754(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x86470
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xdbce
movq 0x1a643b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1504bf(%rip), %rsi    # 0x15e066
leaq 0x15094b(%rip), %rdx    # 0x15e4f9
leaq 0x15094b(%rip), %rcx    # 0x15e500
leaq 0x1508f3(%rip), %r8     # 0x15e4af
movl $0xde, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdbd0
movq 0x1a86f9(%rip), %rdi    # 0x1b62d0
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xd930
movq 0x1a86e5(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x86580
movq 0x20(%rsp), %rdi
callq 0xb760
movq 0x1a86cf(%rip), %rdi    # 0x1b62d8
callq 0x1c3e0
jmp 0xdc1a
movq 0x20(%rsp), %rdi
callq 0xb760
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, 0x1a84f3(%rip)    # 0x1b62d0
jne 0xde17
movq 0x1a61f2(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150276(%rip), %rsi    # 0x15e066
leaq 0x1506aa(%rip), %rdx    # 0x15e4a1
leaq 0x1507ae(%rip), %rcx    # 0x15e5ac
leaq 0x1506aa(%rip), %r8     # 0x15e4af
movl $0x119, %r9d            # imm = 0x119
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xde19
movq (%rsp), %rdi
movq 0x1a84ac(%rip), %rax    # 0x1b62d0
movq 0x20(%rax), %xmm0
movaps 0x150650(%rip), %xmm1   # 0x15e480
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x150654(%rip), %xmm1   # 0x15e490
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x150625(%rip), %xmm1   # 0x15e478
divsd %xmm1, %xmm0
movq 0x1a8472(%rip), %rax    # 0x1b62d0
movq 0x10(%rax), %rdx
leaq 0x150759(%rip), %rsi    # 0x15e5c2
movb $0x1, %al
callq 0xb890
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
cmpq $0x0, 0x1a8444(%rip)    # 0x1b62d0
jne 0xdec6
movq 0x1a6143(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1501c7(%rip), %rsi    # 0x15e066
leaq 0x1505fb(%rip), %rdx    # 0x15e4a1
leaq 0x150747(%rip), %rcx    # 0x15e5f4
leaq 0x1505fb(%rip), %r8     # 0x15e4af
movl $0x123, %r9d            # imm = 0x123
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdec8
movq 0x1a8409(%rip), %rdi    # 0x1b62d8
callq 0x1c340
movb $0x0, 0x13(%rsp)
movq 0x1a83f0(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
leaq 0x86(%rip), %rsi        # 0xdf70
leaq 0x13(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x866f0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xdf3b
movq 0x1a60ce(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x150152(%rip), %rsi    # 0x15e066
leaq 0x1590a3(%rip), %rdx    # 0x166fbe
leaq 0x1506d2(%rip), %rcx    # 0x15e5f4
leaq 0x150586(%rip), %r8     # 0x15e4af
movl $0x128, %r9d            # imm = 0x128
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdf3d
movq 0x1a8394(%rip), %rdi    # 0x1b62d8
callq 0x1c3e0
testb $0x1, 0x13(%rsp)
je 0xdf5a
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0xdf62
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xdfec
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xdfb4
jmp 0xdfec
movq 0x1a601d(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1500a1(%rip), %rsi    # 0x15e066
leaq 0x15067c(%rip), %rdx    # 0x15e648
leaq 0x150627(%rip), %rcx    # 0x15e5fa
leaq 0x1504d5(%rip), %r8     # 0x15e4af
movl $0xf4, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdfee
jmp 0xdff0
cmpq $0x0, 0x30(%rsp)
je 0xe008
cmpq $0x0, 0x28(%rsp)
je 0xe008
cmpq $0x0, 0x20(%rsp)
jne 0xe040
movq 0x1a5fc9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x15004d(%rip), %rsi    # 0x15e066
leaq 0x150702(%rip), %rdx    # 0x15e722
leaq 0x1505d3(%rip), %rcx    # 0x15e5fa
leaq 0x150481(%rip), %r8     # 0x15e4af
movl $0xf5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe042
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0xe085
movq 0x1a5f85(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r8
leaq 0x1506c1(%rip), %rsi    # 0x15e737
movb $0x0, %al
callq 0xb890
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x1a81cf(%rip)    # 0x1b62d0
jne 0xe13b
movq 0x1a5ece(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14ff52(%rip), %rsi    # 0x15e066
leaq 0x150386(%rip), %rdx    # 0x15e4a1
leaq 0x150503(%rip), %rcx    # 0x15e625
leaq 0x150386(%rip), %r8     # 0x15e4af
movl $0x144, %r9d            # imm = 0x144
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe13d
movq 0x1a8194(%rip), %rdi    # 0x1b62d8
callq 0x1c340
movq 0x1a8180(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x61(%rip), %rsi        # 0xe1c0
xorl %eax, %eax
movl %eax, %ecx
callq 0x866f0
movl %eax, 0xc(%rsp)
movq 0x1a8165(%rip), %rdi    # 0x1b62d8
callq 0x1c3e0
cmpl $0x0, 0xc(%rsp)
je 0xe1b7
movq 0x1a5e52(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14fed6(%rip), %rsi    # 0x15e066
leaq 0x158e27(%rip), %rdx    # 0x166fbe
leaq 0x150487(%rip), %rcx    # 0x15e625
leaq 0x15030a(%rip), %r8     # 0x15e4af
movl $0x149, %r9d            # imm = 0x149
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe1b9
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xe23c
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe204
jmp 0xe23c
movq 0x1a5dcd(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14fe51(%rip), %rsi    # 0x15e066
leaq 0x15042c(%rip), %rdx    # 0x15e648
leaq 0x150556(%rip), %rcx    # 0x15e779
leaq 0x150285(%rip), %r8     # 0x15e4af
movl $0x13a, %r9d            # imm = 0x13A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe23e
jmp 0xe240
cmpq $0x0, 0x8(%rsp)
je 0xe258
cmpq $0x0, 0x30(%rsp)
je 0xe258
cmpq $0x0, 0x28(%rsp)
jne 0xe290
movq 0x1a5d79(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14fdfd(%rip), %rsi    # 0x15e066
leaq 0x15051a(%rip), %rdx    # 0x15e78a
leaq 0x150502(%rip), %rcx    # 0x15e779
leaq 0x150231(%rip), %r8     # 0x15e4af
movl $0x13b, %r9d            # imm = 0x13B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe292
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r8
leaq 0x1504e9(%rip), %rsi    # 0x15e7a0
movb $0x0, %al
callq 0xb890
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
jmp 0xe2d3
cmpq $0x0, 0x1a7ff5(%rip)    # 0x1b62d0
jne 0xe315
movq 0x1a5cf4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14fd78(%rip), %rsi    # 0x15e066
leaq 0x1501ac(%rip), %rdx    # 0x15e4a1
leaq 0x150340(%rip), %rcx    # 0x15e63c
leaq 0x1501ac(%rip), %r8     # 0x15e4af
movl $0x14e, %r9d            # imm = 0x14E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe317
movq 0x1a7fba(%rip), %rdi    # 0x1b62d8
callq 0x1c340
movq 0x1a7fa6(%rip), %rax    # 0x1b62d0
movb $0x0, 0x8(%rax)
movq 0x1a7f9b(%rip), %rax    # 0x1b62d0
movq (%rax), %rdi
callq 0x86cc0
movq 0x1a7f94(%rip), %rdi    # 0x1b62d8
callq 0x1c3e0
movq 0x1a7f88(%rip), %rdi    # 0x1b62d8
callq 0x1c2c0
movq 0x1a7f74(%rip), %rdi    # 0x1b62d0
callq 0xb760
movq $0x0, 0x1a7f64(%rip) # 0x1b62d0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xe3c9
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xe391
jmp 0xe3c9
movq 0x1a5c40(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14fcc4(%rip), %rsi    # 0x15e066
leaq 0x15029f(%rip), %rdx    # 0x15e648
leaq 0x1502b6(%rip), %rcx    # 0x15e666
leaq 0x1500f8(%rip), %r8     # 0x15e4af
movl $0x195, %r9d            # imm = 0x195
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe3cb
movq 0x10(%rsp), %rdx
leaq 0x59(%rip), %rdi        # 0xe430
xorl %eax, %eax
movl %eax, %esi
callq 0xe6c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xe404
movq 0x10(%rsp), %rdx
leaq 0x109(%rip), %rdi       # 0xe500
xorl %eax, %eax
movl %eax, %esi
callq 0xe6c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xe424
movq 0x10(%rsp), %rdx
leaq 0x1b9(%rip), %rdi       # 0xe5d0
xorl %eax, %eax
movl %eax, %esi
callq 0xe6c0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x186a0, 0x14(%rsp)    # imm = 0x186A0
jae 0xe496
movl $0x40, %edi
leaq 0x150049(%rip), %rsi    # 0x15e4af
movl $0x162, %edx            # imm = 0x162
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe450
movl $0x0, 0x14(%rsp)
cmpl $0x186a0, 0x14(%rsp)    # imm = 0x186A0
jae 0xe4e3
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x14ffe3(%rip), %rsi    # 0x15e4af
movl $0x167, %edx            # imm = 0x167
callq 0xdab0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe49e
movq 0x18(%rsp), %rdi
callq 0x770a0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x186a0, 0x14(%rsp)    # imm = 0x186A0
jae 0xe56b
movl $0x1, %edi
movl $0x40, %esi
leaq 0x14ff74(%rip), %rdx    # 0x15e4af
movl $0x174, %ecx            # imm = 0x174
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe520
movl $0x0, 0x14(%rsp)
cmpl $0x186a0, 0x14(%rsp)    # imm = 0x186A0
jae 0xe5b8
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x14ff0e(%rip), %rsi    # 0x15e4af
movl $0x179, %edx            # imm = 0x179
callq 0xdab0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe573
movq 0x18(%rsp), %rdi
callq 0x770a0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x186a0, 0x14(%rsp)    # imm = 0x186A0
jae 0xe65a
xorl %eax, %eax
movl %eax, %edi
movl $0x20, %esi
leaq 0x14fea5(%rip), %rdx    # 0x15e4af
movl $0x186, %ecx            # imm = 0x186
callq 0xd730
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x20, %esi
leaq 0x14fe85(%rip), %rdx    # 0x15e4af
movl $0x187, %ecx            # imm = 0x187
callq 0xd730
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe5f0
movl $0x0, 0x14(%rsp)
cmpl $0x186a0, 0x14(%rsp)    # imm = 0x186A0
jae 0xe6a7
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x14fe1f(%rip), %rsi    # 0x15e4af
movl $0x18c, %edx            # imm = 0x18C
callq 0xdab0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe662
movq 0x18(%rsp), %rdi
callq 0x770a0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xe93e
cmpq $0x0, 0x18(%rsp)
jne 0xe976
movq 0x1a5693(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14f717(%rip), %rsi    # 0x15e066
leaq 0x14ff16(%rip), %rdx    # 0x15e86c
leaq 0x14ff25(%rip), %rcx    # 0x15e882
leaq 0x14fef6(%rip), %r8     # 0x15e85a
movl $0xd7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe978
jmp 0xe97a
movb $0x1, %al
testb $0x1, %al
jne 0xe982
jmp 0xe9b3
movq 0x18(%rsp), %rdi
callq 0xb240
cmpq $0x0, %rax
je 0xe9b3
callq 0xb6b0
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0xe9eb
movq 0x1a561e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14f6a2(%rip), %rsi    # 0x15e066
leaq 0x14ff0a(%rip), %rdx    # 0x15e8d5
leaq 0x14feb0(%rip), %rcx    # 0x15e882
leaq 0x14fe81(%rip), %r8     # 0x15e85a
movl $0xd9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xe9ed
jmp 0xe9ef
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xb240
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0xea50
movq 0x1a55b9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14f63d(%rip), %rsi    # 0x15e066
leaq 0x14ff19(%rip), %rdx    # 0x15e949
leaq 0x14fe4b(%rip), %rcx    # 0x15e882
leaq 0x14fe1c(%rip), %r8     # 0x15e85a
movl $0xda, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xea52
movl $0x1, %edi
movl $0x60, %esi
leaq 0x14fdf7(%rip), %rdx    # 0x15e85a
movl $0xdb, %ecx
callq 0xd5b0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7c400
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x7c400
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x8, %edi
callq 0x75ab0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x86190
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xed83
cmpq $0x0, 0x18(%rsp)
jne 0xedbb
movq 0x1a524e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14f2d2(%rip), %rsi    # 0x15e066
leaq 0x14fc9d(%rip), %rdx    # 0x15ea38
leaq 0x14fca1(%rip), %rcx    # 0x15ea43
leaq 0x14fab1(%rip), %r8     # 0x15e85a
movl $0x10e, %r9d            # imm = 0x10E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xedbd
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xeddf
movl $0x10, %edi
callq 0x75ab0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x76220
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfca9
movq 0x1a4360(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14e3e4(%rip), %rsi    # 0x15e066
leaq 0x15c721(%rip), %rdx    # 0x16c3aa
leaq 0x14f7ce(%rip), %rcx    # 0x15f45e
leaq 0x14ebc3(%rip), %r8     # 0x15e85a
movl $0x208, %r9d            # imm = 0x208
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfcab
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x14d80
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x14e40
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xeb00
testb $0x1, 0xf(%rsp)
je 0xfcfd
callq 0x14eb0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xeb00
callq 0x14ef0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xeb00
callq 0x14f30
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xeb00
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xb240
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xfdea
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x17(%rsp)
movsbl 0x17(%rsp), %eax
cmpl $0x20, %eax
jne 0xfd9c
movq 0x28(%rsp), %rdi
movl $0x2d, %esi
callq 0x194d0
jmp 0xfdd5
testb $0x1, 0x27(%rsp)
je 0xfdc4
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movsbl 0x17(%rsp), %edi
callq 0xbbb0
movq (%rsp), %rdi
movsbl %al, %esi
callq 0x194d0
jmp 0xfdd3
movq 0x28(%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0x194d0
jmp 0xfdd5
jmp 0xfdd7
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xfd4f
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18fb0
movq 0x18(%rsp), %rdi
movl $0xa, %esi
callq 0x194d0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb240
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xfe65
movq 0x18(%rsp), %rdi
movl $0x2d, %esi
callq 0x194d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xfe25
movq 0x18(%rsp), %rdi
leaq 0x165d73(%rip), %rsi    # 0x175be4
callq 0x18fb0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/option.c
// Function: gt_option_parser_warn_on_nonascii
static void gt_option_parser_warn_on_nonascii(const char *str)
{
  GtUword j = 1;
  while (*str != '\0') {
    if (!isprint(*str)) {
      gt_warning("option '%s' contains non-ASCII character at "
                 "offset "GT_WU" -- possible copy&paste from "
                 "non-ASCII context?",
                 str, j);
      break;
    }
    str++;
    j++;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x1, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11c78
callq 0xb6b0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x11c5a
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x14d8f9(%rip), %rdi    # 0x15f54a
movb $0x0, %al
callq 0x1c550
jmp 0x11c78
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x11c12
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x11cd6
movq 0x1a2333(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14c3b7(%rip), %rsi    # 0x15e066
leaq 0x14ff2a(%rip), %rdx    # 0x161be0
leaq 0x14d8f3(%rip), %rcx    # 0x15f5b0
leaq 0x14cb96(%rip), %r8     # 0x15e85a
movl $0x2e5, %r9d            # imm = 0x2E5
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11cd8
movq 0x18(%rsp), %rax
testb $0x1, 0x4f(%rax)
je 0x11d36
movl 0x14(%rsp), %eax
addl $0x1, %eax
cmpl 0x10(%rsp), %eax
jge 0x11d2f
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x11d2f
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x17bb82(%rip), %rsi    # 0x18d8a7
callq 0xb850
cmpl $0x0, %eax
jne 0x11d36
movb $0x1, 0x27(%rsp)
jmp 0x11d3b
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x11dbb
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x11d83
jmp 0x11dbb
movq 0x1a224e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14c2d2(%rip), %rsi    # 0x15e066
leaq 0x14c8ad(%rip), %rdx    # 0x15e648
leaq 0x14d81b(%rip), %rcx    # 0x15f5bd
leaq 0x14cab1(%rip), %r8     # 0x15e85a
movl $0x2fe, %r9d            # imm = 0x2FE
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11dbd
movl 0x30(%rsp), %eax
addl $0x1, %eax
cmpl 0x2c(%rsp), %eax
jge 0x11e01
movq 0x18(%rsp), %rax
movl 0x30(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x11e35
movq 0x18(%rsp), %rax
movl 0x30(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x11e35
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x19940
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x14d265(%rip), %rsi    # 0x15f089
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x11e3d
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/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:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11eb6
movq 0x8(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x11e7e
jmp 0x11eb6
movq 0x1a2153(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14c1d7(%rip), %rsi    # 0x15e066
leaq 0x14c7b2(%rip), %rdx    # 0x15e648
leaq 0x14d746(%rip), %rcx    # 0x15f5e3
leaq 0x14c9b6(%rip), %r8     # 0x15e85a
movl $0x2f1, %r9d            # imm = 0x2F1
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11eb8
movl 0x20(%rsp), %eax
addl $0x1, %eax
cmpl 0x1c(%rsp), %eax
jl 0x11ef7
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x19940
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x14d1a3(%rip), %rsi    # 0x15f089
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x11eff
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/option.c
// Function: check_mandatory_options
static int check_mandatory_options(GtOptionParser *op, GtError *err)
{
  GtUword i;
  GtOption *o;
  gt_error_check(err);
  gt_assert(op);
  for (i = 0; i < gt_array_size(op->options); i++) {
    o = *(GtOption**) gt_array_get(op->options, i);
    if (o->is_mandatory && !o->is_set) {
      gt_error_set(err, "option \"-%s\" is mandatory",
                   gt_str_get(o->option_str));
      return -1;
    }
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x126de
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x126a6
jmp 0x126de
movq 0x1a192b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14b9af(%rip), %rsi    # 0x15e066
leaq 0x14bf8a(%rip), %rdx    # 0x15e648
leaq 0x14d0a5(%rip), %rcx    # 0x15f76a
leaq 0x14c18e(%rip), %r8     # 0x15e85a
movl $0x30b, %r9d            # imm = 0x30B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x126e0
jmp 0x126e2
cmpq $0x0, 0x28(%rsp)
jne 0x12722
movq 0x1a18e7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14b96b(%rip), %rsi    # 0x15e066
leaq 0x159ca8(%rip), %rdx    # 0x16c3aa
leaq 0x14d061(%rip), %rcx    # 0x15f76a
leaq 0x14c14a(%rip), %r8     # 0x15e85a
movl $0x30c, %r9d            # imm = 0x30C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12724
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x127ce
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x49(%rax)
je 0x127b9
movq 0x10(%rsp), %rax
testb $0x1, 0x48(%rax)
jne 0x127b9
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x19940
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x14d169(%rip), %rsi    # 0x15f911
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x127d6
jmp 0x127bb
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1272d
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/option.c
// Function: check_option_exclusions
static int check_option_exclusions(GtOptionParser *op, GtError *err)
{
  GtUword i, j;
  GtOption *o, *excluded_option;
  gt_error_check(err);

  for (i = 0; i < gt_array_size(op->options); i++) {
    o = *(GtOption**) gt_array_get(op->options, i);
    if (o->exclusions && o->is_set) {
      for (j = 0; j < gt_array_size(o->exclusions); j++) {
        excluded_option = *(GtOption**) gt_array_get(o->exclusions, j);
        if (excluded_option->is_set) {
          gt_error_set(err, "option \"-%s\" and option \"-%s\" exclude each "
                       "other", gt_str_get(o->option_str),
                       gt_str_get(excluded_option->option_str));
          return -1;
        }
      }
    }
  }
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x12cde
movq 0x40(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x12ca6
jmp 0x12cde
movq 0x1a132b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14b3af(%rip), %rsi    # 0x15e066
leaq 0x14b98a(%rip), %rdx    # 0x15e648
leaq 0x14cb41(%rip), %rcx    # 0x15f806
leaq 0x14bb8e(%rip), %r8     # 0x15e85a
movl $0x362, %r9d            # imm = 0x362
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x12ce0
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x12e1e
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x12e09
movq 0x28(%rsp), %rax
testb $0x1, 0x48(%rax)
je 0x12e09
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x12e07
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x48(%rax)
je 0x12df2
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x19940
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x19940
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x14ca3d(%rip), %rsi    # 0x15f81e
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x12e26
jmp 0x12df4
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x12d55
jmp 0x12e09
jmp 0x12e0b
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x12ce9
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x13206
jmp 0x132ea
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x14b645(%rip), %rsi    # 0x15e85a
movl $0x5c9, %edx            # imm = 0x5C9
callq 0xdab0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x14b62b(%rip), %rsi    # 0x15e85a
movl $0x5ca, %edx            # imm = 0x5CA
callq 0xdab0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x14b611(%rip), %rsi    # 0x15e85a
movl $0x5cb, %edx            # imm = 0x5CB
callq 0xdab0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x132aa
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0x132f0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1325c
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x86cc0
movq 0x10(%rsp), %rdi
leaq 0x14b57a(%rip), %rsi    # 0x15e85a
movl $0x5d1, %edx            # imm = 0x5D1
callq 0xdab0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x13306
jmp 0x133d7
movq 0x10(%rsp), %rax
cmpl $0x0, 0x68(%rax)
je 0x13324
movq 0x10(%rsp), %rax
movl 0x68(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x68(%rax)
jmp 0x133d7
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1afc0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x13397
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0x770a0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x13349
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x770a0
movq 0x10(%rsp), %rdi
leaq 0x14b48d(%rip), %rsi    # 0x15e85a
movl $0x7c1, %edx            # imm = 0x7C1
callq 0xdab0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x13540
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x0, (%rax)
movb 0xf(%rsp), %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movb 0xf(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x13540
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0xa, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, %edi
movl $0x70, %esi
leaq 0x14b2f6(%rip), %rdx    # 0x15e85a
movl $0x7d, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1358b
movq 0x20(%rsp), %rdi
callq 0xb240
cmpq $0x0, %rax
jne 0x135c3
movq 0x1a0a46(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14aaca(%rip), %rsi    # 0x15e066
leaq 0x14c388(%rip), %rdx    # 0x15f92b
leaq 0x14c3a2(%rip), %rcx    # 0x15f94c
leaq 0x14b2a9(%rip), %r8     # 0x15e85a
movl $0x7e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x135c5
jmp 0x135c7
movb $0x1, %al
testb $0x1, %al
jne 0x135cf
jmp 0x135dc
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x13614
movq 0x1a09f5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14aa79(%rip), %rsi    # 0x15e066
leaq 0x14c3ae(%rip), %rdx    # 0x15f9a2
leaq 0x14c351(%rip), %rcx    # 0x15f94c
leaq 0x14b258(%rip), %r8     # 0x15e85a
movl $0x80, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x13616
movq 0x20(%rsp), %rdi
callq 0x18f70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x18f70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x13540
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x2, (%rax)
movsd 0x8(%rsp), %xmm0
movq (%rsp), %rax
movsd %xmm0, 0x20(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movsd 0x18(%rsp), %xmm0
callq 0x13660
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x1, 0x4b(%rax)
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movsd 0x18(%rsp), %xmm0
callq 0x13660
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x1, 0x4b(%rax)
movsd 0x10(%rsp), %xmm0
movq (%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq (%rsp), %rax
movb $0x1, 0x4c(%rax)
movsd 0x8(%rsp), %xmm0
movq (%rsp), %rax
movsd %xmm0, 0x40(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x13540
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x7, (%rax)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)