LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rbtree.c
// Function: move
static inline void *move(GtRBTreeIter *trav, int dir, GT_UNUSED bool strict)
{
  if (trav->it->link[dir] != NULL) {
    /* Continue down this branch */
    trav->path[trav->top++] = trav->it;
    trav->it = trav->it->link[dir];

    while (trav->it->link[(int) !dir] != NULL) {
      trav->path[trav->top++] = trav->it;
      trav->it = trav->it->link[(int) !dir];
    }
  } else {
    /* Move to the next branch */
    GtRBTreeNode *last;

    do {
      if (trav->top == 0) {
        trav->it = NULL;
        break;
      }

      last = trav->it;
      trav->it = trav->path[--trav->top];
    } while (last == trav->it->link[dir]);
  }

  return trav->it == NULL ? NULL : trav->it->key;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rsp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x1ba5c5
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rsi
movq 0x210(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x210(%rsi)
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, -0xc(%rsp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x1ba5c3
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rsi
movq 0x210(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x210(%rsi)
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, -0xc(%rsp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
movq 0x10(%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1ba544
jmp 0x1ba63c
jmp 0x1ba5c7
movq -0x8(%rsp), %rax
cmpq $0x0, 0x210(%rax)
jne 0x1ba5e5
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x1ba63a
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rdx
movq 0x210(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x210(%rdx)
movq 0x8(%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0xc(%rsp), %rdx
cmpq 0x10(%rcx,%rdx,8), %rax
je 0x1ba5c7
jmp 0x1ba63c
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1ba651
xorl %eax, %eax
movq %rax, -0x20(%rsp)
jmp 0x1ba663
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1ba719
movq 0x4818b8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x35b921(%rip), %rsi    # 0x516013
leaq 0x3a681a(%rip), %rdx    # 0x560f13
leaq 0x3a687f(%rip), %rcx    # 0x560f7f
leaq 0x3a6629(%rip), %r8     # 0x560d30
movl $0x338, %r9d            # imm = 0x338
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1ba71b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1ba740
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x1ba748
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x1ba748
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rbtree.c
// Function: nrbt_cmp_fn
static int nrbt_cmp_fn(const void* a, const void* b, GT_UNUSED void *info)
{
  GtUword va, vb;

  va = *(GtUword *) a;
  vb = *(GtUword *) b;

  if (va < vb) {
    return -1;
  }
  if (va > vb) {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x30(%rsp), %rax
jae 0x1bbb1f
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1bbb3d
movq -0x28(%rsp), %rax
cmpq -0x30(%rsp), %rax
jbe 0x1bbb35
movl $0x1, -0x4(%rsp)
jmp 0x1bbb3d
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x20, %edi
leaq 0x3a4cab(%rip), %rsi    # 0x560d30
movl $0x72, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_permuteintarray
static void gt_rbtree_permuteintarray (GtUword *arr)
{
  GtUword i, j, c;

  for (i = 0; i < (GtUword) GT_RBTREE_SIZE; ++i) {
    j = (GtUword) (random () % GT_RBTREE_SIZE);
    c = arr[i];
    arr[i] = arr[j];
    arr[j] = c;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x64, 0x18(%rsp)
jae 0x1bc167
callq 0x127e80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl $0x64, %ecx
cqto
idivq %rcx
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1bc0f2
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x486ce8(%rip), %rax    # 0x642e88
jbe 0x1bc1ae
movq 0x18(%rsp), %rax
movq %rax, 0x486cda(%rip)    # 0x642e88
cmpl $0x3, 0x24(%rsp)
je 0x1bc1bc
cmpl $0x0, 0x24(%rsp)
jne 0x1bc1eb
movq 0x486cb5(%rip), %rax    # 0x642e78
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rdx
movq 0x486ca0(%rip), %rax    # 0x642e80
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1bc224
movq 0x486c8e(%rip), %rax    # 0x642e80
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x18(%rsp), %rax
je 0x1bc222
movq 0x47fd2f(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
leaq 0x3a51f7(%rip), %rdi    # 0x56140a
callq 0x126bb0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1bc22c
jmp 0x1bc224
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_init_desc_encoding
static int gt_rcr_init_desc_encoding(GtRcrEncoder *rcr_enc,
                                     GtTimer *timer,
                                     GtError *err)
{
  int had_err = 0;
  if (timer != NULL)
    gt_timer_show_progress(timer, "init desc encoding",
                           stdout);

  rcr_enc->encdesc_enc = gt_encdesc_encoder_new();
  gt_encdesc_encoder_set_sampling_none(rcr_enc->encdesc_enc);
  rcr_enc->sam_iter =
    gt_samfile_iterator_new_bam(rcr_enc->samfilename,
                                gt_encseq_alphabet(rcr_enc->encseq),
                                err);
  if (rcr_enc->sam_iter == NULL)
    had_err = -1;
  if (!had_err) {
    rcr_enc->cstr_iterator = gt_sam_query_name_iterator_new(rcr_enc->sam_iter,
                                                            err);
    if (rcr_enc->cstr_iterator == NULL)
      had_err = -1;
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1bcd6e
movq 0x18(%rsp), %rdi
movq 0x47f1d9(%rip), %rax    # 0x63bf38
movq (%rax), %rdx
leaq 0x3a4a21(%rip), %rsi    # 0x56178a
callq 0x121930
callq 0x15eec0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x15efd0
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0xb0f00
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
callq 0x1cf9b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x1bcde5
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x0, 0xc(%rsp)
jne 0x1bce24
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1cf240
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1bce22
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1bce24
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x1bcf7e
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x1819e0
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x1819e0
movq (%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0xfdf10
movq (%rsp), %rax
cmpq $0x0, 0x90(%rax)
je 0x1bcee0
movq (%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x19ef0
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x19ef0
jmp 0x1bcee2
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xa5bf0
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x1cf910
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x48eb50
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x162fd0
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
leaq 0x3a4580(%rip), %rsi    # 0x5614df
movl $0x89a, %edx            # imm = 0x89A
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x3a456b(%rip), %rsi    # 0x5614df
movl $0x89b, %edx            # imm = 0x89B
callq 0xe88c0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_encoder_encode
int gt_rcr_encoder_encode(GtRcrEncoder *rcr_enc, const char *name,
                          GtTimer *timer, GtError *err)
{
  int had_err = 0;
  gt_assert(rcr_enc && name);
  gt_error_check(err);
  if (timer != NULL)
    gt_timer_show_progress(timer, "write encoding", stdout);
  rcr_enc->prev_readpos = 0;
  rcr_enc->cur_read = 0;
  had_err = rcr_write_data(name, rcr_enc, err);
  if (!had_err &&
      rcr_enc->encdesc_enc != NULL) {
    had_err = gt_encdesc_encoder_encode(rcr_enc->encdesc_enc,
                                        rcr_enc->cstr_iterator,
                                        name,
                                        err);
  }

  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1bcfb0
cmpq $0x0, 0x18(%rsp)
jne 0x1bcfe8
movq 0x47efe9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x359052(%rip), %rsi    # 0x516013
leaq 0x3a4578(%rip), %rdx    # 0x561540
leaq 0x3a4581(%rip), %rcx    # 0x561550
leaq 0x3a4509(%rip), %r8     # 0x5614df
movl $0x55e, %r9d            # imm = 0x55E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1bcfea
jmp 0x1bcfec
cmpq $0x0, 0x8(%rsp)
je 0x1bd03c
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1bd004
jmp 0x1bd03c
movq 0x47ef95(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x358ffe(%rip), %rsi    # 0x516013
leaq 0x3591a3(%rip), %rdx    # 0x5161bf
leaq 0x3a452d(%rip), %rcx    # 0x561550
leaq 0x3a44b5(%rip), %r8     # 0x5614df
movl $0x55f, %r9d            # imm = 0x55F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1bd03e
cmpq $0x0, 0x10(%rsp)
je 0x1bd061
movq 0x10(%rsp), %rdi
movq 0x47eee6(%rip), %rax    # 0x63bf38
movq (%rax), %rdx
leaq 0x3913aa(%rip), %rsi    # 0x54e406
callq 0x121930
movq 0x20(%rsp), %rax
movq $0x0, 0x1a8(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x180(%rax)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1bd0e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1bd0d1
movq 0x20(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1bd0d1
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x15f270
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_decoder_init
static GtRcrDecoder *gt_rcr_decoder_init(const char *name,
                                         const GtEncseq *ref,
                                         GtError *err)
{
  size_t alpha_size =
    (size_t) gt_alphabet_size(gt_encseq_alphabet(ref));
  GtRcrDecoder *rcr_dec = gt_malloc(sizeof (GtRcrDecoder));

  rcr_dec->basename = name;
  rcr_dec->inputname = gt_str_new_cstr(name);
  gt_str_append_cstr(rcr_dec->inputname,RCRFILESUFFIX);
  rcr_dec->encseq = ref;

  rcr_dec->encdesc = NULL;
  rcr_dec->qual_huff = NULL;
  rcr_dec->qual_mapping_huff = NULL;
  rcr_dec->readlenghts_huff = NULL;
  rcr_dec->readpos_golomb = NULL;
  rcr_dec->varpos_golomb = NULL;

  rcr_dec->ins_bases = gt_calloc(alpha_size + 1, sizeof (GtUint64));

  rcr_dec->fp = gt_fa_fopen(gt_str_get(rcr_dec->inputname),
                            "rb", err);
  if (rcr_dec->fp == NULL) {
    gt_rcr_decoder_delete(rcr_dec);
    return NULL;
  }
  return rcr_dec;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x7e920
movl %eax, %eax
movq %rax, 0x10(%rsp)
movl $0xe8, %edi
leaq 0x3a3e07(%rip), %rsi    # 0x5614df
movl $0x81f, %edx            # imm = 0x81F
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x28(%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x3a4091(%rip), %rsi    # 0x5617ac
callq 0x11d550
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
movl $0x8, %esi
leaq 0x3a3d4e(%rip), %rdx    # 0x5614df
movl $0x82d, %ecx            # imm = 0x82D
callq 0xe83c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x18(%rsp), %r8
leaq 0x3ba721(%rip), %rsi    # 0x577ee5
leaq 0x3a3d14(%rip), %rdx    # 0x5614df
movl $0x830, %ecx            # imm = 0x830
callq 0xd8df0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1bd800
movq 0x8(%rsp), %rdi
callq 0x1bf190
movq $0x0, 0x30(%rsp)
jmp 0x1bd80a
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_decoder_enable_description_support
int gt_rcr_decoder_enable_description_support(GtRcrDecoder *rcr_dec,
                                              GtError *err)
{
  gt_assert(rcr_dec != NULL);
  rcr_dec->encdesc = gt_encdesc_load(rcr_dec->basename, err);
  if (rcr_dec->encdesc == NULL)
    return -1;
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1be35d
movq 0x47dc74(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x357cdd(%rip), %rsi    # 0x516013
leaq 0x3a32c4(%rip), %rdx    # 0x561601
leaq 0x3a32cd(%rip), %rcx    # 0x561611
leaq 0x3a3194(%rip), %r8     # 0x5614df
movl $0x85b, %r9d            # imm = 0x85B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1be35f
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
movq (%rsp), %rsi
callq 0x161930
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1be393
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x1be39b
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_decoder_decode
int gt_rcr_decoder_decode(GtRcrDecoder *rcr_dec,
                          const char *name,
                          GtTimer *timer,
                          GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  gt_assert(rcr_dec && name);

  if (timer != NULL)
    gt_timer_show_progress(timer, "decode rcr", stdout);
  if (!had_err) {
    rcr_dec->fp = gt_fa_fopen_with_suffix(name, ".rcr.decoded", "w", err);
    if (rcr_dec->fp == NULL)
      had_err = -1;
  }
  if (!had_err)
    had_err = rcr_write_decoding_to_file(rcr_dec, err);

  gt_fa_xfclose(rcr_dec->fp);
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1be490
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1be458
jmp 0x1be490
movq 0x47db41(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x357baa(%rip), %rsi    # 0x516013
leaq 0x357d4f(%rip), %rdx    # 0x5161bf
leaq 0x3a31ef(%rip), %rcx    # 0x561666
leaq 0x3a3061(%rip), %r8     # 0x5614df
movl $0x86f, %r9d            # imm = 0x86F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1be492
jmp 0x1be494
cmpq $0x0, 0x20(%rsp)
je 0x1be4a4
cmpq $0x0, 0x18(%rsp)
jne 0x1be4dc
movq 0x47daf5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x357b5e(%rip), %rsi    # 0x516013
leaq 0x3a31c0(%rip), %rdx    # 0x56167c
leaq 0x3a31a3(%rip), %rcx    # 0x561666
leaq 0x3a3015(%rip), %r8     # 0x5614df
movl $0x870, %r9d            # imm = 0x870
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1be4de
cmpq $0x0, 0x10(%rsp)
je 0x1be501
movq 0x10(%rsp), %rdi
movq 0x47da46(%rip), %rax    # 0x63bf38
movq (%rax), %rdx
leaq 0x3a3190(%rip), %rsi    # 0x56168c
callq 0x121930
cmpl $0x0, 0x4(%rsp)
jne 0x1be552
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %r9
leaq 0x3a317e(%rip), %rsi    # 0x561697
leaq 0x3a79a5(%rip), %rdx    # 0x565ec5
leaq 0x3a2fb8(%rip), %rcx    # 0x5614df
movl $0x875, %r8d            # imm = 0x875
callq 0xd92c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1be550
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1be552
cmpl $0x0, 0x4(%rsp)
jne 0x1be56c
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1be590
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0xd9570
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x1bf243
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x192210
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1819e0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1819e0
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x161bb0
movq (%rsp), %rax
movq 0x60(%rax), %rdi
leaq 0x3a22bb(%rip), %rsi    # 0x5614df
movl $0x8af, %edx            # imm = 0x8AF
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x3a22a6(%rip), %rsi    # 0x5614df
movl $0x8b1, %edx            # imm = 0x8B1
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_bambase2char
static inline char rcr_bambase2char(uint8_t base)
{
  switch (base) {
    case BAMBASEA:
      return 'A';
    case BAMBASEC:
      return 'C';
    case BAMBASEG:
      return 'G';
    case BAMBASET:
      return 'T';
    case BAMBASEN:
    default:
      return 'N';
  }
}

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movzbl -0x2(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rsp)
subl $0xe, %eax
ja 0x1bff8d
movq -0x10(%rsp), %rax
leaq 0x3a14f2(%rip), %rcx    # 0x561458
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x41, -0x1(%rsp)
jmp 0x1bff92
movb $0x43, -0x1(%rsp)
jmp 0x1bff92
movb $0x47, -0x1(%rsp)
jmp 0x1bff92
movb $0x54, -0x1(%rsp)
jmp 0x1bff92
jmp 0x1bff8d
movb $0x4e, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x18, %edi
leaq 0x3a152a(%rip), %rsi    # 0x5614df
movl $0x2a9, %edx            # imm = 0x2A9
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $-0x1, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0xaa(%rip), %rsi        # 0x1c00a0
callq 0xa55e0
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0xc5(%rip), %rsi        # 0x1c00d0
callq 0xa55e0
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
leaq 0x3a14b7(%rip), %rsi    # 0x5614df
movl $0x2b0, %edx            # imm = 0x2B0
callq 0xe88c0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_get_m
static void rcr_get_m(GtUword key, GtUint64 value,
                      void *data)
{
  MedianData *md = (MedianData*) data;
  md->x = md->x + value;
  if (md->x > (md->n) / 2 && (md->median == GT_UNDEF_UWORD))
    md->median = key;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rsp), %rcx
movq (%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
jbe 0x1c0133
movq -0x20(%rsp), %rax
cmpq $-0x1, 0x10(%rax)
jne 0x1c0133
movq -0x8(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_write_node
static int rcr_write_node(GtUword symbol,
                          GtUint64 freq,
                          GT_UNUSED GtBitsequence code,
                          GT_UNUSED unsigned length,
                          void *pt)
{
  RcrData *data = (RcrData*) pt;
  if (fwrite(&symbol, sizeof (symbol), (size_t) 1, data->fp) == (size_t) 1)
    if (fwrite(&freq, sizeof (freq), (size_t) 1, data->fp) == (size_t) 1)
      return 0;
  return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq %r8, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rcx
leaq 0x28(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x19ea0
cmpq $0x1, %rax
jne 0x1c0e23
movq (%rsp), %rax
movq (%rax), %rcx
leaq 0x20(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x19ea0
cmpq $0x1, %rax
jne 0x1c0e21
movl $0x0, 0x34(%rsp)
jmp 0x1c0e2b
jmp 0x1c0e23
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_write_read_to_file
static void rcr_write_read_to_file(FILE *fp, uint8_t *seq, uint8_t *qual,
                                  const char *desc, GtUword seq_l)
{
  GtUword i,
                cur_width;
  gt_xfputc(DESCSEPSEQ, fp);
  gt_xfputs(desc, fp);
  gt_xfputc('\n', fp);

  for (i = 0, cur_width = 0; i < seq_l; i++, cur_width++) {
    if (cur_width == RCR_LINEWIDTH) {
      cur_width = 0;
      gt_xfputc('\n', fp);
    }
    gt_xfputc(rcr_bambase2char((uint8_t) bam1_seqi(seq, i)), fp);
  }
  gt_xfputc('\n', fp);
  gt_xfputc(DESCSEPQUAL, fp);
  gt_xfputc('\n', fp);

  for (i = 0, cur_width = 0; i < seq_l; i++, cur_width++) {
    if (cur_width == RCR_LINEWIDTH) {
      cur_width = 0;
      gt_xfputc('\n', fp);
    }
    gt_xfputc((int) qual[i] + PHREDOFFSET, fp);
  }
  gt_xfputc('\n', fp);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rsi
movl $0x40, %edi
callq 0x126b70
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x126bb0
movq 0x30(%rsp), %rsi
movl $0xa, %edi
callq 0x126b70
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x1c1fd4
cmpq $0x50, (%rsp)
jne 0x1c1f75
movq $0x0, (%rsp)
movq 0x30(%rsp), %rsi
movl $0xa, %edi
callq 0x126b70
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
shrq %rcx
movzbl (%rax,%rcx), %eax
movq 0x8(%rsp), %rdx
andq $0x1, %rdx
movl $0x1, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
sarl %cl, %eax
andl $0xf, %eax
movzbl %al, %edi
callq 0x1bff40
movsbl %al, %edi
movq 0x30(%rsp), %rsi
callq 0x126b70
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1c1f4b
movq 0x30(%rsp), %rsi
movl $0xa, %edi
callq 0x126b70
movq 0x30(%rsp), %rsi
movl $0x2b, %edi
callq 0x126b70
movq 0x30(%rsp), %rsi
movl $0xa, %edi
callq 0x126b70
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x1c2073
cmpq $0x50, (%rsp)
jne 0x1c203c
movq $0x0, (%rsp)
movq 0x30(%rsp), %rsi
movl $0xa, %edi
callq 0x126b70
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %edi
addl $0x21, %edi
movq 0x30(%rsp), %rsi
callq 0x126b70
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1c2012
movq 0x30(%rsp), %rsi
movl $0xa, %edi
callq 0x126b70
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x192440
movl 0x4(%rsp), %eax
movl %eax, %ecx
movq 0x20(%rsp), %rax
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
movl 0x4(%rsp), %eax
movl %eax, %ecx
movq 0x20(%rsp), %rax
addq 0x178(%rax), %rcx
movq %rcx, 0x178(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x489fa0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1813c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x8a9b0
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0x170(%rax), %rcx
movq %rcx, 0x170(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x48a070
movq 0x8(%rsp), %rdi
callq 0x8af40
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_elias_encode_write
static void rcr_elias_encode_write(GtRcrEncoder *rcr_enc,
                                   GtUword val)
{
  GtBittab *code = gt_elias_gamma_encode(val);
  GtUword size = gt_bittab_size(code);
  rcr_enc->all_bits += size;
  rcr_enc->dellen_bits += size;
  gt_bitoutstream_append_bittab(rcr_enc->bitstream, code);
  gt_bittab_delete(code);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x15e990
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8a9b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x48a070
movq 0x10(%rsp), %rdi
callq 0x8af40
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $0x0, 0x10(%rsp)
movb %al, 0x7(%rsp)
jne 0x1c2771
cmpl $0x0, 0xc(%rsp)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1c277e
jmp 0x1c280f
movq 0x28(%rsp), %rdi
leaq 0x17(%rsp), %rsi
callq 0x489d10
cmpl $0x1, %eax
je 0x1c27c0
movq 0x18(%rsp), %rdi
leaq 0x39f440(%rip), %rsi    # 0x561bde
movl $0x61a, %edx            # imm = 0x61A
leaq 0x39ed35(%rip), %rcx    # 0x5614df
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x1c27ca
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1c27ca
movl (%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x1c280a
movq 0x30(%rsp), %rdi
movb 0x17(%rsp), %al
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
andb $0x1, %al
movzbl %al, %esi
callq 0x192fd0
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x1c2808
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x1c280a
jmp 0x1c2758
movl 0x10(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $0x0, 0x10(%rsp)
movb %al, 0x7(%rsp)
jne 0x1c2861
cmpl $0x0, 0xc(%rsp)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1c286e
jmp 0x1c28fa
movq 0x28(%rsp), %rdi
leaq 0x17(%rsp), %rsi
callq 0x489d10
cmpl $0x1, %eax
je 0x1c28b0
movq 0x18(%rsp), %rdi
leaq 0x39f350(%rip), %rsi    # 0x561bde
movl $0x63f, %edx            # imm = 0x63F
leaq 0x39ec45(%rip), %rcx    # 0x5614df
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x1c28ba
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1c28ba
movl (%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x1c28f5
movq 0x30(%rsp), %rdi
movb 0x17(%rsp), %al
movq 0x20(%rsp), %rdx
andb $0x1, %al
movzbl %al, %esi
callq 0x181700
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x1c28f3
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x1c28f5
jmp 0x1c2848
movl 0x10(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
movb %al, 0x7(%rsp)
jne 0x1c295c
movq 0x8(%rsp), %rax
cmpq 0x30(%rsp), %rax
setb %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1c2966
jmp 0x1c29ac
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %rdx
callq 0x1c2730
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x1c29aa
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movsbl %al, %esi
callq 0x11da70
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1c293e
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_convert_cigar_string
static void rcr_convert_cigar_string(GtStr *cigar_str)
{
  GtUword i,
                cur_cigar_len = 1UL;
  char cur_cigar_op = gt_str_get(cigar_str)[0];
  GtStr *new_cigar_str = gt_str_new();

  for (i = 1UL; i < gt_str_length(cigar_str); i++) {
    if ((cur_cigar_op != gt_str_get(cigar_str)[i])) {
      gt_str_append_uword(new_cigar_str, cur_cigar_len);
      gt_str_append_char(new_cigar_str, cur_cigar_op);
      cur_cigar_op = gt_str_get(cigar_str)[i];
      cur_cigar_len = 1UL;
      if (i == gt_str_length(cigar_str) - 1) {
        gt_str_append_uword(new_cigar_str, cur_cigar_len);
        gt_str_append_char(new_cigar_str, cur_cigar_op);
      }
    }
    else if (i == gt_str_length(cigar_str) - 1) {
      gt_str_append_uword(new_cigar_str, ++cur_cigar_len);
      gt_str_append_char(new_cigar_str, cur_cigar_op);
    }
    else
      cur_cigar_len++;
  }
  gt_str_reset(cigar_str);
  gt_str_append_str(cigar_str, new_cigar_str);
  gt_str_delete(new_cigar_str);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11dee0
movb (%rax), %al
movb %al, 0x2f(%rsp)
callq 0x11d4a0
movq %rax, 0x20(%rsp)
movq $0x1, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11dfa0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1c30e8
movsbl 0x2f(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11dee0
movq %rax, %rcx
movl 0x14(%rsp), %eax
movq 0x38(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1c3077
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x11d930
movq 0x20(%rsp), %rdi
movsbl 0x2f(%rsp), %esi
callq 0x11da70
movq 0x40(%rsp), %rdi
callq 0x11dee0
movq 0x38(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x2f(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11dfa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1c3075
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x11d930
movq 0x20(%rsp), %rdi
movsbl 0x2f(%rsp), %esi
callq 0x11da70
jmp 0x1c30d3
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x11dfa0
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1c30c3
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rsp)
callq 0x11d930
movq 0x20(%rsp), %rdi
movsbl 0x2f(%rsp), %esi
callq 0x11da70
jmp 0x1c30d1
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1c30d3
jmp 0x1c30d5
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x1c2fa5
movq 0x40(%rsp), %rdi
callq 0x11e110
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11d750
movq 0x20(%rsp), %rdi
callq 0x11f560
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_delete_decode_info
static void rcr_delete_decode_info(RcrDecodeInfo *info)
{
  if (info != NULL) {
    gt_elias_gamma_bitwise_decoder_delete(info->del_len_ebwd);
    gt_golomb_bitwise_decoder_delete(info->varpos_gbwd);
    gt_huffman_bitwise_decoder_delete(info->base_hbwd);
    gt_huffman_bitwise_decoder_delete(info->cigar_hbwd);
    gt_huffman_bitwise_decoder_delete(info->qual_hbwd);
    gt_str_delete(info->base_string);
    gt_str_delete(info->cigar_string);
    gt_str_delete(info->qual_string);
    gt_free(info);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x1c3199
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x15ec60
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x181a00
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x193140
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x193140
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x193140
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq (%rsp), %rdi
leaq 0x39e350(%rip), %rsi    # 0x5614df
movl $0x716, %edx            # imm = 0x716
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x1c3257
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xaa4b0
movb %al, 0x17(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
movzbl 0x17(%rsp), %edi
callq 0x19dd0
movq (%rsp), %rdi
movsbl %al, %esi
callq 0x11da70
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rdi
movl $0x3d, %esi
callq 0x11da70
movq 0x30(%rsp), %rax
testb $0x1, 0xe1(%rax)
jne 0x1c3242
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdi
movl $0x2d, %esi
callq 0x11da70
jmp 0x1c3244
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1c31c2
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_decode_mismatch
static int rcr_decode_mismatch(GtRcrDecoder *rcr_dec, GtUword pos,
                               RcrDecodeInfo *info, GtBitInStream *bitstream,
                               GtError *err)
{
  bool bit;
  int had_err = 0;
  GtBitsequence coded = 0,
                first_bit = (GtBitsequence) 1 << 1,
                second_bit = (GtBitsequence) 1;
  GtUchar base,
          ref = gt_encseq_get_encoded_char(rcr_dec->encseq, pos,
                                           GT_READMODE_FORWARD);

  if (RCR_NEXT_BIT(bit)) {
    if (bit)
      coded = first_bit;
  }
  if (!had_err && RCR_NEXT_BIT(bit)) {
    if (bit)
      coded |= second_bit;

    base = rcr_transdecode(ref, coded, info->alphabet);

    gt_str_append_char(info->base_string,
                       toupper(gt_alphabet_decode(info->alphabet, base)));
  }
  return had_err;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x2, 0x28(%rsp)
movq $0x1, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x58(%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movb %al, 0x1e(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x3f(%rsp), %rsi
callq 0x489d10
cmpl $0x1, %eax
je 0x1c32fc
movq 0x40(%rsp), %rdi
leaq 0x39e905(%rip), %rsi    # 0x561bde
movl $0x671, %edx            # imm = 0x671
leaq 0x39e1fa(%rip), %rcx    # 0x5614df
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, 0x10(%rsp)
jmp 0x1c3307
movl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1c3307
movl 0x10(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x1c3329
testb $0x1, 0x3f(%rsp)
je 0x1c3327
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1c3329
cmpl $0x0, 0x38(%rsp)
jne 0x1c33f7
movq 0x48(%rsp), %rdi
leaq 0x3f(%rsp), %rsi
callq 0x489d10
cmpl $0x1, %eax
je 0x1c3377
movq 0x40(%rsp), %rdi
leaq 0x39e88a(%rip), %rsi    # 0x561bde
movl $0x675, %edx            # imm = 0x675
leaq 0x39e17f(%rip), %rcx    # 0x5614df
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x1c3382
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1c3382
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x1c33f7
testb $0x1, 0x3f(%rsp)
je 0x1c33a7
movq 0x20(%rsp), %rax
orq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movb 0x1e(%rsp), %al
movq 0x30(%rsp), %rsi
movq 0x50(%rsp), %rcx
movq (%rcx), %rdx
movzbl %al, %edi
callq 0x1c3740
movb %al, 0x1f(%rsp)
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movzbl 0x1f(%rsp), %esi
callq 0x7f7b0
movsbl %al, %edi
callq 0x19dd0
movq (%rsp), %rdi
movsbl %al, %esi
callq 0x11da70
movl 0x38(%rsp), %eax
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rcr.c
// Function: rcr_decode_mismatch_qual
static int rcr_decode_mismatch_qual(GtRcrDecoder *rcr_dec,
                                    GtBitInStream *bitstream,
                                    RcrDecodeInfo *info,
                                    GtError *err)
{
  int had_err = 0;
  GtUword symbol = 0;

  if (rcr_dec->store_var_qual) {
    had_err = rcr_huff_read(info->qual_hbwd, bitstream, &symbol, err);
    gt_str_append_char(info->qual_string, (char) symbol);
  }
  else {
    if (!rcr_dec->store_all_qual)
      gt_str_append_char(info->qual_string, DEFAULTQUAL);
  }
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0xe2(%rax)
je 0x1c3470
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x8(%rsp), %rdx
callq 0x1c2730
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rax
movsbl %al, %esi
callq 0x11da70
jmp 0x1c3493
movq 0x30(%rsp), %rax
testb $0x1, 0xe1(%rax)
jne 0x1c3491
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movl $0x2d, %esi
callq 0x11da70
jmp 0x1c3493
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)