LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x16b6dd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x1543bd
movq 0x30(%rbx), %rdi
callq 0x1543bd
movq 0x38(%rbx), %rdi
callq 0x1543bd
movq 0x28(%rbx), %rdi
callq 0x1543bd
movq 0x40(%rbx), %rdi
callq 0x1543bd
movq 0x10(%rbx), %rdi
callq 0x14c6bb
movq 0x18(%rbx), %rdi
callq 0x14c6bb
movq 0x48(%rbx), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x13c44c
movq 0x60(%rbx), %rdi
leaq 0x22361a(%rip), %r14    # 0x38ecd3
movq %r14, %rsi
movl $0x8af, %edx            # imm = 0x8AF
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8b1, %edx            # imm = 0x8B1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2235e6(%rip), %r14    # 0x38ecd3
movl $0x18, %edi
movq %r14, %rsi
movl $0x2a9, %edx            # imm = 0x2A9
callq 0x104226
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $-0x1, 0x10(%rax)
leaq 0x44(%rip), %rsi        # 0x16b75b
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe56e5
leaq 0x36(%rip), %rsi        # 0x16b75f
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe56e5
movq 0x10(%r15), %rbx
movq %r15, %rdi
movq %r14, %rsi
movl $0x2b0, %edx            # imm = 0x2B0
callq 0x1045eb
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1544f4
movl (%r15), %edx
addq %rdx, 0xb8(%rbx)
addq %rdx, 0x178(%rbx)
movq 0x10(%rbx), %rdi
movq (%r14), %rsi
callq 0x2faf4f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14c449
movq %rax, %r14
movq %rax, %rdi
callq 0xd6f10
addq %rax, 0xb8(%rbx)
addq %rax, 0x170(%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2fafaf
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7151
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xf(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2fae18
cmpl $0x1, %eax
jne 0x16b8cb
movzbl 0xf(%rsp), %esi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x154969
movl %eax, %ecx
cmpl $-0x1, %eax
sete %al
testl %ecx, %ecx
setne %dl
xorb %al, %dl
jne 0x16b88b
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
negl %eax
jmp 0x16b8ed
leaq 0x223af9(%rip), %rsi    # 0x38f3cb
leaq 0x2233fa(%rip), %rcx    # 0x38ecd3
movq %rbx, %rdi
movl $0x61a, %edx            # imm = 0x61A
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xf(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2fae18
cmpl $0x1, %eax
jne 0x16b956
movzbl 0xf(%rsp), %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x14c5da
movl %eax, %ecx
cmpl $-0x1, %eax
sete %al
testl %ecx, %ecx
setne %dl
xorb %al, %dl
jne 0x16b919
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
negl %eax
jmp 0x16b978
leaq 0x223a6e(%rip), %rsi    # 0x38f3cb
leaq 0x22336f(%rip), %rcx    # 0x38ecd3
movq %rbx, %rdi
movl $0x63f, %edx            # imm = 0x63F
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
je 0x16b9d4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
movq %r13, %rdi
movq %r12, %rsi
movq %rsp, %rdx
movq %rbx, %rcx
callq 0x16b86d
testl %eax, %eax
jne 0x16b9d7
movsbl (%rsp), %esi
movq %r14, %rdi
callq 0x11af23
incq %rbp
cmpq %r15, %rbp
jb 0x16b9a7
xorl %eax, %eax
jmp 0x16b9dc
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16ba63
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 0xe7e3c
movq 0x30(%r15), %r13
movzbl %al, %edi
callq 0x17ec0
movsbl %al, %esi
movq %r13, %rdi
callq 0x11af23
movq 0x40(%r15), %rdi
movl $0x3d, %esi
callq 0x11af23
cmpb $0x0, 0xe1(%r12)
jne 0x16ba52
movq 0x38(%r15), %rdi
movl $0x2d, %esi
callq 0x11af23
incq %r14
cmpq %r14, %rbx
jne 0x16ba05
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %rcx, %r14
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %r12
leaq 0xb(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r15, %rdi
movq %r13, %rsi
callq 0x2fae18
cmpl $0x1, %eax
jne 0x16bc31
movzbl 0xb(%rsp), %esi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x13aadf
testl %eax, %eax
jne 0x16bbe0
xorl %r14d, %r14d
cmpq $0x0, 0x10(%rsp)
je 0x16bc56
xorl %r15d, %r15d
movsbl 0xc(%rsp), %ebp
movq 0x40(%rbx), %rdi
movl %ebp, %esi
callq 0x11af23
incq %r15
movq 0x10(%rsp), %rax
cmpq %rax, %r15
jb 0x16bc17
jmp 0x16bc58
leaq 0x223793(%rip), %rsi    # 0x38f3cb
leaq 0x223094(%rip), %rcx    # 0x38ecd3
movq %r14, %rdi
movl $0x6ca, %edx            # imm = 0x6CA
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x16bc5c
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2f7c10
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_O3/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 0x16bd86
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x16bd86
leaq 0x2237ec(%rip), %r14    # 0x38f536
movl $0x1, %edi
movq %r14, %rdx
movl $0x6d, %ecx
callq 0x10436a
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x6f, %ecx
callq 0x10436a
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5032e
// File: /workspace/github_c_makefile_star2_O3/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 0x16bdba
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
testl %eax, %eax
je 0x16bdc2
decl %eax
movl %eax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x16be07
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x16bddc
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x223753(%rip), %r14    # 0x38f536
movq %r14, %rsi
movl $0x83, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x84, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
callq 0x5039c
// File: /workspace/github_c_makefile_star2_O3/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 0x16be40
movq (%rdi), %rax
testq %rax, %rax
je 0x16be40
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x16be3d
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5040e
// File: /workspace/github_c_makefile_star2_O3/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 0x16be66
movq (%rdi), %rax
testq %rax, %rax
je 0x16be66
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x16be5e
jmpq *%rax
movq $-0x1, %rax
retq
pushq %rax
callq 0x50447
// File: /workspace/github_c_makefile_star2_O3/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 0x16be87
movq (%rdi), %rax
testq %rax, %rax
je 0x16be87
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x16be84
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x50480
// File: /workspace/github_c_makefile_star2_O3/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 0x16bea8
movq (%rdi), %rax
testq %rax, %rax
je 0x16bea8
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x16bea5
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x504b9
// File: /workspace/github_c_makefile_star2_O3/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 0x16beda
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x16beda
leaq 0x223670(%rip), %rdx    # 0x38f536
movl $0x1, %edi
movl $0xb1, %ecx
callq 0x10436a
movq %rbx, (%rax)
popq %rbx
retq
callq 0x504f2
// File: /workspace/github_c_makefile_star2_O3/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 0x16bf13
movq (%rdi), %rax
testq %rax, %rax
je 0x16bf13
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x16bf10
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x50564
// File: /workspace/github_c_makefile_star2_O3/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 0x16bf34
movq (%rdi), %rax
testq %rax, %rax
je 0x16bf34
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x16bf31
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5059d
// File: /workspace/github_c_makefile_star2_O3/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 0x16bf55
movq (%rdi), %rax
testq %rax, %rax
je 0x16bf55
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x16bf52
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x505d6
// File: /workspace/github_c_makefile_star2_O3/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 0x16bf76
movq (%rdi), %rax
testq %rax, %rax
je 0x16bf76
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x16bf73
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5060f
// File: /workspace/github_c_makefile_star2_O3/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 0x16bf97
movq (%rdi), %rax
testq %rax, %rax
je 0x16bf97
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x16bf94
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x50648
// File: /workspace/github_c_makefile_star2_O3/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 0x16bfb8
movq (%rdi), %rax
testq %rax, %rax
je 0x16bfb8
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x16bfb5
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x50681
// File: /workspace/github_c_makefile_star2_O3/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 0x16bfd9
movq (%rdi), %rax
testq %rax, %rax
je 0x16bfd9
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x16bfd6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x506ba
// File: /workspace/github_c_makefile_star2_O3/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 0x16c013
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x16c015
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x16bffe
movq %rbx, %rdi
callq *%rax
leaq 0x223531(%rip), %rsi    # 0x38f536
movq %rbx, %rdi
movl $0xff, %edx
popq %rbx
jmp 0x1045eb
popq %rbx
retq
callq 0x506f3
// File: /workspace/github_c_makefile_star2_O3/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 0x16c03a
testq %rdx, %rdx
je 0x16c03a
movq (%rdi), %rax
testq %rax, %rax
je 0x16c03a
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x16c037
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5072c
// File: /workspace/github_c_makefile_star2_O3/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 0x16c060
testq %rdx, %rdx
je 0x16c060
movq (%rdi), %rax
testq %rax, %rax
je 0x16c060
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x16c05d
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x50765
// File: /workspace/github_c_makefile_star2_O3/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 0x16c086
testq %rdx, %rdx
je 0x16c086
movq (%rdi), %rax
testq %rax, %rax
je 0x16c086
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x16c083
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x5079e
// File: /workspace/github_c_makefile_star2_O3/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 0x16c0ac
testq %rdx, %rdx
je 0x16c0ac
movq (%rdi), %rax
testq %rax, %rax
je 0x16c0ac
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x16c0a9
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
callq 0x507d7
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x16c152
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x16c0e0
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c157
movq %rsp, %rsi
movq %r14, %rdi
callq 0x280609
testl %eax, %eax
je 0x16c11a
movq (%rsp), %rdi
callq 0x27c968
leaq 0x2236ab(%rip), %rsi    # 0x38f7aa
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movq (%rsp), %rdi
callq 0x27f4bb
jmp 0x16c147
callq 0x16c161
movq %rax, %rdi
callq 0x16bd2e
movq %rax, %r14
callq 0x16c161
movq %rax, %rdi
movq %r14, %rsi
callq 0x16be0c
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
je 0x16c15c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5087e
callq 0x50810
callq 0x50847
// File: /workspace/github_c_makefile_star2_O3/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 0xe252f
cmpq $0x0, 0x3526c1(%rip)    # 0x4be830
jne 0x16c1b0
leaq 0x2b4(%rip), %rax       # 0x16c42c
movq %rax, (%rsp)
leaq 0x3b(%rip), %rsi        # 0x16c1be
leaq 0x5c(%rip), %rdx        # 0x16c1e6
leaq 0x142(%rip), %rcx       # 0x16c2d3
leaq 0x179(%rip), %r8        # 0x16c311
leaq 0x1c8(%rip), %r9        # 0x16c367
movl $0x18, %edi
callq 0x16bc70
movq %rax, 0x352680(%rip)    # 0x4be830
callq 0xe2545
movq 0x352674(%rip), %rax    # 0x4be830
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16c2c9
movq %rsi, %r12
testq %rsi, %rsi
je 0x16c2c9
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0x16c22e
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c2ce
callq 0x16c161
movq %rax, %rdi
movq %r15, %rsi
callq 0x16be0c
movq %rax, %r15
movq 0x10(%rax), %rdi
leaq 0x8(%rsp), %rcx
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0x27c93f
testl %eax, %eax
je 0x16c284
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x27c968
leaq 0x22357f(%rip), %rsi    # 0x38f7ef
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
jmp 0x16c2b9
callq 0x16c4f1
movq %rax, %rdi
callq 0x16beae
movq %rax, %r12
callq 0x16c4f1
movq %rax, %rdi
movq %r12, %rsi
callq 0x16bedf
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 0x508b5
callq 0x508ec
// File: /workspace/github_c_makefile_star2_O3/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 0x16c307
movq %rdi, %rbx
testq %rdx, %rdx
je 0x16c2ed
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c30c
callq 0x16c161
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16be0c
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x27f4a9
callq 0x5095a
callq 0x50923
// File: /workspace/github_c_makefile_star2_O3/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 0x16c35d
movq %rsi, %r14
testq %rsi, %rsi
je 0x16c35d
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x16c33a
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c362
callq 0x16c161
movq %rax, %rdi
movq %r15, %rsi
callq 0x16be0c
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x16cbf5
callq 0x50991
callq 0x509c8
// File: /workspace/github_c_makefile_star2_O3/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 0x16c422
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x16c393
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c427
leaq 0x2234c9(%rip), %rsi    # 0x38f863
xorl %ebx, %ebx
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x16bef8
testq %rax, %rax
je 0x16c413
movq %rax, %r15
callq 0xe48d0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x16bfbe
testl %eax, %eax
jne 0x16c3fd
callq 0x11ac6c
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x16c066
movq %r12, %rdi
callq 0x11b0a1
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe4936
movq %r12, %rdi
callq 0x11bdbf
jmp 0x16c3b9
testl %eax, %eax
jns 0x16c40b
movq %rbx, %rdi
callq 0xe4c43
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x16bfdf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x50a38
callq 0x509ff
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_get_tables
static GtCstrTable* gt_rdb_sqlite_get_tables(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='table'",
                                  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 0x16c4e7
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x16c458
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c4ec
leaq 0x22344f(%rip), %rsi    # 0x38f8ae
xorl %ebx, %ebx
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x16bef8
testq %rax, %rax
je 0x16c4d8
movq %rax, %r15
callq 0xe48d0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x16bfbe
testl %eax, %eax
jne 0x16c4c2
callq 0x11ac6c
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x16c066
movq %r12, %rdi
callq 0x11b0a1
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe4936
movq %r12, %rdi
callq 0x11bdbf
jmp 0x16c47e
testl %eax, %eax
jns 0x16c4d0
movq %rbx, %rdi
callq 0xe4c43
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x16bfdf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x50aaa
callq 0x50a71
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_class
const GtRDBStmtClass* gt_rdb_stmt_sqlite_class(void)
{
  static const GtRDBStmtClass *rdbss = NULL;
  gt_class_alloc_lock_enter();
  if (!rdbss) {
    rdbss = gt_rdb_stmt_class_new(sizeof (GtRDBStmtSqlite),
                                  gt_rdb_stmt_sqlite_reset,
                                  gt_rdb_stmt_sqlite_bind_int,
                                  gt_rdb_stmt_sqlite_bind_ulong,
                                  gt_rdb_stmt_sqlite_bind_string,
                                  gt_rdb_stmt_sqlite_bind_double,
                                  gt_rdb_stmt_sqlite_exec,
                                  gt_rdb_stmt_sqlite_get_int,
                                  gt_rdb_stmt_sqlite_get_ulong,
                                  gt_rdb_stmt_sqlite_get_string,
                                  gt_rdb_stmt_sqlite_get_double,
                                  gt_rdb_stmt_sqlite_delete);
  }
  gt_class_alloc_lock_leave();
  return rdbss;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0xe252f
cmpq $0x0, 0x352335(%rip)    # 0x4be838
jne 0x16c571
leaq 0x631(%rip), %rax       # 0x16cb3d
leaq 0x5ab(%rip), %r10       # 0x16cabe
leaq 0x510(%rip), %r11       # 0x16ca2a
leaq 0x489(%rip), %rbx       # 0x16c9aa
leaq 0x405(%rip), %r14       # 0x16c92d
leaq 0x378(%rip), %r15       # 0x16c8a7
leaq 0x4d(%rip), %rsi        # 0x16c583
leaq 0xcc(%rip), %rdx        # 0x16c609
leaq 0x15f(%rip), %rcx       # 0x16c6a3
leaq 0x1f8(%rip), %r8        # 0x16c743
leaq 0x2b1(%rip), %r9        # 0x16c803
movl $0x20, %edi
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq %r15
callq 0x16bcc6
addq $0x30, %rsp
movq %rax, 0x3522c7(%rip)    # 0x4be838
callq 0xe2545
movq 0x3522bb(%rip), %rax    # 0x4be838
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_reset
static int gt_rdb_stmt_sqlite_reset(GtRDBStmt *st, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  rval = sqlite3_reset(sts->stmt);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  if (!had_err) {
    rval = sqlite3_clear_bindings(sts->stmt);
    if (rval != SQLITE_OK) {
      gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
      had_err = -1;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x16c5ff
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x16c5a3
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c604
callq 0x16c4f1
movq %rax, %rdi
movq %r14, %rsi
callq 0x16bedf
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0x277fa9
testl %eax, %eax
jne 0x16c5d0
movq 0x8(%r14), %rdi
callq 0x2780fa
testl %eax, %eax
je 0x16c5fb
movl %eax, %ebp
movq 0x10(%r14), %rdi
callq 0x27c968
leaq 0x22320d(%rip), %rsi    # 0x38f7ef
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x16c5f6
callq 0x50b1c
callq 0x50ae3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_bind_int
static int gt_rdb_stmt_sqlite_bind_int(GtRDBStmt *st, GtUword param_no,
                                       int val, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  gt_assert(param_no < sts->num_params);
  rval = sqlite3_bind_int(sts->stmt, param_no + 1, val);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16c694
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x16c631
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c69e
callq 0x16c4f1
movq %rax, %rdi
movq %r15, %rsi
callq 0x16bedf
cmpq %r14, 0x18(%rax)
jbe 0x16c699
movq %rax, %r15
movq 0x8(%rax), %rdi
incl %r14d
movl %r14d, %esi
movl %ebp, %edx
callq 0x27a170
testl %eax, %eax
je 0x16c687
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x27c968
leaq 0x22317e(%rip), %rsi    # 0x38f7ef
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x16c689
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x50bc7
callq 0x50b8e
callq 0x50b55
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_bind_string
static int gt_rdb_stmt_sqlite_bind_string(GtRDBStmt *st, GtUword param_no,
                                          const char *val, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  gt_assert(param_no < sts->num_params);
  rval = sqlite3_bind_text(sts->stmt, param_no + 1, val, strlen(val),
                           SQLITE_STATIC);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16c7f4
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x16c778
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c7fe
callq 0x16c4f1
movq %rax, %rdi
movq %r12, %rsi
callq 0x16bedf
cmpq %r15, 0x18(%rax)
jbe 0x16c7f9
movq %rax, %r12
movq 0x8(%rax), %rbp
incl %r15d
movq %r14, %rdi
callq 0x172f0
xorl %r13d, %r13d
movq %rbp, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x27a260
testl %eax, %eax
je 0x16c7e2
movl %eax, %ebp
movq 0x10(%r12), %rdi
callq 0x27c968
leaq 0x223022(%rip), %rsi    # 0x38f7ef
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x50d1d
callq 0x50ce4
callq 0x50cab
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_bind_double
static int gt_rdb_stmt_sqlite_bind_double(GtRDBStmt *st, GtUword param_no,
                                          double val, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  gt_assert(param_no < sts->num_params);
  rval = sqlite3_bind_double(sts->stmt, param_no + 1, val);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16c898
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, (%rsp)
testq %rdx, %rdx
je 0x16c832
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c8a2
callq 0x16c4f1
movq %rax, %rdi
movq %r15, %rsi
callq 0x16bedf
cmpq %r14, 0x18(%rax)
jbe 0x16c89d
movq %rax, %r15
movq 0x8(%rax), %rdi
incl %r14d
movl %r14d, %esi
movsd (%rsp), %xmm0
callq 0x279fad
testl %eax, %eax
je 0x16c88b
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x27c968
leaq 0x222f7a(%rip), %rsi    # 0x38f7ef
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x16c88d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x50dc8
callq 0x50d8f
callq 0x50d56
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_exec
static int gt_rdb_stmt_sqlite_exec(GtRDBStmt *st, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  switch ((rval = sqlite3_step(sts->stmt))) {
    case SQLITE_ROW:
      break;
    case SQLITE_DONE:
      had_err = 1;  /* last row read */
      break;
    default:
      gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
      had_err = -1;
      break;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x16c923
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x16c8c7
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c928
callq 0x16c4f1
movq %rax, %rdi
movq %r14, %rsi
callq 0x16bedf
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0x278b63
cmpl $0x64, %eax
je 0x16c8f6
movl %eax, %ebp
cmpl $0x65, %eax
jne 0x16c8fa
movl $0x1, %eax
jmp 0x16c91e
xorl %eax, %eax
jmp 0x16c91e
movq 0x10(%r14), %rdi
callq 0x27c968
leaq 0x222ee5(%rip), %rsi    # 0x38f7ef
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x50e3a
callq 0x50e01
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_int
static int gt_rdb_stmt_sqlite_get_int(GtRDBStmt *st, GtUword field_no,
                                      int *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    *result = sqlite3_column_int(sts->stmt, field_no);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16c9a0
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x16c957
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16c9a5
callq 0x16c4f1
movq %rax, %rdi
movq %r12, %rsi
callq 0x16bedf
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x16c97e
movl %r15d, %esi
callq 0x279cc0
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0x16c994
leaq 0x22303a(%rip), %rsi    # 0x38f9bf
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x50eac
callq 0x50e73
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_ulong
static int gt_rdb_stmt_sqlite_get_ulong(GtRDBStmt *st, GtUword field_no,
                                        GtUword *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    *result = (GtUword) sqlite3_column_int(sts->stmt, field_no);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16ca20
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x16c9d4
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16ca25
callq 0x16c4f1
movq %rax, %rdi
movq %r12, %rsi
callq 0x16bedf
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x16c9fe
movl %r15d, %esi
callq 0x279cc0
cltq
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x16ca14
leaq 0x222fba(%rip), %rsi    # 0x38f9bf
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x50f1e
callq 0x50ee5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_string
static int gt_rdb_stmt_sqlite_get_string(GtRDBStmt *st, GtUword field_no,
                                         GtStr *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    gt_str_reset(result);
    gt_str_append_cstr(result,
                       (const char*) sqlite3_column_text(sts->stmt, field_no));
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16cab4
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %rcx, %rcx
je 0x16ca54
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16cab9
callq 0x16c4f1
movq %rax, %rdi
movq %r12, %rsi
callq 0x16bedf
cmpq $0x0, 0x8(%rax)
je 0x16ca92
movq %rax, %r12
movq %rbx, %rdi
callq 0x11b132
movq 0x8(%r12), %rdi
movl %r14d, %esi
callq 0x279d14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11acf3
xorl %eax, %eax
jmp 0x16caa8
leaq 0x222f26(%rip), %rsi    # 0x38f9bf
movq %r15, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x50f90
callq 0x50f57
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_double
static int gt_rdb_stmt_sqlite_get_double(GtRDBStmt *st, GtUword field_no,
                                         double *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    *result = sqlite3_column_double(sts->stmt, field_no);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16cb33
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x16cae8
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x16cb38
callq 0x16c4f1
movq %rax, %rdi
movq %r12, %rsi
callq 0x16bedf
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x16cb11
movl %r15d, %esi
callq 0x279c91
movsd %xmm0, (%rbx)
xorl %eax, %eax
jmp 0x16cb27
leaq 0x222ea7(%rip), %rsi    # 0x38f9bf
movq %r14, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x51002
callq 0x50fc9