LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x107d6f
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x107d6c
movq 0x8(%rax), %rax
retq
xorl %eax, %eax
retq
pushq %rax
movq 0x3301f1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd292(%rip), %rsi    # 0x2e5013
leaq 0x226d1b(%rip), %rdx    # 0x32eaa3
leaq 0x226d80(%rip), %rcx    # 0x32eb0f
leaq 0x226b2a(%rip), %r8     # 0x32e8c0
movl $0x338, %r9d            # imm = 0x338
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x334a62(%rip), %rdi    # 0x43d7c8
xorl %ebx, %ebx
movl $0x320, %edx            # imm = 0x320
xorl %esi, %esi
callq 0x17380
andq $0x0, 0x334a5c(%rip)    # 0x43d7d8
leaq 0xb6(%rip), %rsi        # 0x108e39
movq %r14, %rdi
xorl %edx, %edx
callq 0x1070c5
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x108dac
movq 0x32f115(%rip), %rax    # 0x437eb0
movq (%rax), %rsi
leaq 0x2261a1(%rip), %rdi    # 0x32ef46
callq 0xb2f4f
movl %ebp, %ebx
xorl %r15d, %r15d
movq 0x32f0fa(%rip), %r12    # 0x437eb0
leaq 0x226196(%rip), %r14    # 0x32ef53
cmpq $0x64, %r15
je 0x108de4
movq 0x3349fe(%rip), %rax    # 0x43d7c8
cmpq $0x1, (%rax,%r15,8)
je 0x108ddf
movq (%r12), %rsi
movq %r14, %rdi
callq 0xb2f4f
movl %ebp, %ebx
incq %r15
jmp 0x108dbd
movq 0x3349ed(%rip), %rsi    # 0x43d7d8
cmpq $0xc, %rsi
jb 0x108e05
leaq 0x226172(%rip), %rdi    # 0x32ef6a
pushq $0xb
popq %rdx
xorl %eax, %eax
callq 0x17070
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_new_node
static GtRBTreeNode *gt_rbtree_new_node(void *key)
{
  GtRBTreeNode *rn = (GtRBTreeNode *) gt_malloc(sizeof *rn);

  rn->red = 1;
  rn->key = key;
  rn->link[0] = rn->link[1] = NULL;

  return rn;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x225aa5(%rip), %rsi    # 0x32e8c0
pushq $0x20
popq %rdi
pushq $0x72
popq %rdx
callq 0x93160
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x334995(%rip)    # 0x43d7d8
jae 0x108e4c
movq %rdx, 0x33498c(%rip)    # 0x43d7d8
cmpl $0x3, %esi
je 0x108e55
testl %esi, %esi
jne 0x108e6e
movq 0x33496c(%rip), %rax    # 0x43d7c8
incq (%rax,%rcx,8)
movq 0x334969(%rip), %rax    # 0x43d7d0
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
retq
movq 0x33495b(%rip), %rsi    # 0x43d7d0
xorl %eax, %eax
cmpq %rdx, (%rsi,%rcx,8)
je 0x108e9b
pushq %rax
movq 0x32f02b(%rip), %rax    # 0x437eb0
movq (%rax), %rsi
leaq 0x22610b(%rip), %rdi    # 0x32ef9a
callq 0xb2f4f
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x109b70
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xf09fc
movq 0x70(%rbx), %rdi
callq 0xf09fc
movq 0x68(%rbx), %rdi
callq 0xf09fc
movq 0x78(%rbx), %rdi
callq 0xf09fc
movq 0x80(%rbx), %rdi
callq 0xf09fc
movq 0x50(%rbx), %rdi
callq 0xe7322
movq 0x58(%rbx), %rdi
callq 0xe7322
movq 0xb0(%rbx), %rdi
callq 0x9e9dd
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x109af3
movq 0x30(%rax), %rdi
callq 0x17f48
movq 0x90(%rbx), %rdi
callq 0x17f48
movq 0x40(%rbx), %rdi
callq 0x6e064
movq 0x20(%rbx), %rdi
callq 0x6e064
movq 0x28(%rbx), %rdi
callq 0x6e064
movq 0x30(%rbx), %rdi
callq 0x6e064
movq 0x38(%rbx), %rdi
callq 0x6e064
movq 0x88(%rbx), %rdi
callq 0x113bc4
movq 0x18(%rbx), %rdi
callq 0x29a166
movq 0x48(%rbx), %rdi
callq 0xd38dc
movq 0xa8(%rbx), %rdi
leaq 0x2254e7(%rip), %r14    # 0x32f033
movq %r14, %rsi
movl $0x89a, %edx            # imm = 0x89A
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x89b, %edx            # imm = 0x89B
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10ca08
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xf09fc
movq 0x30(%rbx), %rdi
callq 0xf09fc
movq 0x38(%rbx), %rdi
callq 0xf09fc
movq 0x28(%rbx), %rdi
callq 0xf09fc
movq 0x40(%rbx), %rdi
callq 0xf09fc
movq 0x10(%rbx), %rdi
callq 0xe7322
movq 0x18(%rbx), %rdi
callq 0xe7322
movq 0x48(%rbx), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xd2c7f
movq 0x60(%rbx), %rdi
leaq 0x22264f(%rip), %r14    # 0x32f033
movq %r14, %rsi
movl $0x8af, %edx            # imm = 0x8AF
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8b1, %edx            # imm = 0x8B1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2225d6(%rip), %r14    # 0x32f033
pushq $0x18
popq %rdi
movq %r14, %rsi
movl $0x2a9, %edx            # imm = 0x2A9
callq 0x93160
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
orq $-0x1, 0x10(%rax)
leaq 0x44(%rip), %rsi        # 0x10cac6
movq %rbx, %rdi
movq %rax, %rdx
callq 0x6dc7c
leaq 0x36(%rip), %rsi        # 0x10caca
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6dc7c
movq 0x10(%r15), %rbx
movq %r15, %rdi
movq %r14, %rsi
movl $0x2b0, %edx            # imm = 0x2B0
callq 0x936f9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe7079
movq %rax, %r14
movq %rax, %rdi
callq 0x5e96c
addq %rax, 0xb8(%rbx)
addq %rax, 0x170(%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x297244
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5ecf6
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $-0x1
popq %rbp
leaq 0x7(%rsp), %r13
leaq 0x222408(%rip), %r14    # 0x32f033
movl %ebp, %r12d
xorl %eax, %eax
testl %eax, %eax
jne 0x10cc8d
testl %r12d, %r12d
je 0x10cc8d
movq %r15, %rdi
movq %r13, %rsi
callq 0x29705d
cmpl $0x1, %eax
je 0x10cc66
movq %rbx, %rdi
leaq 0x222ad8(%rip), %rsi    # 0x32f72b
movl $0x61a, %edx            # imm = 0x61A
movq %r14, %rcx
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
jmp 0x10cc30
movzbl 0x7(%rsp), %esi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0xf1283
movl %eax, %r12d
xorl %eax, %eax
cmpl $-0x1, %r12d
sete %al
negl %eax
jmp 0x10cc30
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/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, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
pushq $-0x1
popq %rbp
leaq 0x7(%rsp), %r13
leaq 0x22236a(%rip), %r14    # 0x32f033
movl %ebp, %r12d
xorl %eax, %eax
testl %eax, %eax
jne 0x10cd28
testl %r12d, %r12d
je 0x10cd28
movq %r15, %rdi
movq %r13, %rsi
callq 0x29705d
cmpl $0x1, %eax
je 0x10cd04
movq %rbx, %rdi
leaq 0x222a3a(%rip), %rsi    # 0x32f72b
movl $0x63f, %edx            # imm = 0x63F
movq %r14, %rcx
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %eax
jmp 0x10ccce
movzbl 0x7(%rsp), %esi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xe7228
movl %eax, %r12d
xorl %eax, %eax
cmpl $-0x1, %r12d
sete %al
negl %eax
jmp 0x10ccce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/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 %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %r14d, %r14d
xorl %ebp, %ebp
testl %r14d, %r14d
jne 0x10cd93
cmpq %r15, %rbp
jae 0x10cd93
movq %r13, %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x10cbfe
movl %eax, %r14d
testl %eax, %eax
jne 0x10cd5b
movsbl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0xaced9
incq %rbp
jmp 0x10cd5b
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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x3d
popq %rbp
cmpq %rbx, %r14
jae 0x10ce11
movq 0x50(%r12), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x709bc
movq 0x30(%r15), %r13
movzbl %al, %edi
callq 0x17e30
movsbl %al, %esi
movq %r13, %rdi
callq 0xaced9
movq 0x40(%r15), %rdi
movl %ebp, %esi
callq 0xaced9
cmpb $0x0, 0xe1(%r12)
jne 0x10ce0c
movq 0x38(%r15), %rdi
pushq $0x2d
popq %rsi
callq 0xaced9
incq %r14
jmp 0x10cdbf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/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, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
andq $0x0, 0x58(%rbx)
movq 0x18(%rbx), %rdi
movq %r8, %rcx
callq 0x10cbfe
testl %eax, %eax
jne 0x10ceba
movq 0x8(%rsp), %r12
movq 0x48(%rbx), %rax
cmpq %rax, %r12
je 0x10cec0
decq %rax
cmpq %rax, %r12
movl $0xfe, %eax
cmovel %eax, %r12d
movq 0x30(%rbx), %rbp
callq 0x170c0
movq (%rax), %r13
movq (%rbx), %rdi
movzbl %r12b, %esi
callq 0x575cc
movsbq %al, %rax
movsbl (%r13,%rax,4), %esi
movq %rbp, %rdi
callq 0xaced9
incq 0x58(%rbx)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rcx
jmp 0x10ce55
pushq $-0x1
popq %r15
jmp 0x10cf13
xorl %r12d, %r12d
movsbl 0x4(%rsp), %ebp
movq 0x58(%rbx), %rdx
cmpq %rdx, %r12
jae 0x10cee1
movq 0x40(%rbx), %rdi
movl %ebp, %esi
callq 0xaced9
incq %r12
jmp 0x10cec8
movq 0x10(%rsp), %rax
cmpb $0x1, 0xe2(%rax)
jne 0x10cf07
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rcx
movq %r15, %rsi
movq %r14, %r8
callq 0x10cd37
movl %eax, %r15d
jmp 0x10cf13
xorl %r15d, %r15d
cmpb $0x0, 0xe1(%rax)
je 0x10cf25
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
pushq $0x2d
popq %rbp
xorl %r14d, %r14d
cmpq %rdx, %r14
jae 0x10cf13
movq 0x38(%rbx), %rdi
movl %ebp, %esi
callq 0xaced9
incq %r14
movq 0x58(%rbx), %rdx
jmp 0x10cf2e
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x18(%rsp)
pushq $-0x1
popq %rbp
movl %ebp, %r12d
xorl %ebx, %ebx
movb $0x1, %r13b
testb $0x1, %r13b
je 0x10cfd1
testl %ebp, %ebp
je 0x10cfd1
movq %r15, %rdi
leaq 0xb(%rsp), %rsi
callq 0x29705d
cmpl $0x1, %eax
je 0x10cfb9
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0x22278a(%rip), %rsi    # 0x32f72b
movl $0x6ca, %edx            # imm = 0x6CA
leaq 0x222086(%rip), %rcx    # 0x32f033
xorl %eax, %eax
callq 0x89dbb
movl %r12d, %ebx
jmp 0x10cf78
movzbl 0xb(%rsp), %esi
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xd0ff5
movl %eax, %ebp
jmp 0x10cf73
testb $0x1, %r13b
je 0x10d002
xorl %r14d, %r14d
movsbl 0xc(%rsp), %ebp
movq 0x10(%rsp), %r15
movq 0x20(%rsp), %rax
cmpq %rax, %r14
jae 0x10cffe
movq 0x40(%r15), %rdi
movl %ebp, %esi
callq 0xaced9
incq %r14
jmp 0x10cfe4
movq %rax, 0x50(%r15)
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x48
popq %rdi
callq 0x292a70
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_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10d12a
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x10d12a
leaq 0x222787(%rip), %r14    # 0x32f874
pushq $0x1
popq %r15
pushq $0x6d
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x4
popq %rsi
pushq $0x6f
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x32ae37(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7ed8(%rip), %rsi    # 0x2e5013
leaq 0x20a1ac(%rip), %rdx    # 0x3172ee
leaq 0x22271d(%rip), %rcx    # 0x32f866
leaq 0x222724(%rip), %r8     # 0x32f874
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d1c0
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
testl %eax, %eax
je 0x10d1c8
decl %eax
movl %eax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x10d20d
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x10d1e2
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x22268b(%rip), %r14    # 0x32f874
movq %r14, %rsi
movl $0x83, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x84, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x32ad54(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7df5(%rip), %rsi    # 0x2e5013
leaq 0x220698(%rip), %rdx    # 0x32d8bd
leaq 0x222666(%rip), %rcx    # 0x32f892
leaq 0x222641(%rip), %r8     # 0x32f874
movl $0x81, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d2ac
movq (%rdi), %rax
testq %rax, %rax
je 0x10d2ac
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x10d2a9
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32acb4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7d55(%rip), %rsi    # 0x2e5013
leaq 0x222607(%rip), %rdx    # 0x32f8cc
leaq 0x222612(%rip), %rcx    # 0x32f8de
leaq 0x2225a1(%rip), %r8     # 0x32f874
movl $0x8f, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d301
movq (%rdi), %rax
testq %rax, %rax
je 0x10d301
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x10d2fd
jmpq *%rax
pushq $-0x1
popq %rax
retq
pushq %rax
movq 0x32ac5f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7d00(%rip), %rsi    # 0x2e5013
leaq 0x2225b2(%rip), %rdx    # 0x32f8cc
leaq 0x2225cb(%rip), %rcx    # 0x32f8ec
leaq 0x22254c(%rip), %r8     # 0x32f874
movl $0x97, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d355
movq (%rdi), %rax
testq %rax, %rax
je 0x10d355
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x10d352
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32ac0b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7cac(%rip), %rsi    # 0x2e5013
leaq 0x22255e(%rip), %rdx    # 0x32f8cc
leaq 0x22258f(%rip), %rcx    # 0x32f904
leaq 0x2224f8(%rip), %r8     # 0x32f874
movl $0x9f, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d3a9
movq (%rdi), %rax
testq %rax, %rax
je 0x10d3a9
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x10d3a6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32abb7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7c58(%rip), %rsi    # 0x2e5013
leaq 0x22250a(%rip), %rdx    # 0x32f8cc
leaq 0x22254e(%rip), %rcx    # 0x32f917
leaq 0x2224a4(%rip), %r8     # 0x32f874
movl $0xa7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d40c
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x10d40c
leaq 0x22247a(%rip), %rdx    # 0x32f874
pushq $0x1
popq %rdi
movl $0xb1, %ecx
callq 0x9334a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x32ab55(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7bf6(%rip), %rsi    # 0x2e5013
leaq 0x222505(%rip), %rdx    # 0x32f929
leaq 0x22250f(%rip), %rcx    # 0x32f93a
leaq 0x222442(%rip), %r8     # 0x32f874
movl $0xb0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d4ab
movq (%rdi), %rax
testq %rax, %rax
je 0x10d4ab
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x10d4a8
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32aab5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7b56(%rip), %rsi    # 0x2e5013
leaq 0x222408(%rip), %rdx    # 0x32f8cc
leaq 0x2224bb(%rip), %rcx    # 0x32f986
leaq 0x2223a2(%rip), %r8     # 0x32f874
movl $0xbf, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d4ff
movq (%rdi), %rax
testq %rax, %rax
je 0x10d4ff
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x10d4fc
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32aa61(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7b02(%rip), %rsi    # 0x2e5013
leaq 0x22247d(%rip), %rdx    # 0x32f995
leaq 0x22248c(%rip), %rcx    # 0x32f9ab
leaq 0x22234e(%rip), %r8     # 0x32f874
movl $0xc7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d553
movq (%rdi), %rax
testq %rax, %rax
je 0x10d553
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x10d550
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32aa0d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7aae(%rip), %rsi    # 0x2e5013
leaq 0x222429(%rip), %rdx    # 0x32f995
leaq 0x22244a(%rip), %rcx    # 0x32f9bd
leaq 0x2222fa(%rip), %r8     # 0x32f874
movl $0xd0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d5a7
movq (%rdi), %rax
testq %rax, %rax
je 0x10d5a7
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x10d5a4
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a9b9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7a5a(%rip), %rsi    # 0x2e5013
leaq 0x2223d5(%rip), %rdx    # 0x32f995
leaq 0x22240b(%rip), %rcx    # 0x32f9d2
leaq 0x2222a6(%rip), %r8     # 0x32f874
movl $0xd9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d5fb
movq (%rdi), %rax
testq %rax, %rax
je 0x10d5fb
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x10d5f8
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a965(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7a06(%rip), %rsi    # 0x2e5013
leaq 0x222381(%rip), %rdx    # 0x32f995
leaq 0x2223ce(%rip), %rcx    # 0x32f9e9
leaq 0x222252(%rip), %r8     # 0x32f874
movl $0xe2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d64f
movq (%rdi), %rax
testq %rax, %rax
je 0x10d64f
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x10d64c
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a911(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d79b2(%rip), %rsi    # 0x2e5013
leaq 0x22232d(%rip), %rdx    # 0x32f995
leaq 0x222392(%rip), %rcx    # 0x32fa01
leaq 0x2221fe(%rip), %r8     # 0x32f874
movl $0xeb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d6a3
movq (%rdi), %rax
testq %rax, %rax
je 0x10d6a3
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x10d6a0
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a8bd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d795e(%rip), %rsi    # 0x2e5013
leaq 0x2222d9(%rip), %rdx    # 0x32f995
leaq 0x222356(%rip), %rcx    # 0x32fa19
leaq 0x2221aa(%rip), %r8     # 0x32f874
movl $0xf3, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d710
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x10d712
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x10d6fb
movq %rbx, %rdi
callq *%rax
leaq 0x222172(%rip), %rsi    # 0x32f874
movq %rbx, %rdi
movl $0xff, %edx
popq %rbx
jmp 0x936f9
popq %rbx
retq
movq 0x32a84f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d78f0(%rip), %rsi    # 0x2e5013
leaq 0x222273(%rip), %rdx    # 0x32f99d
leaq 0x2222f9(%rip), %rcx    # 0x32fa2a
leaq 0x22213c(%rip), %r8     # 0x32f874
movl $0xfc, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d76a
testq %rdx, %rdx
je 0x10d76a
movq (%rdi), %rax
testq %rax, %rax
je 0x10d76a
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x10d767
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a7f6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7897(%rip), %rsi    # 0x2e5013
leaq 0x2222ba(%rip), %rdx    # 0x32fa3d
leaq 0x2222d3(%rip), %rcx    # 0x32fa5d
leaq 0x2220e3(%rip), %r8     # 0x32f874
movl $0x105, %r9d            # imm = 0x105
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d7c3
testq %rdx, %rdx
je 0x10d7c3
movq (%rdi), %rax
testq %rax, %rax
je 0x10d7c3
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x10d7c0
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a79d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d783e(%rip), %rsi    # 0x2e5013
leaq 0x222261(%rip), %rdx    # 0x32fa3d
leaq 0x222290(%rip), %rcx    # 0x32fa73
leaq 0x22208a(%rip), %r8     # 0x32f874
movl $0x10e, %r9d            # imm = 0x10E
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d81c
testq %rdx, %rdx
je 0x10d81c
movq (%rdi), %rax
testq %rax, %rax
je 0x10d81c
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x10d819
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a744(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d77e5(%rip), %rsi    # 0x2e5013
leaq 0x222208(%rip), %rdx    # 0x32fa3d
leaq 0x22224b(%rip), %rcx    # 0x32fa87
leaq 0x222031(%rip), %r8     # 0x32f874
movl $0x117, %r9d            # imm = 0x117
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10d875
testq %rdx, %rdx
je 0x10d875
movq (%rdi), %rax
testq %rax, %rax
je 0x10d875
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x10d872
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x32a6eb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d778c(%rip), %rsi    # 0x2e5013
leaq 0x2221af(%rip), %rdx    # 0x32fa3d
leaq 0x222209(%rip), %rcx    # 0x32fa9e
leaq 0x221fd8(%rip), %r8     # 0x32f874
movl $0x120, %r9d            # imm = 0x120
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0x10d94f
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x10d8dd
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10d979
movq %rsp, %rsi
movq %r14, %rdi
callq 0x22b3e1
testl %eax, %eax
je 0x10d917
movq (%rsp), %rdi
callq 0x2280b1
leaq 0x2221ec(%rip), %rsi    # 0x32fae8
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x89dbb
movq (%rsp), %rdi
callq 0x22a5cd
jmp 0x10d944
callq 0x10d9d9
movq %rax, %rdi
callq 0x10d0ce
movq %rax, %r14
callq 0x10d9d9
movq %rax, %rdi
movq %r14, %rsi
callq 0x10d245
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
je 0x10d9a3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x32a612(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d76b3(%rip), %rsi    # 0x2e5013
leaq 0x22214e(%rip), %rdx    # 0x32fab5
leaq 0x22214e(%rip), %rcx    # 0x32fabc
leaq 0x222159(%rip), %r8     # 0x32face
pushq $0x39
jmp 0x10d9cb
movq 0x32a5e8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7689(%rip), %rsi    # 0x2e5013
leaq 0x1d782e(%rip), %rdx    # 0x2e51bf
leaq 0x222124(%rip), %rcx    # 0x32fabc
leaq 0x22212f(%rip), %r8     # 0x32face
pushq $0x3a
jmp 0x10d9cb
movq 0x32a5be(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d765f(%rip), %rsi    # 0x2e5013
leaq 0x222146(%rip), %rdx    # 0x32fb01
leaq 0x2220fa(%rip), %rcx    # 0x32fabc
leaq 0x222105(%rip), %r8     # 0x32face
pushq $0x45
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x32fdf9(%rip)    # 0x43d7e0
jne 0x10da26
leaq 0x40b(%rip), %rax       # 0x10ddfb
movq %rax, (%rsp)
leaq 0x39(%rip), %rsi        # 0x10da34
leaq 0x5a(%rip), %rdx        # 0x10da5c
leaq 0x191(%rip), %rcx       # 0x10db9a
leaq 0x21e(%rip), %r8        # 0x10dc2e
leaq 0x2c3(%rip), %r9        # 0x10dcda
pushq $0x18
popq %rdi
callq 0x10d014
movq %rax, 0x32fdba(%rip)    # 0x43d7e0
callq 0x69ede
movq 0x32fdae(%rip), %rax    # 0x43d7e0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x10db3a
movq %rsi, %r12
testq %rsi, %rsi
je 0x10db3a
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0x10daa1
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10db64
callq 0x10d9d9
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d245
movq %rax, %r15
movq 0x10(%rax), %rdi
pushq $-0x1
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r12, %rsi
xorl %r8d, %r8d
callq 0x228088
testl %eax, %eax
je 0x10daf5
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x2280b1
leaq 0x22204c(%rip), %rsi    # 0x32fb2d
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
jmp 0x10db2a
callq 0x10df1c
movq %rax, %rdi
callq 0x10d3e2
movq %rax, %r12
callq 0x10df1c
movq %rax, %rdi
movq %r12, %rsi
callq 0x10d444
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
movq 0x32a427(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d74c8(%rip), %rsi    # 0x2e5013
leaq 0x221fb8(%rip), %rdx    # 0x32fb0a
leaq 0x221fbe(%rip), %rcx    # 0x32fb17
leaq 0x221f6e(%rip), %r8     # 0x32face
pushq $0x6f
jmp 0x10db8c
movq 0x32a3fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d749e(%rip), %rsi    # 0x2e5013
leaq 0x1d7643(%rip), %rdx    # 0x2e51bf
leaq 0x221f94(%rip), %rcx    # 0x32fb17
leaq 0x221f44(%rip), %r8     # 0x32face
pushq $0x70
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10dbce
movq %rdi, %rbx
testq %rdx, %rdx
je 0x10dbb4
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10dbf8
callq 0x10d9d9
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10d245
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x22a5bb
movq 0x32a393(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7434(%rip), %rsi    # 0x2e5013
leaq 0x221f60(%rip), %rdx    # 0x32fb46
leaq 0x221f5d(%rip), %rcx    # 0x32fb4a
leaq 0x221eda(%rip), %r8     # 0x32face
pushq $0x4f
jmp 0x10dc20
movq 0x32a369(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d740a(%rip), %rsi    # 0x2e5013
leaq 0x1d75af(%rip), %rdx    # 0x2e51bf
leaq 0x221f33(%rip), %rcx    # 0x32fb4a
leaq 0x221eb0(%rip), %r8     # 0x32face
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x10dc7a
movq %rsi, %r14
testq %rsi, %rsi
je 0x10dc7a
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x10dc57
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10dca4
callq 0x10d9d9
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d245
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x10eaee
movq 0x32a2e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d7388(%rip), %rsi    # 0x2e5013
leaq 0x221ed7(%rip), %rdx    # 0x32fb69
leaq 0x221ed9(%rip), %rcx    # 0x32fb72
leaq 0x221e2e(%rip), %r8     # 0x32face
pushq $0x58
jmp 0x10dccc
movq 0x32a2bd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d735e(%rip), %rsi    # 0x2e5013
leaq 0x1d7503(%rip), %rdx    # 0x2e51bf
leaq 0x221eaf(%rip), %rcx    # 0x32fb72
leaq 0x221e04(%rip), %r8     # 0x32face
pushq $0x59
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390