LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1c2d3
jmp 0x1c32c
movq 0x10(%rsp), %rdi
callq 0xb720
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1c320
movq 0x197ce9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x141d6d(%rip), %rsi    # 0x15e066
leaq 0x142779(%rip), %rdx    # 0x15ea79
leaq 0x144a31(%rip), %rcx    # 0x160d38
leaq 0x14497b(%rip), %r8     # 0x160c89
movl $0x81, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1c322
movq 0x10(%rsp), %rdi
callq 0xb760
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, (%rsp)
movq (%rsp), %rsi
leaq 0x1448d5(%rip), %rdi    # 0x160d95
leaq 0x142647(%rip), %rdx    # 0x15eb0e
movb $0x0, %al
callq 0xb070
leaq 0x1448d5(%rip), %rdi    # 0x160daa
movb $0x0, %al
callq 0xb070
leaq 0x144914(%rip), %rdi    # 0x160df7
movb $0x0, %al
callq 0xb070
leaq 0x144950(%rip), %rdi    # 0x160e41
movb $0x0, %al
callq 0xb070
leaq 0x144991(%rip), %rdi    # 0x160e90
leaq 0x14499d(%rip), %rsi    # 0x160ea3
movb $0x0, %al
callq 0xb070
leaq 0x1449fd(%rip), %rdi    # 0x160f11
leaq 0x144a09(%rip), %rsi    # 0x160f24
movb $0x0, %al
callq 0xb070
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/warning.c
// Function: gt_warning
void gt_warning(const char *format, ...)
{
  va_list ap;
  if (warning_handler) {
    va_start(ap, format);
    warning_handler(warning_data, format, ap);
    va_end(ap);
  }
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x1c58c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
cmpq $0x0, 0x198113(%rip)    # 0x1b46c8
je 0x1c607
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1980e2(%rip), %rax    # 0x1b46c8
movq 0x199d1b(%rip), %rdi    # 0x1b6308
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq *%rax
leaq 0xb0(%rsp), %rax
addq $0xd8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb9a0
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
jne 0x1c7b3
movq 0x10(%rsp), %rdi
callq 0xbbf0
cmpl $0x0, %eax
je 0x1c7b1
leaq 0x14486b(%rip), %rdi    # 0x16100d
callq 0xb530
movl $0x1, %edi
callq 0xb780
jmp 0x1c7b3
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xb9b0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x1c817
movq 0x10(%rsp), %rdi
callq 0xbbf0
cmpl $0x0, %eax
je 0x1c815
leaq 0x144818(%rip), %rdi    # 0x16101e
callq 0xb530
movl $0x1, %edi
callq 0xb780
jmp 0x1c817
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/xansi.c
// Function: gt_xfopen
FILE* gt_xfopen(const char *path, const char *mode)
{
  FILE *file;
  if ((file = fopen(path, mode)) == NULL) {
    fprintf(stderr, "fopen(): cannot open file '%s': %s\n", path,
            strerror(errno));
    exit(EXIT_FAILURE);
  }
  return file;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb6f0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x1c8e0
movq 0x197739(%rip), %rax    # 0x1b3fd8
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x14477e(%rip), %rsi    # 0x16104d
movb $0x0, %al
callq 0xb890
movl $0x1, %edi
callq 0xb780
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1c97e
movq 0x19768b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14170f(%rip), %rsi    # 0x15e066
leaq 0x144076(%rip), %rdx    # 0x1609d4
leaq 0x144723(%rip), %rcx    # 0x161088
leaq 0x144726(%rip), %r8     # 0x161092
movl $0x66, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1c980
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xb700
cmpl $-0x1, %eax
jne 0x1c9aa
leaq 0x144708(%rip), %rdi    # 0x1610a3
callq 0xb530
movl $0x1, %edi
callq 0xb780
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0xb900
movq %rax, (%rsp)
cmpq 0x10(%rsp), %rax
jae 0x1ca13
movq 0x8(%rsp), %rdi
callq 0xbbf0
cmpl $0x0, %eax
je 0x1ca11
leaq 0x1446b8(%rip), %rdi    # 0x1610ba
callq 0xb530
movl $0x1, %edi
callq 0xb780
jmp 0x1ca13
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x40000000, %eax       # imm = 0x40000000
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x28(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x1cb5d
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
imulq (%rsp), %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xbc70
cmpq 0x10(%rsp), %rax
je 0x1cb3c
leaq 0x1445d5(%rip), %rdi    # 0x161102
callq 0xb530
movl $0x1, %edi
callq 0xb780
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x1caed
cmpq $0x0, 0x8(%rsp)
jbe 0x1cbaa
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
imulq (%rsp), %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xbc70
cmpq 0x8(%rsp), %rax
je 0x1cba8
leaq 0x144569(%rip), %rdi    # 0x161102
callq 0xb530
movl $0x1, %edi
callq 0xb780
jmp 0x1cbaa
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/xansi.c
// Function: gt_xvsnprintf
int gt_xvsnprintf(char *str, size_t size, const char *format, va_list ap)
{
  int rval;
  if ((rval = vsnprintf(str, size, format, ap)) < 0) {
    perror("cannot vsnprintf");
    exit(EXIT_FAILURE);
  }
  return rval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0xb390
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
jge 0x1cd70
leaq 0x14441e(%rip), %rdi    # 0x16117f
callq 0xb530
movl $0x1, %edi
callq 0xb780
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq 0x199588(%rip), %rdi    # 0x1b6310
callq 0x1c340
movslq 0x199668(%rip), %rcx    # 0x1b63fc
leaq 0x199585(%rip), %rax    # 0x1b6320
movl (%rax,%rcx,4), %eax
movslq 0x19965b(%rip), %rdx    # 0x1b6400
leaq 0x199574(%rip), %rcx    # 0x1b6320
addl (%rcx,%rdx,4), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edx
movslq 0x19963e(%rip), %rcx    # 0x1b63fc
leaq 0x19955b(%rip), %rax    # 0x1b6320
movl %edx, (%rax,%rcx,4)
movl 0x19962e(%rip), %eax    # 0x1b63fc
addl $0x1, %eax
movl %eax, 0x199625(%rip)    # 0x1b63fc
cmpl $0x37, %eax
jl 0x1cde6
movl $0x0, 0x199616(%rip)    # 0x1b63fc
movl 0x199614(%rip), %eax    # 0x1b6400
addl $0x1, %eax
movl %eax, 0x19960b(%rip)    # 0x1b6400
cmpl $0x37, %eax
jl 0x1ce04
movl $0x0, 0x1995fc(%rip)    # 0x1b6400
movq 0x199505(%rip), %rdi    # 0x1b6310
callq 0x1c3e0
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
cmpq $0x0, 0x1994e0(%rip)    # 0x1b6310
jne 0x1ce3e
callq 0x1c240
movq %rax, 0x1994d2(%rip)    # 0x1b6310
cmpl $0x0, 0x34(%rsp)
jne 0x1ce8a
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb9e0
imulq $0x3e7, 0x18(%rsp), %rax # imm = 0x3E7
imulq $0x3e9, 0x20(%rsp), %rcx # imm = 0x3E9
addq %rcx, %rax
movq %rax, 0x8(%rsp)
callq 0xb8d0
movl %eax, %ecx
movq 0x8(%rsp), %rax
imull $0x3eb, %ecx, %ecx      # imm = 0x3EB
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x37, 0x2c(%rsp)
jge 0x1cecc
movslq 0x2c(%rsp), %rcx
leaq 0x1442e3(%rip), %rax    # 0x161190
movl (%rax,%rcx,4), %edx
movslq 0x2c(%rsp), %rcx
leaq 0x199464(%rip), %rax    # 0x1b6320
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1ce9a
movl 0x34(%rsp), %eax
addl 0x19944a(%rip), %eax    # 0x1b6320
movl %eax, 0x199444(%rip)    # 0x1b6320
movl $0x1, 0x2c(%rsp)
cmpl $0x37, 0x2c(%rsp)
jge 0x1cf3b
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x199424(%rip), %rax    # 0x1b6320
imull $0x3e9, (%rax,%rcx,4), %eax # imm = 0x3E9
imull $0x3e7, 0x34(%rsp), %ecx # imm = 0x3E7
addl %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %edx
movslq 0x2c(%rsp), %rcx
leaq 0x1993ff(%rip), %rax    # 0x1b6320
addl (%rax,%rcx,4), %edx
leaq 0x1993f5(%rip), %rax    # 0x1b6320
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1cee4
movl 0x1993df(%rip), %eax    # 0x1b6320
movl $0x37, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, 0x1994ac(%rip)    # 0x1b63fc
movl 0x1994a6(%rip), %eax    # 0x1b63fc
addl $0x14, %eax
movl $0x37, %ecx
cltd
idivl %ecx
movl %edx, 0x199499(%rip)    # 0x1b6400
movl 0x30(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1d0cc
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1d104
movq 0x196f05(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140f89(%rip), %rsi    # 0x15e066
leaq 0x144188(%rip), %rdx    # 0x16126c
leaq 0x144192(%rip), %rcx    # 0x16127d
leaq 0x1441a3(%rip), %r8     # 0x161295
movl $0x67, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d106
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0x14417b(%rip), %rdx    # 0x161295
movl $0x68, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
leaq 0x14414e(%rip), %rdx    # 0x161295
movl $0x6a, %ecx
callq 0xd5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x1bec0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1d1c4
movq 0x196e45(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140ec9(%rip), %rsi    # 0x15e066
leaq 0x15f19d(%rip), %rdx    # 0x17c341
leaq 0x144107(%rip), %rcx    # 0x1612b2
leaq 0x1440e3(%rip), %r8     # 0x161295
movl $0x71, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d1c6
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c100
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1d211
jmp 0x1d309
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c100
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0x1d254
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
jmp 0x1d309
jmp 0x1d256
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1d298
movq 0x196d71(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140df5(%rip), %rsi    # 0x15e066
leaq 0x14404f(%rip), %rdx    # 0x1612c7
leaq 0x144054(%rip), %rcx    # 0x1612d3
leaq 0x14400f(%rip), %r8     # 0x161295
movl $0x81, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d29a
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x1d2b9
movq (%rsp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1bfe0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x143fab(%rip), %rsi    # 0x161295
movl $0x86, %edx
callq 0xdab0
movq (%rsp), %rdi
leaq 0x143f96(%rip), %rsi    # 0x161295
movl $0x87, %edx
callq 0xdab0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1d33e
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1d33e
cmpq $0x0, 0x18(%rsp)
jne 0x1d376
movq 0x196c93(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140d17(%rip), %rsi    # 0x15e066
leaq 0x143f95(%rip), %rdx    # 0x1612eb
leaq 0x143fc5(%rip), %rcx    # 0x161322
leaq 0x143f31(%rip), %r8     # 0x161295
movl $0x8f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d378
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c100
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1d3fe
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1d3fe
cmpq $0x0, 0x18(%rsp)
jne 0x1d436
movq 0x196bd3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140c57(%rip), %rsi    # 0x15e066
leaq 0x143f2d(%rip), %rdx    # 0x161343
leaq 0x143f5e(%rip), %rcx    # 0x16137b
leaq 0x143e71(%rip), %r8     # 0x161295
movl $0x9c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d438
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c100
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1d4be
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1d4be
cmpq $0x0, 0x18(%rsp)
jne 0x1d4f6
movq 0x196b13(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140b97(%rip), %rsi    # 0x15e066
leaq 0x143ec7(%rip), %rdx    # 0x16139d
leaq 0x143ef0(%rip), %rcx    # 0x1613cd
leaq 0x143db1(%rip), %r8     # 0x161295
movl $0xa8, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d4f8
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c100
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1d7fe
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1d7fe
cmpq $0x0, 0x18(%rsp)
jne 0x1d836
movq 0x1967d3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140857(%rip), %rsi    # 0x15e066
leaq 0x143c0c(%rip), %rdx    # 0x161422
leaq 0x143c20(%rip), %rcx    # 0x16143d
leaq 0x143a71(%rip), %r8     # 0x161295
movl $0xd3, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d838
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c060
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1d8d8
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1d8d8
cmpq $0x0, 0x28(%rsp)
je 0x1d8d8
cmpq $0x0, 0x20(%rsp)
je 0x1d8d8
cmpq $0x0, 0x18(%rsp)
jne 0x1d910
movq 0x1966f9(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14077d(%rip), %rsi    # 0x15e066
leaq 0x143b75(%rip), %rdx    # 0x161465
leaq 0x143bb3(%rip), %rcx    # 0x1614aa
leaq 0x143997(%rip), %r8     # 0x161295
movl $0xe1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d912
jmp 0x1d914
movq 0x18(%rsp), %rdi
callq 0x93bd0
cmpq $0x0, %rax
ja 0x1d95c
movq 0x1966ad(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140731(%rip), %rsi    # 0x15e066
leaq 0x143b96(%rip), %rdx    # 0x1614d2
leaq 0x143b67(%rip), %rcx    # 0x1614aa
leaq 0x14394b(%rip), %r8     # 0x161295
movl $0xe2, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1d95e
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c060
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1d9e1
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1da19
movq 0x1965f0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140674(%rip), %rsi    # 0x15e066
leaq 0x143af4(%rip), %rdx    # 0x1614ed
leaq 0x143b15(%rip), %rcx    # 0x161515
leaq 0x14388e(%rip), %r8     # 0x161295
movl $0xef, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1da1b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c060
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1da91
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1dac9
movq 0x196540(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1405c4(%rip), %rsi    # 0x15e066
leaq 0x143a44(%rip), %rdx    # 0x1614ed
leaq 0x143a86(%rip), %rcx    # 0x161536
leaq 0x1437de(%rip), %r8     # 0x161295
movl $0xf9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1dacb
jmp 0x1dacd
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1db14
movq 0x1964f5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140579(%rip), %rsi    # 0x15e066
leaq 0x143a58(%rip), %rdx    # 0x16154c
leaq 0x143a3b(%rip), %rcx    # 0x161536
leaq 0x143793(%rip), %r8     # 0x161295
movl $0xfa, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1db16
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c100
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1db81
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1dbb9
movq 0x196450(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1404d4(%rip), %rsi    # 0x15e066
leaq 0x143954(%rip), %rdx    # 0x1614ed
leaq 0x1439ce(%rip), %rcx    # 0x16156e
leaq 0x1436ee(%rip), %r8     # 0x161295
movl $0x105, %r9d            # imm = 0x105
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1dbbb
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c060
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1dc4b
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1dc4b
cmpq $0x0, 0x18(%rsp)
je 0x1dc4b
cmpq $0x0, 0x10(%rsp)
jne 0x1dc83
movq 0x196386(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x14040a(%rip), %rsi    # 0x15e066
leaq 0x143927(%rip), %rdx    # 0x16158a
leaq 0x14395a(%rip), %rcx    # 0x1615c4
leaq 0x143624(%rip), %r8     # 0x161295
movl $0x112, %r9d            # imm = 0x112
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1dc85
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c060
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1dde3
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1dde3
cmpq $0x0, 0x10(%rsp)
jne 0x1de1b
movq 0x1961ee(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x140272(%rip), %rsi    # 0x15e066
leaq 0x143818(%rip), %rdx    # 0x161613
leaq 0x143842(%rip), %rcx    # 0x161644
leaq 0x14348c(%rip), %r8     # 0x161295
movl $0x12e, %r9d            # imm = 0x12E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1de1d
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c060
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1c1a0
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1c340
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
leaq 0x196113(%rip), %rcx    # 0x1b46c4
imull $0x3e8, (%rcx), %ecx    # imm = 0x3E8
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x1e5d3
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1c3e0
xorl %eax, %eax
addq $0x28, %rsp
retq
jmp 0x1e5d5
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x1e636
movq 0x1959d3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13fa57(%rip), %rsi    # 0x15e066
leaq 0x1431c7(%rip), %rdx    # 0x1617dd
leaq 0x1431ef(%rip), %rcx    # 0x16180c
leaq 0x142c71(%rip), %r8     # 0x161295
movl $0x158, %r9d            # imm = 0x158
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1e638
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1c3e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x1d3d0
movq 0x18(%rsp), %rdi
callq 0x26eb0
jmp 0x1e593
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
callq 0x1eb70
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x1de70
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1ea4a
cmpq $0x0, 0x28(%rsp)
jne 0x1ea82
movq 0x195587(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13f60b(%rip), %rsi    # 0x15e066
leaq 0x142dc9(%rip), %rdx    # 0x16182b
leaq 0x142dcb(%rip), %rcx    # 0x161834
leaq 0x142dec(%rip), %r8     # 0x16185c
movl $0x4b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1ea84
movq 0x28(%rsp), %rdi
callq 0x258a0
movq %rax, %rdi
callq 0x19940
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x86470
cmpq $0x0, %rax
jne 0x1eb61
movl $0x1, %edi
movl $0x20, %esi
leaq 0x142d93(%rip), %rdx    # 0x16185c
movl $0x4e, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x25140
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x83bb(%rip), %rdi      # 0x26eb0
callq 0x89ac0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $-0x1, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x86510
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x1eb5f
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x1eb61
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_class
const GtFeatureIndexClass* gt_feature_index_memory_class(void)
{
  static const GtFeatureIndexClass *fic = NULL;
  gt_class_alloc_lock_enter();
  if (!fic) {
    fic = gt_feature_index_class_new(sizeof (GtFeatureIndexMemory),
                     gt_feature_index_memory_add_region_node,
                     gt_feature_index_memory_add_feature_node,
                     gt_feature_index_memory_remove_node,
                     gt_feature_index_memory_get_features_for_seqid,
                     gt_feature_index_memory_get_features_for_range,
                     gt_feature_index_memory_get_first_seqid,
                     NULL,
                     gt_feature_index_memory_get_seqids,
                     gt_feature_index_memory_get_range_for_seqid,
                     gt_feature_index_memory_get_orig_range_for_seqid,
                     gt_feature_index_memory_has_seqid,
                     gt_feature_index_memory_delete);
  }
  gt_class_alloc_lock_leave();
  return fic;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
callq 0x7b730
cmpq $0x0, 0x197882(%rip)    # 0x1b6408
jne 0x1ec12
movl $0x48, %edi
leaq -0x188(%rip), %rsi      # 0x1ea10
leaq 0x91(%rip), %rdx        # 0x1ec30
leaq 0x2ca(%rip), %rcx       # 0x1ee70
leaq 0x493(%rip), %r8        # 0x1f040
leaq 0x5fc(%rip), %r9        # 0x1f1b0
leaq 0x835(%rip), %r15       # 0x1f3f0
xorl %eax, %eax
leaq 0x8cc(%rip), %r14       # 0x1f490
leaq 0xa75(%rip), %rbx       # 0x1f640
leaq 0xbde(%rip), %r11       # 0x1f7b0
leaq 0xd07(%rip), %r10       # 0x1f8e0
leaq 0xda0(%rip), %rax       # 0x1f980
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x1cfa0
movq %rax, 0x1977f6(%rip)    # 0x1b6408
callq 0x7b790
movq 0x1977ea(%rip), %rax    # 0x1b6408
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_remove_node
int gt_feature_index_memory_remove_node(GtFeatureIndex *gfi,
                                        GtFeatureNode *gn,
                                        GT_UNUSED GtError *err)
{
  char* seqid;
  GtFeatureIndexMemory *fi;
  GtRange node_range;
  GtFeatureIndexMemoryByPtrExtractInfo info;
  RegionInfo *rinfo;
  gt_assert(gfi && gn);

  fi = gt_feature_index_memory_cast(gfi);
  node_range = gt_genome_node_get_range((GtGenomeNode*) gn);
  if (!gt_hashmap_get(fi->nodes_in_index, gn))
    return 0;
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) gn));
  rinfo = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  if (!rinfo)
    return 0;
  info.genome_node = (GtGenomeNode*) gn;
  info.node = NULL;

  gt_interval_tree_iterate_overlapping(rinfo->features,
                                   gt_feature_index_memory_get_itreenode_by_ptr,
                                   node_range.start,
                                   node_range.end,
                                   &info);

  if (info.node)
    gt_interval_tree_remove(rinfo->features, info.node);
  return 0;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x1ee93
cmpq $0x0, 0x50(%rsp)
jne 0x1eecb
movq 0x19513e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13f1c2(%rip), %rsi    # 0x15e066
leaq 0x142a08(%rip), %rdx    # 0x1618b3
leaq 0x142a0b(%rip), %rcx    # 0x1618bd
leaq 0x1429a3(%rip), %r8     # 0x16185c
movl $0xa2, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1eecd
callq 0x1eb70
movq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x1de70
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
callq 0x259f0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x50(%rsp), %rsi
callq 0x86470
cmpq $0x0, %rax
jne 0x1ef30
movl $0x0, 0x64(%rsp)
jmp 0x1efc9
movq 0x50(%rsp), %rdi
callq 0x258a0
movq %rax, %rdi
callq 0x19940
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x86470
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1ef71
movl $0x0, 0x64(%rsp)
jmp 0x1efc9
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x43(%rip), %rsi        # 0x1efe0
leaq 0x18(%rsp), %r8
callq 0x8a0f0
cmpq $0x0, 0x18(%rsp)
je 0x1efc1
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x8a630
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_itreenode_by_ptr
static int gt_feature_index_memory_get_itreenode_by_ptr(GtIntervalTreeNode *n,
                                                        void *data)
{
  GtFeatureIndexMemoryByPtrExtractInfo *i =
                                   (GtFeatureIndexMemoryByPtrExtractInfo*) data;
  if (i->genome_node == gt_interval_tree_node_get_data(n)) {
    i->node = n;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x89b80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0x1f02a
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_features_for_seqid
GtArray* gt_feature_index_memory_get_features_for_seqid(GtFeatureIndex *gfi,
                                                        const char *seqid,
                                                        GT_UNUSED GtError *err)
{
  RegionInfo *ri;
  GT_UNUSED int had_err = 0;
  GtArray *a;
  GtFeatureIndexMemory *fi;
  gt_assert(gfi && seqid);
  fi = gt_feature_index_memory_cast(gfi);
  a = gt_array_new(sizeof (GtFeatureNode*));
  ri = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  if (ri) {
    had_err = gt_interval_tree_traverse(ri->features,
                                        collect_features_from_itree,
                                        a);
  }
  gt_assert(!had_err);   /* collect_features_from_itree() is sane */
  return a;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1f06b
cmpq $0x0, 0x28(%rsp)
jne 0x1f0a3
movq 0x194f66(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13efea(%rip), %rsi    # 0x15e066
leaq 0x14285e(%rip), %rdx    # 0x1618e1
leaq 0x142864(%rip), %rcx    # 0x1618ee
leaq 0x1427cb(%rip), %r8     # 0x16185c
movl $0xca, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1f0a5
callq 0x1eb70
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x1de70
movq %rax, (%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x86470
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1f106
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x63(%rip), %rsi        # 0x1f160
callq 0x89dd0
movl %eax, 0x14(%rsp)
jmp 0x1f108
cmpl $0x0, 0x14(%rsp)
je 0x1f147
movq 0x194ec2(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0x13ef46(%rip), %rsi    # 0x15e066
leaq 0x147e97(%rip), %rdx    # 0x166fbe
leaq 0x1427c0(%rip), %rcx    # 0x1618ee
leaq 0x142727(%rip), %r8     # 0x16185c
movl $0xd3, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1f149
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: collect_features_from_itree
static int collect_features_from_itree(GtIntervalTreeNode *node, void *data)
{
  GtArray *a = (GtArray*) data;
  GtGenomeNode *gn = (GtGenomeNode*) gt_interval_tree_node_get_data(node);
  gt_array_add(a, gn);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x89b80
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)