LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x15fee
movq %rdi, %rbx
callq 0xb750
testl %eax, %eax
jne 0x15ff0
movq %rbx, %rdi
popq %rbx
jmp 0xb790
popq %rbx
retq
movq 0x117fc1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb4065(%rip), %rsi     # 0xca066
leaq 0xb4adf(%rip), %rdx     # 0xcaae7
leaq 0xb6cb3(%rip), %rcx     # 0xcccc2
leaq 0xb6bfd(%rip), %r8      # 0xccc13
movl $0x81, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16039
callq 0xb910
testl %eax, %eax
jne 0x16067
popq %rax
retq
movq 0x117f78(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb401c(%rip), %rsi     # 0xca066
leaq 0xb6c81(%rip), %rdx     # 0xcccd2
leaq 0xb6c80(%rip), %rcx     # 0xcccd8
leaq 0xb6bb4(%rip), %r8      # 0xccc13
movl $0x88, %r9d
jmp 0x16093
movq 0x117f4a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3fee(%rip), %rsi     # 0xca066
leaq 0xb4a68(%rip), %rdx     # 0xcaae7
leaq 0xb6c52(%rip), %rcx     # 0xcccd8
leaq 0xb6b86(%rip), %r8      # 0xccc13
movl $0x8a, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x160b0
callq 0xb470
testl %eax, %eax
jne 0x160de
popq %rax
retq
movq 0x117f01(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3fa5(%rip), %rsi     # 0xca066
leaq 0xb6c0a(%rip), %rdx     # 0xcccd2
leaq 0xb6c1c(%rip), %rcx     # 0xccceb
leaq 0xb6b3d(%rip), %r8      # 0xccc13
movl $0x90, %r9d
jmp 0x1610a
movq 0x117ed3(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3f77(%rip), %rsi     # 0xca066
leaq 0xb49f1(%rip), %rdx     # 0xcaae7
leaq 0xb6bee(%rip), %rcx     # 0xccceb
leaq 0xb6b0f(%rip), %r8      # 0xccc13
movl $0x92, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xb6be4(%rip), %rdi     # 0xccd1f
leaq 0xb4a3a(%rip), %rdx     # 0xcab7c
xorl %eax, %eax
callq 0xb070
leaq 0xb6d10(%rip), %rdi     # 0xcce60
callq 0xb9b0
leaq 0xb6d50(%rip), %rdi     # 0xcceac
callq 0xb9b0
leaq 0xb6d8d(%rip), %rdi     # 0xccef5
callq 0xb9b0
leaq 0xb6bc0(%rip), %rdi     # 0xccd34
leaq 0xb6bcc(%rip), %rsi     # 0xccd47
xorl %eax, %eax
callq 0xb070
leaq 0xb6c2c(%rip), %rdi     # 0xccdb5
leaq 0xb6c38(%rip), %rsi     # 0xccdc8
xorl %eax, %eax
popq %rcx
jmp 0xb070
// File: /workspace/github_c_makefile_star2_O2/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 0xb9d0
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x16343
movq %r14, %rdi
callq 0xbc20
testl %eax, %eax
jne 0x1634d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb6c40(%rip), %rdi     # 0xccf94
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 0xb9e0
movq %rax, %r14
testq %rax, %rax
jne 0x16381
movq %rbx, %rdi
callq 0xbc20
testl %eax, %eax
jne 0x1638c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb6c12(%rip), %rdi     # 0xccfa5
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb720
testq %rax, %rax
je 0x163d9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x117bd8(%rip), %rax    # 0x12dfb8
movq (%rax), %r14
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
leaq 0xb6bde(%rip), %rsi     # 0xccfd4
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 0x16441
callq 0xb730
cmpl $-0x1, %eax
je 0x16477
popq %rax
retq
movq 0x117b70(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3c14(%rip), %rsi     # 0xca066
leaq 0xb655a(%rip), %rdx     # 0xcc9b3
leaq 0xb6baf(%rip), %rcx     # 0xcd00f
leaq 0xb6bb2(%rip), %r8      # 0xcd019
pushq $0x66
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
leaq 0xb6bac(%rip), %rdi     # 0xcd02a
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 0xb930
movq %rax, %r14
cmpq %r15, %rax
jae 0x164af
movq %rbx, %rdi
callq 0xbc20
testl %eax, %eax
jne 0x164b8
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb6b82(%rip), %rdi     # 0xcd041
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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, (%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movl $0x40000000, %eax       # imm = 0x40000000
xorl %edx, %edx
divq %rsi
movq %rax, %r13
movq %rbx, %r12
subq %r13, %r12
jb 0x16561
movq %rbp, %rdi
imulq %r14, %rdi
addq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq (%rsp), %rcx
callq 0xbca0
cmpq %r13, %rax
jne 0x16593
addq %r13, %rbp
movq %r12, %rbx
jmp 0x16536
testq %rbx, %rbx
je 0x16584
imulq %r14, %rbp
addq %rbp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq (%rsp), %rcx
callq 0xbca0
cmpq %rax, %rbx
jne 0x16593
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb6aef(%rip), %rdi     # 0xcd089
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rax
callq 0xb3b0
testl %eax, %eax
js 0x16693
popq %rcx
retq
leaq 0xb6a6c(%rip), %rdi     # 0xcd106
callq 0xb550
pushq $0x1
popq %rdi
callq 0xb7b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x119370(%rip), %rdi    # 0x12fa20
callq 0x16028
movslq 0x119450(%rip), %rax    # 0x12fb0c
leaq 0x11936d(%rip), %rcx    # 0x12fa30
movslq 0x119446(%rip), %rdx    # 0x12fb10
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, 0x11941f(%rip)    # 0x12fb0c
cmovgel %edi, %r8d
movl %r8d, 0x119418(%rip)    # 0x12fb10
movq 0x119321(%rip), %rdi    # 0x12fa20
callq 0x1609f
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movl %edi, %ebx
cmpq $0x0, 0x119308(%rip)    # 0x12fa20
jne 0x16726
callq 0x15f7b
movq %rax, 0x1192fa(%rip)    # 0x12fa20
testl %ebx, %ebx
jne 0x16756
leaq 0x8(%rsp), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xba10
imull $0x3e7, (%rbx), %eax    # imm = 0x3E7
imull $0x3e9, 0x8(%rbx), %ebp # imm = 0x3E9
addl %eax, %ebp
callq 0xb900
imull $0x3eb, %eax, %ebx      # imm = 0x3EB
addl %ebp, %ebx
xorl %eax, %eax
leaq 0xb69c1(%rip), %rdx     # 0xcd120
leaq 0x1192ca(%rip), %rcx    # 0x12fa30
cmpq $0xdc, %rax
je 0x1677a
movl (%rax,%rdx), %esi
movl %esi, (%rax,%rcx)
addq $0x4, %rax
jmp 0x16766
movl 0x1192b0(%rip), %eax    # 0x12fa30
addl %ebx, %eax
movl %eax, 0x1192a8(%rip)    # 0x12fa30
pushq $0x1
popq %rdx
movl %eax, %edi
movl %ebx, %esi
cmpq $0x37, %rdx
je 0x167b0
imull $0x3e9, %edi, %edi      # imm = 0x3E9
imull $0x3e7, %esi, %esi      # imm = 0x3E7
addl %edi, %esi
movl (%rcx,%rdx,4), %edi
addl %esi, %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
jmp 0x1678f
pushq $0x37
popq %rcx
xorl %edx, %edx
divl %ecx
movl %edx, 0x11934f(%rip)    # 0x12fb0c
leal -0x23(%rdx), %eax
leal 0x14(%rdx), %ecx
cmpl $0x23, %edx
cmovael %eax, %ecx
movl %ecx, 0x119341(%rip)    # 0x12fb10
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x168d1
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x168d1
leaq 0xb699f(%rip), %r14     # 0xcd225
pushq $0x1
popq %r15
pushq $0x68
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x10
popq %rsi
pushq $0x6a
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, 0x8(%r12)
callq 0x15d09
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1176e0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3784(%rip), %rsi     # 0xca066
leaq 0xb6913(%rip), %rdx     # 0xcd1fc
leaq 0xb691d(%rip), %rcx     # 0xcd20d
leaq 0xb692e(%rip), %r8      # 0xcd225
pushq $0x67
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16931
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x15f0a
movq %rbx, %rax
popq %rbx
retq
movq 0x117680(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3724(%rip), %rsi     # 0xca066
leaq 0xd0838(%rip), %rdx     # 0xe7181
leaq 0xb68f2(%rip), %rcx     # 0xcd242
leaq 0xb68ce(%rip), %r8      # 0xcd225
pushq $0x71
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1699e
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x169a6
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15f0a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x16a05
movq 0x60(%rcx), %rcx
testq %rcx, %rcx
je 0x169c0
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15dd5
movq 0x8(%rbx), %rdi
leaq 0xb6844(%rip), %r14     # 0xcd225
movq %r14, %rsi
movl $0x86, %edx
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0x87, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0x1175ac(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3650(%rip), %rsi     # 0xca066
leaq 0xb683a(%rip), %rdx     # 0xcd257
leaq 0xb683f(%rip), %rcx     # 0xcd263
leaq 0xb67fa(%rip), %r8      # 0xcd225
movl $0x81, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16a95
movq %rsi, %r15
testq %rsi, %rsi
je 0x16a95
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x16a95
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x11751c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb35c0(%rip), %rsi     # 0xca066
leaq 0xb67ce(%rip), %rdx     # 0xcd27b
leaq 0xb67fe(%rip), %rcx     # 0xcd2b2
leaq 0xb676a(%rip), %r8      # 0xcd225
movl $0x8f, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16b25
movq %rsi, %r15
testq %rsi, %rsi
je 0x16b25
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x16b25
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x11748c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3530(%rip), %rsi     # 0xca066
leaq 0xb6796(%rip), %rdx     # 0xcd2d3
leaq 0xb67c7(%rip), %rcx     # 0xcd30b
leaq 0xb66da(%rip), %r8      # 0xcd225
movl $0x9c, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16bb5
movq %rsi, %r15
testq %rsi, %rsi
je 0x16bb5
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x16bb5
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1173fc(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb34a0(%rip), %rsi     # 0xca066
leaq 0xb6760(%rip), %rdx     # 0xcd32d
leaq 0xb6789(%rip), %rcx     # 0xcd35d
leaq 0xb664a(%rip), %r8      # 0xcd225
movl $0xa8, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16e0a
movq %rsi, %r15
testq %rsi, %rsi
je 0x16e0a
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x16e0a
movq %rdx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
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 0x15f0a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x1171a7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb324b(%rip), %rsi     # 0xca066
leaq 0xb6590(%rip), %rdx     # 0xcd3b2
leaq 0xb65a4(%rip), %rcx     # 0xcd3cd
leaq 0xb63f5(%rip), %r8      # 0xcd225
movl $0xd3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16ef1
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 0x16ef1
movq %r8, %r14
movq %r15, %rdi
callq 0x5d05e
testq %rax, %rax
je 0x16f1f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
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 0x15f0a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1170c0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3164(%rip), %rsi     # 0xca066
leaq 0xb64ec(%rip), %rdx     # 0xcd3f5
leaq 0xb652a(%rip), %rcx     # 0xcd43a
leaq 0xb630e(%rip), %r8      # 0xcd225
movl $0xe1, %r9d
jmp 0x16f4b
movq 0x117092(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3136(%rip), %rsi     # 0xca066
leaq 0xb652b(%rip), %rdx     # 0xcd462
leaq 0xb64fc(%rip), %rcx     # 0xcd43a
leaq 0xb62e0(%rip), %r8      # 0xcd225
movl $0xe2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x16fa0
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x16fa0
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x117011(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb30b5(%rip), %rsi     # 0xca066
leaq 0xb64c5(%rip), %rdx     # 0xcd47d
leaq 0xb64e6(%rip), %rcx     # 0xcd4a5
leaq 0xb625f(%rip), %r8      # 0xcd225
movl $0xef, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x17025
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x17025
cmpq $0x0, 0x38(%rax)
je 0x17053
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x116f8c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3030(%rip), %rsi     # 0xca066
leaq 0xb6440(%rip), %rdx     # 0xcd47d
leaq 0xb6482(%rip), %rcx     # 0xcd4c6
leaq 0xb61da(%rip), %r8      # 0xcd225
movl $0xf9, %r9d
jmp 0x1707f
movq 0x116f5e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb3002(%rip), %rsi     # 0xca066
leaq 0xb6471(%rip), %rdx     # 0xcd4dc
leaq 0xb6454(%rip), %rcx     # 0xcd4c6
leaq 0xb61ac(%rip), %r8      # 0xcd225
movl $0xfa, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x170d4
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x170d4
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x116edd(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb2f81(%rip), %rsi     # 0xca066
leaq 0xb6391(%rip), %rdx     # 0xcd47d
leaq 0xb640b(%rip), %rcx     # 0xcd4fe
leaq 0xb612b(%rip), %r8      # 0xcd225
movl $0x105, %r9d            # imm = 0x105
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1716e
movq %rdx, %r15
testq %rdx, %rdx
je 0x1716e
movq %rsi, %r12
testq %rsi, %rsi
je 0x1716e
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1716e
movq %rcx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
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 0x15f0a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x116e43(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb2ee7(%rip), %rsi     # 0xca066
leaq 0xb6394(%rip), %rdx     # 0xcd51a
leaq 0xb63c7(%rip), %rcx     # 0xcd554
leaq 0xb6091(%rip), %r8      # 0xcd225
movl $0x112, %r9d            # imm = 0x112
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1729d
movq %rdx, %r15
testq %rdx, %rdx
je 0x1729d
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1729d
movq %rcx, %r14
movq %rsi, %r12
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
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 0x15f0a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x116d14(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb2db8(%rip), %rsi     # 0xca066
leaq 0xb62ee(%rip), %rdx     # 0xcd5a3
leaq 0xb6318(%rip), %rcx     # 0xcd5d4
leaq 0xb5f62(%rip), %r8      # 0xcd225
movl $0x12e, %r9d            # imm = 0x12E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x116ea1(%rip), %r15    # 0x12e6d4
movq 0x18(%rbx), %rdi
callq 0x16028
movq 0x20(%rbx), %r14
imull $0x3e8, (%r15), %eax    # imm = 0x3E8
cmpq %rax, %r14
je 0x17894
movq 0x10(%rbx), %rdi
callq 0x4b988
cmpq %rax, %r14
jae 0x178a5
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x20(%rbx)
callq 0x4b48e
movq (%rax), %r14
movq 0x18(%rbx), %rdi
callq 0x1609f
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
callq 0x16acd
movq %r14, %rdi
callq 0x1d1e3
jmp 0x17833
movq 0x18(%rbx), %rdi
callq 0x1609f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x11670c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb27b0(%rip), %rsi     # 0xca066
leaq 0xb5eb0(%rip), %rdx     # 0xcd76d
leaq 0xb5ed8(%rip), %rcx     # 0xcd79c
leaq 0xb595a(%rip), %r8      # 0xcd225
movl $0x158, %r9d            # imm = 0x158
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x17bc8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x172d5
testq %r14, %r14
je 0x17b92
movq %rax, %rbx
testq %rax, %rax
je 0x17b92
movq %r14, %rdi
callq 0x1c31a
movq %rax, %rdi
callq 0x143d2
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x55ef6
testq %rax, %rax
jne 0x17b84
leaq 0xb5cc6(%rip), %rdx     # 0xcd7ec
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x4e
popq %rcx
callq 0xce9a
movq %rax, %r12
movq %r14, %rdi
callq 0x1bec8
movq %rax, 0x8(%r12)
leaq 0x5698(%rip), %rdi      # 0x1d1e3
callq 0x57bf5
movq %rax, (%r12)
orq $-0x1, 0x10(%r12)
andq $0x0, 0x18(%r12)
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x55f31
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
testq %rax, %rax
jne 0x17b84
movq %r15, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x11641f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb24c3(%rip), %rsi     # 0xca066
leaq 0xb5c11(%rip), %rdx     # 0xcd7bb
leaq 0xb5c13(%rip), %rcx     # 0xcd7c4
leaq 0xb5c34(%rip), %r8      # 0xcd7ec
pushq $0x4b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x4f21f
cmpq $0x0, 0x117f3e(%rip)    # 0x12fb18
jne 0x17c4c
subq $0x8, %rsp
leaq 0x92d(%rip), %rax       # 0x18514
leaq 0x8b1(%rip), %r10       # 0x1849f
leaq 0x7e9(%rip), %r11       # 0x183de
leaq 0x70b(%rip), %rbx       # 0x18307
leaq 0x5cf(%rip), %r14       # 0x181d2
leaq 0x564(%rip), %r15       # 0x1816e
leaq -0x149(%rip), %rsi      # 0x17ac8
leaq 0x46(%rip), %rdx        # 0x17c5e
leaq 0x1a4(%rip), %rcx       # 0x17dc3
leaq 0x2bc(%rip), %r8        # 0x17ee2
leaq 0x3a6(%rip), %r9        # 0x17fd3
pushq $0x48
popq %rdi
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq $0x0
pushq %r15
callq 0x167f8
addq $0x40, %rsp
movq %rax, 0x117ecc(%rip)    # 0x12fb18
callq 0x4f266
movq 0x117ec0(%rip), %rax    # 0x12fb18
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x17e86
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17e86
movq %rdi, %r14
callq 0x17bc8
movq %rax, %rdi
movq %r14, %rsi
callq 0x172d5
movq %rax, %r12
movq %rbx, %rdi
callq 0x1c3c4
movq %rax, %r14
movq %rdx, %r15
movq 0x18(%r12), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x17e76
movq %rbx, %rdi
callq 0x1c31a
movq %rax, %rdi
callq 0x143d2
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x17e76
movq %rax, %r12
movq %rsp, %r13
movq %rbx, 0x8(%r13)
andq $0x0, (%r13)
movq (%rax), %rdi
leaq 0x68(%rip), %rsi        # 0x17ebe
movq %r14, %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0x57ebd
movq (%r13), %rsi
testq %rsi, %rsi
je 0x17e76
movq (%r12), %rdi
callq 0x5815e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x11612b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb21cf(%rip), %rsi     # 0xca066
leaq 0xb59a5(%rip), %rdx     # 0xcd843
leaq 0xb59a8(%rip), %rcx     # 0xcd84d
leaq 0xb5940(%rip), %r8      # 0xcd7ec
movl $0xa2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x17f45
movq %rsi, %rbx
testq %rsi, %rsi
je 0x17f45
movq %rdi, %r14
callq 0x17bc8
movq %rax, %rdi
movq %r14, %rsi
callq 0x172d5
movq %rax, %r15
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x17f3c
movq (%rax), %rdi
leaq 0x7b(%rip), %rsi        # 0x17fab
movq %r14, %rdx
callq 0x57d4b
testl %eax, %eax
jne 0x17f73
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x11606c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb2110(%rip), %rsi     # 0xca066
leaq 0xb5914(%rip), %rdx     # 0xcd871
leaq 0xb591a(%rip), %rcx     # 0xcd87e
leaq 0xb5881(%rip), %r8      # 0xcd7ec
movl $0xca, %r9d
jmp 0x17f9f
movq 0x11603e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb20e2(%rip), %rsi     # 0xca066
leaq 0xb2688(%rip), %rdx     # 0xca613
leaq 0xb58ec(%rip), %rcx     # 0xcd87e
leaq 0xb5853(%rip), %r8      # 0xcd7ec
movl $0xd3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x57c60
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x4b801
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_features_for_range
int gt_feature_index_memory_get_features_for_range(GtFeatureIndex *gfi,
                                                   GtArray *results,
                                                   const char *seqid,
                                                   const GtRange *qry_range,
                                                   GtError *err)
{
  RegionInfo *ri;
  GtFeatureIndexMemory *fi;
  gt_error_check(err);
  gt_assert(gfi && results);

  fi = gt_feature_index_memory_cast(gfi);
  ri = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  if (!ri) {
    gt_error_set(err, "feature index does not contain the given sequence id");
    return -1;
  }
  gt_interval_tree_find_all_overlapping(ri->features, qry_range->start,
                                        qry_range->end, results);
  gt_array_sort(results, gt_genome_node_cmp_range_start);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
testq %r8, %r8
je 0x18000
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x1809c
testq %r13, %r13
je 0x1806e
testq %rbx, %rbx
je 0x1806e
callq 0x17bc8
movq %rax, %rdi
movq %r13, %rsi
callq 0x172d5
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x18050
movq (%rax), %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rcx
callq 0x57dbe
leaq 0x90(%rip), %rsi        # 0x180d4
movq %rbx, %rdi
callq 0x4ba94
xorl %eax, %eax
jmp 0x18064
leaq 0xb5894(%rip), %rsi     # 0xcd8eb
movq %r14, %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x115f43(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1fe7(%rip), %rsi     # 0xca066
leaq 0xb5856(%rip), %rdx     # 0xcd8dc
leaq 0xb5820(%rip), %rcx     # 0xcd8ad
leaq 0xb5758(%rip), %r8      # 0xcd7ec
movl $0xe8, %r9d
jmp 0x180c8
movq 0x115f15(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1fb9(%rip), %rsi     # 0xca066
leaq 0xb25a5(%rip), %rdx     # 0xca659
leaq 0xb57f2(%rip), %rcx     # 0xcd8ad
leaq 0xb572a(%rip), %r8      # 0xcd7ec
movl $0xe7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_node_by_ptr
GtFeatureNode*  gt_feature_index_memory_get_node_by_ptr(GtFeatureIndexMemory
                                                                          *fim,
                                                        GtFeatureNode *ptr,
                                                        GtError *err)
{
  GtFeatureNode *retnode;
  gt_assert(fim);

  if (!(retnode = gt_hashmap_get(fim->nodes_in_index, ptr))) {
    gt_error_set(err, "feature index does not contain a node with address %p",
                 ptr);
  }
  return retnode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18136
movq %rdx, %r14
movq %rsi, %rbx
movq 0x18(%rdi), %rdi
callq 0x55ef6
movq %rax, %r15
testq %rax, %rax
jne 0x1812d
leaq 0xb582c(%rip), %rsi     # 0xcd94c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xc007
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x115e7b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1f1f(%rip), %rsi     # 0xca066
leaq 0xb57d2(%rip), %rdx     # 0xcd920
leaq 0xb57cf(%rip), %rcx     # 0xcd924
leaq 0xb5690(%rip), %r8      # 0xcd7ec
movl $0xfc, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_first_seqid
char* gt_feature_index_memory_get_first_seqid(const GtFeatureIndex *gfi,
                                              GT_UNUSED GtError *err)
{
  GtFeatureIndexMemory *fi;
  gt_assert(gfi);

  fi = gt_feature_index_memory_cast((GtFeatureIndex*) gfi);
  return fi->firstseqid ? gt_cstr_dup(fi->firstseqid) : NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1819a
movq %rdi, %rbx
callq 0x17bc8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x172d5
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x18196
popq %rbx
jmp 0x4f8ae
xorl %eax, %eax
popq %rbx
retq
movq 0x115e17(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1ebb(%rip), %rsi     # 0xca066
leaq 0xb57d0(%rip), %rdx     # 0xcd982
leaq 0xb57cd(%rip), %rcx     # 0xcd986
leaq 0xb562c(%rip), %r8      # 0xcd7ec
movl $0x109, %r9d            # imm = 0x109
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_seqids
GtStrArray* gt_feature_index_memory_get_seqids(const GtFeatureIndex *gfi,
                                               GT_UNUSED GtError *err)
{
  GtCstrTable* seqids;
  GtStrArray *ret;
  GT_UNUSED int rval;
  GtFeatureIndexMemory *fi;
  gt_assert(gfi);

  fi = gt_feature_index_memory_cast((GtFeatureIndex*) gfi);
  seqids = gt_cstr_table_new();
  rval = gt_hashmap_foreach_in_key_order(fi->regions, store_seqid, seqids,
                                         NULL);
  gt_assert(!rval); /* store_seqid() is sane */
  ret = gt_cstr_table_get_all(seqids);
  gt_cstr_table_delete(seqids);
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18230
movq %rdi, %rbx
callq 0x17bc8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x172d5
movq %rax, %r14
callq 0x5005c
movq %rax, %rbx
movq 0x10(%r14), %rdi
leaq 0x92(%rip), %rsi        # 0x18296
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x56009
testl %eax, %eax
jne 0x1825e
movq %rbx, %rdi
callq 0x501e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x5055b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x115d81(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1e25(%rip), %rsi     # 0xca066
leaq 0xb573a(%rip), %rdx     # 0xcd982
leaq 0xb575f(%rip), %rcx     # 0xcd9ae
leaq 0xb5596(%rip), %r8      # 0xcd7ec
movl $0x122, %r9d            # imm = 0x122
jmp 0x1828a
movq 0x115d53(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1df7(%rip), %rsi     # 0xca066
leaq 0xb2871(%rip), %rdx     # 0xcaae7
leaq 0xb5731(%rip), %rcx     # 0xcd9ae
leaq 0xb5568(%rip), %r8      # 0xcd7ec
movl $0x128, %r9d            # imm = 0x128
xorl %eax, %eax
callq 0xb8c0
callq 0xb300