LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_new
GtLogger* gt_logger_new(bool enabled, const char *prefix, FILE *target)
{
  GtLogger *l;
  gt_assert(target);
  l = (GtLogger*) gt_calloc((size_t) 1, sizeof (GtLogger));
  l->target = target;
  l->prefix = gt_cstr_dup(prefix);
  l->enabled = enabled;
  return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xc6f1
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
leaq 0xbdcd9(%rip), %rdx     # 0xca395
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x24
popq %rcx
callq 0xce9a
movq %rax, %r12
movq %r15, (%rax)
movq %r14, %rdi
callq 0x4f8ae
movq %rax, 0x8(%r12)
movb %bl, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1218c0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd964(%rip), %rsi     # 0xca066
leaq 0xbdd3a(%rip), %rdx     # 0xca443
leaq 0xbdc77(%rip), %rcx     # 0xca387
leaq 0xbdc7e(%rip), %r8      # 0xca395
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_force
void gt_logger_log_force(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va_force(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xc8c4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0xc8f8
testq %rsi, %rsi
je 0xc900
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0xc936
addq $0xd8, %rsp
retq
movq 0x1216b1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd755(%rip), %rsi     # 0xca066
leaq 0xbd87e(%rip), %rdx     # 0xca196
leaq 0xbdaf0(%rip), %rcx     # 0xca40f
leaq 0xbda6f(%rip), %r8      # 0xca395
pushq $0x4d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va_force
void gt_logger_log_va_force(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc985
movq %rsi, %r15
testq %rsi, %rsi
je 0xc98b
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xc98b
movq %rdx, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xc967
callq 0xb730
movq (%rbx), %rsi
movq %rsi, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb810
movq (%rbx), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xbc80
popq %rbx
popq %r14
popq %r15
retq
movq 0x121626(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd6ca(%rip), %rsi     # 0xca066
leaq 0xbda8e(%rip), %rdx     # 0xca431
leaq 0xbdaa0(%rip), %rcx     # 0xca44a
leaq 0xbd9e4(%rip), %r8      # 0xca395
pushq $0x61
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log
void gt_logger_log(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xca17
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0xca51
cmpb $0x1, 0x10(%rdi)
jne 0xca51
testq %rsi, %rsi
je 0xca59
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0xca8f
addq $0xd8, %rsp
retq
movq 0x121558(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd5fc(%rip), %rsi     # 0xca066
leaq 0xbd725(%rip), %rdx     # 0xca196
leaq 0xbd9ab(%rip), %rcx     # 0xca423
leaq 0xbd916(%rip), %r8      # 0xca395
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va
void gt_logger_log_va(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xcae4
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0xcae4
movq %rsi, %r15
testq %rsi, %rsi
je 0xcaea
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xcaea
movq %rdx, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xcac6
callq 0xb730
movq (%rbx), %rsi
movq %rsi, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb810
movq (%rbx), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xbc80
popq %rbx
popq %r14
popq %r15
retq
movq 0x1214c7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd56b(%rip), %rsi     # 0xca066
leaq 0xbd92f(%rip), %rdx     # 0xca431
leaq 0xbd958(%rip), %rcx     # 0xca461
leaq 0xbd885(%rip), %r8      # 0xca395
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_init
void gt_ma_init(bool bookkeeping)
{
  gt_assert(!ma);
  ma = xcalloc(1, sizeof (MA), 0, __FILE__, __LINE__);
  gt_assert(!ma->bookkeeping);
  ma->allocated_pointer = gt_hashmap_new_no_ma(GT_HASH_DIRECT, NULL,
                                               (GtFree) ma_info_free);
  /* MA is ready to use */
  ma->bookkeeping = bookkeeping;
  bookkeeping_lock = gt_mutex_new();
  ma->global_space_peak = false;
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x122e7f(%rip)    # 0x12f9e0
jne 0xcbc0
movl %edi, %ebx
leaq 0xbd94b(%rip), %rcx     # 0xca4b7
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x6b
popq %r8
xorl %edx, %edx
callq 0xcc20
movq %rax, 0x122e5c(%rip)    # 0x12f9e0
cmpb $0x1, 0x8(%rax)
je 0xcbea
leaq 0x11a(%rip), %rdx       # 0xccab
xorl %edi, %edi
xorl %esi, %esi
callq 0x55ee5
movq 0x122e3f(%rip), %rcx    # 0x12f9e0
movq %rax, (%rcx)
movb %bl, 0x8(%rcx)
callq 0x15f7b
movq %rax, 0x122e35(%rip)    # 0x12f9e8
movq 0x122e26(%rip), %rax    # 0x12f9e0
movb $0x0, 0x9(%rax)
popq %rbx
retq
movq 0x1213f1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd495(%rip), %rsi     # 0xca066
leaq 0xbd8d0(%rip), %rdx     # 0xca4a8
leaq 0xbd8cd(%rip), %rcx     # 0xca4ac
leaq 0xbd8d1(%rip), %r8      # 0xca4b7
pushq $0x6a
jmp 0xcc12
movq 0x1213c7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd46b(%rip), %rsi     # 0xca066
leaq 0xbd8c3(%rip), %rdx     # 0xca4c5
leaq 0xbd8a3(%rip), %rcx     # 0xca4ac
leaq 0xbd8a7(%rip), %r8      # 0xca4b7
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/ma.c
// Function: xcalloc
static void* xcalloc(size_t nmemb, size_t size, GtUword current_size,
                     const char *src_file, int src_line)
{
  void *p;
  if ((p = calloc(nmemb, size)) == NULL) {
    fprintf(stderr, "cannot calloc("GT_ZU", "GT_ZU") memory\n", nmemb, size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
           src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0xb410
testq %rax, %rax
je 0xcc53
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12135e(%rip), %r13    # 0x12dfb8
movq (%r13), %rdi
leaq 0xbda22(%rip), %rsi     # 0xca687
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xb8c0
movq (%r13), %rdi
leaq 0xbd8aa(%rip), %rsi     # 0xca527
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8c0
testq %rbx, %rbx
je 0xcca3
movq (%r13), %rdi
leaq 0xbda0e(%rip), %rsi     # 0xca6a7
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/ma.c
// Function: gt_malloc_mem
void* gt_malloc_mem(size_t size, const char *src_file, int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xmalloc(size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xmalloc(size, ma->current_size, src_file, src_line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x122d22(%rip), %rax    # 0x12f9e0
testq %rax, %rax
je 0xcd7f
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rax)
jne 0xcd67
movq 0x122d08(%rip), %rdi    # 0x12f9e8
callq 0x16028
movq 0x122cf4(%rip), %rax    # 0x12f9e0
incq 0x10(%rax)
movq 0x18(%rax), %rsi
pushq $0x18
popq %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xcdb7
movq %rax, %r15
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x122ccb(%rip), %rax    # 0x12f9e0
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xcdb7
movq %rax, %r14
movq 0x122cb0(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55f31
movq 0x122c9b(%rip), %rdi    # 0x12f9e0
movq %rbx, %rsi
callq 0xce32
movq 0x122c94(%rip), %rdi    # 0x12f9e8
callq 0x1609f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcdb7
movq 0x121232(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd2d6(%rip), %rsi     # 0xca066
leaq 0xbd712(%rip), %rdx     # 0xca4a9
leaq 0xbd738(%rip), %rcx     # 0xca4d6
leaq 0xbd712(%rip), %r8      # 0xca4b7
movl $0x8c, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/ma.c
// Function: xmalloc
static void* xmalloc(size_t size, GtUword current_size,
                     const char *src_file, int src_line)
{
  void *p;
  if ((p = malloc(size)) == NULL) {
    fprintf(stderr, "cannot malloc("GT_ZU") memory\n", size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
            src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xbce8
testq %rax, %rax
je 0xcddd
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x1211d4(%rip), %r12    # 0x12dfb8
movq (%r12), %rdi
leaq 0xbd8dd(%rip), %rsi     # 0xca6cc
movq %r15, %rdx
xorl %eax, %eax
callq 0xb8c0
movq (%r12), %rdi
leaq 0xbd723(%rip), %rsi     # 0xca527
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8c0
testq %rbx, %rbx
je 0xce2a
movq (%r12), %rdi
leaq 0xbd887(%rip), %rsi     # 0xca6a7
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/ma.c
// Function: add_size
static void add_size(MA* ma, GtUword size)
{
  gt_assert(ma);
  ma->current_size += size;
  if (ma->global_space_peak)
    gt_spacepeak_add(size);
  if (ma->current_size > ma->max_size)
    ma->max_size = ma->current_size;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xce64
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq %rsi, %rax
movq %rax, 0x18(%rdi)
cmpb $0x1, 0x9(%rdi)
jne 0xce58
movq %rsi, %rdi
callq 0x1230e
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
jbe 0xce62
movq %rax, 0x20(%rbx)
popq %rbx
retq
movq 0x12114d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd1f1(%rip), %rsi     # 0xca066
leaq 0xbd62d(%rip), %rdx     # 0xca4a9
leaq 0xbd864(%rip), %rcx     # 0xca6e7
leaq 0xbd62d(%rip), %r8      # 0xca4b7
pushq $0x77
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x122b34(%rip), %rax    # 0x12f9e0
testq %rax, %rax
je 0xcf8a
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x1, 0x8(%rax)
jne 0xcf67
movq 0x122b17(%rip), %rdi    # 0x12f9e8
callq 0x16028
movq 0x122b03(%rip), %rax    # 0x12f9e0
incq 0x10(%rax)
movq 0x18(%rax), %rsi
pushq $0x18
popq %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0xcdb7
movq %rax, %r13
movq %r15, %rbp
imulq %r12, %rbp
movq %rbp, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x122ad3(%rip), %rax    # 0x12f9e0
movq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
movl %ebx, %r8d
callq 0xcc20
movq %rax, %rbx
movq 0x122ab4(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x55f31
movq 0x122a9f(%rip), %rdi    # 0x12f9e0
movq %rbp, %rsi
callq 0xce32
movq 0x122a98(%rip), %rdi    # 0x12f9e8
callq 0x1609f
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 0xcc20
movq 0x121027(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd0cb(%rip), %rsi     # 0xca066
leaq 0xbd507(%rip), %rdx     # 0xca4a9
leaq 0xbd53b(%rip), %rcx     # 0xca4e4
leaq 0xbd507(%rip), %r8      # 0xca4b7
movl $0xa2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x122a0f(%rip), %rax    # 0x12f9e0
testq %rax, %rax
je 0xd0dd
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x1, 0x8(%rax)
jne 0xd0c0
movq 0x1229f2(%rip), %rdi    # 0x12f9e8
callq 0x16028
movq 0x1229de(%rip), %rax    # 0x12f9e0
incq 0x10(%rax)
testq %r15, %r15
je 0xd047
movq (%rax), %rdi
movq %r15, %rsi
callq 0x55ef6
testq %rax, %rax
je 0xd10b
movq 0x1229ba(%rip), %rdi    # 0x12f9e0
movq (%rax), %rsi
callq 0xd143
movq 0x1229ab(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
movq %r15, %rsi
callq 0x55f6f
movq 0x122999(%rip), %rax    # 0x12f9e0
movq 0x18(%rax), %rsi
pushq $0x18
popq %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xcdb7
movq %rax, %r12
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x122974(%rip), %rax    # 0x12f9e0
movq 0x18(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
movl %ebp, %r8d
callq 0xd1cd
movq %rax, %r14
movq 0x122955(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x55f31
movq 0x122940(%rip), %rdi    # 0x12f9e0
movq %rbx, %rsi
callq 0xce32
movq 0x122939(%rip), %rdi    # 0x12f9e8
callq 0x1609f
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 0xd1cd
movq 0x120ed4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbcf78(%rip), %rsi     # 0xca066
leaq 0xbd3b4(%rip), %rdx     # 0xca4a9
leaq 0xbd3f6(%rip), %rcx     # 0xca4f2
leaq 0xbd3b4(%rip), %r8      # 0xca4b7
movl $0xb7, %r9d
jmp 0xd137
movq 0x120ea6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbcf4a(%rip), %rsi     # 0xca066
leaq 0xbd3de(%rip), %rdx     # 0xca501
leaq 0xbd3c8(%rip), %rcx     # 0xca4f2
leaq 0xbd386(%rip), %r8      # 0xca4b7
movl $0xbd, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xd167
movq 0x18(%rdi), %rax
subq %rsi, %rax
jb 0xd195
movq %rax, 0x18(%rdi)
cmpb $0x1, 0x9(%rdi)
jne 0xd165
movq %rsi, %rdi
popq %rax
jmp 0x1237e
popq %rax
retq
movq 0x120e4a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbceee(%rip), %rsi     # 0xca066
leaq 0xbd32a(%rip), %rdx     # 0xca4a9
leaq 0xbd56a(%rip), %rcx     # 0xca6f0
leaq 0xbd32a(%rip), %r8      # 0xca4b7
movl $0x81, %r9d
jmp 0xd1c1
movq 0x120e1c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbcec0(%rip), %rsi     # 0xca066
leaq 0xbd551(%rip), %rdx     # 0xca6fe
leaq 0xbd53c(%rip), %rcx     # 0xca6f0
leaq 0xbd2fc(%rip), %r8      # 0xca4b7
movl $0x82, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/ma.c
// Function: xrealloc
static void* xrealloc(void *ptr, size_t size, GtUword current_size,
                      const char *src_file, int src_line)
{
  void *p;
  if ((p = realloc(ptr, size)) == NULL) {
    fprintf(stderr, "cannot realloc("GT_ZU") memory\n", size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
            src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
callq 0xba60
testq %rax, %rax
je 0xd1f4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x120dbd(%rip), %r12    # 0x12dfb8
movq (%r12), %rdi
leaq 0xbd511(%rip), %rsi     # 0xca717
movq %r15, %rdx
xorl %eax, %eax
callq 0xb8c0
movq (%r12), %rdi
leaq 0xbd30c(%rip), %rsi     # 0xca527
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8c0
testq %rbx, %rbx
je 0xd241
movq (%r12), %rdi
leaq 0xbd470(%rip), %rsi     # 0xca6a7
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 0x12278c(%rip), %rax    # 0x12f9e0
testq %rax, %rax
je 0xd304
movq %rdi, %rbx
testq %rdi, %rdi
je 0xd2f3
cmpb $0x1, 0x8(%rax)
jne 0xd2f8
movl %edx, %ebp
movq %rsi, %r14
movq 0x122769(%rip), %rdi    # 0x12f9e8
callq 0x16028
movq 0x122755(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0xd332
movq 0x12273a(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0xd357
movq 0x12271f(%rip), %rdi    # 0x12f9e0
movq (%rax), %rsi
callq 0xd143
movq 0x122710(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x55f6f
movq %rbx, %rdi
callq 0xb790
movq 0x1226fe(%rip), %rdi    # 0x12f9e8
popq %rbx
popq %r14
popq %rbp
jmp 0x1609f
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb790
movq 0x120cad(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbcd51(%rip), %rsi     # 0xca066
leaq 0xbd18d(%rip), %rdx     # 0xca4a9
leaq 0xbd1e5(%rip), %rcx     # 0xca508
leaq 0xbd18d(%rip), %r8      # 0xca4b7
movl $0xd2, %r9d
jmp 0xd383
movq 0x120c7f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbd1d1(%rip), %rsi     # 0xca514
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8c0
pushq $0x2
popq %rdi
callq 0xb7b0
movq 0x120c5a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbccfe(%rip), %rsi     # 0xca066
leaq 0xbd192(%rip), %rdx     # 0xca501
leaq 0xbd192(%rip), %rcx     # 0xca508
leaq 0xbd13a(%rip), %r8      # 0xca4b7
movl $0xde, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x12250b(%rip), %rax    # 0x12f9e0
testq %rax, %rax
je 0xd514
movsd 0x20(%rax), %xmm1
unpcklps 0xbcf9a(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xbcfa2(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0xbcf9e(%rip), %xmm0    # 0xca4a0
movq 0x10(%rax), %rdx
leaq 0xbd0bd(%rip), %rsi     # 0xca5ca
movb $0x1, %al
jmp 0xb8c0
pushq %rax
movq 0x120a9c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbcb40(%rip), %rsi     # 0xca066
leaq 0xbcf7c(%rip), %rdx     # 0xca4a9
leaq 0xbd080(%rip), %rcx     # 0xca5b4
leaq 0xbcf7c(%rip), %r8      # 0xca4b7
movl $0x119, %r9d            # imm = 0x119
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, 0x12248a(%rip)    # 0x12f9e0
je 0xd59d
movq 0x122489(%rip), %rdi    # 0x12f9e8
callq 0x16028
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq 0x12246d(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
leaq 0x86(%rip), %rsi        # 0xd603
xorl %ecx, %ecx
callq 0x55fe2
testl %eax, %eax
jne 0xd5cb
movq 0x122459(%rip), %rdi    # 0x12f9e8
callq 0x1609f
movzbl 0x7(%rsp), %eax
negl %eax
popq %rcx
retq
movq 0x120a14(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbcab8(%rip), %rsi     # 0xca066
leaq 0xbcef4(%rip), %rdx     # 0xca4a9
leaq 0xbd040(%rip), %rcx     # 0xca5fc
leaq 0xbcef4(%rip), %r8      # 0xca4b7
movl $0x123, %r9d            # imm = 0x123
jmp 0xd5f7
movq 0x1209e6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbca8a(%rip), %rsi     # 0xca066
leaq 0xbd030(%rip), %rdx     # 0xca613
leaq 0xbd012(%rip), %rcx     # 0xca5fc
leaq 0xbcec6(%rip), %r8      # 0xca4b7
movl $0x128, %r9d            # imm = 0x128
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xd622
movq %rcx, %rdi
callq 0xc103
testb %al, %al
jne 0xd694
testq %r15, %r15
je 0xd666
testq %r14, %r14
je 0xd666
testq %rbx, %rbx
je 0xd666
cmpb $0x0, (%rbx)
je 0xd63e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x120973(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
movl 0x10(%r14), %ecx
movq (%r14), %rdx
movq 0x8(%r14), %r8
leaq 0xbd0ee(%rip), %rsi     # 0xca748
xorl %eax, %eax
callq 0xb8c0
movb $0x1, (%rbx)
jmp 0xd636
movq 0x12094b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc9ef(%rip), %rsi     # 0xca066
leaq 0xbd0b5(%rip), %rdx     # 0xca733
leaq 0xbcf7d(%rip), %rcx     # 0xca602
leaq 0xbce2b(%rip), %r8      # 0xca4b7
movl $0xf5, %r9d
jmp 0xd6c0
movq 0x12091d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc9c1(%rip), %rsi     # 0xca066
leaq 0xbcfad(%rip), %rdx     # 0xca659
leaq 0xbcf4f(%rip), %rcx     # 0xca602
leaq 0xbcdfd(%rip), %r8      # 0xca4b7
movl $0xf4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, 0x1222c2(%rip)    # 0x12f9e0
je 0xd75e
movq %rdi, %rbx
movq 0x1222be(%rip), %rdi    # 0x12f9e8
callq 0x16028
movq 0x1222aa(%rip), %rax    # 0x12f9e0
movq (%rax), %rdi
leaq 0x84(%rip), %rsi        # 0xd7c4
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x55fe2
movl %eax, %ebx
movq 0x122295(%rip), %rdi    # 0x12f9e8
callq 0x1609f
testl %ebx, %ebx
jne 0xd78c
popq %rbx
retq
movq 0x120853(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc8f7(%rip), %rsi     # 0xca066
leaq 0xbcd33(%rip), %rdx     # 0xca4a9
leaq 0xbceb9(%rip), %rcx     # 0xca636
leaq 0xbcd33(%rip), %r8      # 0xca4b7
movl $0x144, %r9d            # imm = 0x144
jmp 0xd7b8
movq 0x120825(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc8c9(%rip), %rsi     # 0xca066
leaq 0xbce6f(%rip), %rdx     # 0xca613
leaq 0xbce8b(%rip), %rcx     # 0xca636
leaq 0xbcd05(%rip), %r8      # 0xca4b7
movl $0x149, %r9d            # imm = 0x149
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xd7e3
movq %rcx, %rdi
callq 0xc103
testb %al, %al
jne 0xd844
testq %r14, %r14
je 0xd816
testq %r15, %r15
je 0xd816
testq %rbx, %rbx
je 0xd816
movl 0x10(%r14), %ecx
movq (%r14), %rdx
movq 0x8(%r14), %r8
leaq 0xbcfad(%rip), %rsi     # 0xca7b1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb8c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x12079b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc83f(%rip), %rsi     # 0xca066
leaq 0xbcf6d(%rip), %rdx     # 0xca79b
leaq 0xbcf55(%rip), %rcx     # 0xca78a
leaq 0xbcc7b(%rip), %r8      # 0xca4b7
movl $0x13b, %r9d            # imm = 0x13B
jmp 0xd870
movq 0x12076d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc811(%rip), %rsi     # 0xca066
leaq 0xbcdfd(%rip), %rdx     # 0xca659
leaq 0xbcf27(%rip), %rcx     # 0xca78a
leaq 0xbcc4d(%rip), %r8      # 0xca4b7
movl $0x13a, %r9d            # imm = 0x13A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, 0x12215b(%rip)    # 0x12f9e0
je 0xd8d4
movq 0x12215a(%rip), %rdi    # 0x12f9e8
callq 0x16028
movq 0x122146(%rip), %rax    # 0x12f9e0
movb $0x0, 0x8(%rax)
movq (%rax), %rdi
callq 0x563a7
movq 0x12213b(%rip), %rdi    # 0x12f9e8
callq 0x1609f
movq 0x12212f(%rip), %rdi    # 0x12f9e8
callq 0x15fd3
movq 0x12211b(%rip), %rdi    # 0x12f9e0
callq 0xb790
andq $0x0, 0x12210e(%rip)    # 0x12f9e0
popq %rax
retq
movq 0x1206dd(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc781(%rip), %rsi     # 0xca066
leaq 0xbcbbd(%rip), %rdx     # 0xca4a9
leaq 0xbcd5a(%rip), %rcx     # 0xca64d
leaq 0xbcbbd(%rip), %r8      # 0xca4b7
movl $0x14e, %r9d            # imm = 0x14E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xd921
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xd95f
leaq 0x6f(%rip), %rdi        # 0xd997
xorl %esi, %esi
movq %rbx, %rdx
callq 0xdba8
testl %eax, %eax
jne 0xd94b
leaq 0x100(%rip), %rdi       # 0xda3d
xorl %esi, %esi
movq %rbx, %rdx
callq 0xdba8
testl %eax, %eax
je 0xd94d
popq %rbx
retq
leaq 0x194(%rip), %rdi       # 0xdae8
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0xdba8
movq 0x120652(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc6f6(%rip), %rsi     # 0xca066
leaq 0xbcce2(%rip), %rdx     # 0xca659
leaq 0xbccf9(%rip), %rcx     # 0xca677
leaq 0xbcb32(%rip), %r8      # 0xca4b7
movl $0x195, %r9d            # imm = 0x195
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xbcafa(%rip), %r15     # 0xca4b7
pushq $0x40
popq %r12
movq %rsp, %r13
subl $0x1, %ebp
jb 0xd9ed
movq %r12, %rdi
movq %r15, %rsi
movl $0x162, %edx            # imm = 0x162
callq 0xccb0
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4b801
jmp 0xd9c4
xorl %r14d, %r14d
leaq 0xbcac0(%rip), %r15     # 0xca4b7
cmpq $0x186a0, %r14          # imm = 0x186A0
je 0xda24
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x167, %edx            # imm = 0x167
callq 0xd249
incq %r14
jmp 0xd9f7
movq %rbx, %rdi
callq 0x4c19d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %rbx
movl $0x186a0, %r14d         # imm = 0x186A0
leaq 0xbca57(%rip), %r15     # 0xca4b7
pushq $0x1
popq %r12
pushq $0x40
popq %r13
movq %rsp, %rbp
subl $0x1, %r14d
jb 0xda98
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl $0x174, %ecx            # imm = 0x174
callq 0xce9a
movq %rax, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
pushq $0x8
popq %rdx
callq 0x4b801
jmp 0xda6b
xorl %r14d, %r14d
leaq 0xbca15(%rip), %r15     # 0xca4b7
cmpq $0x186a0, %r14          # imm = 0x186A0
je 0xdacf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x179, %edx            # imm = 0x179
callq 0xd249
incq %r14
jmp 0xdaa2
movq %rbx, %rdi
callq 0x4c19d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, %rbx
movl $0x186a0, %ebp          # imm = 0x186A0
leaq 0xbc9a9(%rip), %r15     # 0xca4b7
pushq $0x20
popq %r12
movq %rsp, %r13
subl $0x1, %ebp
jb 0xdb57
xorl %edi, %edi
movq %r12, %rsi
movq %r15, %rdx
movl $0x186, %ecx            # imm = 0x186
callq 0xcfc2
movq %rax, (%rsp)
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x187, %ecx            # imm = 0x187
callq 0xcfc2
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4b801
jmp 0xdb15
xorl %r14d, %r14d
leaq 0xbc956(%rip), %r15     # 0xca4b7
cmpq $0x186a0, %r14          # imm = 0x186A0
je 0xdb8e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movl $0x18c, %edx            # imm = 0x18C
callq 0xd249
incq %r14
jmp 0xdb61
movq %rbx, %rdi
callq 0x4c19d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xdbd1
movq %r12, %rdi
callq 0xc103
testb %al, %al
jne 0xdcd1
testq %r14, %r14
je 0xdca7
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %rbx
pushq $0x1
popq %r13
leaq 0x120ae4(%rip), %rbp    # 0x12e6d4
cmpl (%rbp), %r13d
jae 0xdc20
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x15ba0
movq %rax, (%rsp)
testq %rax, %rax
je 0xdc60
movq %rbx, %rdi
movq %rsp, %rsi
pushq $0x8
popq %rdx
callq 0x4b801
incl %r13d
jmp 0xdbf0
movq %r15, %rdi
callq *%r14
xorl %ebp, %ebp
xorl %eax, %eax
movl %eax, %r14d
movq %rbx, %rdi
callq 0x4b988
cmpq %r14, %rax
jbe 0xdc8e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %rdi, (%rsp)
callq 0x15c93
movq (%rsp), %rdi
callq 0x16116
leal 0x1(%r14), %eax
jmp 0xdc2a
xorl %eax, %eax
pushq $-0x1
popq %rbp
movl %eax, %r14d
movq %rbx, %rdi
callq 0x4b988
cmpq %r14, %rax
jbe 0xdc8e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x16116
leal 0x1(%r14), %eax
jmp 0xdc65
movq %rbx, %rdi
callq 0x4c19d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12030a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc3ae(%rip), %rsi     # 0xca066
leaq 0xc9e61(%rip), %rdx     # 0xd7b20
leaq 0xbcb20(%rip), %rcx     # 0xca7e6
leaq 0xbcb28(%rip), %r8      # 0xca7f5
pushq $0x1e
jmp 0xdcf9
movq 0x1202e0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc384(%rip), %rsi     # 0xca066
leaq 0xbc970(%rip), %rdx     # 0xca659
leaq 0xbcaf6(%rip), %rcx     # 0xca7e6
leaq 0xbcafe(%rip), %r8      # 0xca7f5
pushq $0x1d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xde23
movq %rsi, %rbx
testq %rsi, %rsi
je 0xde23
movq %rdi, %r14
movq %rbx, %rdi
callq 0xb260
testq %rax, %rax
je 0xddf5
movq %rax, %r15
callq 0xb6e0
movq (%rax), %rax
movsbq (%rbx), %rcx
testb $0x1, 0x1(%rax,%rcx,2)
je 0xddf5
cmpb $0x2e, -0x1(%rbx,%r15)
jne 0xde51
leaq 0xbcb66(%rip), %rdx     # 0xca906
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
movl $0xdb, %ecx
callq 0xce9a
movq %rax, %r15
movq %r14, %rdi
callq 0x4f8ae
movq %rax, 0x8(%r15)
movq %rbx, %rdi
callq 0x4f8ae
movq %rax, 0x10(%r15)
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x18(%r15)
orq $-0x1, 0x50(%r15)
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, 0x58(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x1201bc(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc260(%rip), %rsi     # 0xca066
leaq 0xbcb36(%rip), %rdx     # 0xca943
leaq 0xbcb1a(%rip), %rcx     # 0xca92e
leaq 0xbcaeb(%rip), %r8      # 0xca906
movl $0xd9, %r9d
jmp 0xde7d
movq 0x12018e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc232(%rip), %rsi     # 0xca066
leaq 0xbcadd(%rip), %rdx     # 0xca918
leaq 0xbcaec(%rip), %rcx     # 0xca92e
leaq 0xbcabd(%rip), %r8      # 0xca906
movl $0xd7, %r9d
jmp 0xde7d
movq 0x120160(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbc204(%rip), %rsi     # 0xca066
leaq 0xbcb4e(%rip), %rdx     # 0xca9b7
leaq 0xbcabe(%rip), %rcx     # 0xca92e
leaq 0xbca8f(%rip), %r8      # 0xca906
movl $0xda, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xe07c
movq %rsi, %r14
testq %rsi, %rsi
je 0xe07c
movq %rdx, %rbx
movq %rdi, %r15
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0xe060
pushq $0x10
popq %rdi
callq 0x4b380
movq %rax, %rdi
movq %rax, 0x20(%r15)
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, 0x8(%rsi)
pushq $0x10
popq %rdx
callq 0x4b801
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x11ff35(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbbfd9(%rip), %rsi     # 0xca066
leaq 0xbca12(%rip), %rdx     # 0xcaaa6
leaq 0xbca16(%rip), %rcx     # 0xcaab1
leaq 0xbc864(%rip), %r8      # 0xca906
movl $0x10e, %r9d            # imm = 0x10E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xe0d4
movq 0x58(%rdi), %rdi
leaq 0x75(%rip), %rsi        # 0xe13a
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x55fe2
testl %eax, %eax
jne 0xe102
popq %rax
retq
movq 0x11fedd(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbbf81(%rip), %rsi     # 0xca066
leaq 0xc9eb7(%rip), %rdx     # 0xd7fa3
leaq 0xbc9dd(%rip), %rcx     # 0xcaad0
leaq 0xbc80c(%rip), %r8      # 0xca906
movl $0x121, %r9d            # imm = 0x121
jmp 0xe12e
movq 0x11feaf(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbbf53(%rip), %rsi     # 0xca066
leaq 0xbc9cd(%rip), %rdx     # 0xcaae7
leaq 0xbc9af(%rip), %rcx     # 0xcaad0
leaq 0xbc7de(%rip), %r8      # 0xca906
movl $0x123, %r9d            # imm = 0x123
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/option.c
// Function: add_common_options
static void add_common_options(GtOptionParser *op)
{
  bool has_extended_options;
  GtOption *option;
  gt_assert(op);
  has_extended_options = has_extended_option(op->options);
  option = gt_option_new_help(has_extended_options);
  gt_option_parser_add_option(op, option);
  if (has_extended_options) {
    option = gt_option_new_helpplus();
    gt_option_parser_add_option(op, option);
  }
  option = gt_option_new_helpdev();
  gt_option_parser_add_option(op, option);
  option = gt_option_new_version();
  gt_option_parser_add_option(op, option);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0xea3f
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x4b988
cmpq %rax, %r15
jae 0xe9b9
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b48e
movq (%rax), %rax
incq %r15
cmpb $0x1, 0x4d(%rax)
jne 0xe94e
leaq 0xbcce1(%rip), %rdi     # 0xcb65a
leaq 0xbcb60(%rip), %rsi     # 0xcb4e0
xorl %edx, %edx
callq 0x10962
movl $0x4, (%rax)
movb $0x0, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xbcb7b(%rip), %rdi     # 0xcb51e
leaq 0xbcb7a(%rip), %rsi     # 0xcb524
xorl %edx, %edx
callq 0x10962
movl $0x5, (%rax)
jmp 0xe9d4
leaq 0xbcc9a(%rip), %rdi     # 0xcb65a
leaq 0xbcb41(%rip), %rsi     # 0xcb508
xorl %edx, %edx
callq 0x10962
movl $0x4, (%rax)
xorl %r14d, %r14d
movb %r14b, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xbcb5d(%rip), %rdi     # 0xcb54a
leaq 0xbcb5e(%rip), %rsi     # 0xcb552
xorl %edx, %edx
callq 0x10962
movl $0x6, (%rax)
movb %r14b, 0x20(%rax)
movb $0x1, 0x4e(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xd333e(%rip), %rdi     # 0xe1d59
leaq 0xbcb5e(%rip), %rsi     # 0xcb580
xorl %edx, %edx
callq 0x10962
movl $0xe, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xde89
movq 0x11f572(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xbb616(%rip), %rsi     # 0xca066
leaq 0xdeed0(%rip), %rdx     # 0xed927
leaq 0xbca6e(%rip), %rcx     # 0xcb4cc
leaq 0xbbea1(%rip), %r8      # 0xca906
movl $0x1fb, %r9d            # imm = 0x1FB
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $0x2d
popq %rbp
movq %r15, %rdi
callq 0xb260
cmpq %rax, %r12
jae 0xead2
movsbq (%r15,%r12), %r13
cmpq $0x20, %r13
setne %cl
movl %ebp, %eax
cmovnel %r13d, %eax
andb %bl, %cl
cmpb $0x1, %cl
jne 0xeac2
callq 0xb0b0
movq (%rax), %rax
movb (%rax,%r13,4), %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x140b1
incq %r12
jmp 0xea90
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x13dd3
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x140b1
xorl %r15d, %r15d
pushq $0x2d
popq %rbp
movq %r14, %rdi
callq 0xb260
cmpq %rax, %r15
jae 0xeb26
movq %rbx, %rdi
movl %ebp, %esi
callq 0x140b1
incq %r15
jmp 0xeb0a
leaq 0xd209b(%rip), %rsi     # 0xe0bc8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13dd3