LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_exact_show
void gt_alignment_exact_show(GtUchar *buffer,
                             const GtAlignment *alignment,
                             FILE *fp,
                             unsigned int width,
                             const GtUchar *characters)
{
  GtUword idx;
  unsigned int pos = 0;
  GtUchar *topbuf = buffer, *midbuf = NULL, *lowbuf = NULL;

  if ((GtUword) width > alignment->ulen)
  {
    width = (unsigned int) alignment->ulen;
  }
  topbuf[width] = '\n';
  midbuf = topbuf + width + 1;
  for (idx = 0; idx < (GtUword) width; idx++)
  {
    midbuf[idx] = (GtUchar) MATCHSYMBOL;
  }
  midbuf[width] = '\n';
  lowbuf = midbuf + width + 1;
  lowbuf[width] = '\n';
  for (idx = 0; idx < alignment->ulen; idx++)
  {
    if (characters != NULL)
    {
      lowbuf[pos] = topbuf[pos] = characters[alignment->u[idx]];
    } else
    {
      lowbuf[pos] = topbuf[pos] = alignment->u[idx];
    }
    pos = gt_alignment_show_advance(pos,width,topbuf,fp);
  }
  if (pos > 0)
  {
    topbuf[pos] = '\n';
    fwrite(topbuf,sizeof *topbuf,pos+1,fp);
    midbuf[pos] = '\n';
    fwrite(midbuf,sizeof *midbuf,pos+1,fp);
    lowbuf[pos] = '\n';
    fwrite(lowbuf,sizeof *lowbuf,pos+1,fp);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r14
movl %ecx, %eax
movq 0x38(%rsi), %rdx
cmpq %rax, %rdx
cmovael %ecx, %edx
leaq 0x1(%rdi,%rdx), %rsi
movb $0xa, -0x1(%rsi)
movq %rdx, 0x18(%rsp)
movq %rdx, %rax
negq %rax
xorl %ecx, %ecx
movq %rax, %rdx
addq %rcx, %rdx
je 0xb609b
movb $0x7c, (%rsi,%rcx)
incq %rcx
jmp 0xb608a
movq 0x18(%rsp), %rdi
leaq (%rsi,%rdi), %rax
movb $0xa, %cl
movq %rsi, 0x20(%rsp)
leaq (%rsi,%rdi), %rdx
incq %rdx
movq %rdx, 0x8(%rsp)
movb %cl, -0x1(%rdx)
movb %cl, 0x1(%rdi,%rax)
xorl %ebx, %ebx
xorl %r15d, %r15d
movl %r15d, %ebp
cmpq 0x38(%r13), %rbx
jae 0xb6108
movq 0x20(%r13), %rax
movb (%rax,%rbx), %al
testq %r12, %r12
je 0xb60df
movzbl %al, %eax
movb (%r12,%rax), %al
movb %al, (%r14,%rbp)
movq 0x8(%rsp), %rcx
movb %al, (%rcx,%rbp)
movl %r15d, %edi
movq 0x18(%rsp), %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
callq 0xb5fba
movl %eax, %r15d
incq %rbx
jmp 0xb60c3
testl %r15d, %r15d
je 0xb616c
movb $0xa, %r12b
movb %r12b, (%r14,%rbp)
incl %r15d
pushq $0x1
popq %rbx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %r14
movq %r14, %rcx
callq 0x17f00
movq 0x20(%rsp), %rdi
movb %r12b, (%rdi,%rbp)
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x17f00
movq 0x8(%rsp), %rdi
movb %r12b, (%rdi,%rbp)
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17f00
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_show_with_mapped_chars
void gt_alignment_show_with_mapped_chars(const GtAlignment *alignment,
                                         const GtUchar *characters,
                                         GtUchar wildcardshow,
                                         FILE *fp,
                                         unsigned int width)
{
  GtUchar *buffer = gt_alignment_buffer_new(width);

  gt_assert(characters != NULL);
  gt_alignment_show_generic(buffer,false,alignment, fp, width, characters,
                            wildcardshow);
  gt_alignment_buffer_delete(buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r13
movl %r8d, %edi
callq 0xb617b
testq %r14, %r14
je 0xb6400
movq %rax, %r12
movzbl %bpl, %eax
movl %eax, (%rsp)
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movl %ebx, %r8d
movq %r14, %r9
callq 0xb5b91
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb6199
movq 0x381b61(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22ec02(%rip), %rsi    # 0x2e5013
leaq 0x25ee92(%rip), %rdx    # 0x3152aa
leaq 0x25ee9e(%rip), %rcx    # 0x3152bd
leaq 0x25eaea(%rip), %r8     # 0x314f10
movl $0x31a, %r9d            # imm = 0x31A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/alignment.c
// Function: gt_alignment_clone
void gt_alignment_clone(const GtAlignment *alignment_from,
                        GtAlignment *alignment_to)
{
  gt_assert(alignment_from != NULL && alignment_to != NULL);

  alignment_to->u = alignment_from->u;
  alignment_to->v = alignment_from->v;
  alignment_to->ulen = alignment_from->ulen;
  alignment_to->vlen = alignment_from->vlen;
  alignment_to->aligned_range_u = alignment_from->aligned_range_u;
  alignment_to->aligned_range_v = alignment_from->aligned_range_v;
  gt_multieoplist_clone(alignment_to->eops,alignment_from->eops);
  alignment_to->alilen = alignment_from->alilen;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb64f6
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb64f6
movq %rdi, %r14
movups 0x20(%rdi), %xmm0
movups %xmm0, 0x20(%rbx)
movups 0x38(%rdi), %xmm0
movups %xmm0, 0x38(%rbx)
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
movq 0x30(%r14), %rsi
callq 0x1016b3
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x381a6b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22eb0c(%rip), %rsi    # 0x2e5013
leaq 0x25edf3(%rip), %rdx    # 0x315301
leaq 0x25ee1b(%rip), %rcx    # 0x315330
leaq 0x25e9f4(%rip), %r8     # 0x314f10
movl $0x330, %r9d            # imm = 0x330
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_anno_db_gfflike_class
const GtAnnoDBSchemaClass* gt_anno_db_gfflike_class()
{
  static const GtAnnoDBSchemaClass *adbsc = NULL;
  gt_class_alloc_lock_enter();
  if (!adbsc) {
    adbsc = gt_anno_db_schema_class_new(sizeof (GtAnnoDBGFFlike),
                                        anno_db_gfflike_free,
                                        anno_db_gfflike_build);
  }
  gt_class_alloc_lock_leave();
  return adbsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x3862fd(%rip)    # 0x43d648
jne 0xb736a
leaq -0x35(%rip), %rsi       # 0xb731f
leaq 0x142a(%rip), %rdx      # 0xb8785
pushq $0x20
popq %rdi
callq 0xba4a4
movq %rax, 0x3862de(%rip)    # 0x43d648
callq 0x69ede
movq 0x3862d2(%rip), %rax    # 0x43d648
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: feature_index_gfflike_class
const GtFeatureIndexClass* feature_index_gfflike_class(void)
{
  static const GtFeatureIndexClass *fic = NULL;
  if (!fic) {
    fic = gt_feature_index_class_new(sizeof (GtFeatureIndexGFFlike),
                                gt_feature_index_gfflike_add_region_node,
                                gt_feature_index_gfflike_add_feature_node,
                                gt_feature_index_gfflike_remove_node,
                                gt_feature_index_gfflike_get_features_for_seqid,
                                gt_feature_index_gfflike_get_features_for_range,
                                gt_feature_index_gfflike_get_first_seqid,
                                gt_feature_index_gfflike_save,
                                gt_feature_index_gfflike_get_seqids,
                                gt_feature_index_gfflike_get_range_for_seqid,
                                gt_feature_index_gfflike_get_range_for_seqid,
                                gt_feature_index_gfflike_has_seqid,
                                gt_feature_index_gfflike_delete);
  }
  return fic;
}

// Assembly:
movq 0x3861d8(%rip), %rax    # 0x43d650
testq %rax, %rax
je 0xb747e
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x8, %rsp
leaq 0x121d(%rip), %rax      # 0xb86ab
leaq 0x10ad(%rip), %r10      # 0xb8542
leaq 0xf05(%rip), %r11       # 0xb83a1
leaq 0xddd(%rip), %rbx       # 0xb8280
leaq 0x28c5(%rip), %r14      # 0xb9d6f
leaq 0xc48(%rip), %r15       # 0xb80f9
leaq -0x140(%rip), %rsi      # 0xb7378
leaq 0x3c(%rip), %rdx        # 0xb74fb
leaq 0x19f(%rip), %rcx       # 0xb7665
leaq 0x24a(%rip), %r8        # 0xb7717
leaq 0x95c(%rip), %r9        # 0xb7e30
movl $0x180, %edi            # imm = 0x180
pushq %rax
pushq %r10
pushq %r11
pushq %r11
pushq %rbx
pushq %r14
pushq %r15
callq 0xd7608
addq $0x40, %rsp
movq %rax, 0x38615b(%rip)    # 0x43d650
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_add_feature_node
int gt_feature_index_gfflike_add_feature_node(GtFeatureIndex *gfi,
                                              GtFeatureNode *gf,
                                              GtError *err)
{
  GtFeatureIndexGFFlike *fi;
  int had_err = 0;
  gt_assert(gfi && gf);

  fi = feature_index_gfflike_cast(gfi);
  had_err = insert_feature_node(fi,
                                (GtFeatureNode*)
                                         gt_genome_node_ref((GtGenomeNode*) gf),
                                err);
  if (!had_err)
    gt_hashmap_add(fi->ref_nodes, gf, (void*) 1);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xb762d
movq %rsi, %r12
testq %rsi, %rsi
je 0xb762d
movq %rdx, %r15
movq %rdi, %rbx
callq 0xb7471
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd80e5
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0xdccf8
movq %rax, %r13
movq 0x10(%r14), %rdi
callq 0x8f5bc
movq 0x10(%r14), %rsi
leaq 0x1eb0(%rip), %rdx      # 0xb940b
xorl %r12d, %r12d
pushq $0x1
popq %rcx
movq %r13, %rdi
xorl %r8d, %r8d
callq 0xdac92
movq %r13, %rdi
callq 0xda769
testb %al, %al
je 0xb758e
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0xb9524
movl %eax, %r12d
movq %r13, %rdi
callq 0xdc6f0
movq %rax, %r13
leaq 0x10(%rsp), %rbx
testl %r12d, %r12d
jne 0xb75d8
movq %r13, %rdi
callq 0xdc92e
testq %rax, %rax
je 0xb75dd
movq %rax, %rbp
movq 0x160(%r14), %rsi
movq %rax, %rdi
callq 0xd97c0
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0xb9524
movl %eax, %r12d
jmp 0xb759e
pushq $-0x1
popq %rbx
jmp 0xb75f5
movq 0x10(%r14), %rdi
leaq 0x238b(%rip), %rsi      # 0xb9973
movq %r14, %rdx
movq %r15, %rcx
callq 0x8f56e
xorl %ebx, %ebx
movq %r13, %rdi
callq 0xdc9f1
movq 0x10(%r14), %rdi
callq 0x8f5bc
testl %r12d, %r12d
jne 0xb761c
movq 0x30(%r14), %rdi
pushq $0x1
popq %rdx
movq 0x8(%rsp), %rsi
callq 0x8f4bd
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x380934(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d9d5(%rip), %rsi    # 0x2e5013
leaq 0x25dfa2(%rip), %rdx    # 0x3155e7
leaq 0x25dfa5(%rip), %rcx    # 0x3155f1
leaq 0x25dec3(%rip), %r8     # 0x315516
movl $0x3fe, %r9d            # imm = 0x3FE
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_remove_node
int gt_feature_index_gfflike_remove_node(GtFeatureIndex *gfi,
                                         GtFeatureNode *gf,
                                         GT_UNUSED GtError *err)
{
  GtFeatureIndexGFFlike *fi;
  int had_err = 0;
  gt_assert(gfi && gf);

  fi = feature_index_gfflike_cast(gfi);
  if (gt_hashmap_get(fi->added, gf)) {
    gt_hashmap_remove(fi->added, gf);
  }
  if (gt_hashmap_get(fi->changed, gf)) {
    gt_hashmap_remove(fi->changed, gf);
  }
  gt_hashmap_add(fi->deleted, gf, (void*) 1);

  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb76df
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb76df
movq %rdi, %r14
callq 0xb7471
movq %rax, %rdi
movq %r14, %rsi
callq 0xd80e5
movq %rax, %r14
movq 0x38(%rax), %rdi
movq %rbx, %rsi
callq 0x8f482
testq %rax, %rax
je 0xb76a9
movq 0x38(%r14), %rdi
movq %rbx, %rsi
callq 0x8f4fb
movq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0x8f482
testq %rax, %rax
je 0xb76c6
movq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0x8f4fb
movq 0x40(%r14), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x8f4bd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x380882(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d923(%rip), %rsi    # 0x2e5013
leaq 0x25def0(%rip), %rdx    # 0x3155e7
leaq 0x25df1d(%rip), %rcx    # 0x31561b
leaq 0x25de11(%rip), %r8     # 0x315516
movl $0x44e, %r9d            # imm = 0x44E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_get_features_for_seqid
GtArray* gt_feature_index_gfflike_get_features_for_seqid(GtFeatureIndex *gfi,
                                                         const char *seqid,
                                                         GtError *err)
{
  GtArray *a;
  GtFeatureIndexGFFlike *fi;
  GtRDBStmt *stmt;
  gt_assert(gfi && seqid);
  gt_error_check(err);
  fi = feature_index_gfflike_cast(gfi);
  stmt = fi->stmts[GT_PSTMT_GET_BY_SEQID_SELECT];
  a = gt_array_new(sizeof (GtFeatureNode*));
  gt_rdb_stmt_reset(stmt, err);
  gt_rdb_stmt_bind_string(stmt, 0, seqid, err);
  get_nodes_for_stmt(fi, a, stmt, err);
  return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xb77aa
movq %rsi, %r14
testq %rsi, %rsi
je 0xb77aa
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xb774c
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xb77d8
callq 0xb7471
movq %rax, %rdi
movq %r15, %rsi
callq 0xd80e5
movq %rax, %r15
movq 0xf0(%rax), %r12
pushq $0x8
popq %rdi
callq 0x5809c
movq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10d5e0
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xb7810
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x3807b7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d858(%rip), %rsi    # 0x2e5013
leaq 0x25de7e(%rip), %rdx    # 0x315640
leaq 0x25de84(%rip), %rcx    # 0x31564d
leaq 0x25dd46(%rip), %r8     # 0x315516
movl $0x5ab, %r9d            # imm = 0x5AB
jmp 0xb7804
movq 0x380789(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d82a(%rip), %rsi    # 0x2e5013
leaq 0x22d9cf(%rip), %rdx    # 0x2e51bf
leaq 0x25de56(%rip), %rcx    # 0x31564d
leaq 0x25dd18(%rip), %r8     # 0x315516
movl $0x5ac, %r9d            # imm = 0x5AC
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_get_features_for_range
int gt_feature_index_gfflike_get_features_for_range(GtFeatureIndex *gfi,
                                                    GtArray *results,
                                                    const char *seqid,
                                                    const GtRange *qry_range,
                                                    GtError *err)
{
  GtFeatureIndexGFFlike *fi;
  int retval;
  gt_error_check(err);
  GtRDBStmt *stmt;
  gt_assert(gfi && results);
  gt_error_check(err);
  fi = feature_index_gfflike_cast(gfi);
  stmt = fi->stmts[GT_PSTMT_GET_RANGE_SELECT];
  gt_mutex_lock(fi->dblock);
  gt_rdb_stmt_reset(stmt, err);
  gt_rdb_stmt_bind_string(stmt, 0, seqid, err);
  gt_rdb_stmt_bind_ulong(stmt, 1, qry_range->end, err);
  gt_rdb_stmt_bind_ulong(stmt, 2, qry_range->start, err);
  retval = get_nodes_for_stmt(fi, results, stmt, err);
  gt_mutex_unlock(fi->dblock);
  return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
testq %r8, %r8
je 0xb7eae
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xb7f80
testq %r13, %r13
je 0xb7f52
testq %r14, %r14
je 0xb7f52
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
je 0xb7ec0
movq 0x3800e4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d185(%rip), %rsi    # 0x2e5013
leaq 0x22d32a(%rip), %rdx    # 0x2e51bf
leaq 0x25d7e1(%rip), %rcx    # 0x31567d
leaq 0x25d673(%rip), %r8     # 0x315516
movl $0x5c1, %r9d            # imm = 0x5C1
jmp 0xb7fac
testq %r13, %r13
je 0xb7f52
testq %r14, %r14
je 0xb7f52
callq 0xb7471
movq %rax, %rdi
movq %r13, %rsi
callq 0xd80e5
movq %rax, %r13
movq 0xc8(%rax), %rbp
movq 0x170(%rax), %rdi
callq 0xaf370
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq %rbp, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x10d5e0
movq 0x8(%r15), %rdx
pushq $0x1
popq %rsi
movq %rbp, %rdi
movq %rbx, %rcx
callq 0x10d58c
movq (%r15), %rdx
pushq $0x2
popq %rsi
movq %rbp, %rdi
movq %rbx, %rcx
callq 0x10d58c
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0xb7810
movq 0x170(%r13), %rdi
callq 0xaf3e7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38000f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d0b0(%rip), %rsi    # 0x2e5013
leaq 0x25d743(%rip), %rdx    # 0x3156ad
leaq 0x25d70c(%rip), %rcx    # 0x31567d
leaq 0x25d59e(%rip), %r8     # 0x315516
movl $0x5c0, %r9d            # imm = 0x5C0
jmp 0xb7fac
movq 0x37ffe1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d082(%rip), %rsi    # 0x2e5013
leaq 0x22d227(%rip), %rdx    # 0x2e51bf
leaq 0x25d6de(%rip), %rcx    # 0x31567d
leaq 0x25d570(%rip), %r8     # 0x315516
movl $0x5be, %r9d            # imm = 0x5BE
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_get_all_features
int gt_feature_index_gfflike_get_all_features(GtFeatureIndex *gfi,
                                              GtArray *results,
                                              GtError *err)
{
  GtFeatureIndexGFFlike *fi;
  int retval;
  gt_error_check(err);
  GtRDBStmt *stmt;
  gt_assert(gfi && results);
  gt_error_check(err);
  fi = feature_index_gfflike_cast(gfi);
  stmt = fi->stmts[GT_PSTMT_GET_ALL];
  gt_mutex_lock(fi->dblock);
  gt_rdb_stmt_reset(stmt, err);
  retval = get_nodes_for_stmt(fi, results, stmt, err);
  gt_mutex_unlock(fi->dblock);
  return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xb802d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xb80c1
testq %r15, %r15
je 0xb8093
testq %r14, %r14
je 0xb8093
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
je 0xb8037
movq 0x37ff65(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22d006(%rip), %rsi    # 0x2e5013
leaq 0x22d1ab(%rip), %rdx    # 0x2e51bf
leaq 0x25d6a1(%rip), %rcx    # 0x3156bc
leaq 0x25d4f4(%rip), %r8     # 0x315516
movl $0x5d7, %r9d            # imm = 0x5D7
jmp 0xb80ed
testq %r15, %r15
je 0xb8093
testq %r14, %r14
je 0xb8093
callq 0xb7471
movq %rax, %rdi
movq %r15, %rsi
callq 0xd80e5
movq %rax, %r15
movq 0xc0(%rax), %r12
movq 0x170(%rax), %rdi
callq 0xaf370
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xb7810
movq 0x170(%r15), %rdi
callq 0xaf3e7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x37fece(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22cf6f(%rip), %rsi    # 0x2e5013
leaq 0x25d602(%rip), %rdx    # 0x3156ad
leaq 0x25d60a(%rip), %rcx    # 0x3156bc
leaq 0x25d45d(%rip), %r8     # 0x315516
movl $0x5d6, %r9d            # imm = 0x5D6
jmp 0xb80ed
movq 0x37fea0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22cf41(%rip), %rsi    # 0x2e5013
leaq 0x22d0e6(%rip), %rdx    # 0x2e51bf
leaq 0x25d5dc(%rip), %rcx    # 0x3156bc
leaq 0x25d42f(%rip), %r8     # 0x315516
movl $0x5d4, %r9d            # imm = 0x5D4
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_get_first_seqid
char* gt_feature_index_gfflike_get_first_seqid(const GtFeatureIndex *gfi,
                                               GtError *err)
{
  GtFeatureIndexGFFlike *fi;
  char *firstseqid = NULL;
  int rval, had_err = 0;
  GtStr *result;
  GtRDBStmt *stmt;
  gt_assert(gfi);
  gt_error_check(err);
  fi = feature_index_gfflike_cast((GtFeatureIndex*) gfi);
  stmt = fi->stmts[GT_PSTMT_GET_FIRST_SEQID_SELECT];
  gt_mutex_lock(fi->dblock);
  gt_rdb_stmt_reset(stmt, err);
  rval = gt_rdb_stmt_exec(stmt, err);
  result = gt_str_new();
  switch (rval) {
    case 0:
      gt_rdb_stmt_get_string(stmt, 0, result, err);
      firstseqid = gt_cstr_dup(gt_str_get(result));
      gt_assert(gt_rdb_stmt_exec(stmt, err) == 1);
      break;
    case 1:
      gt_error_set(err, "no sequence regions in index");
      had_err = -1;
      break;
    default:
      /* error is set */
      had_err = -1;
      break;
  }
  gt_str_delete(result);
  gt_mutex_unlock(fi->dblock);
  return (had_err ? NULL : firstseqid);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb821a
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xb8128
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0xb8248
callq 0xb7471
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd80e5
movq %rax, %rbx
movq 0x100(%rax), %r12
movq 0x170(%rax), %rdi
callq 0xaf370
movq %r12, %rdi
movq %r14, %rsi
callq 0x10d4e4
movq %r12, %rdi
movq %r14, %rsi
callq 0x10d688
movl %eax, %ebp
callq 0xacb84
movq %rax, %r15
cmpl $0x1, %ebp
je 0xb81db
testl %ebp, %ebp
jne 0xb81f1
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x10d7fc
movq %r15, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x6c2be
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x10d688
cmpl $0x1, %eax
je 0xb81f4
movq 0x37fdb7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22ce58(%rip), %rsi    # 0x2e5013
leaq 0x25d551(%rip), %rdx    # 0x315713
leaq 0x25d521(%rip), %rcx    # 0x3156ea
leaq 0x25d346(%rip), %r8     # 0x315516
movl $0x5f5, %r9d            # imm = 0x5F5
jmp 0xb8274
leaq 0x25d552(%rip), %rsi    # 0x315734
xorl %r13d, %r13d
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
jmp 0xb81f4
xorl %r13d, %r13d
movq %r15, %rdi
callq 0xae103
movq 0x170(%rbx), %rdi
callq 0xaf3e7
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x37fd47(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22cde8(%rip), %rsi    # 0x2e5013
leaq 0x25d4b4(%rip), %rdx    # 0x3156e6
leaq 0x25d4b1(%rip), %rcx    # 0x3156ea
leaq 0x25d2d6(%rip), %r8     # 0x315516
movl $0x5e9, %r9d            # imm = 0x5E9
jmp 0xb8274
movq 0x37fd19(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22cdba(%rip), %rsi    # 0x2e5013
leaq 0x22cf5f(%rip), %rdx    # 0x2e51bf
leaq 0x25d483(%rip), %rcx    # 0x3156ea
leaq 0x25d2a8(%rip), %r8     # 0x315516
movl $0x5ea, %r9d            # imm = 0x5EA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_get_seqids
GtStrArray* gt_feature_index_gfflike_get_seqids(const GtFeatureIndex *gfi,
                                                GtError *err)
{
  GtStrArray* seqids;
  GtFeatureIndexGFFlike *fi;
  GtRDBStmt *stmt;
  int rval;
  gt_assert(gfi);
  gt_error_check(err);
  fi = feature_index_gfflike_cast((GtFeatureIndex*) gfi);
  seqids = gt_str_array_new();
  gt_mutex_lock(fi->dblock);
  stmt = fi->stmts[GT_PSTMT_GET_SEQIDS_SELECT];
  gt_rdb_stmt_reset(stmt, err);
  while ((rval = gt_rdb_stmt_exec(stmt, err)) == 0) {
    GtStr *seqid = gt_str_new();
    gt_rdb_stmt_get_string(stmt, 0, seqid, err);
    gt_str_array_add(seqids, seqid);
    gt_str_delete(seqid);
  }
  gt_mutex_unlock(fi->dblock);
  return seqids;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xb833b
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xb82ad
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xb8369
callq 0xb7471
movq %rax, %rdi
movq %r14, %rsi
callq 0xd80e5
movq %rax, %r14
callq 0xae154
movq %rax, %r15
movq 0x170(%r14), %rdi
callq 0xaf370
movq 0xe8(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10d688
testl %eax, %eax
jne 0xb8322
callq 0xacb84
movq %rax, %r13
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x10d7fc
movq %r15, %rdi
movq %r13, %rsi
callq 0xae31d
movq %r13, %rdi
callq 0xae103
jmp 0xb82e6
movq 0x170(%r14), %rdi
callq 0xaf3e7
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x37fc26(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22ccc7(%rip), %rsi    # 0x2e5013
leaq 0x25d393(%rip), %rdx    # 0x3156e6
leaq 0x25d3f7(%rip), %rcx    # 0x315751
leaq 0x25d1b5(%rip), %r8     # 0x315516
movl $0x60c, %r9d            # imm = 0x60C
jmp 0xb8395
movq 0x37fbf8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22cc99(%rip), %rsi    # 0x2e5013
leaq 0x22ce3e(%rip), %rdx    # 0x2e51bf
leaq 0x25d3c9(%rip), %rcx    # 0x315751
leaq 0x25d187(%rip), %r8     # 0x315516
movl $0x60d, %r9d            # imm = 0x60D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_has_seqid
int gt_feature_index_gfflike_has_seqid(const GtFeatureIndex *gfi,
                                       bool *has_seqid,
                                       const char *seqid,
                                       GtError *err)
{
  GtFeatureIndexGFFlike *fi;
  int had_err = 0;
  gt_assert(gfi);
  int rval;
  GtRDBStmt *stmt;
  gt_assert(gfi);
  gt_error_check(err);
  fi = feature_index_gfflike_cast((GtFeatureIndex*) gfi);
  gt_mutex_lock(fi->dblock);
  stmt = fi->stmts[GT_PSTMT_HAS_SEQID_SELECT];
  gt_rdb_stmt_reset(stmt, err);
  gt_rdb_stmt_bind_string(stmt, 0, seqid, err);
  rval = gt_rdb_stmt_exec(stmt, err);
  if (rval < 0) {
    /* error is set */
    had_err = -1;
  }
  if (!had_err) {
    int nof_entries;
    gt_rdb_stmt_get_int(stmt, 0, &nof_entries, err);
    *has_seqid = (nof_entries > 0);
    gt_assert(gt_rdb_stmt_exec(stmt, err) == 1);
  }
  gt_mutex_unlock(fi->dblock);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb8617
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0xb8577
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xb8645
callq 0xb7471
movq %rax, %rdi
movq %r15, %rsi
callq 0xd80e5
movq %rax, %r15
movq 0x170(%rax), %rdi
callq 0xaf370
movq 0xf8(%r15), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x10d5e0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x10d688
movl %eax, %ebp
testl %eax, %eax
js 0xb85f7
leaq 0x4(%rsp), %r12
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x10d7a3
cmpl $0x0, (%r12)
setg (%r14)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x10d688
cmpl $0x1, %eax
jne 0xb8673
sarl $0x1f, %ebp
movq 0x170(%r15), %rdi
callq 0xaf3e7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x37f94a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22c9eb(%rip), %rsi    # 0x2e5013
leaq 0x25d0b7(%rip), %rdx    # 0x3156e6
leaq 0x25d1a6(%rip), %rcx    # 0x3157dc
leaq 0x25ced9(%rip), %r8     # 0x315516
movl $0x647, %r9d            # imm = 0x647
jmp 0xb869f
movq 0x37f91c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22c9bd(%rip), %rsi    # 0x2e5013
leaq 0x22cb62(%rip), %rdx    # 0x2e51bf
leaq 0x25d178(%rip), %rcx    # 0x3157dc
leaq 0x25ceab(%rip), %r8     # 0x315516
movl $0x64b, %r9d            # imm = 0x64B
jmp 0xb869f
movq 0x37f8ee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22c98f(%rip), %rsi    # 0x2e5013
leaq 0x25d088(%rip), %rdx    # 0x315713
leaq 0x25d14a(%rip), %rcx    # 0x3157dc
leaq 0x25ce7d(%rip), %r8     # 0x315516
movl $0x65a, %r9d            # imm = 0x65A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_delete
void gt_feature_index_gfflike_delete(GtFeatureIndex *gfi)
{
  GtFeatureIndexGFFlike *fi;
  GtUword i;
  if (!gfi) return;
  fi = feature_index_gfflike_cast(gfi);
  for (i=0;i<GT_PSTMT_NOF_STATEMENTS;i++) {
    gt_rdb_stmt_delete(fi->stmts[i]);
  }
  if (fi->db)
    gt_rdb_delete(fi->db);
  gt_hashmap_delete(fi->node_to_parent_array);
  unregister_observers(fi, NULL);
  gt_feature_node_observer_delete(fi->obs);
  node_ul_gt_hashmap_delete(fi->cache_node2id);
  ul_node_gt_hashmap_delete(fi->cache_id2node);
  gt_hashmap_delete(fi->ref_nodes);
  gt_hashmap_delete(fi->seqid_cache);
  gt_hashmap_delete(fi->source_cache);
  gt_hashmap_delete(fi->string_caches);
  gt_hashmap_delete(fi->added);
  gt_hashmap_delete(fi->deleted);
  gt_hashmap_delete(fi->changed);
  gt_mutex_delete(fi->dblock);
}

// Assembly:
testq %rdi, %rdi
je 0xb8784
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb7471
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd80e5
movq %rax, %rbx
xorl %r14d, %r14d
cmpq $0x20, %r14
je 0xb86e6
movq 0x60(%rbx,%r14,8), %rdi
callq 0x10d6dc
incq %r14
jmp 0xb86d1
movq 0x168(%rbx), %rdi
testq %rdi, %rdi
je 0xb86f7
callq 0x10d1a6
movq 0x10(%rbx), %rdi
callq 0x8f933
movq 0x30(%rbx), %rdi
leaq 0x161d(%rip), %rsi      # 0xb9d28
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8f56e
movq 0x160(%rbx), %rdi
callq 0xdca79
movq 0x50(%rbx), %rdi
callq 0x9082d
movq 0x58(%rbx), %rdi
callq 0x9082d
movq 0x30(%rbx), %rdi
callq 0x8f933
movq 0x18(%rbx), %rdi
callq 0x8f933
movq 0x20(%rbx), %rdi
callq 0x8f933
movq 0x28(%rbx), %rdi
callq 0x8f933
movq 0x38(%rbx), %rdi
callq 0x8f933
movq 0x40(%rbx), %rdi
callq 0x8f933
movq 0x48(%rbx), %rdi
callq 0x8f933
movq 0x170(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaf31b
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: node_score_changed_callback
static void node_score_changed_callback(GtFeatureNode *changed,
                                        GT_UNUSED double score,
                                        void *data)
{
  GtUword *id;
  ObserverCallbackInfo *info = (ObserverCallbackInfo*) data;
  gt_assert(changed);
  if ((id = node_ul_gt_hashmap_get(info->fis->cache_node2id, changed))) {
    gt_hashmap_add(info->fis->changed, changed, (void*) 1);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb8f28
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x50(%rax), %rdi
movq %rbx, %rsi
callq 0xb9ac3
testq %rax, %rax
je 0xb8f20
movq 0x8(%r14), %rax
movq 0x48(%rax), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8f4bd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x37f039(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22c0da(%rip), %rsi    # 0x2e5013
leaq 0x2bda0b(%rip), %rdx    # 0x37694b
leaq 0x25d87d(%rip), %rcx    # 0x3167c4
leaq 0x25c5c8(%rip), %r8     # 0x315516
movl $0x3dc, %r9d            # imm = 0x3DC
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: node_attribute_change_callback
static void node_attribute_change_callback(GtFeatureNode *changed,
                                           GT_UNUSED bool added,
                                           GT_UNUSED const char *key,
                                           GT_UNUSED const char *value,
                                           void *data)
{
  GtUword *id;
  ObserverCallbackInfo *info = (ObserverCallbackInfo*) data;
  gt_assert(changed);
  if ((id = node_ul_gt_hashmap_get(info->fis->cache_node2id, changed))) {
    gt_hashmap_add(info->fis->changed, changed, (void*) 1);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb9028
movq %r8, %r14
movq %rdi, %rbx
movq 0x8(%r8), %rax
movq 0x50(%rax), %rdi
movq %rbx, %rsi
callq 0xb9ac3
testq %rax, %rax
je 0xb9020
movq 0x8(%r14), %rax
movq 0x48(%rax), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8f4bd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x37ef39(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22bfda(%rip), %rsi    # 0x2e5013
leaq 0x2bd90b(%rip), %rdx    # 0x37694b
leaq 0x25d799(%rip), %rcx    # 0x3167e0
leaq 0x25c4c8(%rip), %r8     # 0x315516
movl $0x3b2, %r9d            # imm = 0x3B2
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: node_attribute_delete_callback
static void node_attribute_delete_callback(GtFeatureNode *changed,
                                           GT_UNUSED const char *key,
                                           GT_UNUSED void *data)
{
  GtUword *id;
  ObserverCallbackInfo *info = (ObserverCallbackInfo*) data;
  gt_assert(changed);
  if ((id = node_ul_gt_hashmap_get(info->fis->cache_node2id, changed))) {
    gt_hashmap_add(info->fis->changed, changed, (void*) 1);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb90a6
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
movq 0x50(%rax), %rdi
movq %rbx, %rsi
callq 0xb9ac3
testq %rax, %rax
je 0xb909e
movq 0x8(%r14), %rax
movq 0x48(%rax), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8f4bd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x37eebb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22bf5c(%rip), %rsi    # 0x2e5013
leaq 0x2bd88d(%rip), %rdx    # 0x37694b
leaq 0x25d73a(%rip), %rcx    # 0x3167ff
leaq 0x25c44a(%rip), %r8     # 0x315516
movl $0x3be, %r9d            # imm = 0x3BE
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: node_child_add_callback
static int node_child_add_callback(GtFeatureNode *parent,
                                   GtFeatureNode *child,
                                   void *data)
{
  int had_err = 0;
  GtUword *id, *child_id;
  ObserverCallbackInfo *info = (ObserverCallbackInfo*) data;
  gt_assert(parent && child);

  if ((id = node_ul_gt_hashmap_get(info->fis->cache_node2id, parent))) {
    if (!(child_id = node_ul_gt_hashmap_get(info->fis->cache_node2id, child))) {
      gt_hashmap_add(info->fis->added, child, (void*) 1);
    }
    gt_hashmap_add(info->fis->changed, parent, (void*) 1);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb914e
movq %rsi, %r15
testq %rsi, %rsi
je 0xb914e
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
movq 0x50(%rax), %rdi
movq %rbx, %rsi
callq 0xb9ac3
testq %rax, %rax
je 0xb9146
movq 0x8(%r14), %rax
movq 0x50(%rax), %rdi
movq %r15, %rsi
callq 0xb9ac3
testq %rax, %rax
jne 0xb9133
movq 0x8(%r14), %rax
movq 0x38(%rax), %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x8f4bd
movq 0x8(%r14), %rax
movq 0x48(%rax), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x8f4bd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x37ee13(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22beb4(%rip), %rsi    # 0x2e5013
leaq 0x25d6b8(%rip), %rdx    # 0x31681e
leaq 0x25d6c1(%rip), %rcx    # 0x31682e
leaq 0x25c3a2(%rip), %r8     # 0x315516
movl $0x3cb, %r9d            # imm = 0x3CB
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_anno_db_gfflike_new
GtAnnoDBSchema* gt_anno_db_gfflike_new(void)
{
  GtAnnoDBSchema *s = gt_anno_db_schema_create(gt_anno_db_gfflike_class());
  GtAnnoDBGFFlike *adg = anno_db_gfflike_cast(s);
  adg->visitor = gfflike_setup_visitor_new(adg);
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0xb733d
movq %rax, %rdi
callq 0xba4cb
movq %rax, %rbx
callq 0xb733d
movq %rax, %rdi
movq %rbx, %rsi
callq 0xba63c
movq %rax, %r14
callq 0xba467
movq %rax, %rdi
callq 0x10ea46
movq %rax, %r15
callq 0xba467
movq %rax, %rdi
movq %r15, %rsi
callq 0x10eaa4
testq %r14, %r14
je 0xb91e4
movq %r14, 0x10(%rax)
movq %r15, 0x18(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x37ed7d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22be1e(%rip), %rsi    # 0x2e5013
leaq 0x25e0d4(%rip), %rdx    # 0x3172d0
leaq 0x25e0d1(%rip), %rcx    # 0x3172d4
leaq 0x25c30c(%rip), %r8     # 0x315516
movl $0x7e5, %r9d            # imm = 0x7E5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: set_parents
static int set_parents(void *key, void *value, void *data,
                       GtError *err)
{
  int had_err = 0;
  GtFeatureNode *fn = (GtFeatureNode*) key,
                *parent = NULL;
  GtArray *parent_array = (GtArray*) value;
  GtFeatureIndexGFFlike *fi = (GtFeatureIndexGFFlike*) data;
  GtUword *num, *parent_id;

  num = node_ul_gt_hashmap_get(fi->cache_node2id, fn);
  gt_assert(num);
  if (parent_array && gt_array_size(parent_array)) {
    GtUword i;
    int rval = 0;
    for (i=0;i<gt_array_size(parent_array);i++) {
      if (rval < 0) {
        had_err = -1;
        break;
      }
      parent = *(GtFeatureNode**) gt_array_get(parent_array, i);
      parent_id = node_ul_gt_hashmap_get(fi->cache_node2id, parent);
      gt_assert(parent_id);
      /* insert parents */
      gt_rdb_stmt_reset(fi->stmts[GT_PSTMT_PARENT_INSERT], err);
      gt_rdb_stmt_bind_int(fi->stmts[GT_PSTMT_PARENT_INSERT], 0, *num, err);
      gt_rdb_stmt_bind_int(fi->stmts[GT_PSTMT_PARENT_INSERT], 1, *parent_id,
                           err);
      rval = gt_rdb_stmt_exec(fi->stmts[GT_PSTMT_PARENT_INSERT], err);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
movq 0x50(%rdx), %rdi
callq 0xb9ac3
testq %rax, %rax
je 0xb9a95
xorl %r12d, %r12d
testq %r15, %r15
je 0xb9a4b
movq %rax, %r13
movq %r15, %rdi
callq 0x586a4
testq %rax, %rax
je 0xb9a4b
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x586a4
cmpq %rax, %r12
jae 0xb9a40
testl %ebp, %ebp
js 0xb9a45
movq %r15, %rdi
movq %r12, %rsi
callq 0x581aa
movq (%rax), %rsi
movq 0x50(%r14), %rdi
callq 0xb9ac3
testq %rax, %rax
je 0xb9a5d
movq %rax, %rbp
movq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq 0x80(%r14), %rdi
movl (%r13), %edx
xorl %esi, %esi
movq %rbx, %rcx
callq 0x10d538
movq 0x80(%r14), %rdi
movl (%rbp), %edx
pushq $0x1
popq %rsi
movq %rbx, %rcx
callq 0x10d538
movq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x10d688
movl %eax, %ebp
incq %r12
jmp 0xb99c1
xorl %r12d, %r12d
jmp 0xb9a4b
pushq $-0x1
popq %rax
movl %eax, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x37e504(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22b5a5(%rip), %rsi    # 0x2e5013
leaq 0x2c5d60(%rip), %rdx    # 0x37f7d5
leaq 0x25cc95(%rip), %rcx    # 0x316711
leaq 0x25ba93(%rip), %r8     # 0x315516
movl $0x2f7, %r9d            # imm = 0x2F7
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x37e4cc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22b56d(%rip), %rsi    # 0x2e5013
leaq 0x26b7e1(%rip), %rdx    # 0x32528e
leaq 0x25cc5d(%rip), %rcx    # 0x316711
leaq 0x25ba5b(%rip), %r8     # 0x315516
movl $0x2ec, %r9d            # imm = 0x2EC
jmp 0xb9a89
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: unregister_observer
static int
unregister_observer(void *key, GT_UNUSED void *val, GT_UNUSED void *data,
                    GT_UNUSED GtError *err)
{
  GtFeatureNode *fn = (void*) key;
  gt_assert(fn);
  gt_feature_node_unset_observer(fn);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xb9d37
callq 0xd9834
xorl %eax, %eax
popq %rcx
retq
movq 0x37e22a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22b2cb(%rip), %rsi    # 0x2e5013
leaq 0x2c4151(%rip), %rdx    # 0x37dea0
leaq 0x25c9f6(%rip), %rcx    # 0x31674c
leaq 0x25b7b9(%rip), %r8     # 0x315516
movl $0x665, %r9d            # imm = 0x665
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gt_feature_index_gfflike_save_del
static int gt_feature_index_gfflike_save_del(void *key, GT_UNUSED void *val,
                                             void *data, GtError *err)
{
  GtFeatureNode *fn = (GtFeatureNode*) key;
  GtFeatureNodeIterator *it;
  GtUword *id;
  ObserverCallbackInfo *oci = (ObserverCallbackInfo*) data;
  int had_err = 0;

  it = gt_feature_node_iterator_new(fn);
  id = node_ul_gt_hashmap_get(oci->fis->cache_node2id, fn);
  if (!id) {
    return 0;
  }

  while ((fn = gt_feature_node_iterator_next(it))) {
    id = node_ul_gt_hashmap_get(oci->fis->cache_node2id, fn);
    remove_node_by_id(oci->fis, *id, err);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
callq 0xdc6f0
movq %rax, %r15
movq 0x8(%r14), %rax
movq 0x50(%rax), %rdi
movq %r12, %rsi
callq 0xb9ac3
testq %rax, %rax
je 0xba142
movq %r15, %rdi
callq 0xdc92e
testq %rax, %rax
je 0xba142
movq 0x8(%r14), %rcx
movq 0x50(%rcx), %rdi
movq %rax, %rsi
callq 0xb9ac3
movq 0x8(%r14), %r12
movq (%rax), %rbp
movq 0x118(%r12), %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq 0x118(%r12), %rdi
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x10d538
movq 0x118(%r12), %rdi
pushq $0x1
popq %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x10d538
movq 0x118(%r12), %rdi
movq %rbx, %rsi
callq 0x10d688
testl %eax, %eax
js 0xb9f7c
movq 0xe0(%r12), %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq 0xe0(%r12), %rdi
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x10d538
movq 0xe0(%r12), %rdi
movq %rbx, %rsi
callq 0x10d688
testl %eax, %eax
js 0xb9f7c
movl %eax, %r13d
movq 0xe0(%r12), %rdi
xorl %esi, %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x10d74a
cmpq $0x0, 0x10(%rsp)
jne 0xba0c2
movq 0x108(%r12), %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq 0x108(%r12), %rdi
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x10d538
movq 0x108(%r12), %rdi
movq %rbx, %rsi
callq 0x10d688
testl %eax, %eax
js 0xb9f7c
movq 0x150(%r12), %rdi
movq %rbx, %rsi
callq 0x10d4e4
movq 0x150(%r12), %rdi
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x10d538
movq 0x150(%r12), %rdi
movq %rbx, %rsi
callq 0x10d688
movl %eax, %r13d
testl %r13d, %r13d
jne 0xb9f7c
movq 0x58(%r12), %rdi
movq %rbp, %rsi
callq 0xb9d0c
movq (%rax), %r13
testq %r13, %r13
je 0xba0f4
movq 0x58(%r12), %rdi
movq %rbp, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x8ffa2
movq 0x50(%r12), %rdi
movq %r13, %rsi
callq 0xb9ac3
testq %rax, %rax
je 0xba11a
movq 0x50(%r12), %rdi
movq %r13, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x8ffa2
movq 0x30(%r12), %rdi
movq %r13, %rsi
callq 0x8f482
testq %rax, %rax
je 0xb9f7c
movq 0x30(%r12), %rdi
movq %r13, %rsi
callq 0x8f4fb
jmp 0xb9f7c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: resave_each_attribute
static void resave_each_attribute(const char *attr_name, const char *attr_value,
                                  void *data)
{
  GFFlikeAttributeInfo *ai = (GFFlikeAttributeInfo*) data;
  gt_rdb_stmt_reset(ai->fis->stmts[GT_PSTMT_ATTRIBUTE_INSERT], ai->err);
  gt_rdb_stmt_bind_int(ai->fis->stmts[GT_PSTMT_ATTRIBUTE_INSERT], 0, ai->id,
                       ai->err);
  gt_rdb_stmt_bind_string(ai->fis->stmts[GT_PSTMT_ATTRIBUTE_INSERT], 1,
                          attr_name, ai->err);
  gt_rdb_stmt_bind_string(ai->fis->stmts[GT_PSTMT_ATTRIBUTE_INSERT], 2,
                          attr_value, ai->err);
  gt_rdb_stmt_exec(ai->fis->stmts[GT_PSTMT_ATTRIBUTE_INSERT], ai->err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
movq 0x10(%rdx), %rsi
movq 0xb8(%rax), %rdi
callq 0x10d4e4
movq (%rbx), %rax
movq 0xb8(%rax), %rdi
movl 0x8(%rbx), %edx
movq 0x10(%rbx), %rcx
xorl %esi, %esi
callq 0x10d538
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0xb8(%rax), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
callq 0x10d5e0
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0xb8(%rax), %rdi
pushq $0x2
popq %rsi
movq %r14, %rdx
callq 0x10d5e0
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
movq 0xb8(%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10d688
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_gfflike.c
// Function: gfflike_setup_visitor_class
static const GtRDBVisitorClass* gfflike_setup_visitor_class()
{
  static const GtRDBVisitorClass *svc = NULL;
  gt_class_alloc_lock_enter();
  if (!svc) {
    svc = gt_rdb_visitor_class_new(sizeof (GtAnnoDBGFFlike),
                                   NULL,
                                   anno_db_gfflike_init_sqlite,
                                   anno_db_gfflike_init_mysql);
  }
  gt_class_alloc_lock_leave();
  return svc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x3831e3(%rip)    # 0x43d658
jne 0xba496
leaq -0x3dd6(%rip), %rdx     # 0xb66a8
leaq -0x37c2(%rip), %rcx     # 0xb6cc3
pushq $0x20
popq %rdi
xorl %esi, %esi
callq 0x10e9d4
movq %rax, 0x3831c2(%rip)    # 0x43d658
callq 0x69ede
movq 0x3831b6(%rip), %rax    # 0x43d658
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_schema.c
// Function: gt_anno_db_schema_create
GtAnnoDBSchema* gt_anno_db_schema_create(const GtAnnoDBSchemaClass *dbc)
{
  GtAnnoDBSchema *s;
  gt_assert(dbc && dbc->size);
  s = gt_calloc(1, dbc->size);
  s->c_class = dbc;
  s->members = gt_calloc(1, sizeof (GtAnnoDBSchemaMembers));
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba527
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xba527
leaq 0x25ce2e(%rip), %r14    # 0x317318
pushq $0x1
popq %r15
pushq $0x2f
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x4
popq %rsi
pushq $0x31
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x37da3a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22aadb(%rip), %rsi    # 0x2e5013
leaq 0x25cdaf(%rip), %rdx    # 0x3172ee
leaq 0x25cdb9(%rip), %rcx    # 0x3172ff
leaq 0x25cdcb(%rip), %r8     # 0x317318
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/anno_db_schema.c
// Function: gt_anno_db_schema_delete
void gt_anno_db_schema_delete(GtAnnoDBSchema *s)
{
  if (!s) return;
  if (s->members->reference_count) {
    s->members->reference_count--;
    return;
  }
  gt_assert(s->c_class);
  if (s->c_class->free_func) s->c_class->free_func(s);
  gt_free(s->members);
  gt_free(s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba5bd
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
testl %eax, %eax
je 0xba5c5
decl %eax
movl %eax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0xba606
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xba5df
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x25cd32(%rip), %r14    # 0x317318
pushq $0x45
popq %rdx
movq %r14, %rsi
callq 0x936f9
pushq $0x46
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x37d95b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22a9fc(%rip), %rsi    # 0x2e5013
leaq 0x25cd7f(%rip), %rdx    # 0x31739d
leaq 0x25cd27(%rip), %rcx    # 0x31734c
leaq 0x25ccec(%rip), %r8     # 0x317318
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390