LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_previous_key
void* gt_rbtree_previous_key(const GtRBTree *tree, void *key,
                             GtCompareWithData cmpfun, void *cmpinfo)
{
  int cmp;
  const GtRBTreeNode *current,
                     *found = NULL;
  gt_assert(tree);
  gt_assert(key);
  gt_assert(cmpfun);
  current = tree->root;

  while (current != NULL) {
    cmp = cmpfun(key, current->key, cmpinfo);
    if (cmp == 0) {
      if (current->link[0] == NULL) {
        if (found == NULL) {
          return NULL;
        }
        return found->key;
      }
      return gt_rbtree_maximum_key_for_node(current->link[0]);
    } else {
      if (cmp < 0) {
        current = current->link[0];
      } else {
        found = current;
        current = current->link[1];
      }
    }
  }
  if (found == NULL) {
    return NULL;
  }
  return found->key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x16eb14
movq %rsi, %r15
testq %rsi, %rsi
je 0x16eb19
movq %rdx, %r14
testq %rdx, %rdx
je 0x16eb1e
movq (%rdi), %r13
testq %r13, %r13
je 0x16eae0
movq %rcx, %rbx
xorl %r12d, %r12d
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x16eae5
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsq %r13, %r12
movq 0x10(%r13,%rcx,8), %r13
testq %r13, %r13
jne 0x16eab6
jmp 0x16eafc
xorl %r12d, %r12d
jmp 0x16eafc
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x16eafc
movq %rax, %r12
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x16eaee
jmp 0x16eb01
testq %r12, %r12
je 0x16eb08
movq 0x8(%r12), %rax
jmp 0x16eb0a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5030e
callq 0x502d5
callq 0x5029c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_previous_equal_key
void* gt_rbtree_previous_equal_key(const GtRBTree *tree, void *key,
                                   GtCompareWithData cmpfun, void *cmpinfo)
{
  int cmp;
  const GtRBTreeNode *current,
                     *found = NULL;
  gt_assert(tree);
  gt_assert(key);
  gt_assert(cmpfun);
  current = tree->root;

  while (current != NULL) {
    cmp = cmpfun(key, current->key, cmpinfo);
    if (cmp == 0) {
      return current->key;
    } else {
      if (cmp < 0) {
        current = current->link[0];
      } else {
        found = current;
        current = current->link[1];
      }
    }
  }
  if (found == NULL) {
    return NULL;
  }
  return found->key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x16eb98
movq %rsi, %r15
testq %rsi, %rsi
je 0x16eb9d
movq %rdx, %r14
testq %rdx, %rdx
je 0x16eba2
movq (%rdi), %r12
testq %r12, %r12
je 0x16eb7a
movq %rcx, %rbx
xorl %r13d, %r13d
movq 0x8(%r12), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x16eb85
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsq %r12, %r13
movq 0x10(%r12,%rcx,8), %r12
testq %r12, %r12
jne 0x16eb4f
jmp 0x16eb7d
xorl %r13d, %r13d
movq %r13, %r12
testq %r13, %r13
je 0x16eb8c
movq 0x8(%r12), %rax
jmp 0x16eb8e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x503b9
callq 0x50380
callq 0x50347
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_next_key
void* gt_rbtree_next_key(const GtRBTree *tree, void *key,
                         GtCompareWithData cmpfun, void *cmpinfo)
{
  int cmp;
  const GtRBTreeNode *current,
                     *found = NULL;
  gt_assert(tree);
  gt_assert(key);
  gt_assert(cmpfun);
  current = tree->root;

  while (current != NULL) {
    cmp = cmpfun(key, current->key, cmpinfo);
    if (cmp == 0) {
      if (current->link[1] == NULL) {
        if (found == NULL) {
          return NULL;
        }
        return found->key;
      }
      return gt_rbtree_minimum_key_for_node(current->link[1]);
    } else {
      if (cmp < 0) {
        found = current;
        current = current->link[0];
      } else {
        current = current->link[1];
      }
    }
  }
  if (found == NULL) {
    return NULL;
  }
  return found->key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x16ec31
movq %rsi, %r15
testq %rsi, %rsi
je 0x16ec36
movq %rdx, %r14
testq %rdx, %rdx
je 0x16ec3b
movq (%rdi), %r13
testq %r13, %r13
je 0x16ebfd
movq %rcx, %rbx
xorl %r12d, %r12d
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x16ec02
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovsq %r13, %r12
movq 0x10(%r13,%rcx,8), %r13
testq %r13, %r13
jne 0x16ebd3
jmp 0x16ec19
xorl %r12d, %r12d
jmp 0x16ec19
movq 0x18(%r13), %rax
testq %rax, %rax
je 0x16ec19
movq %rax, %r12
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x16ec0b
jmp 0x16ec1e
testq %r12, %r12
je 0x16ec25
movq 0x8(%r12), %rax
jmp 0x16ec27
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x50464
callq 0x5042b
callq 0x503f2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_iter_new_from_first
GtRBTreeIter* gt_rbtree_iter_new_from_first(const GtRBTree *tree)
{
  GtRBTreeIter *trav = gt_malloc(sizeof (GtRBTreeIter));
  gt_assert(tree);
  (void) start(trav, tree, 0);
  return trav;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x228bd1(%rip), %rsi    # 0x3978a0
movl $0x218, %edi            # imm = 0x218
movl $0x30f, %edx            # imm = 0x30F
callq 0x1092b2
testq %rbx, %rbx
je 0x16ed2a
movq %rbx, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x210(%rax)
testq %rcx, %rcx
je 0x16ed28
cmpq $0x0, 0x10(%rcx)
je 0x16ed28
xorl %edx, %edx
movq %rcx, 0x10(%rax,%rdx,8)
incq %rdx
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x10(%rcx)
jne 0x16ed06
movq %rdx, 0x210(%rax)
popq %rbx
retq
callq 0x50548
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_iter_new_from_last
GtRBTreeIter* gt_rbtree_iter_new_from_last(const GtRBTree *tree)
{
  GtRBTreeIter *trav = gt_malloc(sizeof (GtRBTreeIter));
  gt_assert(tree);
  (void) start(trav, tree, 1);
  return trav;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x228b66(%rip), %rsi    # 0x3978a0
movl $0x218, %edi            # imm = 0x218
movl $0x317, %edx            # imm = 0x317
callq 0x1092b2
testq %rbx, %rbx
je 0x16ed95
movq %rbx, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x210(%rax)
testq %rcx, %rcx
je 0x16ed93
cmpq $0x0, 0x18(%rcx)
je 0x16ed93
xorl %edx, %edx
movq %rcx, 0x10(%rax,%rdx,8)
incq %rdx
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x18(%rcx)
jne 0x16ed71
movq %rdx, 0x210(%rax)
popq %rbx
retq
callq 0x50581
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_iter_data
void *gt_rbtree_iter_data (GtRBTreeIter *trav)
{
  GtRBTreeNode *node;
  gt_assert(trav);
  node = trav->it;
  return (node != NULL ? node->key : NULL);
}

// Assembly:
testq %rdi, %rdi
je 0x16efb8
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x16efb5
movq 0x8(%rax), %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x5069e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: nrbt_walk_tree
static int nrbt_walk_tree(GtRBTree *tree,GtUword expected_count)
{
  GtUword i;
  int error = 0;

  memset(gt_rbtree_ztab, 0, (GT_RBTREE_SIZE * sizeof (*gt_rbtree_ztab)));
  gt_rbtree_max_depth = 0;

  if (gt_rbtree_walk(tree, nrbt_walk_action, NULL) != 0) {
    gt_xfputs("walk failed\n", stdout);
    error = 1;
  }
  for (i = 0; i < expected_count; ++i) {
    if (gt_rbtree_ztab[i] != 1UL) {
      gt_xfputs("Node was not visited.\n", stdout);
      error = 1;
    }
  }
  if (gt_rbtree_max_depth >
      (GtUword) (log ((double) expected_count) * 2.0 +
                       2.0)) {
    printf("Depth too large during tree walk ("GT_WU" vs "GT_WU").\n",
                         gt_rbtree_max_depth,
                         (GtUword) (log ((double) expected_count) * 2.0 +
                         2.0) );
    error = 1;
  }
  return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x3598c6(%rip), %rdi    # 0x4c9818
xorl %ebx, %ebx
movl $0x320, %edx            # imm = 0x320
xorl %esi, %esi
callq 0x173a0
movq $0x0, 0x3598bd(%rip) # 0x4c9828
leaq 0x95(%rip), %rsi        # 0x170007
movq %r14, %rdi
xorl %edx, %edx
callq 0x16e691
testl %eax, %eax
je 0x16ff9b
movq 0x353f61(%rip), %rax    # 0x4c3ee8
movq (%rax), %rsi
leaq 0x227f95(%rip), %rdi    # 0x397f26
callq 0x1255e8
movl $0x1, %ebx
xorl %r15d, %r15d
movq 0x353f43(%rip), %r12    # 0x4c3ee8
leaq 0x227f87(%rip), %r14    # 0x397f33
movq 0x359865(%rip), %rax    # 0x4c9818
cmpq $0x1, (%rax,%r15,8)
je 0x16ffcb
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1255e8
movl $0x1, %ebx
incq %r15
cmpq $0x64, %r15
jne 0x16ffac
movq 0x35984d(%rip), %rsi    # 0x4c9828
cmpq $0xc, %rsi
jb 0x16fff9
leaq 0x227f62(%rip), %rdi    # 0x397f4a
movl $0xb, %edx
xorl %eax, %eax
callq 0x17070
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rbtree.c
// Function: nrbt_walk_action
static int nrbt_walk_action(void* nodekey, const GtRBTreeContext which,
                            const GtUword depth, GT_UNUSED void *actinfo)
{
  GtUword key = *(GtUword *) nodekey;

  if (depth > gt_rbtree_max_depth) {
    gt_rbtree_max_depth = depth;
  }
  if (which == GT_RBTREE_LEAF || which == GT_RBTREE_PREORDER) {
    ++gt_rbtree_ztab[key];
    gt_rbtree_depths[key] = depth;
  } else {
    if (gt_rbtree_depths[key] != depth) {
      gt_xfputs("Depth for one element is not constant during tree walk.\n",
                stdout);
      return -1;
    }
  }
  return 0;
}

// Assembly:
movq (%rdi), %rcx
cmpq %rdx, 0x359817(%rip)    # 0x4c9828
jae 0x17001a
movq %rdx, 0x35980e(%rip)    # 0x4c9828
cmpl $0x3, %esi
je 0x170023
testl %esi, %esi
jne 0x17003c
movq 0x3597ee(%rip), %rax    # 0x4c9818
incq (%rax,%rcx,8)
movq 0x3597eb(%rip), %rax    # 0x4c9820
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
retq
movq 0x3597dd(%rip), %rsi    # 0x4c9820
xorl %eax, %eax
cmpq %rdx, (%rsi,%rcx,8)
je 0x17006b
pushq %rax
movq 0x353e95(%rip), %rax    # 0x4c3ee8
movq (%rax), %rsi
leaq 0x227f1d(%rip), %rdi    # 0x397f7a
callq 0x1255e8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_encoder_delete
void gt_rcr_encoder_delete(GtRcrEncoder *rcr_enc)
{
  if (rcr_enc != NULL) {
    gt_huffman_delete(rcr_enc->readlenghts_huff);
    gt_huffman_delete(rcr_enc->qual_mapping_huff);
    gt_huffman_delete(rcr_enc->qual_huff);
    gt_huffman_delete(rcr_enc->cigar_ops_huff);
    gt_huffman_delete(rcr_enc->bases_huff);

    gt_golomb_delete(rcr_enc->readpos_golomb);
    gt_golomb_delete(rcr_enc->varpos_golomb);

    gt_queue_delete(rcr_enc->not_exact_matches);

    bam_destroy1(rcr_enc->sam_align);

    gt_disc_distri_delete(rcr_enc->qual_mapping_distr);
    gt_disc_distri_delete(rcr_enc->readlength_distr);
    gt_disc_distri_delete(rcr_enc->readpos_distr);
    gt_disc_distri_delete(rcr_enc->varpos_distr);
    gt_disc_distri_delete(rcr_enc->qual_distr);

    gt_samfile_iterator_delete(rcr_enc->sam_iter);
    gt_cstr_iterator_delete(rcr_enc->cstr_iterator);
    gt_encdesc_encoder_delete(rcr_enc->encdesc_enc);

    gt_free(rcr_enc->ins_bases);
    gt_free(rcr_enc);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x170dcc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15bc80
movq 0x70(%rbx), %rdi
callq 0x15bc80
movq 0x68(%rbx), %rdi
callq 0x15bc80
movq 0x78(%rbx), %rdi
callq 0x15bc80
movq 0x80(%rbx), %rdi
callq 0x15bc80
movq 0x50(%rbx), %rdi
callq 0x153c93
movq 0x58(%rbx), %rdi
callq 0x153c93
movq 0xb0(%rbx), %rdi
callq 0x112f03
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x170d4f
movq 0x30(%rax), %rdi
callq 0x17fe8
movq 0x90(%rbx), %rdi
callq 0x17fe8
movq 0x40(%rbx), %rdi
callq 0xe9ff6
movq 0x20(%rbx), %rdi
callq 0xe9ff6
movq 0x28(%rbx), %rdi
callq 0xe9ff6
movq 0x30(%rbx), %rdi
callq 0xe9ff6
movq 0x38(%rbx), %rdi
callq 0xe9ff6
movq 0x88(%rbx), %rdi
callq 0x178e1a
movq 0x18(%rbx), %rdi
callq 0x30717a
movq 0x48(%rbx), %rdi
callq 0x143a77
movq 0xa8(%rbx), %rdi
leaq 0x22734b(%rip), %r14    # 0x3980f3
movq %r14, %rsi
movl $0x89a, %edx            # imm = 0x89A
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x89b, %edx            # imm = 0x89B
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_decoder_delete
void gt_rcr_decoder_delete(GtRcrDecoder *rcr_dec)
{
  if (rcr_dec != NULL) {
    gt_huffman_delete(rcr_dec->readlenghts_huff);
    gt_huffman_delete(rcr_dec->qual_mapping_huff);
    gt_huffman_delete(rcr_dec->cigar_ops_huff);
    gt_huffman_delete(rcr_dec->qual_huff);
    gt_huffman_delete(rcr_dec->bases_huff);

    gt_golomb_delete(rcr_dec->readpos_golomb);
    gt_golomb_delete(rcr_dec->varpos_golomb);

    gt_str_delete(rcr_dec->inputname);

    gt_encdesc_delete(rcr_dec->encdesc);

    gt_free(rcr_dec->ins_bases);

    gt_free(rcr_dec);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x17389d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x15bc80
movq 0x30(%rbx), %rdi
callq 0x15bc80
movq 0x38(%rbx), %rdi
callq 0x15bc80
movq 0x28(%rbx), %rdi
callq 0x15bc80
movq 0x40(%rbx), %rdi
callq 0x15bc80
movq 0x10(%rbx), %rdi
callq 0x153c93
movq 0x18(%rbx), %rdi
callq 0x153c93
movq 0x48(%rbx), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x142ea2
movq 0x60(%rbx), %rdi
leaq 0x22487a(%rip), %r14    # 0x3980f3
movq %r14, %rsi
movl $0x8af, %edx            # imm = 0x8AF
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8b1, %edx            # imm = 0x8B1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_get_median
static GtUword rcr_get_median(GtDiscDistri *distr)
{
  GtUword median;
  MedianData *md;

  md = gt_malloc(sizeof (MedianData));
  md->n = 0;
  md->x = 0;
  md->median = GT_UNDEF_UWORD;
  gt_disc_distri_foreach(distr, rcr_get_n, md);
  gt_disc_distri_foreach(distr, rcr_get_m, md);
  median = md->median;
  gt_free(md);
  return median;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x224846(%rip), %r14    # 0x3980f3
movl $0x18, %edi
movq %r14, %rsi
movl $0x2a9, %edx            # imm = 0x2A9
callq 0x1092b2
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $-0x1, 0x10(%rax)
leaq 0x44(%rip), %rsi        # 0x17391b
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe9bdf
leaq 0x36(%rip), %rsi        # 0x17391f
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe9bdf
movq 0x10(%r15), %rbx
movq %r15, %rdi
movq %r14, %rsi
movl $0x2b0, %edx            # imm = 0x2B0
callq 0x109670
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_huff_encode_write
static void rcr_huff_encode_write(GtRcrEncoder *rcr_enc,
                                  GtHuffman *huff,
                                  GtUword val)
{
  GtBitsequence code;
  unsigned bits_to_write;

  gt_huffman_encode(huff, val, &code, &bits_to_write);
  rcr_enc->all_bits += bits_to_write;
  rcr_enc->vartype_bits += bits_to_write;
  gt_bitoutstream_append(rcr_enc->bitstream, code, bits_to_write);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x15bdb3
movl (%r15), %edx
addq %rdx, 0xb8(%rbx)
addq %rdx, 0x178(%rbx)
movq 0x10(%rbx), %rdi
movq (%r14), %rsi
callq 0x304beb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_golomb_encode_write
static void rcr_golomb_encode_write(GtRcrEncoder *rcr_enc,
                                    GtGolomb *gol,
                                    GtUword val)
{
  GtBittab *code = gt_golomb_encode(gol, val);
  GtUword size = gt_bittab_size(code);
  rcr_enc->all_bits += size;
  rcr_enc->varpos_bits += size;
  gt_bitoutstream_append_bittab(rcr_enc->bitstream, code);
  gt_bittab_delete(code);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x153a29
movq %rax, %r14
movq %rax, %rdi
callq 0xd9585
addq %rax, 0xb8(%rbx)
addq %rax, 0x170(%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x304c52
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd97e0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_huff_read
static int rcr_huff_read(GtHuffmanBitwiseDecoder *hbwd,
                         GtBitInStream *bitstream,
                         GtUword *val,
                         GtError *err)
{
  bool bit;
  int had_err = 0,
      stat = -1;
  while (!had_err && stat != 0) {
    if (RCR_NEXT_BIT(bit)) {
      stat = gt_huffman_bitwise_decoder_next(hbwd, bit, val, err);
      if (stat == -1)
        had_err = stat;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x7(%rsp), %r13
xorl %r14d, %r14d
movq %r15, %rdi
movq %r13, %rsi
callq 0x304ab4
movl %eax, %r12d
cmpl $0x1, %eax
je 0x173a8e
movq %rbx, %rdi
leaq 0x224d7d(%rip), %rsi    # 0x3987f2
movl $0x61a, %edx            # imm = 0x61A
leaq 0x224672(%rip), %rcx    # 0x3980f3
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0x1, %r12d
jne 0x173ab4
movzbl 0x7(%rsp), %esi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x15c27f
movl %eax, %ebp
cmpl $-0x1, %eax
cmovel %eax, %r14d
testl %r14d, %r14d
jne 0x173abd
testl %ebp, %ebp
jne 0x173a58
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_golomb_read
static int rcr_golomb_read(GtGolombBitwiseDecoder *gbwd,
                           GtBitInStream *bitstream,
                           GtUword *val,
                           GtError *err)
{
  bool bit;
  int had_err = 0,
      stat = -1;
  while (!had_err && stat != 0) {
    if (RCR_NEXT_BIT(bit)) {
      stat = gt_golomb_bitwise_decoder_next(gbwd, bit, val);
      if (stat == -1)
        had_err = stat;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x7(%rsp), %r13
xorl %ebx, %ebx
movq %r15, %rdi
movq %r13, %rsi
callq 0x304ab4
movl %eax, %r14d
cmpl $0x1, %eax
je 0x173b30
movq 0x10(%rsp), %rdi
leaq 0x224cda(%rip), %rsi    # 0x3987f2
movl $0x63f, %edx            # imm = 0x63F
leaq 0x2245cf(%rip), %rcx    # 0x3980f3
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x1, %r14d
jne 0x173b50
movzbl 0x7(%rsp), %esi
movq %r12, %rdi
movq 0x8(%rsp), %rdx
callq 0x153bb5
movl %eax, %ebp
cmpl $-0x1, %eax
cmovel %eax, %ebx
testl %ebx, %ebx
jne 0x173b58
testl %ebp, %ebp
jne 0x173af9
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_huff_read_string
static int rcr_huff_read_string(GtHuffmanBitwiseDecoder *hbwd,
                                GtBitInStream *bitstream,
                                GtUword length,
                                GtStr *str,
                                GtError *err)
{
  int had_err = 0;
  GtUword symbol,
                read = 0;
  while (!had_err && read < length) {
    had_err = rcr_huff_read(hbwd, bitstream, &symbol, err);
    if (!had_err) {
      gt_str_append_char(str, (char) symbol);
      read++;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
testq %rdx, %rdx
je 0x173bc7
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
movq %r13, %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x173a2d
movl %eax, %r14d
testl %eax, %eax
jne 0x173bbb
movsbl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x120ba5
incq %rbp
testl %r14d, %r14d
jne 0x173bca
cmpq %r15, %rbp
jb 0x173b8f
jmp 0x173bca
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_decode_exact_range
static void rcr_decode_exact_range(GtRcrDecoder *rcr_dec,
                                   RcrDecodeInfo *info,
                                   GtUword start,
                                   GtUword end)
{
  GtUchar ref;
  GtUword i;
  for (i = start; i < end ; i++) {
    ref = (GtUchar) gt_encseq_get_decoded_char(rcr_dec->encseq, i,
                                               GT_READMODE_FORWARD);
    gt_str_append_char(info->base_string, toupper((int) ref));
    gt_str_append_char(info->cigar_string, '=');
    if (!rcr_dec->store_all_qual)
      gt_str_append_char(info->qual_string, DEFAULTQUAL);
  }
}

// Assembly:
cmpq %rcx, %rdx
jae 0x173c54
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x50(%r12), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xec478
movq 0x30(%r15), %r13
movzbl %al, %edi
callq 0x17ec0
movsbl %al, %esi
movq %r13, %rdi
callq 0x120ba5
movq 0x40(%r15), %rdi
movl $0x3d, %esi
callq 0x120ba5
cmpb $0x0, 0xe1(%r12)
jne 0x173c43
movq 0x38(%r15), %rdi
movl $0x2d, %esi
callq 0x120ba5
incq %r14
cmpq %r14, %rbx
jne 0x173bf6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_decode_insert_var
static int rcr_decode_insert_var(GtRcrDecoder *rcr_dec,
                                 GtBitInStream *bitstream,
                                 RcrDecodeInfo *info,
                                 char type,
                                 GtError *err)
{
  int had_err = 0;
  GtUword symbol = 0, i;
  GtUchar base;

  info->inserted_bases = 0;

  had_err = rcr_huff_read(info->base_hbwd, bitstream, &symbol, err);
  while (!had_err && symbol != info->alpha_size) {
    if (symbol == (info->alpha_size - 1)) {
      base = (GtUchar) GT_WILDCARD;
    }
    else
      base = (GtUchar) symbol;

    gt_str_append_char(info->base_string,
                       toupper(gt_alphabet_decode(info->alphabet, base)));
    info->inserted_bases++;
    had_err = rcr_huff_read(info->base_hbwd, bitstream, &symbol, err);
  }

  if (!had_err) {
    for (i = 0; i < info->inserted_bases; i++)
      gt_str_append_char(info->cigar_string, type);

    if (rcr_dec->store_var_qual) {
      had_err = rcr_huff_read_string(info->qual_hbwd, bitstream,
                                     info->inserted_bases, info->qual_string,
                                     err);
    }
    else {
      if (!rcr_dec->store_all_qual) {
        for (i = 0; i < info->inserted_bases; i++)
          gt_str_append_char(info->qual_string, DEFAULTQUAL);
      }
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rax, 0x58(%rbx)
movq 0x18(%rbx), %rdi
movq %r8, %rcx
callq 0x173a2d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x173d96
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq (%rsp), %r13
movq 0x48(%rbx), %rax
cmpq %rax, %r13
je 0x173d19
decq %rax
cmpq %rax, %r13
movl $0xfe, %eax
cmovel %eax, %r13d
movq %r14, %r15
movl %ebp, %r14d
movq 0x30(%rbx), %rbp
callq 0x170d0
movq (%rax), %r12
movq (%rbx), %rdi
movzbl %r13b, %esi
callq 0xd3da7
movsbq %al, %rax
movsbl (%r12,%rax,4), %esi
movq %rbp, %rdi
movl %r14d, %ebp
movq %r15, %r14
movq 0x10(%rsp), %r15
callq 0x120ba5
incq 0x58(%rbx)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %rsp, %rdx
movq %r14, %rcx
callq 0x173a2d
testl %eax, %eax
je 0x173ca1
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x173d96
movq 0x58(%rbx), %rdx
testq %rdx, %rdx
je 0x173d40
xorl %r12d, %r12d
movsbl %bpl, %ebp
movq 0x40(%rbx), %rdi
movl %ebp, %esi
callq 0x120ba5
incq %r12
movq 0x58(%rbx), %rdx
cmpq %rdx, %r12
jb 0x173d29
movq 0x8(%rsp), %rax
cmpb $0x1, 0xe2(%rax)
jne 0x173d66
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rcx
movq %r15, %rsi
movq %r14, %r8
callq 0x173b69
movl %eax, %r13d
jmp 0x173d96
xorl %r13d, %r13d
cmpb $0x0, 0xe1(%rax)
jne 0x173d96
cmpq $0x0, 0x58(%rbx)
je 0x173d96
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x38(%rbx), %rdi
movl $0x2d, %esi
callq 0x120ba5
incq %r14
cmpq 0x58(%rbx), %r14
jb 0x173d7f
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_decode_delete_var
static int rcr_decode_delete_var(RcrDecodeInfo *info,
                                 GtBitInStream *bitstream,
                                 char type,
                                 GtError *err)
{
  /* TODO DW remove loop and just set in as xD */
  int had_err = 0;
  GtUword del_length , i;
  had_err = rcr_elias_read(info->del_len_ebwd, bitstream, &del_length, err);
  if (!had_err) {
    for (i = 0; i < del_length; i++)
      gt_str_append_char(info->cigar_string, type);
    info->offset = del_length;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq 0x8(%rdi), %r13
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0xb(%rsp), %rbp
xorl %r14d, %r14d
movq %r12, %rdi
movq %rbp, %rsi
callq 0x304ab4
movl %eax, %r15d
cmpl $0x1, %eax
je 0x173e10
movq 0x20(%rsp), %rdi
leaq 0x2249fb(%rip), %rsi    # 0x3987f2
movl $0x6ca, %edx            # imm = 0x6CA
leaq 0x2242f0(%rip), %rcx    # 0x3980f3
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0x1, %r15d
jne 0x173e2a
movzbl 0xb(%rsp), %esi
movq %r13, %rdi
leaq 0x10(%rsp), %rdx
callq 0x141523
movl %eax, %ebx
testl %r14d, %r14d
jne 0x173e33
testl %ebx, %ebx
jne 0x173dd8
testl %r14d, %r14d
jne 0x173e6d
movq 0x10(%rsp), %rax
testq %rax, %rax
movq 0x18(%rsp), %r12
je 0x173e68
xorl %r15d, %r15d
movsbl 0xc(%rsp), %ebx
movq 0x40(%r12), %rdi
movl %ebx, %esi
callq 0x120ba5
incq %r15
movq 0x10(%rsp), %rax
cmpq %rax, %r15
jb 0x173e4f
movq %rax, 0x50(%r12)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_class_new
const GtRDBClass* gt_rdb_class_new(size_t size,
                                   GtRDBFreeFunc free_func,
                                   GtRDBPrepareFunc prepare_func,
                                   GtRDBGetLastInsertIDFunc last_id_func,
                                   GtRDBAcceptVisitorFunc accept_func,
                                   GtRDBGetIndexesFunc get_indexes_func,
                                   GtRDBGetTablesFunc get_tables_func)
{
  GtRDBClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free_func = free_func;
  c_class->prepare_func = prepare_func;
  c_class->accept_func = accept_func;
  c_class->last_id_func = last_id_func;
  c_class->get_indexes_func = get_indexes_func;
  c_class->get_tables_func = get_tables_func;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x48, %edi
callq 0x301854
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
movq %rbx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_create
GtRDB* gt_rdb_create(const GtRDBClass *dbc)
{
  GtRDB *ns;
  gt_assert(dbc && dbc->size);
  ns = gt_calloc(1, dbc->size);
  ns->c_class = dbc;
  ns->members = gt_calloc(1, sizeof (GtRDBMembers));
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x173f96
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x173f96
leaq 0x224a04(%rip), %r14    # 0x39895e
movl $0x1, %edi
movq %r14, %rdx
movl $0x6d, %ecx
callq 0x1093ef
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x6f, %ecx
callq 0x1093ef
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5125c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_delete
void gt_rdb_delete(GtRDB *ns)
{
  if (!ns) return;
  if (ns->members->reference_count) {
    ns->members->reference_count--;
    return;
  }
  gt_assert(ns->c_class);
  if (ns->c_class->free_func) ns->c_class->free_func(ns);
  gt_free(ns->members);
  gt_free(ns);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x173fca
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x173fd2
decl %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x174017
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x173fe8
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x22496b(%rip), %r14    # 0x39895e
movq %r14, %rsi
movl $0x83, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x84, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
callq 0x512ca
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_accept
int gt_rdb_accept(GtRDB *db, GtRDBVisitor *v, GtError *err)
{
  gt_assert(db && db->c_class);
  if (db->c_class->accept_func)
    return db->c_class->accept_func(db, v, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x174050
movq (%rdi), %rax
testq %rax, %rax
je 0x174050
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x17404d
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5133c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_last_inserted_id
GtUword gt_rdb_last_inserted_id(GtRDB *db, const char *table, GtError *e)
{
  gt_assert(db && db->c_class);
  if (db->c_class->last_id_func)
    return db->c_class->last_id_func(db, table, e);
  return GT_UNDEF_UWORD;
}

// Assembly:
testq %rdi, %rdi
je 0x174076
movq (%rdi), %rax
testq %rax, %rax
je 0x174076
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x17406e
jmpq *%rax
movq $-0x1, %rax
retq
pushq %rax
callq 0x51375
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_get_indexes
GtCstrTable* gt_rdb_get_indexes(GtRDB *db, GtError *err)
{
  gt_assert(db && db->c_class);
  if (db->c_class->get_indexes_func)
    return db->c_class->get_indexes_func(db, err);
  return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x174097
movq (%rdi), %rax
testq %rax, %rax
je 0x174097
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x174094
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x513ae
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_get_tables
GtCstrTable* gt_rdb_get_tables(GtRDB *db, GtError *err)
{
  gt_assert(db && db->c_class);
  if (db->c_class->get_tables_func)
    return db->c_class->get_tables_func(db, err);
  return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x1740b8
movq (%rdi), %rax
testq %rax, %rax
je 0x1740b8
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x1740b5
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x513e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_create
GtRDBStmt* gt_rdb_stmt_create(const GtRDBStmtClass *stc)
{
  GtRDBStmt *st;
  gt_assert(stc && stc->size);
  st = gt_calloc(1, stc->size);
  st->c_class = stc;
  return st;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1740ea
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1740ea
leaq 0x224888(%rip), %rdx    # 0x39895e
movl $0x1, %edi
movl $0xb1, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x51420
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_prepare
GtRDBStmt* gt_rdb_prepare(GtRDB *db, const char *query,
                          GtUword num_params, GtError *err)
{
  gt_assert(db && db->c_class);
  if (db->c_class->prepare_func)
    return db->c_class->prepare_func(db, query, num_params, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x174123
movq (%rdi), %rax
testq %rax, %rax
je 0x174123
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x174120
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x51492
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_reset
int gt_rdb_stmt_reset(GtRDBStmt *stmt, GtError *err)
{
  gt_assert(stmt && stmt->c_class);
  if (stmt->c_class->reset_func)
    return stmt->c_class->reset_func(stmt, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x174144
movq (%rdi), %rax
testq %rax, %rax
je 0x174144
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x174141
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x514cb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_bind_int
int gt_rdb_stmt_bind_int(GtRDBStmt *stmt, GtUword param_no,
                         int val, GtError *err)
{
  gt_assert(stmt && stmt->c_class);
  if (stmt->c_class->bind_int_func)
    return stmt->c_class->bind_int_func(stmt, param_no, val, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x174165
movq (%rdi), %rax
testq %rax, %rax
je 0x174165
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x174162
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x51504
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_bind_ulong
int gt_rdb_stmt_bind_ulong(GtRDBStmt *stmt, GtUword param_no,
                           GtUword val, GtError *err)
{
  gt_assert(stmt && stmt->c_class);
  if (stmt->c_class->bind_ulong_func)
    return stmt->c_class->bind_ulong_func(stmt, param_no, val, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x174186
movq (%rdi), %rax
testq %rax, %rax
je 0x174186
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x174183
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5153d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_bind_string
int gt_rdb_stmt_bind_string(GtRDBStmt *stmt, GtUword param_no,
                            const char *val, GtError *err)
{
  gt_assert(stmt && stmt->c_class);
  if (stmt->c_class->bind_string_func)
    return stmt->c_class->bind_string_func(stmt, param_no, val, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1741a7
movq (%rdi), %rax
testq %rax, %rax
je 0x1741a7
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1741a4
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x51576
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_bind_double
int gt_rdb_stmt_bind_double(GtRDBStmt *stmt, GtUword param_no,
                            double val, GtError *err)
{
  gt_assert(stmt && stmt->c_class);
  if (stmt->c_class->bind_double_func)
    return stmt->c_class->bind_double_func(stmt, param_no, val, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1741c8
movq (%rdi), %rax
testq %rax, %rax
je 0x1741c8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1741c5
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x515af
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_exec
int gt_rdb_stmt_exec(GtRDBStmt *stmt, GtError *err)
{
  gt_assert(stmt && stmt->c_class);
  if (stmt->c_class->fetch_func)
    return stmt->c_class->fetch_func(stmt, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1741e9
movq (%rdi), %rax
testq %rax, %rax
je 0x1741e9
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x1741e6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x515e8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_delete
void gt_rdb_stmt_delete(GtRDBStmt *stmt)
{
  if (!stmt) return;
  gt_assert(stmt->c_class);
  if (stmt->c_class->free_func)
    stmt->c_class->free_func(stmt);
  gt_free(stmt);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x174223
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x174225
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x17420e
movq %rbx, %rdi
callq *%rax
leaq 0x224749(%rip), %rsi    # 0x39895e
movq %rbx, %rdi
movl $0xff, %edx
popq %rbx
jmp 0x109670
popq %rbx
retq
callq 0x51621
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_get_ulong
int gt_rdb_stmt_get_ulong(GtRDBStmt *stmt, GtUword field_no,
                          GtUword *result, GtError *err)
{
  gt_assert(stmt && stmt->c_class && result);
  if (stmt->c_class->get_ulong_func)
    return stmt->c_class->get_ulong_func(stmt, field_no, result, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x17424a
testq %rdx, %rdx
je 0x17424a
movq (%rdi), %rax
testq %rax, %rax
je 0x17424a
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x174247
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5165a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_get_int
int gt_rdb_stmt_get_int(GtRDBStmt *stmt, GtUword field_no,
                        int *result, GtError *err)
{
  gt_assert(stmt && stmt->c_class && result);
  if (stmt->c_class->get_int_func)
    return stmt->c_class->get_int_func(stmt, field_no, result, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x174270
testq %rdx, %rdx
je 0x174270
movq (%rdi), %rax
testq %rax, %rax
je 0x174270
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x17426d
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x51693
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_get_string
int gt_rdb_stmt_get_string(GtRDBStmt *stmt, GtUword field_no,
                           GtStr *result, GtError *err)
{
  gt_assert(stmt && stmt->c_class && result);
  if (stmt->c_class->get_string_func)
    return stmt->c_class->get_string_func(stmt, field_no, result, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x174296
testq %rdx, %rdx
je 0x174296
movq (%rdi), %rax
testq %rax, %rax
je 0x174296
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x174293
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x516cc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb.c
// Function: gt_rdb_stmt_get_double
int gt_rdb_stmt_get_double(GtRDBStmt *stmt, GtUword field_no,
                           double *result, GtError *err)
{
  gt_assert(stmt && stmt->c_class && result);
  if (stmt->c_class->get_double_func)
    return stmt->c_class->get_double_func(stmt, field_no, result, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x1742bc
testq %rdx, %rdx
je 0x1742bc
movq (%rdi), %rax
testq %rax, %rax
je 0x1742bc
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x1742b9
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x51705
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_new
GtRDB* gt_rdb_sqlite_new(const char *dbpath, GtError *err)
{
  GtRDBSqlite *rdbs;
  int retval, had_err = 0;
  sqlite3 *db = NULL;
  GtRDB *rdb = NULL;
  gt_assert(dbpath);
  gt_error_check(err);
  retval = sqlite3_open(dbpath, &db);
  if (retval != SQLITE_OK) {
    gt_error_set(err, "cannot open database: %s", sqlite3_errmsg(db));
    sqlite3_close(db);
    had_err = -1;
  }
  if (!had_err) {
    rdb = gt_rdb_create(gt_rdb_sqlite_class());
    rdbs = gt_rdb_sqlite_cast(rdb);
    rdbs->db = db;
    gt_assert(rdbs->db);
  }
  return (had_err ? NULL : rdb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x174362
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1742f0
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174367
movq %rsp, %rsi
movq %r14, %rdi
callq 0x28a147
testl %eax, %eax
je 0x17432a
movq (%rsp), %rdi
callq 0x286451
leaq 0x2248c3(%rip), %rsi    # 0x398bd2
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movq (%rsp), %rdi
callq 0x2890a3
jmp 0x174357
callq 0x174371
movq %rax, %rdi
callq 0x173f3e
movq %rax, %r14
callq 0x174371
movq %rax, %rdi
movq %r14, %rsi
callq 0x17401c
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
je 0x17436c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x517ac
callq 0x5173e
callq 0x51775
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_class
const GtRDBClass* gt_rdb_sqlite_class(void)
{
  static const GtRDBClass *rdbs = NULL;
  gt_class_alloc_lock_enter();
  if (!rdbs) {
    rdbs = gt_rdb_class_new(sizeof (GtRDBSqlite),
                            gt_rdb_sqlite_delete,
                            gt_rdb_sqlite_prepare,
                            gt_rdb_sqlite_last_inserted_id,
                            gt_rdb_sqlite_accept,
                            gt_rdb_sqlite_get_indexes,
                            gt_rdb_sqlite_get_tables);
  }
  gt_class_alloc_lock_leave();
  return rdbs;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x3554b1(%rip)    # 0x4c9830
jne 0x1743c0
leaq 0x2b4(%rip), %rax       # 0x17463c
movq %rax, (%rsp)
leaq 0x3b(%rip), %rsi        # 0x1743ce
leaq 0x5c(%rip), %rdx        # 0x1743f6
leaq 0x142(%rip), %rcx       # 0x1744e3
leaq 0x179(%rip), %r8        # 0x174521
leaq 0x1c8(%rip), %r9        # 0x174577
movl $0x18, %edi
callq 0x173e80
movq %rax, 0x355470(%rip)    # 0x4c9830
callq 0xe6a19
movq 0x355464(%rip), %rax    # 0x4c9830
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_prepare
static GtRDBStmt* gt_rdb_sqlite_prepare(GtRDB *rdb, const char *query,
                                        GtUword num_params, GtError *err)
{
  GtRDBStmt *st = NULL;
  GtRDBStmtSqlite *sts = NULL;
  GtRDBSqlite *rdbs;
  int retval, had_err = 0;
  sqlite3_stmt *tmp = NULL;
  gt_assert(rdb && query);
  gt_error_check(err);
  rdbs = gt_rdb_sqlite_cast(rdb);
  retval = sqlite3_prepare_v2(rdbs->db, query, -1, &tmp, NULL);
  if (retval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, retval, sqlite3_errmsg(rdbs->db));
    had_err = -1;
  }
  if (!had_err) {
    st = gt_rdb_stmt_create(gt_rdb_stmt_sqlite_class());
    sts = gt_rdb_stmt_sqlite_cast(st);
    sts->num_params = num_params;
    sts->stmt = tmp;
    sts->db = rdbs->db;
  }
  return st;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x1744d9
movq %rsi, %r12
testq %rsi, %rsi
je 0x1744d9
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0x17443e
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1744de
callq 0x174371
movq %rax, %rdi
movq %r15, %rsi
callq 0x17401c
movq %rax, %r15
movq 0x10(%rax), %rdi
leaq 0x8(%rsp), %rcx
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0x286428
testl %eax, %eax
je 0x174494
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x286451
leaq 0x224797(%rip), %rsi    # 0x398c17
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
jmp 0x1744c9
callq 0x174701
movq %rax, %rdi
callq 0x1740be
movq %rax, %r12
callq 0x174701
movq %rax, %rdi
movq %r12, %rsi
callq 0x1740ef
movq %rbx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rax)
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x517e3
callq 0x5181a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_last_inserted_id
static GtUword gt_rdb_sqlite_last_inserted_id(GtRDB *rdb,
                                                   GT_UNUSED const char *table,
                                                   GT_UNUSED GtError *err)
{
  GtRDBSqlite *rdbs;
  gt_assert(rdb);
  gt_error_check(err);
  rdbs = gt_rdb_sqlite_cast(rdb);
  return (GtUword) sqlite3_last_insert_rowid(rdbs->db);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x174517
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1744fd
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17451c
callq 0x174371
movq %rax, %rdi
movq %rbx, %rsi
callq 0x17401c
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x289091
callq 0x51888
callq 0x51851
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_accept
static int gt_rdb_sqlite_accept(GtRDB *rdb, GtRDBVisitor *v, GtError *err)
{
  GtRDBSqlite *rdbs;
  gt_assert(rdb && v);
  gt_error_check(err);
  rdbs = gt_rdb_sqlite_cast(rdb);
  return gt_rdb_visitor_visit_sqlite(v, rdbs, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x17456d
movq %rsi, %r14
testq %rsi, %rsi
je 0x17456d
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x17454a
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174572
callq 0x174371
movq %rax, %rdi
movq %r15, %rsi
callq 0x17401c
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x174e4d
callq 0x518bf
callq 0x518f6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_get_indexes
static GtCstrTable* gt_rdb_sqlite_get_indexes(GtRDB *rdb, GtError *err)
{
  GtRDBStmt *stmt;
  GtCstrTable *tab;
  int rval = 0;
  gt_assert(rdb);
  gt_error_check(err);
  if ((stmt = gt_rdb_prepare(rdb, "SELECT name FROM sqlite_master "
                                  "WHERE type='index'",
                                  0,
                                  err)) == NULL)
    return NULL;
  tab = gt_cstr_table_new();
  while (!rval) {
    GtStr *key;
    rval = gt_rdb_stmt_exec(stmt, err);
    if (rval) break;
    key = gt_str_new();
    gt_rdb_stmt_get_string(stmt, 0, key, err);
    gt_cstr_table_add(tab, gt_str_get(key));
    gt_str_delete(key);
  }
  if (rval < 0) {
    gt_cstr_table_delete(tab);
    gt_rdb_stmt_delete(stmt);
    return NULL;
  }
  gt_rdb_stmt_delete(stmt);
  return tab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x174632
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x1745a3
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174637
leaq 0x2246e1(%rip), %rsi    # 0x398c8b
xorl %ebx, %ebx
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x174108
testq %rax, %rax
je 0x174623
movq %rax, %r15
callq 0xe8d9c
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1741ce
testl %eax, %eax
jne 0x17460d
callq 0x1208f8
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x174276
movq %r12, %rdi
callq 0x120d23
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe8e02
movq %r12, %rdi
callq 0x121b03
jmp 0x1745c9
testl %eax, %eax
jns 0x17461b
movq %rbx, %rdi
callq 0xe9120
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x1741ef
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x51966
callq 0x5192d