LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_parser.c
// Function: delete_mRNAs
static int delete_mRNAs(GT_UNUSED void *key, void *value,
                        GT_UNUSED void *data, GT_UNUSED GtError *err)
{
  GtArray *gt_genome_node_array = (GtArray*) value;
  GtUword i;

  gt_assert(key && value);
  for (i = 0; i < gt_array_size(gt_genome_node_array); i++) {
    GtGenomeNode *gn = *(GtGenomeNode**) gt_array_get(gt_genome_node_array, i);
    gt_genome_node_delete(gn);
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x155cee
movq %rsi, %rbx
testq %rsi, %rsi
je 0x155cee
movq %rbx, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x155ce4
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x14c43a
incq %r14
movq %rbx, %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x155cc1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x47c35
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gt_gtf_visitor_class
const GtNodeVisitorClass* gt_gtf_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtGTFVisitor),
                                    gtf_visitor_free,
                                    gtf_visitor_comment_node,
                                    gtf_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x373a6e(%rip)    # 0x4c9770
jne 0x155d38
movq $0x0, (%rsp)
leaq 0x33(%rip), %rsi        # 0x155d46
leaq 0x60(%rip), %rdx        # 0x155d7a
leaq 0xb3(%rip), %rcx        # 0x155dd4
movl $0x38, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x373a38(%rip)    # 0x4c9770
callq 0xe6a19
movq 0x373a2c(%rip), %rax    # 0x4c9770
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_visitor_free
static void gtf_visitor_free(GtNodeVisitor *nv)
{
  GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv);
  gt_assert(gtf_visitor);
  gt_array_delete(gtf_visitor->exon_features);
  gt_array_delete(gtf_visitor->CDS_features);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x155cf4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
testq %rax, %rax
je 0x155d75
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0xd4ef4
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0xd4ef4
callq 0x47c6e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_visitor_comment_node
static int gtf_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *c,
                                    GT_UNUSED GtError *err)
{
  GtGTFVisitor *gtf_visitor;
  gt_error_check(err);
  gtf_visitor = gtf_visitor_cast(nv);
  gt_file_xprintf(gtf_visitor->outfp, "#%s\n", gt_comment_node_get_comment(c));
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x155d95
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x155dcf
callq 0x155cf4
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq 0x30(%rax), %r14
movq %rbx, %rdi
callq 0x3069d3
leaq 0x235469(%rip), %rsi    # 0x38b221
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x47ca5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_visitor_feature_node
static int gtf_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                    GtError *err)
{
  GtGTFVisitor *gtf_visitor;
  int had_err;
  gt_error_check(err);
  gtf_visitor = gtf_visitor_cast(nv);
  had_err = gt_feature_node_traverse_children(fn, gtf_visitor,
                                              gtf_show_feature_node, false,
                                              err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x155df3
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x155e1f
callq 0x155cf4
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
leaq 0x76(%rip), %rdx        # 0x155e80
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x149fca
callq 0x47cdc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gt_gtf_visitor_new
GtNodeVisitor* gt_gtf_visitor_new(GtFile *outfp)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_gtf_visitor_class());
  GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv);
  gtf_visitor->gene_id = 0;
  gtf_visitor->exon_features = gt_array_new(sizeof (GtGenomeNode*));
  gtf_visitor->CDS_features = gt_array_new(sizeof (GtGenomeNode*));
  gtf_visitor->outfp = outfp;
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x155cf4
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r14
callq 0x155cf4
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r15
movq $0x0, 0x10(%rax)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x20(%r15)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x28(%r15)
movq %rbx, 0x30(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_show_feature_node
static int gtf_show_feature_node(GtFeatureNode *fn, void *data, GtError *err)
{
  GtGTFVisitor *gtf_visitor = (GtGTFVisitor*) data;
  int had_err = 0;
  if (gt_feature_node_has_type(fn, gt_ft_gene)) {
      gtf_visitor->gene_id++;
      gtf_visitor->transcript_id = 0;
      had_err = gtf_show_transcript(fn, gtf_visitor, err);
  }
  else if (gt_feature_node_has_type(fn, gt_ft_mRNA)) {
    had_err = gtf_show_transcript(fn, gtf_visitor, err);
  }
  else if (!(gt_feature_node_has_type(fn, gt_ft_CDS) ||
             gt_feature_node_has_type(fn, gt_ft_exon))) {
      gt_warning("skipping GFF3 feature of type \"%s\" (from line %u in file "
                 "\"%s\")",
                 gt_feature_node_get_type(fn),
                 gt_genome_node_get_line_number((GtGenomeNode*) fn),
                 gt_genome_node_get_filename((GtGenomeNode*) fn));
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x290fb4(%rip), %rsi    # 0x3e6e4b
callq 0x149d45
testb %al, %al
je 0x155eae
incq 0x10(%r15)
movq $0x0, 0x18(%r15)
jmp 0x155ec1
leaq 0x22de41(%rip), %rsi    # 0x383cf6
movq %rbx, %rdi
callq 0x149d45
testb %al, %al
je 0x155ed6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x155f3c
leaq 0x2358ff(%rip), %rsi    # 0x38b7dc
movq %rbx, %rdi
callq 0x149d45
testb %al, %al
jne 0x155f2f
leaq 0x247d4e(%rip), %rsi    # 0x39dc3e
movq %rbx, %rdi
callq 0x149d45
testb %al, %al
jne 0x155f2f
movq %rbx, %rdi
callq 0x149bb2
movq %rax, %r14
movq %rbx, %rdi
callq 0x14b88c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x14b86c
leaq 0x235a2a(%rip), %rdi    # 0x38b94a
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x125448
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: save_exon_node
static int save_exon_node(GtFeatureNode *fn, void *data, GT_UNUSED GtError *err)
{
  GtGTFVisitor *gtf_visitor;
  gt_error_check(err);
  gt_assert(fn && data);
  gtf_visitor = (GtGTFVisitor*) data;
  if (gt_feature_node_has_type(fn, gt_ft_exon))
    gt_array_add(gtf_visitor->exon_features, fn);
  else if (gt_feature_node_has_type(fn, gt_ft_CDS))
    gt_array_add(gtf_visitor->CDS_features, fn);
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0x156110
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15616e
testq %rbx, %rbx
je 0x156169
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x156169
leaq 0x247b18(%rip), %rsi    # 0x39dc3e
callq 0x149d45
movl $0x20, %ecx
testb %al, %al
jne 0x15614e
movq 0x8(%rsp), %rdi
leaq 0x23569c(%rip), %rsi    # 0x38b7dc
callq 0x149d45
movl $0x28, %ecx
testb %al, %al
je 0x156161
movq (%rbx,%rcx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0xd49ce
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x47dba
callq 0x47d83
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_decoder_delete
void gt_hcr_decoder_delete(GtHcrDecoder *hcr_dec)
{
  if (hcr_dec != NULL) {
    hcr_seq_decoder_delete(hcr_dec->seq_dec);
    gt_encdesc_delete(hcr_dec->encdesc);
    gt_free(hcr_dec);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1567d6
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x157ed1
movq (%rbx), %rdi
callq 0x142ea2
leaq 0x235247(%rip), %rsi    # 0x38ba0f
movq %rbx, %rdi
movl $0x53d, %edx            # imm = 0x53D
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: reset_data_iterator_to_pos
static void reset_data_iterator_to_pos(HcrHuffDataIterator *data_iter,
                                       size_t pos)
{
  gt_assert(data_iter);
  gt_assert(pos < data_iter->end);
  gt_assert(data_iter->start <= pos);
  gt_fa_xmunmap(data_iter->data);
  data_iter->data = NULL;
  data_iter->pos = pos;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x156c87
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x156c8c
cmpq %rbx, 0x10(%r14)
ja 0x156c91
movq 0x8(%r14), %rdi
callq 0x102b12
movq $0x0, 0x8(%r14)
movq %rbx, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x48304
callq 0x48292
callq 0x482cb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_base_qual_distr_trim
static void hcr_base_qual_distr_trim(GtBaseQualDistr *bqd)
{
  if (bqd->min_qual != 0) {
    GtUint64 **distr_trimmed;
    unsigned nrows_new,
             i,
             j;

    nrows_new = bqd->max_qual - bqd->min_qual + 1;
    gt_array2dim_calloc(distr_trimmed, (GtUword) nrows_new, bqd->ncols);

    for (i = 0; i < nrows_new; i++)
      for (j = 0; j < bqd->ncols; j++)
        distr_trimmed[i][j] = bqd->distr[i + bqd->min_qual][j];
    gt_array2dim_delete(bqd->distr);
    bqd->distr = distr_trimmed;
    bqd->nrows = nrows_new;
    bqd->qual_offset = bqd->min_qual;
  }
}

// Assembly:
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0x157607
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r12d
subl %eax, %r12d
incl %r12d
leaq (,%r12,8), %rdi
leaq 0x2344da(%rip), %r15    # 0x38ba0f
movq %r15, %rsi
movl $0xa4, %edx
callq 0x1092b2
movq %rax, %r14
movl 0x10(%rbx), %edi
imulq %r12, %rdi
movl $0x8, %esi
movq %r15, %rdx
movl $0xa4, %ecx
callq 0x1093ef
movq %rax, (%r14)
cmpl $0x2, %r12d
jb 0x157588
movl 0x10(%rbx), %eax
shlq $0x3, %rax
movq (%r14), %rcx
addq %rax, %rcx
movl $0x1, %edx
movq %rcx, (%r14,%rdx,8)
incq %rdx
addq %rax, %rcx
cmpq %rdx, %r12
jne 0x157579
testl %r12d, %r12d
je 0x1575c5
movl 0x10(%rbx), %eax
movl %r12d, %ecx
xorl %edx, %edx
testq %rax, %rax
je 0x1575bd
movq (%rbx), %rsi
movl 0x1c(%rbx), %edi
addl %edx, %edi
movq (%rsi,%rdi,8), %rsi
movq (%r14,%rdx,8), %rdi
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movq %r9, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x1575ad
incq %rdx
cmpq %rcx, %rdx
jne 0x157595
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x23443d(%rip), %r15    # 0x38ba0f
movq %r15, %rsi
movl $0xa9, %edx
callq 0x109670
movq (%rbx), %rdi
movq %r15, %rsi
movl $0xa9, %edx
callq 0x109670
movq %r14, (%rbx)
movl %r12d, 0x14(%rbx)
movl 0x1c(%rbx), %eax
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_none
void gt_hcr_encoder_set_sampling_none(GtHcrEncoder *hcr_enc)
{
  gt_assert(hcr_enc);
  hcr_enc->page_sampling = hcr_enc->regular_sampling = false;
  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_none(hcr_enc->encdesc_encoder);
}

// Assembly:
testq %rdi, %rdi
je 0x157698
movw $0x0, 0x38(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x1417e6
retq
pushq %rax
callq 0x48577
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_regular
void gt_hcr_encoder_set_sampling_regular(GtHcrEncoder *hcr_enc)
{
  gt_assert(hcr_enc);
  hcr_enc->page_sampling = false;
  hcr_enc->regular_sampling = true;
  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_regular(hcr_enc->encdesc_encoder);
}

// Assembly:
testq %rdi, %rdi
je 0x1576b6
movw $0x100, 0x38(%rdi)      # imm = 0x100
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x1417f8
retq
pushq %rax
callq 0x485b0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_page
void gt_hcr_encoder_set_sampling_page(GtHcrEncoder *hcr_enc)
{
  gt_assert(hcr_enc);
  hcr_enc->page_sampling = true;
  hcr_enc->regular_sampling = false;
  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_page(hcr_enc->encdesc_encoder);
}

// Assembly:
testq %rdi, %rdi
je 0x1576d4
movw $0x1, 0x38(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x14180a
retq
pushq %rax
callq 0x485e9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_rate
void gt_hcr_encoder_set_sampling_rate(GtHcrEncoder *hcr_enc,
                                      GtUword srate)
{
  gt_assert(hcr_enc);
  hcr_enc->sampling_rate = srate;

  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_rate(hcr_enc->encdesc_encoder, srate);
}

// Assembly:
testq %rdi, %rdi
je 0x1576f0
movq %rsi, 0x28(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x14183a
retq
pushq %rax
callq 0x48622
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_delete
void gt_hcr_encoder_delete(GtHcrEncoder *hcr_enc)
{
  if (!hcr_enc)
    return;
  gt_huffman_delete(hcr_enc->seq_encoder->huffman);
  gt_sampling_delete(hcr_enc->seq_encoder->sampling);
  gt_free(hcr_enc->seq_encoder->fileinfos);
  gt_free(hcr_enc->seq_encoder);
  gt_encdesc_encoder_delete(hcr_enc->encdesc_encoder);
  gt_free(hcr_enc);
}

// Assembly:
testq %rdi, %rdi
je 0x157ed0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
callq 0x15bc80
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x1796f3
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x233b7c(%rip), %r14    # 0x38ba0f
movq %r14, %rsi
movl $0x532, %edx            # imm = 0x532
callq 0x109670
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x533, %edx            # imm = 0x533
callq 0x109670
movq (%rbx), %rdi
callq 0x143a77
movq %rbx, %rdi
movq %r14, %rsi
movl $0x535, %edx            # imm = 0x535
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_seq_decoder_delete
static void hcr_seq_decoder_delete(GtHcrSeqDecoder *seq_dec)
{
  if (seq_dec != NULL) {
    gt_free(seq_dec->fileinfos);
    gt_huffman_decoder_delete(seq_dec->huff_dec);
    gt_huffman_delete(seq_dec->huffman);
    gt_sampling_delete(seq_dec->sampling);
    gt_rbtree_delete(seq_dec->file_info_rbt);
    gt_str_delete(seq_dec->filename);
    data_iterator_delete(seq_dec->data_iter);
    gt_array_delete(seq_dec->symbols);
    gt_free(seq_dec);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x157f6a
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x233b23(%rip), %rsi    # 0x38ba0f
movl $0x2e6, %edx            # imm = 0x2E6
callq 0x109670
movq 0x28(%rbx), %rdi
callq 0x15c238
movq 0x20(%rbx), %rdi
callq 0x15bc80
movq 0x38(%rbx), %rdi
callq 0x1796f3
movq 0x30(%rbx), %rdi
callq 0x16df09
movq 0x40(%rbx), %rdi
callq 0x121b03
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x157f35
movq 0x8(%r14), %rdi
callq 0x102b12
leaq 0x233ad3(%rip), %r15    # 0x38ba0f
movq %r14, %rdi
movq %r15, %rsi
movl $0x2ab, %edx            # imm = 0x2AB
callq 0x109670
movq 0x10(%rbx), %rdi
callq 0xd4ef4
movq %rbx, %rdi
movq %r15, %rsi
movl $0x2ee, %edx            # imm = 0x2EE
popq %rbx
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: get_next_file_chunk_for_huffman
static int get_next_file_chunk_for_huffman(GtBitsequence **bits,
                                           GtUword *length,
                                           GtUword *offset,
                                           GtUword *pad_length,
                                           void *meminfo)
{
  const int empty = 0,
            success = 1;
  HcrHuffDataIterator *data_iter;
  gt_assert(meminfo);
  gt_assert(bits && length && offset && pad_length);
  data_iter = (HcrHuffDataIterator*) meminfo;

  if (data_iter->pos < data_iter->end) {
    gt_fa_xmunmap(data_iter->data);
    data_iter->data = NULL;
    data_iter->data = gt_fa_xmmap_read_range(data_iter->path,
                                        (size_t) data_iter->blocksize,
                                        data_iter->pos);
    data_iter->pos += data_iter->blocksize;
    if (data_iter->pos > data_iter->end) {
      gt_safe_assign(*length,
                    (data_iter->blocksize - (data_iter->pos - data_iter->end)));
      *length /= sizeof (GtBitsequence);
    }
    else
      *length = data_iter->bitseq_per_chunk;

    *offset = 0;
    *pad_length = 0;
    *bits = data_iter->data;
    return success;
  }
  gt_fa_xmunmap(data_iter->data);
  data_iter->data = NULL;
  *bits = NULL;
  *length = 0;
  *offset = 0;
  *pad_length = 0;
  return empty;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %r8, %r8
je 0x158076
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, (%rsp)
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x15807b
movq %r8, %r13
movq 0x8(%r8), %rdi
movq 0x20(%r8), %rbp
movq 0x18(%r8), %rbx
callq 0x102b12
movq $0x0, 0x8(%r13)
cmpq %rbx, %rbp
jae 0x158036
movq 0x40(%r13), %rsi
movq (%r13), %rdi
movq 0x20(%r13), %rdx
leaq 0x233a0d(%rip), %rcx    # 0x38ba0f
movl $0x27e, %r8d            # imm = 0x27E
callq 0x102a6a
movq %rax, 0x8(%r13)
movq 0x18(%r13), %rcx
movq 0x40(%r13), %rdx
movq 0x20(%r13), %rsi
addq %rdx, %rsi
movq %rsi, 0x20(%r13)
subq %rsi, %rcx
jae 0x15804b
addq %rdx, %rcx
movq %rcx, (%r12)
shrq $0x3, %rcx
jmp 0x15804f
xorl %eax, %eax
movq %rax, (%r15)
movq %rax, (%r12)
movq %rax, (%r14)
movq (%rsp), %rcx
movq %rax, (%rcx)
jmp 0x158067
movq 0x30(%r13), %rcx
movq %rcx, (%r12)
xorl %ecx, %ecx
movq %rcx, (%r14)
movq (%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, (%r15)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x48823
callq 0x487ea
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_huffman_write_base_qual_freq
static int hcr_huffman_write_base_qual_freq(GtUword symbol,
                                            GtUint64 freq,
                                            GT_UNUSED GtBitsequence code,
                                            GT_UNUSED unsigned code_length,
                                            void *pt)
{
  GtUchar base,
          qual;
  WriteNodeInfo *info = (WriteNodeInfo*)pt;

  gt_safe_assign(base, (symbol % gt_alphabet_size(info->alpha)));
  if (base == (GtUchar) gt_alphabet_size(info->alpha) - 1)
    base = (GtUchar) GT_WILDCARD;
  gt_safe_assign(base, (toupper(gt_alphabet_decode(info->alpha, base))));

  gt_xfwrite_one(&base, info->output);

  gt_safe_assign(qual,
                 (symbol / gt_alphabet_size(info->alpha) + info->qual_offset));

  gt_xfwrite_one(&qual, info->output);
  gt_xfwrite_one(&freq, info->output);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x8(%r8), %rdi
callq 0xd3724
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
cmpq $0xff, %rdx
ja 0x1581bd
movq %rdx, %r15
testq %rdx, %rdx
setne %al
testl %r15d, %r15d
setle %cl
testb %cl, %al
jne 0x1581bd
movb %r15b, 0x6(%rsp)
movq 0x8(%rbx), %rdi
callq 0xd3724
movzbl %al, %eax
decl %eax
cmpl %r15d, %eax
jne 0x15810e
movb $-0x2, 0x6(%rsp)
callq 0x170d0
movq (%rax), %r15
movq 0x8(%rbx), %rdi
movzbl 0x6(%rsp), %esi
callq 0xd3da7
movsbq %al, %rax
movl (%r15,%rax,4), %eax
cmpl $0xff, %eax
ja 0x1581c7
leaq 0x6(%rsp), %rdi
movb %al, (%rdi)
movq (%rbx), %rcx
movl $0x1, %esi
movl $0x1, %edx
callq 0x125658
movq 0x8(%rbx), %rdi
callq 0xd3724
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movl 0x10(%rbx), %ecx
addq %rax, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jae 0x1581c2
testq %rcx, %rcx
setne %al
testl %ecx, %ecx
setle %dl
testb %dl, %al
jne 0x1581c2
leaq 0x7(%rsp), %rdi
movb %cl, (%rdi)
movq (%rbx), %rcx
movl $0x1, %esi
movl $0x1, %edx
callq 0x125658
movq (%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x125658
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x48895
callq 0x488ef
callq 0x488c2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_write_seq
static GtUword hcr_write_seq(GtHcrSeqEncoder *seq_encoder,
                                   const GtUchar *seq,
                                   const GtUchar *qual,
                                   GtUword len,
                                   GtBitOutStream *bitstream,
                                   bool dry)
{
  unsigned bits_to_write,
           cur_char_code,
           cur_qual,
           symbol;
  GtUword i,
                written_bits = 0;
  GtBitsequence code;

  for (i = 0; i < len; i++) {
    cur_char_code = (unsigned) seq[i];

    if (cur_char_code == GT_WILDCARD)
      cur_char_code = gt_alphabet_size(seq_encoder->alpha) - 1;

    cur_qual = (unsigned) qual[i];

    if (seq_encoder->qrange.start != GT_UNDEF_UINT) {
      if (cur_qual <= seq_encoder->qrange.start)
        cur_qual = seq_encoder->qrange.start;
    }

    if (seq_encoder->qrange.end != GT_UNDEF_UINT) {
      if (cur_qual >= seq_encoder->qrange.end)
        cur_qual = seq_encoder->qrange.end;
    }

    cur_qual = cur_qual - seq_encoder->qual_offset;

    symbol = gt_alphabet_size(seq_encoder->alpha) * cur_qual + cur_char_code;
    gt_huffman_encode(seq_encoder->huffman, (GtUword) symbol,
                      &code, &bits_to_write);
    written_bits += bits_to_write;
    if (!dry) {
      gt_bitoutstream_append(bitstream, code, bits_to_write);
    }
  }
  return written_bits;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, (%rsp)
movq %r8, 0x8(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
testq %rcx, %rcx
je 0x1582a4
movq %rcx, %r15
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
movzbl (%rax,%r13), %ebx
cmpl $0xfe, %ebx
jne 0x158220
movq 0x10(%r14), %rdi
callq 0xd3724
movl %eax, %ebx
decl %ebx
movq 0x18(%rsp), %rax
movzbl (%rax,%r13), %eax
movl (%r14), %ecx
cmpl %eax, %ecx
movl %eax, %edx
cmoval %ecx, %edx
movl 0x4(%r14), %esi
cmpl $-0x1, %ecx
cmovel %eax, %edx
cmpl %esi, %edx
movl %esi, %r12d
cmovbl %edx, %r12d
cmpl $-0x1, %esi
cmovel %edx, %r12d
subl 0x48(%r14), %r12d
movq 0x10(%r14), %rdi
callq 0xd3724
imull %eax, %r12d
addl %ebx, %r12d
movq 0x18(%r14), %rdi
movq %r12, %rsi
leaq 0x20(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x15bdb3
movl 0x4(%rsp), %ebx
cmpb $0x0, (%rsp)
jne 0x158293
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdi
movl %ebx, %edx
callq 0x304beb
addq %rbx, %rbp
incq %r13
cmpq %r13, %r15
jne 0x158201
jmp 0x1582a6
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_new
GtHMM* gt_hmm_new(unsigned int num_of_states, unsigned int num_of_symbols)
{
  GtHMM *hmm;
  unsigned int i, j;

  gt_assert(num_of_states && num_of_symbols);

  /* alloc */
  hmm = gt_malloc(sizeof *hmm);
  hmm->initial_state_prob = gt_malloc(sizeof (double) * num_of_states);
  gt_array2dim_malloc(hmm->transition_prob, num_of_states, num_of_states);
  gt_array2dim_malloc(hmm->emission_prob, num_of_states, num_of_symbols);

  /* init */
  hmm->num_of_states = num_of_states;
  hmm->num_of_symbols = num_of_symbols;

  for (i = 0; i < num_of_states; i++)
    gt_hmm_set_initial_state_probability(hmm, i, 1.0 / num_of_states);

  for (i = 0; i < num_of_states; i++) {
    for (j = 0; j < num_of_states; j++)
      gt_hmm_set_transition_probability(hmm, i, j, 0.0);
  }

  for (i = 0; i < num_of_states; i++) {
    for (j = 0; j < num_of_symbols; j++)
      gt_hmm_set_emission_probability(hmm, i, j, 0.0);
  }

  return hmm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x158469
movl %esi, %ebx
testl %esi, %esi
je 0x158469
movl %edi, %ebp
leaq 0x233e7d(%rip), %r12    # 0x38c15b
movl $0x20, %edi
movq %r12, %rsi
movl $0x3c, %edx
callq 0x1092b2
movq %rax, %r14
movl %ebp, %r13d
leaq (,%r13,8), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x3d, %edx
callq 0x1092b2
movq %rax, 0x8(%r14)
movq %r15, %rdi
movq %r12, %rsi
movl $0x3e, %edx
callq 0x1092b2
movq %rax, 0x10(%r14)
movq %r15, %rdi
imulq %r13, %rdi
movq %r12, %rsi
movl $0x3e, %edx
callq 0x1092b2
movq 0x10(%r14), %rcx
movq %rax, (%rcx)
cmpl $0x2, %ebp
jb 0x158363
movl $0x1, %eax
movq 0x10(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rdx
addq %r15, %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x15834b
leaq 0x233df1(%rip), %rsi    # 0x38c15b
movq %r15, %rdi
movl $0x3f, %edx
callq 0x1092b2
movq %rax, 0x18(%r14)
movl %ebx, %r12d
imulq %r12, %r15
movq %r15, %rdi
leaq 0x233dcf(%rip), %rsi    # 0x38c15b
movl $0x3f, %edx
callq 0x1092b2
movq 0x18(%r14), %rcx
movq %rax, (%rcx)
cmpl $0x2, %ebp
jb 0x1583c3
movl $0x1, %eax
shlq $0x3, %r12
movq 0x18(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rdx
addq %r12, %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1583ab
movl %ebp, (%r14)
movl %ebx, 0x4(%r14)
cvtsi2sd %r13, %xmm0
movsd 0x1f6e51(%rip), %xmm1   # 0x34f228
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
cmpl $0x1, %ebp
adcl $0x0, %ebp
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
movsd (%rsp), %xmm0
callq 0x15846e
incl %r15d
cmpl %r15d, %ebp
jne 0x1583e9
xorl %r15d, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x1584d5
incl %r12d
cmpl %r12d, %ebp
jne 0x158407
incl %r15d
cmpl %ebp, %r15d
jne 0x158404
cmpl $0x1, %ebx
adcl $0x0, %ebx
xorl %r15d, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x15854c
incl %r12d
cmpl %r12d, %ebx
jne 0x158435
incl %r15d
cmpl %ebp, %r15d
jne 0x158432
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4891c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_set_initial_state_probability
void gt_hmm_set_initial_state_probability(GtHMM *hmm, unsigned int state_num,
                                       double probability)
{
  gt_assert(hmm);
  gt_assert(probability >= 0.0 && probability <= 1.0);
  gt_assert(state_num < hmm->num_of_states);
  if (probability == 0.0)
    hmm->initial_state_prob[state_num] = MINUSINFINITY;
  else
    hmm->initial_state_prob[state_num] = log(probability);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1584c6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1584cb
movsd 0x1f6d9f(%rip), %xmm1   # 0x34f228
ucomisd %xmm0, %xmm1
jb 0x1584cb
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jbe 0x1584d0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1584ae
jp 0x1584ae
movsd 0x233c74(%rip), %xmm0   # 0x38c120
jmp 0x1584b3
callq 0x17610
movq 0x8(%r14), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x489c1
callq 0x48953
callq 0x4898a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_set_transition_probability
void gt_hmm_set_transition_probability(GtHMM *hmm,
                                    unsigned int from_state_num,
                                    unsigned int to_state_num,
                                    double probability)
{
  gt_assert(hmm);
  gt_assert(probability >= 0.0 && probability <= 1.0);
  gt_assert(from_state_num < hmm->num_of_states);
  gt_assert(to_state_num < hmm->num_of_states);
  if (probability == 0.0)
    hmm->transition_prob[from_state_num][to_state_num] = MINUSINFINITY;
  else
    hmm->transition_prob[from_state_num][to_state_num] = log(probability);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x158538
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x15853d
movsd 0x1f6d38(%rip), %xmm1   # 0x34f228
ucomisd %xmm0, %xmm1
jb 0x15853d
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %eax
cmpl %esi, %eax
jbe 0x158542
movl %edx, %ebx
cmpl %edx, %eax
jbe 0x158547
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x15851d
jp 0x15851d
movsd 0x233c05(%rip), %xmm0   # 0x38c120
jmp 0x158522
callq 0x17610
movq 0x10(%r14), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x48a9d
callq 0x489f8
callq 0x48a2f
callq 0x48a66
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_set_emission_probability
void gt_hmm_set_emission_probability(GtHMM *hmm,
                                  unsigned int state_num,
                                  unsigned int symbol_num,
                                  double probability)
{
  gt_assert(hmm);
  gt_assert(probability >= 0.0 && probability <= 1.0);
  gt_assert(state_num < hmm->num_of_states);
  symbol_num = (symbol_num == GT_WILDCARD) ? hmm->num_of_symbols - 1
                                           : symbol_num;
  gt_assert(symbol_num < hmm->num_of_symbols);
  if (probability == 0.0)
    hmm->emission_prob[state_num][symbol_num] = MINUSINFINITY;
  else
    hmm->emission_prob[state_num][symbol_num] = log(probability);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1585bd
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1585c2
movsd 0x1f6cc1(%rip), %xmm1   # 0x34f228
ucomisd %xmm0, %xmm1
jb 0x1585c2
movl %esi, %ebp
movq %rdi, %r14
cmpl %esi, (%rdi)
jbe 0x1585c7
movl %edx, %ebx
cmpl $0xfe, %edx
jne 0x158586
movl 0x4(%r14), %ebx
decl %ebx
cmpl 0x4(%r14), %ebx
jae 0x1585cc
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1585a2
jp 0x1585a2
movsd 0x233b80(%rip), %xmm0   # 0x38c120
jmp 0x1585a7
callq 0x17610
movq 0x18(%r14), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x48b7f
callq 0x48ad4
callq 0x48b0d
callq 0x48b46
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_get_initial_state_probability
double gt_hmm_get_initial_state_probability(const GtHMM *hmm,
                                            unsigned int state_num)
{
  gt_assert(hmm);
  gt_assert(state_num < hmm->num_of_states);
  if (hmm->initial_state_prob[state_num] == MINUSINFINITY)
    return 0.0;
  return exp(hmm->initial_state_prob[state_num]);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1585fe
cmpl %esi, (%rdi)
jbe 0x158603
movq 0x8(%rdi), %rax
movl %esi, %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x233b32(%rip), %xmm0   # 0x38c120
jne 0x1585f8
jp 0x1585f8
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17e30
callq 0x48bef
callq 0x48bb8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_get_transition_probability
double gt_hmm_get_transition_probability(const GtHMM *hmm,
                                      unsigned int from_state_num,
                                      unsigned int to_state_num)
{
  gt_assert(hmm);
  gt_assert(from_state_num < hmm->num_of_states);
  gt_assert(to_state_num < hmm->num_of_states);
  if (hmm->transition_prob[from_state_num][to_state_num] == MINUSINFINITY)
    return 0.0;
  return exp(hmm->transition_prob[from_state_num][to_state_num]);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x158641
movl (%rdi), %eax
cmpl %esi, %eax
jbe 0x158646
cmpl %edx, %eax
jbe 0x15864b
movq 0x10(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x233aef(%rip), %xmm0   # 0x38c120
jne 0x15863b
jp 0x15863b
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17e30
callq 0x48c96
callq 0x48c26
callq 0x48c5d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_set_missing_transition_probabilities
void gt_hmm_set_missing_transition_probabilities(GtHMM *hmm)
{
  unsigned int row, column, num_of_missing_entries;
  double prob, sum_of_probabilities;

  gt_assert(hmm);

  for (row = 0; row < hmm->num_of_states; row++) {
    /* determine sum of probabilities */
    sum_of_probabilities = 0.0;
    num_of_missing_entries = 0;
    for (column = 0; column < hmm->num_of_states; column++) {
      prob = gt_hmm_get_transition_probability(hmm, row, column);
      if (prob == 0.0)
        num_of_missing_entries++;
      else
        sum_of_probabilities += prob;
    }

    /* set missing probabilites (equal distribution) */
    if (num_of_missing_entries) {
      for (column = 0; column < hmm->num_of_states; column++) {
        prob = gt_hmm_get_transition_probability(hmm, row, column);
        if (prob == 0.0) {
          gt_hmm_set_transition_probability(hmm, row, column,
                                         (1.0 - sum_of_probabilities) /
                                         num_of_missing_entries);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x158757
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x15874c
xorl %ebp, %ebp
cmpl $0x0, (%rbx)
movl $0x0, %r15d
xorpd %xmm2, %xmm2
je 0x1586e0
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x158608
movsd 0x8(%rsp), %xmm2
ucomisd 0x21c92b(%rip), %xmm0   # 0x374fe0
addsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
jne 0x1586c7
jp 0x1586c7
movsd 0x10(%rsp), %xmm2
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
subl %eax, %r15d
incl %r14d
movapd %xmm2, %xmm0
cmpl (%rbx), %r14d
jb 0x15868e
testl %r15d, %r15d
je 0x158742
cmpl $0x0, (%rbx)
je 0x158742
movsd 0x1f6b36(%rip), %xmm1   # 0x34f228
subsd %xmm2, %xmm1
movl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
xorl %r14d, %r14d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x158608
ucomisd 0x21c8bd(%rip), %xmm0   # 0x374fe0
jne 0x15873a
jp 0x15873a
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
movsd 0x8(%rsp), %xmm0
callq 0x1584d5
incl %r14d
cmpl (%rbx), %r14d
jb 0x15870e
incl %ebp
cmpl (%rbx), %ebp
jb 0x158671
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x48ccd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_get_emission_probability
double gt_hmm_get_emission_probability(const GtHMM *hmm,
                                    unsigned int state_num,
                                    unsigned int symbol_num)
{
  gt_assert(hmm);
  gt_assert(state_num < hmm->num_of_states);
  symbol_num = (symbol_num == GT_WILDCARD) ? hmm->num_of_symbols - 1
                                           : symbol_num;
  gt_assert(symbol_num < hmm->num_of_symbols);
  if (hmm->emission_prob[state_num][symbol_num] == MINUSINFINITY)
    return 0.0;
  return exp(hmm->emission_prob[state_num][symbol_num]);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1587a1
cmpl %esi, (%rdi)
jbe 0x1587a6
cmpl $0xfe, %edx
jne 0x158773
movl 0x4(%rdi), %edx
decl %edx
cmpl 0x4(%rdi), %edx
jae 0x1587ab
movq 0x18(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x23398f(%rip), %xmm0   # 0x38c120
jne 0x15879b
jp 0x15879b
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17e30
callq 0x48d78
callq 0x48d06
callq 0x48d3f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_is_valid
bool gt_hmm_is_valid(const GtHMM *hmm)
{
  gt_assert(hmm);
  return (gt_hmm_has_valid_initial_state_probs(hmm) &&
          gt_hmm_has_valid_emissions(hmm) &&
          gt_hmm_has_valid_states(hmm));

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1588e7
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x1587f8
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1585d1
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %ebp
cmpl (%rbx), %ebp
jb 0x1587ce
jmp 0x1587fc
xorpd %xmm0, %xmm0
callq 0x10ac0a
testb %al, %al
je 0x1588d4
cmpl $0x0, (%rbx)
sete %r15b
je 0x15886b
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpl $0x0, 0x4(%rbx)
je 0x158854
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x15875c
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %r14d
cmpl 0x4(%rbx), %r14d
jb 0x158824
jmp 0x158858
xorpd %xmm0, %xmm0
callq 0x10ac0a
testb %al, %al
je 0x15886b
incl %ebp
cmpl (%rbx), %ebp
setae %r15b
jb 0x158817
testb $0x1, %r15b
je 0x1588d4
cmpl $0x0, (%rbx)
sete %bpl
je 0x1588d6
xorl %r14d, %r14d
cmpl $0x0, (%rbx)
je 0x1588b9
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x158608
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %r15d
cmpl (%rbx), %r15d
jb 0x158889
jmp 0x1588bd
xorpd %xmm0, %xmm0
callq 0x10ac0a
testb %al, %al
je 0x1588d6
incl %r14d
cmpl (%rbx), %r14d
setae %bpl
jb 0x15887d
jmp 0x1588d6
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x48db1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_emit
void gt_hmm_emit(GtHMM *hmm, GtUword num_of_emissions,
              void (*proc_emission)(unsigned int symbol, void *data),
              void *data)
{
  GtUword i;
  unsigned int state, symbol, next_state;
  double random_value, cumulative_prob;
  gt_assert(hmm);

  /* determine initial state */
  random_value = gt_rand_0_to_1();
  cumulative_prob = 0.0;
  for (state = 0; state < hmm->num_of_states - 1; state++) {
    cumulative_prob += gt_hmm_get_initial_state_probability(hmm, state);
    if (cumulative_prob - random_value > DBL_EPSILON)
      break;
  }

  /* emit loop */
  for (i = 0; i < num_of_emissions; i++) {
    /* emit character */
    random_value = gt_rand_0_to_1();
    cumulative_prob = 0.0;
    for (symbol = 0; symbol < hmm->num_of_symbols - 1; symbol++) {
      cumulative_prob += gt_hmm_get_emission_probability(hmm, state, symbol);
      if (cumulative_prob - random_value > DBL_EPSILON)
        break;
    }
    if (proc_emission != NULL)
      proc_emission(symbol, data);
    /* go to next state */
    random_value = gt_rand_0_to_1();
    cumulative_prob = 0.0;
    for (next_state = 0; next_state < hmm->num_of_states - 1; next_state++) {
      cumulative_prob += gt_hmm_get_transition_probability(hmm,
                                                           state, next_state);
      if (cumulative_prob - random_value > DBL_EPSILON)
        break;
    }
    state = next_state;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
testq %rdi, %rdi
je 0x1593c1
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x10af04
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
cmpl $0x1, (%r12)
je 0x1592d9
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
callq 0x1585d1
addsd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%rsp), %xmm1
ucomisd 0x232e5d(%rip), %xmm1   # 0x38c128
ja 0x1592d9
incl %ebp
movl (%r12), %eax
decl %eax
cmpl %eax, %ebp
jb 0x1592a4
testq %r15, %r15
je 0x1593b2
xorl %ebx, %ebx
callq 0x10af04
movsd %xmm0, (%rsp)
cmpl $0x1, 0x4(%r12)
movl $0x0, %r13d
je 0x15933e
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x15875c
addsd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%rsp), %xmm1
ucomisd 0x232dfb(%rip), %xmm1   # 0x38c128
ja 0x15933e
incl %r13d
movl 0x4(%r12), %eax
decl %eax
cmpl %eax, %r13d
jb 0x159303
testq %r14, %r14
je 0x15934e
movl %r13d, %edi
movq 0x10(%rsp), %rsi
callq *%r14
callq 0x10af04
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
cmpl $0x1, (%r12)
je 0x1593a3
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x158608
addsd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%rsp), %xmm1
ucomisd 0x232d95(%rip), %xmm1   # 0x38c128
ja 0x1593a3
incl %r13d
movl (%r12), %eax
decl %eax
cmpl %eax, %r13d
jb 0x159369
incq %rbx
movl %r13d, %ebp
cmpq %r15, %rbx
jne 0x1592e4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x49141
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_show
void gt_hmm_show(const GtHMM *hmm, FILE *fp)
{
  unsigned int i, j;
  gt_assert(hmm && fp);
  fprintf(fp, "# of states: %u\n", hmm->num_of_states);
  fprintf(fp, "# of symbols: %u\n", hmm->num_of_symbols);
  fprintf(fp, "initial state probabilities:\n");
  for (i = 0; i < hmm->num_of_states; i++) {
    fprintf(fp, "%2u: %f", i, gt_hmm_get_initial_state_probability(hmm, i));
  }
  gt_xfputc('\n', fp);
  fprintf(fp, "transition probabilities:\n");
  for (i = 0; i < hmm->num_of_states; i++) {
    fprintf(fp, "%2u:", i);
    for (j = 0; j < hmm->num_of_states; j++) {
      fprintf(fp, " %.2f", gt_hmm_get_transition_probability(hmm, i, j));
    }
    gt_xfputc('\n', fp);
  }
  fprintf(fp, "emission probabilities:\n");
  for (i = 0; i < hmm->num_of_states; i++) {
    fprintf(fp, "%2u:", i);
    for (j = 0; j < hmm->num_of_symbols; j++) {
      fprintf(fp, " %.2f", gt_hmm_get_emission_probability(hmm, i, j));
    }
    gt_xfputc('\n', fp);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15970b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15970b
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x232ef3(%rip), %rsi    # 0x38c47f
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movl 0x4(%r14), %edx
leaq 0x232eed(%rip), %rsi    # 0x38c490
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
leaq 0x232eee(%rip), %rdi    # 0x38c4a2
movl $0x1d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
cmpl $0x0, (%r14)
je 0x1595f3
leaq 0x232eed(%rip), %r15    # 0x38c4c0
movq %r14, %rdi
movl %ebp, %esi
callq 0x1585d1
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movb $0x1, %al
callq 0x17ab0
incl %ebp
cmpl (%r14), %ebp
jb 0x1595d3
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1255d6
leaq 0x232ec1(%rip), %rdi    # 0x38c4c8
movl $0x1a, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
cmpl $0x0, (%r14)
je 0x15967d
leaq 0x232ebd(%rip), %r15    # 0x38c4e3
leaq 0x227023(%rip), %r12    # 0x380650
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17ab0
cmpl $0x0, (%r14)
je 0x159669
xorl %r13d, %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x158608
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x17ab0
incl %r13d
cmpl (%r14), %r13d
jb 0x159647
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1255d6
incl %ebp
cmpl (%r14), %ebp
jb 0x15962f
leaq 0x232e64(%rip), %rdi    # 0x38c4e8
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
cmpl $0x0, (%r14)
je 0x1596fc
leaq 0x232e40(%rip), %r15    # 0x38c4e3
leaq 0x226fa6(%rip), %r12    # 0x380650
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17ab0
cmpl $0x0, 0x4(%r14)
je 0x1596e8
xorl %r13d, %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x15875c
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x17ab0
incl %r13d
cmpl 0x4(%r14), %r13d
jb 0x1596c5
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1255d6
incl %ebp
cmpl (%r14), %ebp
jb 0x1596ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x49297
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_delete
void gt_hmm_delete(GtHMM *hmm)
{
  if (!hmm) return;
  gt_free(hmm->initial_state_prob);
  gt_array2dim_delete(hmm->transition_prob);
  gt_array2dim_delete(hmm->emission_prob);
  gt_free(hmm);
}

// Assembly:
testq %rdi, %rdi
je 0x159c43
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x232586(%rip), %r14    # 0x38c15b
movq %r14, %rsi
movl $0x2bf, %edx            # imm = 0x2BF
callq 0x109670
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
movl $0x2c0, %edx            # imm = 0x2C0
callq 0x109670
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x2c0, %edx            # imm = 0x2C0
callq 0x109670
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
movl $0x2c1, %edx            # imm = 0x2C1
callq 0x109670
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x2c1, %edx            # imm = 0x2C1
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2c2, %edx            # imm = 0x2C2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_new
GtHpolProcessor *gt_hpol_processor_new(GtEncseq *encseq, GtUword hmin)
{
  GtHpolProcessor *hpp;
  hpp = gt_malloc(sizeof (GtHpolProcessor));
  gt_assert(encseq != NULL);
  gt_assert(hmin > 0);
  hpp->encseq = encseq;
  hpp->hmin = hmin;
  hpp->read_hmin = 0;
  hpp->qmax = 0;
  hpp->mapqmin = 0;
  hpp->covmin = 0;
  hpp->allow_partial = false;
  hpp->allow_multiple = false;
  hpp->hdist = gt_disc_distri_new();
  hpp->nof_h = 0;
  hpp->hdist_e = gt_disc_distri_new();
  hpp->nof_h_e = 0;
  hpp->hlen_max = 0;
  hpp->cds_oracle = NULL;
  hpp->asp = NULL;
  hpp->nof_complete_edited = 0;
  hpp->nof_complete_not_edited = 0;
  hpp->nof_skipped = 0;
  hpp->nof_unmapped = 0;
  hpp->nof_multihits = 0;
  hpp->nof_replaced = 0;
  hpp->clenmax = GT_UNDEF_UWORD;
  hpp->altmax = (double) 1.0;
  hpp->refmin = (double) 0.0;
  hpp->alpha = gt_alphabet_new_dna();
  hpp->adjust_s_hlen = false;
  hpp->output_segments = false;
  hpp->outfp_segments = NULL;
  hpp->output_stats = false;
  hpp->output_multihit_stats = false;
  hpp->outfp_stats = NULL;
  hpp->processed_segments = NULL;
  hpp->reads_iters = NULL;
  hpp->outfiles = NULL;
  hpp->nfiles = 0;
  return hpp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x232d21(%rip), %rsi    # 0x38c979
movl $0x100, %edi            # imm = 0x100
movl $0x39, %edx
callq 0x1092b2
testq %r15, %r15
je 0x159d2c
testq %r14, %r14
je 0x159d31
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
xorl %ebp, %ebp
movw %bp, 0x38(%rax)
callq 0xe99dc
movq %rax, 0x50(%rbx)
movq $0x0, 0x90(%rbx)
callq 0xe99dc
movq %rax, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
movq $-0x1, 0x10(%rbx)
movsd 0x1f5547(%rip), %xmm0   # 0x34f228
movups %xmm0, 0x40(%rbx)
callq 0xd340f
movq %rax, 0xf0(%rbx)
movb %bpl, 0xb8(%rbx)
movw %bp, 0xf8(%rbx)
movb %bpl, 0xfa(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x49340
callq 0x49309