LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str.c
// Function: gt_str_clone
GtStr* gt_str_clone(const GtStr *s)
{
  GtStr *s_copy;
  gt_assert(s);
  s_copy = gt_malloc(sizeof *s_copy);
  s->cstr[s->length] = '\0';
  s_copy->cstr = gt_cstr_dup(s->cstr);
  s_copy->length = s->length;
  s_copy->allocated = s->length + 1;
  s_copy->reference_count = 0;
  return s_copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3c55c
movq %rdi, %rbx
leaq 0xa7002(%rip), %rsi     # 0xe3510
movl $0x20, %edi
movl $0xee, %edx
callq 0x35ee2
movq %rax, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %rdi
callq 0x722dc
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rax
incq %rax
movq %rax, 0x10(%r14)
movl $0x0, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xe1fb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str.c
// Function: gt_str_delete
void gt_str_delete(GtStr *s)
{
  if (!s) return;           /* return without action if 's' is NULL */
  if (s->reference_count) { /* there are multiple references to this string */
    s->reference_count--;   /* decrement the reference counter */
    return;                 /* return without freeing the object */
  }
  gt_free(s->cstr);         /* free the stored the C string */
  gt_free(s);               /* free the actual string object */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d203
movq %rdi, %rbx
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x3d20b
decl %eax
movl %eax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
leaq 0xa62fb(%rip), %r14     # 0xe3510
movq %r14, %rsi
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1d9, %edx            # imm = 0x1D9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_new
GtStrArray* gt_str_array_new(void)
{
  GtStrArray *sa = gt_malloc(sizeof *sa);
  sa->strings = gt_array_new(sizeof (GtStr*));
  sa->reference_count = 0;
  return sa;
}

// Assembly:
pushq %rbx
leaq 0xa6727(%rip), %rsi     # 0xe396b
movl $0x10, %edi
movl $0x1d, %edx
callq 0x35ee2
movq %rax, %rbx
movl $0x8, %edi
callq 0x6e93c
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_new_file
GtStrArray* gt_str_array_new_file(const char *path)
{
  GtStrArray *filecontent;
  GtFile *fpin;
  GtStr *line;
  fpin = gt_file_xopen(path, "r");
  gt_assert(fpin);
  line = gt_str_new();
  filecontent = gt_str_array_new();
  while (gt_str_read_next_line_generic(line, fpin) != EOF) {
    gt_str_array_add_cstr(filecontent, gt_str_get(line));
    gt_str_reset(line);
  }
  gt_str_delete(line);
  gt_file_delete(fpin);
  return filecontent;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xb1c1e(%rip), %rsi     # 0xeeea8
callq 0x756a8
testq %rax, %rax
je 0x3d313
movq %rax, %rbx
callq 0x3bfe0
movq %rax, %r14
leaq 0xa66c5(%rip), %rsi     # 0xe396b
movl $0x10, %edi
movl $0x1d, %edx
callq 0x35ee2
movq %rax, %r15
movl $0x8, %edi
callq 0x6e93c
movq %rax, (%r15)
movl $0x0, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c6ed
cmpl $-0x1, %eax
je 0x3d2fa
movq %r14, %rdi
callq 0x3c40b
movq %r15, %rdi
movq %rax, %rsi
callq 0x3d318
movq %r14, %rdi
callq 0x3c49c
jmp 0x3d2cd
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rdi
callq 0x75b7c
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xe2df
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_add_cstr
void gt_str_array_add_cstr(GtStrArray *sa, const char *cstr)
{
  GtStr *str;
  gt_assert(sa && cstr);
  str = gt_str_new_cstr(cstr);
  gt_array_add(sa->strings, str);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3d34d
testq %rsi, %rsi
je 0x3d34d
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3c03d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
movl $0x8, %edx
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
retq
callq 0xe316
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_add_cstr_nt
void gt_str_array_add_cstr_nt(GtStrArray *sa, const char *cstr,
                             GtUword length)
{
  GtStr *str;
  gt_assert(sa && cstr);
  str = gt_str_new();
  gt_str_append_cstr_nt(str, cstr, length);
  gt_array_add(sa->strings, str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d3a3
movq %rsi, %r15
testq %rsi, %rsi
je 0x3d3a3
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3bfe0
movq %rsp, %r12
movq %rax, (%r12)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3c185
movq (%rbx), %rdi
movl $0x8, %edx
movq %r12, %rsi
callq 0x6ec0e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xe34d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_add
void gt_str_array_add(GtStrArray *sa, const GtStr *str)
{
  GtStr *clone;
  gt_assert(sa && str);
  clone = gt_str_clone(str);
  gt_array_add(sa->strings, clone);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3d3dd
testq %rsi, %rsi
je 0x3d3dd
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3c4fb
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rdi
movl $0x8, %edx
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
retq
callq 0xe384
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_set_cstr
void gt_str_array_set_cstr(GtStrArray *sa, GtUword strnum,
                           const char *cstr)
{
  GtStr *str;
  gt_assert(sa && strnum < gt_array_size(sa->strings) && cstr);
  str = *(GtStr**) gt_array_get(sa->strings, strnum);
  gt_str_set(str, cstr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3d494
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x6ecda
testq %rbx, %rbx
je 0x3d494
cmpq %r14, %rax
jbe 0x3d494
movq (%r15), %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3c0cc
callq 0xe429
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_set
void gt_str_array_set(GtStrArray *sa, GtUword strnum, const GtStr *instr)
{
  GtStr *str;
  gt_assert(sa && strnum < gt_array_size(sa->strings) && instr);
  str = *(GtStr**) gt_array_get(sa->strings, strnum);
  gt_str_set(str, gt_str_get(instr));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3d4e4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x6ecda
testq %rbx, %rbx
je 0x3d4e4
cmpq %r14, %rax
jbe 0x3d4e4
movq (%r15), %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %r14
movq %rbx, %rdi
callq 0x3c40b
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3c0cc
callq 0xe460
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_set_size
void gt_str_array_set_size(GtStrArray *sa, GtUword size)
{
  GtUword i;
  gt_assert(sa && size <= gt_array_size(sa->strings));
  for (i = size; i < gt_array_size(sa->strings); i++)
    gt_str_delete(*(GtStr**) gt_array_get(sa->strings, i));
  gt_array_set_size(sa->strings, size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3d549
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x6ecda
cmpq %rbx, %rax
jb 0x3d549
movq (%r14), %rdi
callq 0x6ecda
cmpq %rbx, %rax
jbe 0x3d539
movq %rbx, %r15
movq (%r14), %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x3d1eb
incq %r15
movq (%r14), %rdi
callq 0x6ecda
cmpq %rax, %r15
jb 0x3d516
movq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6ecf7
callq 0xe497
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/str_array.c
// Function: gt_str_array_delete
void gt_str_array_delete(GtStrArray *sa)
{
  GtUword i;
  if (!sa) return;
  if (sa->reference_count) {
    sa->reference_count--;
    return;
  }
  for (i = 0; i < gt_array_size(sa->strings); i++)
    gt_str_delete(*(GtStr**) gt_array_get(sa->strings, i));
  gt_array_delete(sa->strings);
  gt_free(sa);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d58b
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x3d593
decl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x3d5c6
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x3d1eb
incq %r14
movq (%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r14
jb 0x3d5a3
movq (%rbx), %rdi
callq 0x6f134
leaq 0xa6396(%rip), %rsi     # 0xe396b
movq %rbx, %rdi
movl $0x93, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/strand.c
// Function: gt_strand_join
GtStrand gt_strand_join(GtStrand strand_a, GtStrand strand_b)
{
  switch (strand_b) {
    case GT_STRAND_FORWARD:
      gt_assert(strand_a != GT_STRAND_REVERSE);
      return GT_STRAND_FORWARD;
    case GT_STRAND_REVERSE:
      gt_assert(strand_a != GT_STRAND_FORWARD);
      return GT_STRAND_REVERSE;
    case GT_STRAND_BOTH: break;
    case GT_STRAND_UNKNOWN:
      /* strand_a == GT_STRAND_FORWARD -> stays the same */
      /* strand_a == GT_STRAND_REVERSE -> stays the same */
      /* strand_a == GT_STRAND_UNKNOWN -> stays the same */
      if (strand_a == GT_STRAND_BOTH)
        return GT_STRAND_UNKNOWN;
      break;
    default: gt_assert(0);
  }
  return strand_a;
}

// Assembly:
pushq %rax
cmpl $0x3, %esi
ja 0x3d675
movl %esi, %eax
leaq 0xa64e5(%rip), %rcx     # 0xe3b2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
cmpl $0x1, %edi
jne 0x3d673
callq 0xe5ac
movl $0x3, %eax
cmpl $0x2, %edi
je 0x3d673
movl %edi, %eax
jmp 0x3d673
movl $0x1, %eax
testl %edi, %edi
je 0x3d67a
popq %rcx
retq
callq 0xe5e3
callq 0xe575
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/symbol.c
// Function: gt_symbol_init
void gt_symbol_init(void)
{
  if (!symbols)
    symbols = gt_cstr_table_new();
  if (!symbol_mutex)
    symbol_mutex = gt_mutex_new();
}

// Assembly:
pushq %rax
cmpq $0x0, 0x11538f(%rip)    # 0x152a18
jne 0x3d697
callq 0x72918
movq %rax, 0x115381(%rip)    # 0x152a18
cmpq $0x0, 0x115381(%rip)    # 0x152a20
jne 0x3d6ad
callq 0x3d96a
movq %rax, 0x115373(%rip)    # 0x152a20
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/symbol.c
// Function: gt_symbol
const char* gt_symbol(const char *cstr)
{
  const char *symbol;
  if (!cstr)
    return NULL;
  gt_mutex_lock(symbol_mutex);
  if (!(symbol = gt_cstr_table_get(symbols, cstr))) {
    gt_cstr_table_add(symbols, cstr);
    symbol = gt_cstr_table_get(symbols, cstr);
  }
  gt_mutex_unlock(symbol_mutex);
  return symbol;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d70d
movq %rdi, %rbx
movq 0x11535e(%rip), %rdi    # 0x152a20
callq 0x3d9b7
movq 0x11534a(%rip), %rdi    # 0x152a18
movq %rbx, %rsi
callq 0x729dd
movq %rax, %r14
testq %rax, %rax
jne 0x3d6ff
movq 0x115333(%rip), %rdi    # 0x152a18
movq %rbx, %rsi
callq 0x7297e
movq 0x115324(%rip), %rdi    # 0x152a18
movq %rbx, %rsi
callq 0x729dd
movq %rax, %r14
movq 0x11531a(%rip), %rdi    # 0x152a20
callq 0x3d9d2
jmp 0x3d710
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/symbol.c
// Function: test_symbol
static void* test_symbol(GT_UNUSED void *data)
{
  GtStr *symbol;
  GtUword i;
  symbol = gt_str_new();
  for (i = 0; i < NUMBER_OF_SYMBOLS; i++) {
    gt_str_reset(symbol);
    gt_str_append_uword(symbol, gt_rand_max(MAX_SYMBOL));
    gt_symbol(gt_str_get(symbol));
    gt_assert(!strcmp(gt_symbol(gt_str_get(symbol)), gt_str_get(symbol)));
  }
  gt_str_delete(symbol);
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x2710, %r15d          # imm = 0x2710
callq 0x3bfe0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3c49c
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x7a188
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3c1dc
movq %rbx, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x3d6af
movq %rbx, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x3d6af
movq %rax, %r14
movq %rbx, %rdi
callq 0x3c40b
movq %r14, %rdi
movq %rax, %rsi
callq 0xb890
testl %eax, %eax
jne 0x3d7e0
decq %r15
jne 0x3d774
movq %rbx, %rdi
callq 0x3d1eb
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xe651
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_thread_new
GtThread* gt_thread_new(GtThreadFunc function, void *data, GtError *err)
{
  GtThread *thread;
  int rval;
  gt_error_check(err);
  gt_assert(function);
  thread = gt_malloc(sizeof (pthread_t));
  rval = pthread_create((pthread_t*) thread, NULL, function, data);
  if (rval) {
    gt_error_set(err, "cannot create thread: %s", strerror(rval));
    gt_free(thread);
    return NULL;
  }
  return thread;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rdx, %rdx
je 0x3d80a
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x3d882
testq %r12, %r12
je 0x3d87d
leaq 0xa6421(%rip), %rsi     # 0xe3c37
movl $0x8, %edi
movl $0x25, %edx
callq 0x35ee2
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0xbbb0
testl %eax, %eax
je 0x3d86e
movl %eax, %edi
callq 0xb1d0
leaq 0xa63ff(%rip), %rsi     # 0xe3c49
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3559f
leaq 0xa63d9(%rip), %rsi     # 0xe3c37
movq %r14, %rdi
movl $0x29, %edx
callq 0x362a0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xe6bf
callq 0xe688
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_thread_join
void gt_thread_join(GtThread *thread)
{
  GT_UNUSED int rval;
  gt_assert(thread);
  rval = pthread_join(*(pthread_t*) thread, NULL);
  gt_assert(!rval); /* XXX */
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d89d
movq (%rdi), %rdi
xorl %esi, %esi
callq 0xb5b0
testl %eax, %eax
jne 0x3d8a2
popq %rax
retq
callq 0xe72d
callq 0xe6f6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_new
GtRWLock* gt_rwlock_new(void)
{
  GtRWLock *rwlock;
  GT_UNUSED int rval;
  /* XXX: can we use gt_malloc() here? */
  rwlock = thread_xmalloc(sizeof (pthread_rwlock_t), __FILE__, __LINE__);
  /* initialize read/write lock with default attributes */
  rval = pthread_rwlock_init((pthread_rwlock_t*) rwlock, NULL);
  gt_assert(!rval);
  return rwlock;
}

// Assembly:
pushq %rbx
movl $0x38, %edi
movl $0x48, %esi
callq 0x3d8d2
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb480
testl %eax, %eax
jne 0x3d8cd
movq %rbx, %rax
popq %rbx
retq
callq 0xe764
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_delete
void gt_rwlock_delete(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  if (!rwlock) return;
  rval = pthread_rwlock_destroy((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
  free(rwlock);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3d912
movq %rdi, %rbx
callq 0xba90
testl %eax, %eax
jne 0x3d914
movq %rbx, %rdi
popq %rbx
jmp 0xb790
popq %rbx
retq
callq 0xe7f9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_rdlock_func
void gt_rwlock_rdlock_func(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  gt_assert(rwlock);
  rval = pthread_rwlock_rdlock((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d92a
callq 0xb5d0
testl %eax, %eax
jne 0x3d92f
popq %rax
retq
callq 0xe867
callq 0xe830
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_wrlock_func
void gt_rwlock_wrlock_func(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  gt_assert(rwlock);
  rval = pthread_rwlock_wrlock((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d945
callq 0xb950
testl %eax, %eax
jne 0x3d94a
popq %rax
retq
callq 0xe8d5
callq 0xe89e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_rwlock_unlock_func
void gt_rwlock_unlock_func(GtRWLock *rwlock)
{
  GT_UNUSED int rval;
  gt_assert(rwlock);
  rval = pthread_rwlock_unlock((pthread_rwlock_t*) rwlock);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d960
callq 0xb800
testl %eax, %eax
jne 0x3d965
popq %rax
retq
callq 0xe943
callq 0xe90c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_new
GtMutex* gt_mutex_new(void)
{
  GtMutex *mutex;
  GT_UNUSED int rval;
  /* XXX: can we use gt_malloc() here? */
  mutex = thread_xmalloc(sizeof (pthread_mutex_t), __FILE__, __LINE__);
  /* initialize mutex with default attributes */
  rval = pthread_mutex_init((pthread_mutex_t*) mutex, NULL);
  gt_assert(!rval);
  return mutex;
}

// Assembly:
pushq %rbx
movl $0x28, %edi
movl $0x75, %esi
callq 0x3d8d2
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb930
testl %eax, %eax
jne 0x3d990
movq %rbx, %rax
popq %rbx
retq
callq 0xe97a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_delete
void gt_mutex_delete(GtMutex *mutex)
{
  GT_UNUSED int rval;
  if (!mutex) return;
  rval = pthread_mutex_destroy((pthread_mutex_t*) mutex);
  gt_assert(!rval);
  free(mutex);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3d9b0
movq %rdi, %rbx
callq 0xb750
testl %eax, %eax
jne 0x3d9b2
movq %rbx, %rdi
popq %rbx
jmp 0xb790
popq %rbx
retq
callq 0xe9b1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_lock_func
void gt_mutex_lock_func(GtMutex *mutex)
{
  GT_UNUSED int rval;
  gt_assert(mutex);
  rval = pthread_mutex_lock((pthread_mutex_t*) mutex);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d9c8
callq 0xb920
testl %eax, %eax
jne 0x3d9cd
popq %rax
retq
callq 0xea23
callq 0xe9ea
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/thread.c
// Function: gt_mutex_unlock_func
void gt_mutex_unlock_func(GtMutex *mutex)
{
  GT_UNUSED int rval;
  gt_assert(mutex);
  rval = pthread_mutex_unlock((pthread_mutex_t*) mutex);
  gt_assert(!rval);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3d9e3
callq 0xb470
testl %eax, %eax
jne 0x3d9e8
popq %rax
retq
callq 0xea95
callq 0xea5c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/versionfunc.c
// Function: gt_versionfunc
void gt_versionfunc(const char *progname)
{
  printf("%s (GenomeTools) %s\n", progname, GT_VERSION);
  printf("Copyright (c) 2003-2023 G. Gremme, S. Steinbiss, S. Kurtz, and "
         "CONTRIBUTORS\n");
  printf("Copyright (c) 2003-2023 Center for Bioinformatics, University of "
         "Hamburg\n");
  printf("See LICENSE file or http://genometools.org/license.html for license "
         "details.\n\n");
  printf("Used compiler: %s\n", GT_CC);
  printf("Compile flags: %s\n", GT_CFLAGS);
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0xa6334(%rip), %rdi     # 0xe3d43
leaq 0xa4166(%rip), %rdx     # 0xe1b7c
xorl %eax, %eax
callq 0xb070
leaq 0xa6460(%rip), %rdi     # 0xe3e84
callq 0xb9c0
leaq 0xa64a0(%rip), %rdi     # 0xe3ed0
callq 0xb9c0
leaq 0xa64dd(%rip), %rdi     # 0xe3f19
callq 0xb9c0
leaq 0xa6310(%rip), %rdi     # 0xe3d58
leaq 0xa631c(%rip), %rsi     # 0xe3d6b
xorl %eax, %eax
callq 0xb070
leaq 0xa637c(%rip), %rdi     # 0xe3dd9
leaq 0xa6388(%rip), %rsi     # 0xe3dec
xorl %eax, %eax
popq %rcx
jmp 0xb070
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfgetc
int gt_xfgetc(FILE *stream)
{
  int cc;
  if ((cc = fgetc(stream)) == EOF) {
    if (ferror(stream)) {
      perror("cannot read char");
      exit(EXIT_FAILURE);
    }
  }
  return cc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xb9e0
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x3dbaa
movq %r14, %rdi
callq 0xbc30
testl %eax, %eax
jne 0x3dbb4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xeb4c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfgets
char* gt_xfgets(char *s, int size, FILE *stream)
{
  char *str;
  if ((str = fgets(s, size, stream)) == NULL) {
    if (ferror(stream)) {
      perror("cannot read string");
      exit(EXIT_FAILURE);
    }
  }
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0xb9f0
movq %rax, %r14
testq %rax, %rax
jne 0x3dbd9
movq %rbx, %rdi
callq 0xbc30
testl %eax, %eax
jne 0x3dbe4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xeb61
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfputs
void gt_xfputs(const char *str, FILE *stream)
{
  gt_assert(str);
  if (fputs(str, stream) == EOF) {
    perror("cannot fputs to stream");
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3dc36
callq 0xb730
cmpl $-0x1, %eax
je 0x3dc3b
popq %rax
retq
callq 0xebf1
callq 0xebdc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfread
size_t gt_xfread(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
  size_t rval;
  if ((rval = fread(ptr, size, nmemb, stream)) < nmemb) {
    if (ferror(stream)) {
      perror("cannot read from stream");
      exit(EXIT_FAILURE);
    }
  }
  return rval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
callq 0xb940
movq %rax, %r14
cmpq %r15, %rax
jae 0x3dc64
movq %rbx, %rdi
callq 0xbc30
testl %eax, %eax
jne 0x3dc6d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xec28
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfwrite
void gt_xfwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
{
  GtUword itemsperblock = (1 << 30) / size,
                itemstowrite = nmemb,
                itemswritten = 0;
  while (itemstowrite >= itemsperblock) {
    if (fwrite((char*) ptr + (size * itemswritten), size,
               itemsperblock, stream) != itemsperblock) {
      perror("cannot write to stream");
      exit(EXIT_FAILURE);
    }
    itemstowrite -= itemsperblock;
    itemswritten += itemsperblock;
  }
  if (itemstowrite > 0) {
    if (fwrite((char*)ptr + (size * itemswritten), size,
               itemstowrite, stream) != itemstowrite) {
      perror("cannot write to stream");
      exit(EXIT_FAILURE);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %ebp, %ebp
movl $0x40000000, %eax       # imm = 0x40000000
xorl %edx, %edx
divq %rsi
cmpq %rbx, %rax
ja 0x3dce9
movq %rax, %r13
xorl %ebp, %ebp
movq %rbp, %rdi
imulq %r15, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xbcb0
cmpq %r13, %rax
jne 0x3dd1a
subq %r13, %rbx
addq %r13, %rbp
cmpq %r13, %rbx
jae 0x3dcc1
testq %rbx, %rbx
je 0x3dd0b
imulq %r15, %rbp
addq %rbp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xbcb0
cmpq %rbx, %rax
jne 0x3dd1f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xec67
callq 0xec7c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/yarandom.c
// Function: gt_ya_random
unsigned int
gt_ya_random (void)
{
  register int ret;
  gt_mutex_lock(mutex);
  ret = a[i1] + a[i2];
  a[i1] = ret;
  if (++i1 >= VectorSize) i1 = 0;
  if (++i2 >= VectorSize) i2 = 0;
  gt_mutex_unlock(mutex);
  return ret;
}

// Assembly:
pushq %rbx
movq 0x114c90(%rip), %rdi    # 0x152a30
callq 0x3d9b7
movslq 0x114d70(%rip), %rax    # 0x152b1c
leaq 0x114c8d(%rip), %rcx    # 0x152a40
movslq 0x114d66(%rip), %rdx    # 0x152b20
movl (%rcx,%rdx,4), %ebx
addl (%rcx,%rax,4), %ebx
leal 0x1(%rax), %esi
xorl %edi, %edi
cmpq $0x36, %rax
cmovgel %edi, %esi
leal 0x1(%rdx), %r8d
cmpq $0x36, %rdx
movl %ebx, (%rcx,%rax,4)
movl %esi, 0x114d3f(%rip)    # 0x152b1c
cmovgel %edi, %r8d
movl %r8d, 0x114d38(%rip)    # 0x152b20
movq 0x114c41(%rip), %rdi    # 0x152a30
callq 0x3d9d2
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/yarandom.c
// Function: gt_ya_rand_init
unsigned int
gt_ya_rand_init(unsigned int seed)
{
  unsigned int generated_seed;
  int i;
  if (!mutex)
    mutex = gt_mutex_new();
  if (seed == 0)
    {
      struct timeval tp;
      struct timezone tzp;
      gettimeofday(&tp, &tzp);
      /* ignore overflow */
      seed = (999*tp.tv_sec) + (1001*tp.tv_usec) + (1003 * getpid());
    }
  generated_seed = seed;

  /* allow to call gt_ya_rand_init() multiple times */
  for (i = 0; i < VectorSize; i++)
    a[i] = a_source[i];

  a[0] += seed;
  for (i = 1; i < VectorSize; i++)
    {
      seed = a[i-1]*1001 + seed*999;
      a[i] += seed;
    }

  i1 = a[0] % VectorSize;
  i2 = (i1 + 024) % VectorSize;
  return generated_seed;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
cmpq $0x0, 0x114c26(%rip)    # 0x152a30
jne 0x3de18
callq 0x3d96a
movq %rax, 0x114c18(%rip)    # 0x152a30
testl %ebx, %ebx
jne 0x3de4a
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xba20
imull $0x3e7, (%rbx), %eax    # imm = 0x3E7
imull $0x3e9, 0x8(%rbx), %ebp # imm = 0x3E9
addl %eax, %ebp
callq 0xb910
imull $0x3eb, %eax, %ebx      # imm = 0x3EB
addl %ebp, %ebx
leaq 0x114bef(%rip), %r14    # 0x152a40
leaq 0xa62e8(%rip), %rsi     # 0xe4140
movl $0xdc, %edx
movq %r14, %rdi
callq 0xb520
movl 0x114bd5(%rip), %eax    # 0x152a40
addl %ebx, %eax
movl %eax, 0x114bcd(%rip)    # 0x152a40
movl $0x1, %ecx
movl %eax, %esi
movl %ebx, %edx
imull $0x3e9, %esi, %esi      # imm = 0x3E9
imull $0x3e7, %edx, %edx      # imm = 0x3E7
addl %esi, %edx
movl (%r14,%rcx,4), %esi
addl %edx, %esi
movl %esi, (%r14,%rcx,4)
incq %rcx
cmpq $0x37, %rcx
jne 0x3de7c
movl %eax, %ecx
imulq $0x29e4129f, %rcx, %rcx # imm = 0x29E4129F
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x5, %edx
imull $0x37, %edx, %ecx
movl %eax, %edx
subl %ecx, %edx
movl %edx, 0x114c5a(%rip)    # 0x152b1c
negl %ecx
addl %ecx, %eax
addl $0x14, %eax
imulq $0x4a7904b, %rax, %rcx  # imm = 0x4A7904B
shrq $0x20, %rcx
imull $0x37, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x114c41(%rip)    # 0x152b20
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_create
GtFeatureIndex* gt_feature_index_create(const GtFeatureIndexClass *fic)
{
  GtFeatureIndex *fi;
  gt_assert(fic && fic->size);
  fi = gt_calloc(1, fic->size);
  fi->c_class = fic;
  fi->pvt = gt_calloc(1, sizeof (GtFeatureIndexMembers));
  fi->pvt->lock = gt_rwlock_new();
  return fi;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3dfe2
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x3dfe2
leaq 0xa62ac(%rip), %r14     # 0xe4245
movl $0x1, %edi
movq %r14, %rdx
movl $0x68, %ecx
callq 0x3601f
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r14, %rdx
movl $0x6a, %ecx
callq 0x3601f
movq %rax, 0x8(%r15)
callq 0x3d8a7
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xed44
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_ref
GtFeatureIndex* gt_feature_index_ref(GtFeatureIndex *fi)
{
  gt_assert(fi);
  gt_rwlock_wrlock(fi->pvt->lock);
  fi->pvt->reference_count++;
  gt_rwlock_unlock(fi->pvt->lock);
  return fi;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3e011
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x3d94f
movq %rbx, %rax
popq %rbx
retq
callq 0xed7b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_delete
void gt_feature_index_delete(GtFeatureIndex *fi)
{
  if (!fi) return;
  gt_rwlock_wrlock(fi->pvt->lock);
  if (fi->pvt->reference_count) {
    fi->pvt->reference_count--;
    gt_rwlock_unlock(fi->pvt->lock);
    return;
  }
  gt_assert(fi->c_class);
  if (fi->c_class->free)
    fi->c_class->free(fi);
  gt_rwlock_unlock(fi->pvt->lock);
  gt_rwlock_delete(fi->pvt->lock);
  gt_free(fi->pvt);
  gt_free(fi);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e04d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x3e055
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d94f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x3e0b4
movq 0x60(%rax), %rax
testq %rax, %rax
je 0x3e06b
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d8f7
movq 0x8(%rbx), %rdi
leaq 0xa61b5(%rip), %r14     # 0xe4245
movq %r14, %rsi
movl $0x86, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0xedb2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_add_region_node
int  gt_feature_index_add_region_node(GtFeatureIndex *feature_index,
                                      GtRegionNode *region_node,
                                      GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && region_node);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->add_region_node(feature_index, region_node,
                                                err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e111
movq %rsi, %r15
testq %rsi, %rsi
je 0x3e111
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e111
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x8(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xedeb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_add_feature_node
int  gt_feature_index_add_feature_node(GtFeatureIndex *feature_index,
                                       GtFeatureNode *feature_node,
                                       GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && feature_node);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->add_feature_node(feature_index, feature_node,
                                                 err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e16e
movq %rsi, %r15
testq %rsi, %rsi
je 0x3e16e
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e16e
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xee24
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_remove_node
int  gt_feature_index_remove_node(GtFeatureIndex *feature_index,
                                  GtFeatureNode *node, GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && node);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->remove_node(feature_index, node, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e1cb
movq %rsi, %r15
testq %rsi, %rsi
je 0x3e1cb
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e1cb
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x18(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xee5d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_add_gff3file
int gt_feature_index_add_gff3file(GtFeatureIndex *feature_index,
                                  const char *gff3file, GtError *err)
{
  GtNodeStream *gff3_in_stream;
  GtGenomeNode *gn;
  GtArray *tmp;
  int had_err = 0;
  GtUword i;
  gt_error_check(err);
  gt_assert(feature_index && gff3file);
  tmp = gt_array_new(sizeof (GtGenomeNode*));
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(1, &gff3file);
  while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn)
    gt_array_add(tmp, gn);
  if (!had_err) {
    GtNodeVisitor *feature_visitor = gt_feature_visitor_new(feature_index);
    for (i=0;i<gt_array_size(tmp);i++) {
      gn = *(GtGenomeNode**) gt_array_get(tmp, i);
      /* no need to lock, add_*_node() is synchronized */
      had_err = gt_genome_node_accept(gn, feature_visitor, NULL);
      gt_assert(!had_err); /* cannot happen */
    }
    gt_node_visitor_delete(feature_visitor);
  }
  gt_node_stream_delete(gff3_in_stream);
  for (i=0;i<gt_array_size(tmp);i++)
    gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(tmp, i));
  gt_array_delete(tmp);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %r15
movq %rsi, 0x10(%rsp)
testq %rdx, %rdx
je 0x3e1fe
movq %r12, %rdi
callq 0x3566a
testb %al, %al
jne 0x3e33f
testq %r15, %r15
je 0x3e33a
cmpq $0x0, 0x10(%rsp)
je 0x3e33a
movl $0x8, %edi
callq 0x6e93c
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movl $0x1, %edi
callq 0x42fbb
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x499e4
movl %eax, %ebp
testl %eax, %eax
sete %al
jne 0x3e287
cmpq $0x0, 0x8(%rsp)
je 0x3e287
leaq 0x8(%rsp), %r13
movl $0x8, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6ec0e
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x499e4
movl %eax, %ebp
testl %eax, %eax
sete %al
jne 0x3e287
cmpq $0x0, 0x8(%rsp)
jne 0x3e258
testb %al, %al
je 0x3e2e1
movq %r15, %rdi
callq 0x41c4b
movq %rax, %r15
movq %rbx, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x3e2d7
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
movq %r15, %rsi
xorl %edx, %edx
callq 0x42036
testl %eax, %eax
jne 0x3e335
incq %r12
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r12
jb 0x3e2a6
movq %r15, %rdi
callq 0x49e5e
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x4996a
movq %rbx, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x3e31c
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x42ade
incq %r14
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r14
jb 0x3e2f9
movq %rbx, %rdi
callq 0x6f134
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xef08
callq 0xeecf
callq 0xee96
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_features_for_seqid
GtArray* gt_feature_index_get_features_for_seqid(GtFeatureIndex *fi,
                                                 const char *seqid,
                                                 GtError *err)
{
  GtArray *arr;
  gt_assert(fi && fi->c_class && seqid);
  gt_rwlock_rdlock(fi->pvt->lock);
  arr = fi->c_class->get_features_for_seqid(fi, seqid, err);
  gt_rwlock_unlock(fi->pvt->lock);
  return arr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3e397
movq %rsi, %r15
testq %rsi, %rsi
je 0x3e397
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e397
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x20(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xef41
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_features_for_range
int gt_feature_index_get_features_for_range(GtFeatureIndex *feature_index,
                                            GtArray *results,
                                            const char *seqid,
                                            const GtRange *range, GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && results && seqid &&
            range);
  gt_assert(gt_range_length(range) > 0);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  ret = feature_index->c_class->get_features_for_range(feature_index, results,
                                                       seqid, range, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e44b
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %xmm0
movq %rsi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x3e44b
movq %r8, %r14
movq %r15, %rdi
callq 0x7e05b
testq %rax, %rax
je 0x3e450
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq *0x28(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xefb3
callq 0xef7a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_first_seqid
char* gt_feature_index_get_first_seqid(const GtFeatureIndex
                                             *feature_index,
                                              GtError *err)
{
  const char *str;
  gt_assert(feature_index && feature_index->c_class);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  str = feature_index->c_class->get_first_seqid(feature_index, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return (char*) str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e49e
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e49e
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xefec
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_save
int gt_feature_index_save(GtFeatureIndex *feature_index, GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class);
  gt_assert(feature_index->c_class->save_func);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->save_func(feature_index, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3e4f0
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x3e4f0
cmpq $0x0, 0x38(%rax)
je 0x3e4f5
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0xf05e
callq 0xf025
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_seqids
GtStrArray* gt_feature_index_get_seqids(const GtFeatureIndex *feature_index,
                                        GtError *err)
{
  GtStrArray *strarr;
  gt_assert(feature_index && feature_index->c_class);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  strarr = feature_index->c_class->get_seqids(feature_index, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return strarr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e543
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e543
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf097
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_range_for_seqid
int  gt_feature_index_get_range_for_seqid(GtFeatureIndex *feature_index,
                                          GtRange *range,
                                          const char *seqid,
                                          GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && range && seqid);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  ret = feature_index->c_class->get_range_for_seqid(feature_index, range,
                                                    seqid, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3e5aa
movq %rdx, %r15
testq %rdx, %rdx
je 0x3e5aa
movq %rsi, %r12
testq %rsi, %rsi
je 0x3e5aa
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e5aa
movq %rcx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x48(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xf0d0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_has_seqid
int  gt_feature_index_has_seqid(const GtFeatureIndex *feature_index,
                                bool *has_seqid,
                                const char *seqid,
                                GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && seqid);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  ret = feature_index->c_class->has_seqid(feature_index, has_seqid,
                                          seqid, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3e673
movq %rdx, %r15
testq %rdx, %rdx
je 0x3e673
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3e673
movq %rcx, %r14
movq %rsi, %r12
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x58(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xf142
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_unit_test_add
static void* gt_feature_index_unit_test_add(void *data)
{
  GtFeatureNode *feature;
  GtFeatureIndexTestShared *shm = (GtFeatureIndexTestShared*) data;

  while (true) {
    gt_mutex_lock(shm->mutex);
    if (shm->next_node_idx == GT_FI_TEST_FEATURES_PER_THREAD * gt_jobs) {
      gt_mutex_unlock(shm->mutex);
      return NULL;
    }
    gt_assert(shm->next_node_idx < gt_array_size(shm->nodes));
    feature = *(GtFeatureNode**) gt_array_get(shm->nodes, shm->next_node_idx++);
    gt_mutex_unlock(shm->mutex);
    gt_feature_index_add_feature_node(shm->fi, feature, shm->err);
    gt_genome_node_delete((GtGenomeNode*) feature);
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x3d9b7
movq 0x20(%rbx), %r14
leaq 0x112b48(%rip), %r15    # 0x1516e4
imull $0x3e8, (%r15), %eax    # imm = 0x3E8
cmpq %rax, %r14
je 0x3ebfd
movq 0x10(%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r14
jae 0x3ec0e
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x20(%rbx)
callq 0x6e9fa
movq (%rax), %r14
movq 0x18(%rbx), %rdi
callq 0x3d9d2
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
callq 0x3e116
movq %r14, %rdi
callq 0x42ade
movq 0x18(%rbx), %rdi
callq 0x3d9b7
movq 0x20(%rbx), %r14
jmp 0x3eb9c
movq 0x18(%rbx), %rdi
callq 0x3d9d2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf1ed
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_add_region_node
int gt_feature_index_memory_add_region_node(GtFeatureIndex *gfi,
                                            GtRegionNode *rn,
                                            GT_UNUSED GtError *err)
{
  char *seqid;
  GtFeatureIndexMemory *fi;
  RegionInfo *info;
  fi = gt_feature_index_memory_cast(gfi);
  gt_assert(fi && rn);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn));
  if (!gt_hashmap_get(fi->regions, seqid)) {
    info = gt_calloc(1, sizeof (RegionInfo));
    info->region = (GtRegionNode*) gt_genome_node_ref((GtGenomeNode*) rn);
    info->features = gt_interval_tree_new((GtFree)
                                          gt_genome_node_delete);
    info->dyn_range.start = ~0UL;
    info->dyn_range.end   = 0;
    gt_hashmap_add(fi->regions, seqid, info);
    if (fi->nof_region_nodes++ == 0)
      fi->firstseqid = seqid;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3ef03
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e678
testq %r14, %r14
je 0x3eefe
movq %rax, %rbx
testq %rax, %rax
je 0x3eefe
movq %r14, %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x77109
testq %rax, %rax
jne 0x3eef0
leaq 0xa5986(%rip), %rdx     # 0xe480c
movl $0x1, %edi
movl $0x20, %esi
movl $0x4e, %ecx
callq 0x3601f
movq %rax, %r12
movq %r14, %rdi
callq 0x41ca0
movq %rax, 0x8(%r12)
leaq 0x3c2d(%rip), %rdi      # 0x42ade
callq 0x78e23
movq %rax, (%r12)
movq $-0x1, 0x10(%r12)
movq $0x0, 0x18(%r12)
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x77144
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
testq %rax, %rax
jne 0x3eef0
movq %r15, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xf226