LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xd11cf
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
cmpq $0xff, %rdx
ja 0x150868
movq %rdx, %r15
movq 0x8(%rbx), %rdi
callq 0xd11cf
movl $0xff, %r12d
andl %r12d, %eax
decl %eax
cmpl %r15d, %eax
movl $0xfe, %ebp
cmovnel %r15d, %ebp
callq 0x170d0
movq (%rax), %r15
movq 0x8(%rbx), %rdi
andl %r12d, %ebp
movl %ebp, %esi
callq 0xd187b
movsbq %al, %rax
movl (%r15,%rax,4), %eax
cmpl $0x100, %eax            # imm = 0x100
jae 0x15086d
leaq 0x7(%rsp), %rdi
movb %al, (%rdi)
movq (%rbx), %rcx
movl $0x1, %esi
movl $0x1, %edx
callq 0x11f89c
movq 0x8(%rbx), %rdi
callq 0xd11cf
movl %eax, %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movl 0x10(%rbx), %ecx
addq %rax, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jae 0x150872
leaq 0x6(%rsp), %rdi
movb %cl, (%rdi)
movq (%rbx), %rcx
movl $0x1, %esi
movl $0x1, %edx
callq 0x11f89c
movq (%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x11f89c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x47a21
callq 0x47a4e
callq 0x47a7b
// File: /workspace/github_c_makefile_star2_O3/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 0x15094f
movq %rcx, %r15
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
movzbl (%rax,%r13), %ebx
cmpl $0xfe, %ebx
jne 0x1508cb
movq 0x10(%r14), %rdi
callq 0xd11cf
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 0xd11cf
imull %eax, %r12d
addl %ebx, %r12d
movq 0x18(%r14), %rdi
movq %r12, %rsi
leaq 0x20(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x1544f4
movl 0x4(%rsp), %ebx
cmpb $0x0, (%rsp)
jne 0x15093e
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdi
movl %ebx, %edx
callq 0x2faf4f
addq %rbx, %rbp
incq %r13
cmpq %r13, %r15
jne 0x1508ac
jmp 0x150951
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/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 0x150b09
movl %esi, %ebx
testl %esi, %esi
je 0x150b09
movl %edi, %ebp
leaq 0x232411(%rip), %r12    # 0x382d9b
movl $0x20, %edi
movq %r12, %rsi
movl $0x3c, %edx
callq 0x104226
movq %rax, %r14
movl %ebp, %r13d
leaq (,%r13,8), %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x3d, %edx
callq 0x104226
movq %rax, 0x8(%r14)
movq %r15, %rdi
movq %r12, %rsi
movl $0x3e, %edx
callq 0x104226
movq %rax, 0x10(%r14)
movq %r15, %rdi
imulq %r13, %rdi
movq %r12, %rsi
movl $0x3e, %edx
callq 0x104226
movq 0x10(%r14), %rcx
movq %rax, (%rcx)
cmpl $0x2, %ebp
jb 0x150a0f
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 0x1509f7
leaq 0x232385(%rip), %rsi    # 0x382d9b
movq %r15, %rdi
movl $0x3f, %edx
callq 0x104226
movq %rax, 0x18(%r14)
movl %ebx, %r12d
imulq %r12, %r15
movq %r15, %rdi
leaq 0x232363(%rip), %rsi    # 0x382d9b
movl $0x3f, %edx
callq 0x104226
movq 0x18(%r14), %rcx
movq %rax, (%rcx)
cmpl $0x2, %ebp
jb 0x150a6f
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 0x150a57
movl %ebp, (%r14)
cvtsi2sd %r13, %xmm0
movl %ebx, 0x4(%r14)
movsd 0x1f57a5(%rip), %xmm1   # 0x346228
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
movsd (%rsp), %xmm0
callq 0x150b0e
incl %r15d
cmpl %r15d, %ebp
jne 0x150a8f
xorl %r15d, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x150b75
incl %r12d
cmpl %r12d, %ebp
jne 0x150aad
incl %r15d
cmpl %ebp, %r15d
jne 0x150aaa
xorl %r15d, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x150bec
incl %r12d
cmpl %r12d, %ebx
jne 0x150ad5
incl %r15d
cmpl %ebp, %r15d
jne 0x150ad2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x47aa8
// File: /workspace/github_c_makefile_star2_O3/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 0x150b66
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x150b6b
movsd 0x1f56ff(%rip), %xmm1   # 0x346228
ucomisd %xmm0, %xmm1
jb 0x150b6b
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jbe 0x150b70
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x150b4e
jp 0x150b4e
movsd 0x232214(%rip), %xmm0   # 0x382d60
jmp 0x150b53
callq 0x17610
movq 0x8(%r14), %rax
movl %ebx, %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x47b4d
callq 0x47adf
callq 0x47b16
// File: /workspace/github_c_makefile_star2_O3/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 0x150bd8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x150bdd
movsd 0x1f5698(%rip), %xmm1   # 0x346228
ucomisd %xmm0, %xmm1
jb 0x150bdd
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %eax
cmpl %esi, %eax
jbe 0x150be2
movl %edx, %ebx
cmpl %edx, %eax
jbe 0x150be7
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x150bbd
jp 0x150bbd
movsd 0x2321a5(%rip), %xmm0   # 0x382d60
jmp 0x150bc2
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 0x47c29
callq 0x47b84
callq 0x47bbb
callq 0x47bf2
// File: /workspace/github_c_makefile_star2_O3/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 0x150c5b
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x150c60
movsd 0x1f5621(%rip), %xmm1   # 0x346228
ucomisd %xmm0, %xmm1
jb 0x150c60
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jbe 0x150c65
movl 0x4(%r14), %eax
leal -0x1(%rax), %ebp
cmpl $0xfe, %edx
cmovnel %edx, %ebp
cmpl %eax, %ebp
jae 0x150c6a
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x150c40
jp 0x150c40
movsd 0x232122(%rip), %xmm0   # 0x382d60
jmp 0x150c45
callq 0x17610
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
callq 0x47d0b
callq 0x47c60
callq 0x47c99
callq 0x47cd2
// File: /workspace/github_c_makefile_star2_O3/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 0x150c9c
cmpl %esi, (%rdi)
jbe 0x150ca1
movq 0x8(%rdi), %rax
movl %esi, %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x2320d4(%rip), %xmm0   # 0x382d60
jne 0x150c96
jp 0x150c96
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17e30
callq 0x47d7b
callq 0x47d44
// File: /workspace/github_c_makefile_star2_O3/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 0x150cdf
movl (%rdi), %eax
cmpl %esi, %eax
jbe 0x150ce4
cmpl %edx, %eax
jbe 0x150ce9
movq 0x10(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x232091(%rip), %xmm0   # 0x382d60
jne 0x150cd9
jp 0x150cd9
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17e30
callq 0x47e22
callq 0x47db2
callq 0x47de9
// File: /workspace/github_c_makefile_star2_O3/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 0x150ddc
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x150dd1
xorl %ebp, %ebp
xorps %xmm2, %xmm2
xorl %r15d, %r15d
xorl %r14d, %r14d
movsd %xmm2, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x150ca6
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
addsd %xmm0, %xmm2
jne 0x150d4d
jp 0x150d4d
movsd 0x10(%rsp), %xmm2
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
subl %eax, %r15d
incl %r14d
movl (%rbx), %eax
cmpl %eax, %r14d
jb 0x150d18
testl %r15d, %r15d
je 0x150dc7
testl %eax, %eax
je 0x150dd1
movsd 0x1f54b3(%rip), %xmm1   # 0x346228
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 0x150ca6
ucomisd 0x21afea(%rip), %xmm0   # 0x36bd90
jne 0x150dbd
jp 0x150dbd
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
movsd 0x8(%rsp), %xmm0
callq 0x150b75
incl %r14d
movl (%rbx), %eax
cmpl %eax, %r14d
jb 0x150d91
incl %ebp
cmpl %eax, %ebp
jb 0x150d0f
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x47e59
// File: /workspace/github_c_makefile_star2_O3/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 0x150e27
cmpl %esi, (%rdi)
jbe 0x150e2c
movl 0x4(%rdi), %ecx
leal -0x1(%rcx), %eax
cmpl $0xfe, %edx
cmovnel %edx, %eax
cmpl %ecx, %eax
jae 0x150e31
movq 0x18(%rdi), %rcx
movl %esi, %edx
movq (%rcx,%rdx,8), %rcx
movl %eax, %eax
movsd (%rcx,%rax,8), %xmm0
ucomisd 0x231f49(%rip), %xmm0   # 0x382d60
jne 0x150e21
jp 0x150e21
xorpd %xmm0, %xmm0
popq %rax
retq
popq %rax
jmp 0x17e30
callq 0x47f04
callq 0x47e92
callq 0x47ecb
// File: /workspace/github_c_makefile_star2_O3/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 0x150f4f
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x150e7e
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x150c6f
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %ebp
cmpl (%rbx), %ebp
jb 0x150e54
jmp 0x150e82
xorpd %xmm0, %xmm0
callq 0x105b4e
testb %al, %al
je 0x150f40
movb $0x1, %bpl
cmpl $0x0, (%rbx)
je 0x150f42
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rbx)
je 0x150edc
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x150de1
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %r15d
cmpl 0x4(%rbx), %r15d
jb 0x150eab
jmp 0x150ee0
xorpd %xmm0, %xmm0
callq 0x105b4e
testb %al, %al
je 0x150f40
incl %r14d
movl (%rbx), %eax
cmpl %eax, %r14d
jb 0x150e9e
testl %eax, %eax
je 0x150f42
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x150ca6
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incl %ebp
cmpl (%rbx), %ebp
jb 0x150f00
callq 0x105b4e
movl %eax, %ebp
testb %al, %al
je 0x150f42
incl %r14d
cmpl (%rbx), %r14d
jb 0x150efa
jmp 0x150f42
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x47f3d
// File: /workspace/github_c_makefile_star2_O3/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 0x151a6a
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x105e4d
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
cmpl $0x1, (%r12)
je 0x151982
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
callq 0x150c6f
addsd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%rsp), %xmm1
ucomisd 0x2313f4(%rip), %xmm1   # 0x382d68
ja 0x151982
incl %ebp
movl (%r12), %eax
decl %eax
cmpl %eax, %ebp
jb 0x15194d
testq %r15, %r15
je 0x151a5b
xorl %ebx, %ebx
callq 0x105e4d
movsd %xmm0, (%rsp)
cmpl $0x1, 0x4(%r12)
movl $0x0, %r13d
je 0x1519e7
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x150de1
addsd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%rsp), %xmm1
ucomisd 0x231392(%rip), %xmm1   # 0x382d68
ja 0x1519e7
incl %r13d
movl 0x4(%r12), %eax
decl %eax
cmpl %eax, %r13d
jb 0x1519ac
testq %r14, %r14
je 0x1519f7
movl %r13d, %edi
movq 0x10(%rsp), %rsi
callq *%r14
callq 0x105e4d
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
cmpl $0x1, (%r12)
je 0x151a4c
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x150ca6
addsd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
subsd (%rsp), %xmm1
ucomisd 0x23132c(%rip), %xmm1   # 0x382d68
ja 0x151a4c
incl %r13d
movl (%r12), %eax
decl %eax
cmpl %eax, %r13d
jb 0x151a12
incq %rbx
movl %r13d, %ebp
cmpq %r15, %rbx
jne 0x15198d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x482cd
// File: /workspace/github_c_makefile_star2_O3/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 0x151dc2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x151dc2
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x23147c(%rip), %rsi    # 0x3830bf
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
movl 0x4(%r14), %edx
leaq 0x231476(%rip), %rsi    # 0x3830d0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x17ab0
leaq 0x231477(%rip), %rdi    # 0x3830e2
movl $0x1d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
cmpl $0x0, (%r14)
je 0x151caa
leaq 0x231476(%rip), %r15    # 0x383100
movq %r14, %rdi
movl %ebp, %esi
callq 0x150c6f
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movb $0x1, %al
callq 0x17ab0
incl %ebp
cmpl (%r14), %ebp
jb 0x151c8a
movl $0xa, %edi
movq %rbx, %rsi
callq 0x11f81a
leaq 0x23144a(%rip), %rdi    # 0x383108
movl $0x1a, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
cmpl $0x0, (%r14)
je 0x151d34
leaq 0x231446(%rip), %r15    # 0x383123
leaq 0x2256dc(%rip), %r12    # 0x3773c0
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17ab0
cmpl $0x0, (%r14)
je 0x151d20
xorl %r13d, %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x150ca6
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x17ab0
incl %r13d
cmpl (%r14), %r13d
jb 0x151cfe
movl $0xa, %edi
movq %rbx, %rsi
callq 0x11f81a
incl %ebp
cmpl (%r14), %ebp
jb 0x151ce6
leaq 0x2313ed(%rip), %rdi    # 0x383128
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x17fa0
cmpl $0x0, (%r14)
je 0x151db3
leaq 0x2313c9(%rip), %r15    # 0x383123
leaq 0x22565f(%rip), %r12    # 0x3773c0
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17ab0
cmpl $0x0, 0x4(%r14)
je 0x151d9f
xorl %r13d, %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x150de1
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x17ab0
incl %r13d
cmpl 0x4(%r14), %r13d
jb 0x151d7c
movl $0xa, %edi
movq %rbx, %rsi
callq 0x11f81a
incl %ebp
cmpl (%r14), %ebp
jb 0x151d63
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x48423
// File: /workspace/github_c_makefile_star2_O3/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 0x152336
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x230ad3(%rip), %r14    # 0x382d9b
movq %r14, %rsi
movl $0x2bf, %edx            # imm = 0x2BF
callq 0x1045eb
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
movl $0x2c0, %edx            # imm = 0x2C0
callq 0x1045eb
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x2c0, %edx            # imm = 0x2C0
callq 0x1045eb
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
movl $0x2c1, %edx            # imm = 0x2C1
callq 0x1045eb
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x2c1, %edx            # imm = 0x2C1
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2c2, %edx            # imm = 0x2C2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x23126d(%rip), %rsi    # 0x3835b9
movl $0x100, %edi            # imm = 0x100
movl $0x39, %edx
callq 0x104226
testq %r15, %r15
je 0x152420
testq %r14, %r14
je 0x152425
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 0xe54e0
movq %rax, 0x50(%rbx)
movq $0x0, 0x90(%rbx)
callq 0xe54e0
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 0x1f3e53(%rip), %xmm0   # 0x346228
movups %xmm0, 0x40(%rbx)
callq 0xd0ece
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 0x484cc
callq 0x48495
// File: /workspace/github_c_makefile_star2_O3/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 0x15248c
testq %rsi, %rsi
je 0x152491
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
jne 0x152496
movq %rsi, 0x68(%rbx)
leaq 0x33(%rip), %r14        # 0x15249b
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x120966
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12097a
callq 0x485e3
callq 0x485aa
callq 0x48571
// File: /workspace/github_c_makefile_star2_O3/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 0x1526f7
testq %rsi, %rsi
je 0x1526fc
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
jne 0x152701
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 0x44(%rip), %rax        # 0x152706
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x120966
movq 0x68(%rbx), %rdi
leaq 0xdf(%rip), %rsi        # 0x1527ba
movq %rbx, %rdx
callq 0x12097a
movq 0x68(%rbx), %rdi
leaq 0x146(%rip), %rsi       # 0x152834
movq %rbx, %rdx
popq %rbx
jmp 0x12098e
callq 0x486c7
callq 0x4868e
callq 0x48655
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_process_complete_segment
static void gt_hpol_processor_process_complete_segment(
    GtAlignedSegment *as, void *data)
{
  GtHpolProcessorAddToHashResult multihit = GT_HPOL_PROCESSOR_NEW_RECORD;
  GtHpolProcessor *hpp = data;
  gt_assert(hpp != NULL);
  if (hpp->output_segments)
    gt_hpol_processor_output_segment(as, gt_aligned_segment_has_indels(as),
        hpp->outfp_segments, NULL);
  if (hpp->processed_segments != NULL)
    multihit = gt_hpol_processor_add_segment_to_hashmap(hpp, as);
  if (multihit == GT_HPOL_PROCESSOR_NEW_RECORD)
  {
    if (gt_aligned_segment_seq_edited(as))
      (hpp->nof_complete_edited)++;
    else
      (hpp->nof_complete_not_edited)++;
  }
  else if (multihit == GT_HPOL_PROCESSOR_REPLACED)
  {
    gt_assert(gt_aligned_segment_seq_edited(as));
    (hpp->nof_complete_edited)++;
    gt_assert(hpp->nof_complete_not_edited > 0);
    (hpp->nof_complete_not_edited)--;
  }
  else if (multihit == GT_HPOL_PROCESSOR_NOT_REPLACED)
  {
    gt_aligned_segment_delete(as);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1527ab
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0xf8(%rsi)
jne 0x15273e
movq %r14, %rdi
callq 0x2faa45
movq 0xc0(%rbx), %rdx
movzbl %al, %esi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1539c7
cmpq $0x0, 0xe8(%rbx)
je 0x15275c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x153af6
cmpl $0x1, %eax
je 0x152774
testl %eax, %eax
jne 0x15279c
movq %r14, %rdi
callq 0x2faa17
testb %al, %al
je 0x15276e
incq 0x70(%rbx)
jmp 0x152794
incq 0x78(%rbx)
jmp 0x152794
movq %r14, %rdi
callq 0x2faa17
testb %al, %al
je 0x1527b0
incq 0x70(%rbx)
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x1527b5
decq %rax
movq %rax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2faa54
callq 0x48772
callq 0x48700
callq 0x48739
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_process_skipped_segment
static void gt_hpol_processor_process_skipped_segment(
    GtAlignedSegment *as, void *data)
{
  GtHpolProcessorAddToHashResult multihit = GT_HPOL_PROCESSOR_NEW_RECORD;
  GtHpolProcessor *hpp = data;
  gt_assert(hpp != NULL);
  if (hpp->output_segments)
    gt_hpol_processor_output_segment(as, gt_aligned_segment_has_indels(as),
        hpp->outfp_segments, NULL);
  if (hpp->processed_segments != NULL)
    multihit = gt_hpol_processor_add_segment_to_hashmap(hpp, as);
  gt_assert(multihit != GT_HPOL_PROCESSOR_REPLACED);
  if (multihit == GT_HPOL_PROCESSOR_NEW_RECORD)
    hpp->nof_skipped++;
  else if (multihit == GT_HPOL_PROCESSOR_NOT_REPLACED)
    gt_aligned_segment_delete(as);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x15282a
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xf8(%rsi)
jne 0x1527ee
movq %rbx, %rdi
callq 0x2faa45
movq 0xc0(%r14), %rdx
movzbl %al, %esi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1539c7
cmpq $0x0, 0xe8(%r14)
je 0x15281b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x153af6
testl %eax, %eax
je 0x15281b
cmpl $0x2, %eax
jne 0x15282f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2faa54
incq 0x80(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x487e4
callq 0x487ab
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_process_unmapped_segment
static void gt_hpol_processor_process_unmapped_segment(
    GtAlignedSegment *as, void *data)
{
  GT_UNUSED GtHpolProcessorAddToHashResult multihit =
    GT_HPOL_PROCESSOR_NEW_RECORD;
  GtHpolProcessor *hpp = data;
  gt_assert(hpp != NULL);
  if (hpp->output_segments)
    gt_hpol_processor_output_segment(as, false, hpp->outfp_segments, NULL);
  if (hpp->processed_segments != NULL)
    multihit = gt_hpol_processor_add_segment_to_hashmap(hpp, as);
  gt_assert(multihit == GT_HPOL_PROCESSOR_NEW_RECORD);
  hpp->nof_unmapped++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x152887
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0xf8(%rsi)
jne 0x15285f
movq 0xc0(%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1539c7
cmpq $0x0, 0xe8(%rbx)
je 0x152878
movq %rbx, %rdi
movq %r14, %rsi
callq 0x153af6
testl %eax, %eax
jne 0x15288c
incq 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x48856
callq 0x4881d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_enable_sorted_segments_output
void gt_hpol_processor_enable_sorted_segments_output(GtHpolProcessor *hpp,
    GtUword nfiles, GtSeqIterator **reads_iters, GtFile **outfiles)
{
  gt_assert(hpp != NULL);
  gt_aligned_segments_pile_disable_segment_deletion(hpp->asp);
  hpp->processed_segments = gt_hashmap_new(GT_HASH_STRING, NULL,
      (GtFree)gt_aligned_segment_delete);
  hpp->reads_iters = reads_iters;
  hpp->outfiles = outfiles;
  hpp->nfiles = nfiles;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x152908
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%rdi), %rdi
callq 0x1209a2
leaq 0x1a8180(%rip), %rdx    # 0x2faa54
movl $0x1, %edi
xorl %esi, %esi
callq 0x1008fc
movq %rax, 0xe8(%r15)
movq %r12, 0xd8(%r15)
movq %rbx, 0xd0(%r15)
movq %r14, 0xe0(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x488c8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_delete
void gt_hpol_processor_delete(GtHpolProcessor *hpp)
{
  if (hpp != NULL)
  {
    gt_disc_distri_delete(hpp->hdist);
    gt_disc_distri_delete(hpp->hdist_e);
    gt_hashmap_delete(hpp->processed_segments);
    gt_alphabet_delete(hpp->alpha);
    gt_free(hpp);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1539c6
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0xe5a93
movq 0x58(%rbx), %rdi
callq 0xe5a93
movq 0xe8(%rbx), %rdi
callq 0x10109b
movq 0xf0(%rbx), %rdi
callq 0xd0e1c
leaq 0x22fc01(%rip), %rsi    # 0x3835b9
movq %rbx, %rdi
movl $0x3e9, %edx            # imm = 0x3E9
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_output_segment
static void gt_hpol_processor_output_segment(GtAlignedSegment *as,
    bool may_be_gapped, GtFile *outfp, const char *desc)
{
  GtUword slen;
  if (may_be_gapped)
    gt_aligned_segment_ungap_seq_and_qual(as);
  slen = (GtUword)strlen(gt_aligned_segment_seq(as));
  gt_assert(slen == (GtUword)strlen(gt_aligned_segment_qual(as)));
  if (gt_aligned_segment_is_reverse(as))
  {
    GtError *err = gt_error_new();
    char *q = gt_aligned_segment_qual(as), tmp;
    GtUword i;
    for (i = 0; i < (slen + 1UL) >> 1; i++)
    {
      tmp = q[i];
      q[i] = q[slen - i - 1UL];
      q[slen - i - 1UL] = tmp;
    }
    gt_assert((GtUword)strlen(gt_aligned_segment_qual(as)) == slen);
    if (gt_reverse_complement(gt_aligned_segment_seq(as), slen, err) != 0)
    {
      fprintf(stderr, "error: %s", gt_error_get(err));
      exit(EXIT_FAILURE);
    }
    gt_error_delete(err);
  }
  gt_fastq_show_entry((desc != NULL) ? desc :
      gt_aligned_segment_description(as), gt_aligned_segment_seq(as),
      gt_aligned_segment_qual(as), slen, 0, false, outfp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
testl %esi, %esi
je 0x1539e9
movq %r15, %rdi
callq 0x2fa974
movq %r15, %rdi
callq 0x2fa7ab
movq %rax, %rdi
callq 0x172f0
movq %rax, %r12
movq %r15, %rdi
callq 0x2fa7ba
movq %rax, %rdi
callq 0x172f0
cmpq %rax, %r12
jne 0x153ae7
movq %r15, %rdi
callq 0x2fa80a
testb %al, %al
je 0x153a9b
callq 0xfcb4c
movq %rax, %r13
movq %r15, %rdi
callq 0x2fa7ba
leaq 0x1(%r12), %rcx
cmpq $0x2, %rcx
jb 0x153a64
shrq %rcx
negq %rcx
leaq (%r12,%rax), %rdx
decq %rdx
xorl %esi, %esi
movb (%rax), %dil
movb (%rdx,%rsi), %r8b
movb %r8b, (%rax)
movb %dil, (%rdx,%rsi)
decq %rsi
incq %rax
cmpq %rsi, %rcx
jne 0x153a4b
movq %r15, %rdi
callq 0x2fa7ba
movq %rax, %rdi
callq 0x172f0
cmpq %r12, %rax
jne 0x153aec
movq %r15, %rdi
callq 0x2fa7ab
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x16eef8
movq %r13, %rdi
testl %eax, %eax
jne 0x153af1
callq 0xfcccd
testq %r14, %r14
jne 0x153aab
movq %r15, %rdi
callq 0x2fa9f7
movq %rax, %r14
movq %r15, %rdi
callq 0x2fa7ab
movq %rax, %r13
movq %r15, %rdi
callq 0x2fa7ba
movq %rbx, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xfe880
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x48ac9
callq 0x48b00
callq 0x48b37
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_add_segment_to_hashmap
static GtHpolProcessorAddToHashResult gt_hpol_processor_add_segment_to_hashmap(
    GtHpolProcessor *hpp, GtAlignedSegment *as)
{
  GtAlignedSegment *stored_as;
  if ((stored_as = gt_hashmap_get(hpp->processed_segments,
          gt_aligned_segment_description(as))) != NULL)
  {
    hpp->nof_multihits++;
    if (!gt_aligned_segment_seq_edited(stored_as) &&
        gt_aligned_segment_seq_edited(as))
    {
      hpp->nof_replaced++;
      /* change with newly edited as */
      gt_hashmap_remove(hpp->processed_segments,
          (void*)gt_aligned_segment_description(as));
      gt_hashmap_add(hpp->processed_segments,
          (void*)gt_aligned_segment_description(as), as);
      return GT_HPOL_PROCESSOR_REPLACED;
    }
    /* otherwise discard (todo: implement combination of edits) */
    else
    {
      return GT_HPOL_PROCESSOR_NOT_REPLACED;
    }
  }
  else
  {
    gt_hashmap_add(hpp->processed_segments,
        (void*)gt_aligned_segment_description(as), as);
    return GT_HPOL_PROCESSOR_NEW_RECORD;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xe8(%rdi), %r15
movq %rsi, %rdi
callq 0x2fa9f7
movq %r15, %rdi
movq %rax, %rsi
callq 0x100add
testq %rax, %rax
je 0x153b6e
incq 0xa8(%r14)
movq %rax, %rdi
callq 0x2faa17
movl $0x2, %ebp
testb %al, %al
jne 0x153b8d
movq %rbx, %rdi
callq 0x2faa17
testb %al, %al
je 0x153b8d
incq 0xb0(%r14)
movq 0xe8(%r14), %r15
movq %rbx, %rdi
callq 0x2fa9f7
movq %r15, %rdi
movq %rax, %rsi
callq 0x100b56
movl $0x1, %ebp
jmp 0x153b70
xorl %ebp, %ebp
movq 0xe8(%r14), %r14
movq %rbx, %rdi
callq 0x2fa9f7
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x100b18
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hpol_processor.c
// Function: gt_hpol_processor_subst_in_range
static void gt_hpol_processor_subst_in_range(char *s, char *q,
    GtUword left, GtUword right, GtUword length, char old,
    char new, char qual)
{
  GtUword pos;
  for (pos = right + 1UL; pos > left && length > 0; /**/)
  {
    pos--;
    if (s[pos] == old)
    {
      s[pos] = new;
      q[pos] = qual;
      length--;
    }
  }
  gt_assert(length == 0);
}

// Assembly:
pushq %rax
leaq 0x1(%rcx), %rax
cmpq %rdx, %rax
setbe %al
testq %r8, %r8
sete %r10b
orb %al, %r10b
jne 0x153feb
movb 0x18(%rsp), %al
movb 0x10(%rsp), %r10b
cmpb %r9b, (%rdi,%rcx)
jne 0x153fde
movb %r10b, (%rdi,%rcx)
movb %al, (%rsi,%rcx)
decq %r8
cmpq %rdx, %rcx
jbe 0x153feb
decq %rcx
testq %r8, %r8
jne 0x153fce
testq %r8, %r8
jne 0x153ff2
popq %rax
retq
callq 0x48cb9
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: huffman_tree_set_codes_rec
static void huffman_tree_set_codes_rec(GtHuffmanTree *h_tree)
{
  const char leftbit = 0, rightbit = 1;
  if (h_tree != NULL) {
    if (h_tree->leftchild != NULL) {
        h_tree->leftchild->code.code = h_tree->code.code<< 1 | leftbit;
        h_tree->rightchild->code.code = h_tree->code.code<< 1 | rightbit;
        h_tree->leftchild->code.numofbits =
          h_tree->rightchild->code.numofbits = h_tree->code.numofbits + 1;
        huffman_tree_set_codes_rec(h_tree->leftchild);
        huffman_tree_set_codes_rec(h_tree->rightchild);
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x15436b
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x15436a
movq (%rbx), %rax
addq %rax, %rax
movq %rax, (%rdi)
movq (%rbx), %rax
movq 0x28(%rbx), %rcx
leaq 0x1(,%rax,2), %rax
movq %rax, (%rcx)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rcx)
movl %eax, 0x8(%rdi)
callq 0x154324
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x15432d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_iterate
int gt_huffman_iterate(const GtHuffman *huffman,
                       GtHuffmanActFunc action_func,
                       void *action_info)
{
  gt_assert(huffman != NULL);
  gt_assert(action_func != NULL);

  if (huffman->root_huffman_tree != NULL) {
    return visit_huffman_leaves_rec(huffman->root_huffman_tree,
                                    action_info,
                                    action_func);
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x154390
movq %rsi, %rax
testq %rsi, %rsi
je 0x154395
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x15438c
movq %rdx, %rsi
movq %rax, %rdx
popq %rax
jmp 0x1543f9
xorl %eax, %eax
popq %rcx
retq
callq 0x48f2c
callq 0x48ef3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_delete
void gt_huffman_delete(GtHuffman *huffman)
{
  if (huffman != NULL) {
    gt_rbtree_delete(huffman->rbt_root);
    gt_free(huffman->code_tab);
  }
  gt_free(huffman);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1543e4
movq 0x18(%rbx), %rdi
callq 0x165fc5
movq 0x20(%rbx), %rdi
leaq 0x22ff10(%rip), %rsi    # 0x3842ea
movl $0x16f, %edx            # imm = 0x16F
callq 0x1045eb
leaq 0x22feff(%rip), %rsi    # 0x3842ea
movq %rbx, %rdi
movl $0x171, %edx            # imm = 0x171
popq %rbx
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: visit_huffman_leaves_rec
static int visit_huffman_leaves_rec(GtHuffmanTree *h_tree,
                                    void *actinfo,
                                    GtHuffmanActFunc actfun)
{
  int had_err = 0;

  if (h_tree->leftchild == NULL) {
      had_err = huffman_leaf_call_actfunc(h_tree,
                                          actinfo,
                                          actfun);
  } else {
    had_err =  visit_huffman_leaves_rec(h_tree->leftchild,
                                        actinfo,
                                        actfun);
    if (!had_err) {
      had_err =  visit_huffman_leaves_rec(h_tree->rightchild,
                                          actinfo,
                                          actfun);
    }
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x154429
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1543f9
testl %eax, %eax
jne 0x154445
movq 0x28(%r14), %r14
movq 0x20(%r14), %rdi
jmp 0x15440b
movq 0x18(%r14), %rdi
movq 0x10(%r14), %rsi
movq (%r14), %rdx
movl 0x8(%r14), %ecx
movq %rbx, %r8
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/huffcode.c
// Function: gt_huffman_size
void gt_huffman_size(const GtHuffman *huffman, uint64_t *bits,
                     uint64_t *chars)
{
  gt_assert(huffman != NULL);
  if (bits != NULL)
    *bits = huffman->num_of_text_bits;
  if (chars != NULL)
    *chars = huffman->num_of_text_symbols;
}

// Assembly:
testq %rdi, %rdi
je 0x154468
testq %rsi, %rsi
je 0x15445b
movq (%rdi), %rax
movq %rax, (%rsi)
testq %rdx, %rdx
je 0x154467
movq 0x8(%rdi), %rax
movq %rax, (%rdx)
retq
pushq %rax
callq 0x48f65