LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xe93d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
testq %rax, %rax
je 0xe944c
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0x58eb9
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0x58eb9
movq 0x34eb15(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fbbb6(%rip), %rsi    # 0x2e5013
leaq 0x239592(%rip), %rdx    # 0x3229f6
leaq 0x2394ca(%rip), %rcx    # 0x322935
leaq 0x2394d4(%rip), %r8     # 0x322946
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xe949d
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xe94d7
callq 0xe93d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq 0x30(%rax), %r14
movq %rbx, %rdi
callq 0x299510
leaq 0x238db3(%rip), %rsi    # 0x322273
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8d432
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x34ea8a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fbb2b(%rip), %rsi    # 0x2e5013
leaq 0x1fbcd0(%rip), %rdx    # 0x2e51bf
leaq 0x23946b(%rip), %rcx    # 0x322961
leaq 0x239449(%rip), %r8     # 0x322946
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xe952c
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xe9558
callq 0xe93d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
leaq 0xaf(%rip), %rdx        # 0xe95f2
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0xdac92
movq 0x34ea09(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fbaaa(%rip), %rsi    # 0x2e5013
leaq 0x1fbc4f(%rip), %rdx    # 0x2e51bf
leaq 0x239403(%rip), %rcx    # 0x32297a
leaq 0x2393c8(%rip), %r8     # 0x322946
movl $0x97, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe93d0
movq %rax, %rdi
callq 0x102da0
movq %rax, %r14
callq 0xe93d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rax, %r15
andq $0x0, 0x10(%rax)
pushq $0x8
popq %r12
movq %r12, %rdi
callq 0x5809c
movq %rax, 0x20(%r15)
movq %r12, %rdi
callq 0x5809c
movq %rax, 0x28(%r15)
movq %rbx, 0x30(%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x294512(%rip), %rsi    # 0x37db1b
callq 0xda68b
testb %al, %al
je 0xe961d
incq 0x10(%r15)
andq $0x0, 0x18(%r15)
jmp 0xe9630
leaq 0x2316cb(%rip), %rsi    # 0x31acef
movq %rbx, %rdi
callq 0xda68b
testb %al, %al
je 0xe9645
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe96ab
leaq 0x2391d9(%rip), %rsi    # 0x322825
movq %rbx, %rdi
callq 0xda68b
testb %al, %al
jne 0xe969e
leaq 0x24b4a7(%rip), %rsi    # 0x334b06
movq %rbx, %rdi
callq 0xda68b
testb %al, %al
jne 0xe969e
movq %rbx, %rdi
callq 0xda338
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd108
movl %eax, %ebp
movq %rbx, %rdi
callq 0xdd0b5
leaq 0x239304(%rip), %rdi    # 0x322993
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb2cd0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rsp)
testq %rdx, %rdx
je 0xe98b6
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xe9930
testq %rbx, %rbx
je 0xe9906
testq %r14, %r14
je 0xe9906
leaq 0x24b23f(%rip), %rsi    # 0x334b06
movq %r14, %rdi
callq 0xda68b
testb %al, %al
je 0xe98d7
pushq $0x20
jmp 0xe98ec
leaq 0x238f47(%rip), %rsi    # 0x322825
movq %r14, %rdi
callq 0xda68b
testb %al, %al
je 0xe98fc
pushq $0x28
popq %rax
movq (%rbx,%rax), %rdi
movq %rsp, %rsi
pushq $0x8
popq %rdx
callq 0x5851d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x34e65b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fb6fc(%rip), %rsi    # 0x2e5013
leaq 0x23911c(%rip), %rdx    # 0x322a3a
leaq 0x239106(%rip), %rcx    # 0x322a2b
leaq 0x23901a(%rip), %r8     # 0x322946
pushq $0x40
jmp 0xe9958
movq 0x34e631(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fb6d2(%rip), %rsi    # 0x2e5013
leaq 0x1fb877(%rip), %rdx    # 0x2e51bf
leaq 0x2390dc(%rip), %rcx    # 0x322a2b
leaq 0x238ff0(%rip), %r8     # 0x322946
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xea17d
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xebd33
movq (%rbx), %rdi
callq 0xd2c7f
leaq 0x2388e9(%rip), %rsi    # 0x322a58
movq %rbx, %rdi
movl $0x53d, %edx            # imm = 0x53D
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xea760
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0xea78e
cmpq %rbx, 0x10(%r14)
ja 0xea7bc
movq 0x8(%r14), %rdi
callq 0x8b9fa
andq $0x0, 0x8(%r14)
movq %rbx, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x34d801(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fa8a2(%rip), %rsi    # 0x2e5013
leaq 0x2388cf(%rip), %rdx    # 0x323047
leaq 0x2388d2(%rip), %rcx    # 0x323051
leaq 0x2382d2(%rip), %r8     # 0x322a58
movl $0x299, %r9d            # imm = 0x299
jmp 0xea7e8
movq 0x34d7d3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fa874(%rip), %rsi    # 0x2e5013
leaq 0x2388c6(%rip), %rdx    # 0x32306c
leaq 0x2388a4(%rip), %rcx    # 0x323051
leaq 0x2382a4(%rip), %r8     # 0x322a58
movl $0x29a, %r9d            # imm = 0x29A
jmp 0xea7e8
movq 0x34d7a5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fa846(%rip), %rsi    # 0x2e5013
leaq 0x2388ad(%rip), %rdx    # 0x323081
leaq 0x238876(%rip), %rcx    # 0x323051
leaq 0x238276(%rip), %r8     # 0x322a58
movl $0x29b, %r9d            # imm = 0x29B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xeb27c
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 0x237898(%rip), %r15    # 0x322a58
movq %r15, %rsi
movl $0xa4, %edx
callq 0x93160
movq %rax, %r14
movl 0x10(%rbx), %edi
imulq %r12, %rdi
pushq $0x8
popq %rsi
movq %r15, %rdx
movl $0xa4, %ecx
callq 0x9334a
movq %rax, (%r14)
pushq $0x1
popq %rax
cmpq %r12, %rax
jae 0xeb207
movl 0x10(%rbx), %ecx
shlq $0x3, %rcx
addq -0x8(%r14,%rax,8), %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
jmp 0xeb1ed
xorl %eax, %eax
cmpq %r12, %rax
je 0xeb23a
movl 0x10(%rbx), %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xeb235
movq (%rbx), %rsi
movl 0x1c(%rbx), %edi
addl %eax, %edi
movq (%rsi,%rdi,8), %rsi
movq (%rsi,%rdx,8), %rsi
movq (%r14,%rax,8), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
jmp 0xeb213
incq %rax
jmp 0xeb209
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x237811(%rip), %r15    # 0x322a58
movq %r15, %rsi
movl $0xa9, %edx
callq 0x936f9
movq (%rbx), %rdi
movq %r15, %rsi
movl $0xa9, %edx
callq 0x936f9
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_O2/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 0xeb33f
andw $0x0, 0x38(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0xd12c2
retq
pushq %rax
movq 0x34cc21(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f9cc2(%rip), %rsi    # 0x2e5013
leaq 0x23799f(%rip), %rdx    # 0x322cf7
leaq 0x2379c1(%rip), %rcx    # 0x322d20
leaq 0x2376f2(%rip), %r8     # 0x322a58
movl $0x4d4, %r9d            # imm = 0x4D4
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xeb390
movw $0x100, 0x38(%rdi)      # imm = 0x100
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0xd1306
retq
pushq %rax
movq 0x34cbd0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f9c71(%rip), %rsi    # 0x2e5013
leaq 0x23794e(%rip), %rdx    # 0x322cf7
leaq 0x237991(%rip), %rcx    # 0x322d41
leaq 0x2376a1(%rip), %r8     # 0x322a58
movl $0x4dc, %r9d            # imm = 0x4DC
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xeb3e1
movw $0x1, 0x38(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0xd134b
retq
pushq %rax
movq 0x34cb7f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f9c20(%rip), %rsi    # 0x2e5013
leaq 0x2378fd(%rip), %rdx    # 0x322cf7
leaq 0x237964(%rip), %rcx    # 0x322d65
leaq 0x237650(%rip), %r8     # 0x322a58
movl $0x4e5, %r9d            # imm = 0x4E5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xeb430
movq %rsi, 0x28(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0xd1414
retq
pushq %rax
movq 0x34cb30(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f9bd1(%rip), %rsi    # 0x2e5013
leaq 0x2378ae(%rip), %rdx    # 0x322cf7
leaq 0x237936(%rip), %rcx    # 0x322d86
leaq 0x237601(%rip), %r8     # 0x322a58
movl $0x4ef, %r9d            # imm = 0x4EF
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xebd32
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
callq 0xf09fc
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x1148a7
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x236d63(%rip), %r14    # 0x322a58
movq %r14, %rsi
movl $0x532, %edx            # imm = 0x532
callq 0x936f9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x533, %edx            # imm = 0x533
callq 0x936f9
movq (%rbx), %rdi
callq 0xd38dc
movq %rbx, %rdi
movq %r14, %rsi
movl $0x535, %edx            # imm = 0x535
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xebdcc
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x236d0a(%rip), %rsi    # 0x322a58
movl $0x2e6, %edx            # imm = 0x2E6
callq 0x936f9
movq 0x28(%rbx), %rdi
callq 0xf120d
movq 0x20(%rbx), %rdi
callq 0xf09fc
movq 0x38(%rbx), %rdi
callq 0x1148a7
movq 0x30(%rbx), %rdi
callq 0x10660a
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0xebd97
movq 0x8(%r14), %rdi
callq 0x8b9fa
leaq 0x236cba(%rip), %r15    # 0x322a58
movq %r14, %rdi
movq %r15, %rsi
movl $0x2ab, %edx            # imm = 0x2AB
callq 0x936f9
movq 0x10(%rbx), %rdi
callq 0x58eb9
movq %rbx, %rdi
movq %r15, %rsi
movl $0x2ee, %edx            # imm = 0x2EE
popq %rbx
popq %r14
popq %r15
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x8(%r8), %rdi
callq 0x56cd2
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
cmpq $0xff, %rdx
ja 0xec085
movq %rdx, %r15
movq 0x8(%rbx), %rdi
callq 0x56cd2
movl $0xff, %r12d
andl %r12d, %eax
decl %eax
cmpl %r15d, %eax
movl $0xfe, %ebp
cmovnel %r15d, %ebp
callq 0x170c0
movq (%rax), %r15
movq 0x8(%rbx), %rdi
andl %r12d, %ebp
movl %ebp, %esi
callq 0x575cc
movsbq %al, %rax
movl (%r15,%rax,4), %eax
cmpl $0x100, %eax            # imm = 0x100
jae 0xec0a4
leaq 0x7(%rsp), %rdi
movb %al, (%rdi)
movq (%rbx), %rcx
pushq $0x1
popq %rdx
movq %rdx, %rsi
callq 0xb302c
movq 0x8(%rbx), %rdi
callq 0x56cd2
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movl 0x10(%rbx), %ecx
addq %rax, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jae 0xec0c3
leaq 0x6(%rsp), %rdi
movb %cl, (%rdi)
movq (%rbx), %rcx
pushq $0x1
popq %r14
movq %r14, %rsi
movq %r14, %rdx
callq 0xb302c
movq (%rbx), %rcx
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
movq %r14, %rdx
callq 0xb302c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x34bedc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fcd21(%rip), %rsi    # 0x2e8db7
leaq 0x2369bb(%rip), %rdx    # 0x322a58
movl $0x1dd, %ecx            # imm = 0x1DD
jmp 0xec0e0
movq 0x34bebd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fcd02(%rip), %rsi    # 0x2e8db7
leaq 0x23699c(%rip), %rdx    # 0x322a58
movl $0x1e0, %ecx            # imm = 0x1E0
jmp 0xec0e0
movq 0x34be9e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fcce3(%rip), %rsi    # 0x2e8db7
leaq 0x23697d(%rip), %rdx    # 0x322a58
movl $0x1e5, %ecx            # imm = 0x1E5
xorl %eax, %eax
callq 0x17a50
pushq $0x1
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpq %r13, %r15
je 0xec1c1
movq 0x10(%rsp), %rax
movzbl (%rax,%r13), %ebx
cmpl $0xfe, %ebx
jne 0xec144
movq 0x10(%rbp), %rdi
callq 0x56cd2
movl %eax, %ebx
decl %ebx
movq 0x18(%rsp), %rax
movzbl (%rax,%r13), %eax
movl (%rbp), %ecx
cmpl %eax, %ecx
movl %eax, %edx
cmoval %ecx, %edx
movl 0x4(%rbp), %esi
cmpl $-0x1, %ecx
cmovel %eax, %edx
cmpl %esi, %edx
movl %esi, %r12d
cmovbl %edx, %r12d
cmpl $-0x1, %esi
cmovel %edx, %r12d
subl 0x48(%rbp), %r12d
movq 0x10(%rbp), %rdi
callq 0x56cd2
imull %eax, %r12d
addl %ebx, %r12d
movq 0x18(%rbp), %rdi
movq %r12, %rsi
leaq 0x20(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0xf0b83
movl 0x4(%rsp), %ebx
cmpb $0x0, (%rsp)
jne 0xec1b6
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdi
movl %ebx, %edx
callq 0x2971ea
addq %rbx, %r14
incq %r13
jmp 0xec11c
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/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 0xec3fd
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xec427
movsd 0x1f9e6c(%rip), %xmm1   # 0x2e6228
ucomisd %xmm0, %xmm1
jb 0xec427
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jbe 0xec451
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xec3e5
jp 0xec3e5
movsd 0x236d85(%rip), %xmm0   # 0x323168
jmp 0xec3ea
callq 0x175e0
movq 0x8(%r14), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x34bb64(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8c05(%rip), %rsi    # 0x2e5013
leaq 0x1fcf53(%rip), %rdx    # 0x2e9368
leaq 0x236d9a(%rip), %rcx    # 0x3231b6
leaq 0x236d80(%rip), %r8     # 0x3231a3
pushq $0x58
jmp 0xec479
movq 0x34bb3a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8bdb(%rip), %rsi    # 0x2e5013
leaq 0x236d9c(%rip), %rdx    # 0x3231db
leaq 0x236d70(%rip), %rcx    # 0x3231b6
leaq 0x236d56(%rip), %r8     # 0x3231a3
pushq $0x59
jmp 0xec479
movq 0x34bb10(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8bb1(%rip), %rsi    # 0x2e5013
leaq 0x236de7(%rip), %rdx    # 0x323250
leaq 0x236d46(%rip), %rcx    # 0x3231b6
leaq 0x236d2c(%rip), %r8     # 0x3231a3
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xec4f6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xec520
movsd 0x1f9d82(%rip), %xmm1   # 0x2e6228
ucomisd %xmm0, %xmm1
jb 0xec520
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %eax
cmpl %esi, %eax
jbe 0xec54a
movl %edx, %ebx
cmpl %edx, %eax
jbe 0xec574
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xec4db
jp 0xec4db
movsd 0x236c8f(%rip), %xmm0   # 0x323168
jmp 0xec4e0
callq 0x175e0
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
movq 0x34ba6b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8b0c(%rip), %rsi    # 0x2e5013
leaq 0x1fce5a(%rip), %rdx    # 0x2e9368
leaq 0x236d14(%rip), %rcx    # 0x323229
leaq 0x236c87(%rip), %r8     # 0x3231a3
pushq $0x70
jmp 0xec59c
movq 0x34ba41(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8ae2(%rip), %rsi    # 0x2e5013
leaq 0x236ca3(%rip), %rdx    # 0x3231db
leaq 0x236cea(%rip), %rcx    # 0x323229
leaq 0x236c5d(%rip), %r8     # 0x3231a3
pushq $0x71
jmp 0xec59c
movq 0x34ba17(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8ab8(%rip), %rsi    # 0x2e5013
leaq 0x236ce9(%rip), %rdx    # 0x32324b
leaq 0x236cc0(%rip), %rcx    # 0x323229
leaq 0x236c33(%rip), %r8     # 0x3231a3
pushq $0x72
jmp 0xec59c
movq 0x34b9ed(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8a8e(%rip), %rsi    # 0x2e5013
leaq 0x236ce3(%rip), %rdx    # 0x32326f
leaq 0x236c96(%rip), %rcx    # 0x323229
leaq 0x236c09(%rip), %r8     # 0x3231a3
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xec629
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xec65a
movsd 0x1f9c5f(%rip), %xmm1   # 0x2e6228
ucomisd %xmm0, %xmm1
jb 0xec65a
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jbe 0xec688
movl 0x4(%r14), %eax
leal -0x1(%rax), %ebp
cmpl $0xfe, %edx
cmovnel %edx, %ebp
cmpl %eax, %ebp
jae 0xec6b6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xec60e
jp 0xec60e
movsd 0x236b5c(%rip), %xmm0   # 0x323168
jmp 0xec613
callq 0x175e0
movq 0x18(%r14), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
movl %ebp, %ecx
movsd %xmm0, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x34b938(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f89d9(%rip), %rsi    # 0x2e5013
leaq 0x1fcd27(%rip), %rdx    # 0x2e9368
leaq 0x236c97(%rip), %rcx    # 0x3232df
leaq 0x236b54(%rip), %r8     # 0x3231a3
movl $0xac, %r9d
jmp 0xec6e2
movq 0x34b907(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f89a8(%rip), %rsi    # 0x2e5013
leaq 0x236b69(%rip), %rdx    # 0x3231db
leaq 0x236c66(%rip), %rcx    # 0x3232df
leaq 0x236b23(%rip), %r8     # 0x3231a3
movl $0xad, %r9d
jmp 0xec6e2
movq 0x34b8d9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f897a(%rip), %rsi    # 0x2e5013
leaq 0x236bb0(%rip), %rdx    # 0x323250
leaq 0x236c38(%rip), %rcx    # 0x3232df
leaq 0x236af5(%rip), %r8     # 0x3231a3
movl $0xae, %r9d
jmp 0xec6e2
movq 0x34b8ab(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f894c(%rip), %rsi    # 0x2e5013
leaq 0x236c31(%rip), %rdx    # 0x3232ff
leaq 0x236c0a(%rip), %rcx    # 0x3232df
leaq 0x236ac7(%rip), %r8     # 0x3231a3
movl $0xb1, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xec71b
cmpl %esi, (%rdi)
jbe 0xec745
movq 0x8(%rdi), %rax
movl %esi, %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x236a5d(%rip), %xmm0   # 0x323168
jne 0xec715
jp 0xec715
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17da0
movq 0x34b846(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f88e7(%rip), %rsi    # 0x2e5013
leaq 0x1fcc35(%rip), %rdx    # 0x2e9368
leaq 0x236aca(%rip), %rcx    # 0x323204
leaq 0x236a62(%rip), %r8     # 0x3231a3
pushq $0x64
jmp 0xec76d
movq 0x34b81c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f88bd(%rip), %rsi    # 0x2e5013
leaq 0x236af3(%rip), %rdx    # 0x323250
leaq 0x236aa0(%rip), %rcx    # 0x323204
leaq 0x236a38(%rip), %r8     # 0x3231a3
pushq $0x65
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xec7b4
movl (%rdi), %eax
cmpl %esi, %eax
jbe 0xec7de
cmpl %edx, %eax
jbe 0xec80a
movq 0x10(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x2369c4(%rip), %xmm0   # 0x323168
jne 0xec7ae
jp 0xec7ae
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17da0
movq 0x34b7ad(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f884e(%rip), %rsi    # 0x2e5013
leaq 0x1fcb9c(%rip), %rdx    # 0x2e9368
leaq 0x236abe(%rip), %rcx    # 0x323291
leaq 0x2369c9(%rip), %r8     # 0x3231a3
pushq $0x7e
jmp 0xec806
movq 0x34b783(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f8824(%rip), %rsi    # 0x2e5013
leaq 0x236a55(%rip), %rdx    # 0x32324b
leaq 0x236a94(%rip), %rcx    # 0x323291
leaq 0x23699f(%rip), %r8     # 0x3231a3
pushq $0x7f
popq %r9
jmp 0xec836
movq 0x34b757(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f87f8(%rip), %rsi    # 0x2e5013
leaq 0x236a4d(%rip), %rdx    # 0x32326f
leaq 0x236a68(%rip), %rcx    # 0x323291
leaq 0x236973(%rip), %r8     # 0x3231a3
movl $0x80, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
testq %rdi, %rdi
je 0xec926
movq %rdi, %rbx
movl (%rdi), %eax
xorl %ebp, %ebp
cmpl %eax, %ebp
jae 0xec91b
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
xorl %r15d, %r15d
movsd %xmm1, (%rsp)
cmpl %eax, %r14d
jae 0xec8b7
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0xec77b
ucomisd 0x21f45e(%rip), %xmm0   # 0x30bce8
movsd (%rsp), %xmm2
movapd %xmm2, %xmm1
addsd %xmm0, %xmm1
jne 0xec89f
jp 0xec89f
movapd %xmm2, %xmm1
cmpeqsd 0x21f440(%rip), %xmm0   # 0x30bce8
movq %xmm0, %rax
subl %eax, %r15d
incl %r14d
movl (%rbx), %eax
jmp 0xec86b
testl %r15d, %r15d
je 0xec914
movsd 0x1f9964(%rip), %xmm1   # 0x2e6228
subsd (%rsp), %xmm1
movl %r15d, %ecx
cvtsi2sd %rcx, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
xorl %r14d, %r14d
cmpl %eax, %r14d
jae 0xec914
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0xec77b
ucomisd 0x21f3f1(%rip), %xmm0   # 0x30bce8
jne 0xec90d
jp 0xec90d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
movsd (%rsp), %xmm0
callq 0xec487
incl %r14d
movl (%rbx), %eax
jmp 0xec8dd
incl %ebp
jmp 0xec859
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x34b63b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f86dc(%rip), %rsi    # 0x2e5013
leaq 0x1fca2a(%rip), %rdx    # 0x2e9368
leaq 0x23696e(%rip), %rcx    # 0x3232b3
leaq 0x236857(%rip), %r8     # 0x3231a3
movl $0x8b, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xec9a8
cmpl %esi, (%rdi)
jbe 0xec9d6
movl 0x4(%rdi), %ecx
leal -0x1(%rcx), %eax
cmpl $0xfe, %edx
cmovnel %edx, %eax
cmpl %ecx, %eax
jae 0xeca04
movq 0x18(%rdi), %rcx
movl %esi, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
movsd (%rcx,%rax,8), %xmm0
ucomisd 0x2367d0(%rip), %xmm0   # 0x323168
jne 0xec9a2
jp 0xec9a2
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17da0
movq 0x34b5b9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f865a(%rip), %rsi    # 0x2e5013
leaq 0x1fc9a8(%rip), %rdx    # 0x2e9368
leaq 0x236959(%rip), %rcx    # 0x323320
leaq 0x2367d5(%rip), %r8     # 0x3231a3
movl $0xbc, %r9d
jmp 0xeca30
movq 0x34b58b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f862c(%rip), %rsi    # 0x2e5013
leaq 0x236862(%rip), %rdx    # 0x323250
leaq 0x23692b(%rip), %rcx    # 0x323320
leaq 0x2367a7(%rip), %r8     # 0x3231a3
movl $0xbd, %r9d
jmp 0xeca30
movq 0x34b55d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f85fe(%rip), %rsi    # 0x2e5013
leaq 0x2368e3(%rip), %rdx    # 0x3232ff
leaq 0x2368fd(%rip), %rcx    # 0x323320
leaq 0x236779(%rip), %r8     # 0x3231a3
movl $0xc0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xecb3d
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
cmpl (%rbx), %ebp
jae 0xeca7f
movq %rbx, %rdi
movl %ebp, %esi
movsd %xmm0, (%rsp)
callq 0xec6ee
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %ebp
jmp 0xeca55
callq 0x95536
xorl %ebp, %ebp
testb %al, %al
je 0xecb30
cmpl (%rbx), %ebp
jae 0xecad8
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
cmpl 0x4(%rbx), %r14d
jae 0xecac9
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
movsd %xmm0, (%rsp)
callq 0xec95e
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %r14d
jmp 0xeca99
callq 0x95536
incl %ebp
testb %al, %al
jne 0xeca8e
xorl %ebp, %ebp
jmp 0xecb30
xorl %r14d, %r14d
movl (%rbx), %eax
cmpl %eax, %r14d
setae %bpl
jae 0xecb2d
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
cmpl %eax, %r15d
jae 0xecb1f
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movsd %xmm0, (%rsp)
callq 0xec77b
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %r15d
movl (%rbx), %eax
jmp 0xecaed
callq 0x95536
incl %r14d
testb %al, %al
jne 0xecadb
jmp 0xecb30
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x34b424(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f84c5(%rip), %rsi    # 0x2e5013
leaq 0x1fc813(%rip), %rdx    # 0x2e9368
leaq 0x2367e4(%rip), %rcx    # 0x323340
leaq 0x236640(%rip), %r8     # 0x3231a3
movl $0xfc, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xee1dc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x235035(%rip), %r14    # 0x3231a3
movq %r14, %rsi
movl $0x2bf, %edx            # imm = 0x2BF
callq 0x936f9
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
movl $0x2c0, %edx            # imm = 0x2C0
callq 0x936f9
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x2c0, %edx            # imm = 0x2C0
callq 0x936f9
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
movl $0x2c1, %edx            # imm = 0x2C1
callq 0x936f9
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x2c1, %edx            # imm = 0x2C1
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2c2, %edx            # imm = 0x2C2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2357cf(%rip), %rsi    # 0x3239c1
pushq $0x39
popq %rdx
movl $0x100, %edi            # imm = 0x100
callq 0x93160
testq %r15, %r15
je 0xee2b9
testq %r14, %r14
je 0xee2e3
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
andw $0x0, 0x38(%rax)
callq 0x6d958
movq %rax, 0x50(%rbx)
andq $0x0, 0x90(%rbx)
callq 0x6d958
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)
orq $-0x1, 0x10(%rbx)
movsd 0x1f7fb6(%rip), %xmm0   # 0x2e6228
movups %xmm0, 0x40(%rbx)
callq 0x56967
movq %rax, 0xf0(%rbx)
xorl %eax, %eax
movb %al, 0xb8(%rbx)
andw $0x0, 0xf8(%rbx)
movb %al, 0xfa(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x349ca8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f6d49(%rip), %rsi    # 0x2e5013
leaq 0x251fe1(%rip), %rdx    # 0x3402b2
leaq 0x235707(%rip), %rcx    # 0x3239df
leaq 0x2356e2(%rip), %r8     # 0x3239c1
pushq $0x3a
jmp 0xee30b
movq 0x349c7e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f6d1f(%rip), %rsi    # 0x2e5013
leaq 0x2356fa(%rip), %rdx    # 0x3239f5
leaq 0x2356dd(%rip), %rcx    # 0x3239df
leaq 0x2356b8(%rip), %r8     # 0x3239c1
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_enable_aligned_segments_refregionscheck
void gt_hpol_processor_enable_aligned_segments_refregionscheck(
    GtHpolProcessor *hpp, GtAlignedSegmentsPile *asp)
{
  gt_assert(hpp != NULL);
  gt_assert(asp != NULL);
  gt_assert(hpp->asp == NULL);
  hpp->asp = asp;
  gt_aligned_segments_pile_register_process_complete(hpp->asp,
      gt_hpol_processor_refregioncheck, hpp);
  gt_aligned_segments_pile_register_process_skipped(hpp->asp,
      gt_hpol_processor_refregioncheck, hpp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xee3d5
testq %rsi, %rsi
je 0xee403
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
jne 0xee431
movq %rsi, 0x68(%rbx)
leaq 0xb8(%rip), %r14        # 0xee469
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb480e
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb4853
movq 0x349b8c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f6c2d(%rip), %rsi    # 0x2e5013
leaq 0x235611(%rip), %rdx    # 0x3239fe
leaq 0x23564d(%rip), %rcx    # 0x323a41
leaq 0x2355c6(%rip), %r8     # 0x3239c1
movl $0x126, %r9d            # imm = 0x126
jmp 0xee45d
movq 0x349b5e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f6bff(%rip), %rsi    # 0x2e5013
leaq 0x2268ae(%rip), %rdx    # 0x314cc9
leaq 0x23561f(%rip), %rcx    # 0x323a41
leaq 0x235598(%rip), %r8     # 0x3239c1
movl $0x127, %r9d            # imm = 0x127
jmp 0xee45d
movq 0x349b30(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f6bd1(%rip), %rsi    # 0x2e5013
leaq 0x235632(%rip), %rdx    # 0x323a7b
leaq 0x2355f1(%rip), %rcx    # 0x323a41
leaq 0x23556a(%rip), %r8     # 0x3239c1
movl $0x128, %r9d            # imm = 0x128
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_enable_segments_hlen_adjustment
void gt_hpol_processor_enable_segments_hlen_adjustment(GtHpolProcessor *hpp,
    GtAlignedSegmentsPile *asp, GtUword read_hmin, GtUword qmax,
    double altmax, double refmin, GtUword mapqmin, GtUword covmin,
    bool allow_partial, bool allow_multiple, GtUword clenmax)
{
  gt_assert(hpp != NULL);
  gt_assert(asp != NULL);
  gt_assert(hpp->asp == NULL);
  hpp->adjust_s_hlen = true;
  hpp->asp = asp;
  hpp->read_hmin = read_hmin;
  hpp->qmax = qmax;
  hpp->altmax = altmax;
  hpp->refmin = refmin;
  hpp->mapqmin = mapqmin;
  hpp->covmin = covmin;
  hpp->allow_partial = allow_partial;
  hpp->allow_multiple = allow_multiple;
  hpp->clenmax = clenmax;
  gt_aligned_segments_pile_register_process_complete(hpp->asp,
      gt_hpol_processor_process_complete_segment, hpp);
  gt_aligned_segments_pile_register_process_skipped(hpp->asp,
      gt_hpol_processor_process_skipped_segment, hpp);
  gt_aligned_segments_pile_register_process_unmapped(hpp->asp,
      gt_hpol_processor_process_unmapped_segment, hpp);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xee6e0
testq %rsi, %rsi
je 0xee70e
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
jne 0xee73c
movq 0x20(%rsp), %rax
movb 0x18(%rsp), %dil
movb 0x10(%rsp), %r10b
movb $0x1, 0xb8(%rbx)
movq %rsi, 0x68(%rbx)
movq %rdx, 0x18(%rbx)
movq %rcx, 0x30(%rbx)
movsd %xmm0, 0x40(%rbx)
movsd %xmm1, 0x48(%rbx)
movq %r8, 0x20(%rbx)
movq %r9, 0x28(%rbx)
movb %r10b, 0x38(%rbx)
movb %dil, 0x39(%rbx)
movq %rax, 0x10(%rbx)
leaq 0xc9(%rip), %rax        # 0xee774
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xb480e
movq 0x68(%rbx), %rdi
leaq 0x1ed(%rip), %rsi       # 0xee8b1
movq %rbx, %rdx
callq 0xb4853
movq 0x68(%rbx), %rdi
leaq 0x2b0(%rip), %rsi       # 0xee987
movq %rbx, %rdx
popq %rbx
jmp 0xb4898
movq 0x349881(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f6922(%rip), %rsi    # 0x2e5013
leaq 0x235306(%rip), %rdx    # 0x3239fe
leaq 0x23538d(%rip), %rcx    # 0x323a8c
leaq 0x2352bb(%rip), %r8     # 0x3239c1
movl $0x135, %r9d            # imm = 0x135
jmp 0xee768
movq 0x349853(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f68f4(%rip), %rsi    # 0x2e5013
leaq 0x2265a3(%rip), %rdx    # 0x314cc9
leaq 0x23535f(%rip), %rcx    # 0x323a8c
leaq 0x23528d(%rip), %r8     # 0x3239c1
movl $0x136, %r9d            # imm = 0x136
jmp 0xee768
movq 0x349825(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1f68c6(%rip), %rsi    # 0x2e5013
leaq 0x235327(%rip), %rdx    # 0x323a7b
leaq 0x235331(%rip), %rcx    # 0x323a8c
leaq 0x23525f(%rip), %r8     # 0x3239c1
movl $0x137, %r9d            # imm = 0x137
xorl %eax, %eax
callq 0x17a50
callq 0x17390