LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hcr.c
// Function: seq_decoder_init_huffman
static int seq_decoder_init_huffman(GtHcrSeqDecoder *seq_dec,
                                    GtWord end_of_encoding,
                                    GtBaseQualDistr *bqd,
                                    GtError *err)
{
  int had_err = 0;
  seq_dec->data_iter = decoder_init_data_iterator(seq_dec->start_of_encoding,
                                                  end_of_encoding,
                                                  seq_dec->filename);

  gt_assert(seq_dec->data_iter);
  seq_dec->huffman = gt_huffman_new(bqd, hcr_base_qual_distr_func,
                                    (GtUword) bqd->ncols * bqd->nrows);

  seq_dec->huff_dec =
    gt_huffman_decoder_new_from_memory(seq_dec->huffman,
                                       get_next_file_chunk_for_huffman,
                                       seq_dec->data_iter, err);
  if (seq_dec->huff_dec == NULL) {
    had_err = -1;
    gt_huffman_delete(seq_dec->huffman);
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdx
callq 0x1890e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x188f8c
movq 0x4b3045(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38d0ae(%rip), %rsi    # 0x516013
leaq 0x3cc255(%rip), %rdx    # 0x5551c1
leaq 0x3cc261(%rip), %rcx    # 0x5551d4
leaq 0x3cbd71(%rip), %r8     # 0x554ceb
movl $0x2d4, %r9d            # imm = 0x2D4
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x188f8e
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
imulq %rax, %rdx
leaq -0x1120(%rip), %rsi     # 0x187e90
callq 0x191820
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdx
movq 0x8(%rsp), %rcx
leaq 0x2c1(%rip), %rsi       # 0x1892a0
callq 0x1926f0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x189012
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x192210
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hcr.c
// Function: seq_decoder_init_file_info
static GtRBTree *seq_decoder_init_file_info(FastqFileInfo *fileinfos,
                                            GtUword num_off_files)
{
  GtRBTree *tree;
  bool nodecreated = false;
  GtUword i;

  tree = gt_rbtree_new(hcr_cmp_FastqFileInfo, NULL, NULL);
  for (i = 0; i < num_off_files; i++) {
    (void) gt_rbtree_search(tree, &fileinfos[i], &nodecreated);
  }
  gt_assert(nodecreated);
  return tree;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0xf(%rsp)
leaq 0x546(%rip), %rdi       # 0x189580
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1b7e90
movq %rax, 0x10(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x18908b
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rax
shlq $0x4, %rax
addq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x1b8790
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x189053
jmp 0x18908d
testb $0x1, 0xf(%rsp)
jne 0x1890cc
movq 0x4b2f05(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38cf6e(%rip), %rsi    # 0x516013
leaq 0x3c30a9(%rip), %rdx    # 0x54c155
leaq 0x3cc1d0(%rip), %rcx    # 0x555283
leaq 0x3cbc31(%rip), %r8     # 0x554ceb
movl $0x2b9, %r9d            # imm = 0x2B9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1890ce
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hcr.c
// Function: decoder_init_data_iterator
static HcrHuffDataIterator *decoder_init_data_iterator(GtWord start_of_encoding,
                                                       GtWord end_of_encoding,
                                                       const GtStr *filename)
{
  HcrHuffDataIterator *data_iter = gt_malloc(sizeof (*data_iter));
  data_iter->path = gt_str_get(filename);
  data_iter->pos = data_iter->start = (size_t) start_of_encoding;
  data_iter->end = (size_t) end_of_encoding;
  data_iter->pages_per_chunk = HCR_PAGES_PER_CHUNK;
  data_iter->pagesize = gt_pagesize();
  gt_assert(data_iter->start % data_iter->pagesize == 0);
  data_iter->blocksize = data_iter->pagesize * data_iter->pages_per_chunk;
  gt_safe_assign(data_iter->bitseq_per_chunk,
                 (data_iter->blocksize / sizeof (GtBitsequence)));
  data_iter->data = NULL;
  return data_iter;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x50, %edi
leaq 0x3cbbec(%rip), %rsi    # 0x554ceb
movl $0x25e, %edx            # imm = 0x25E
callq 0xe80f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq $0xa, 0x28(%rax)
callq 0xa2640
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
divq 0x38(%rcx)
cmpq $0x0, %rdx
je 0x1891b8
movq 0x4b2e19(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38ce82(%rip), %rsi    # 0x516013
leaq 0x3cc055(%rip), %rdx    # 0x5551ed
leaq 0x3cc07a(%rip), %rcx    # 0x555219
leaq 0x3cbb45(%rip), %r8     # 0x554ceb
movl $0x264, %r9d            # imm = 0x264
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1891ba
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x18(%rsp), %rax
imulq 0x28(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
shrq $0x3, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x189234
cmpq $0x1, 0x10(%rsp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x1, 0x8(%rsp)
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x189234
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rax)
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x18923e
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0x18923e
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x18927a
movq 0x4b2d4d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38edc8(%rip), %rsi    # 0x518025
leaq 0x3cba87(%rip), %rdx    # 0x554ceb
movl $0x267, %ecx            # imm = 0x267
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
jmp 0x18927c
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_cmp_FastqFileInfo
static int hcr_cmp_FastqFileInfo(const void *node1, const void *node2,
                                 GT_UNUSED void *unused)
{
  FastqFileInfo *n1 = (FastqFileInfo*) node1,
                *n2 = (FastqFileInfo*) node2;

  gt_assert(n1 && n2);

  if (n1->readnum < n2->readnum)
    return -1;
  if (n1->readnum > n2->readnum)
    return 1;
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1895b7
cmpq $0x0, 0x8(%rsp)
jne 0x1895ef
movq 0x4b29e2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38ca4b(%rip), %rsi    # 0x516013
leaq 0x3cbccf(%rip), %rdx    # 0x55529e
leaq 0x3cbcd1(%rip), %rcx    # 0x5552a7
leaq 0x3cb70e(%rip), %r8     # 0x554ceb
movl $0x125, %r9d            # imm = 0x125
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1895f1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x18960f
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x189635
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x18962d
movl $0x1, 0x34(%rsp)
jmp 0x189635
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hcr.c
// Function: get_base_from_symbol
static unsigned char get_base_from_symbol(GtHcrSeqDecoder *seq_dec,
                                 GtUword symbol)
{
  unsigned char base = (unsigned char) symbol % seq_dec->alphabet_size;
  if (base == (unsigned char) seq_dec->alphabet_size)
    return (unsigned char) GT_WILDCARD;
  return base;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl %al, %eax
movq -0x10(%rsp), %rcx
xorl %edx, %edx
divl 0x78(%rcx)
movb %dl, %al
movb %al, -0x19(%rsp)
movzbl -0x19(%rsp), %eax
movq -0x10(%rsp), %rcx
movl 0x78(%rcx), %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1896ad
movb $-0x2, -0x1(%rsp)
jmp 0x1896b5
movb -0x19(%rsp), %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_write_file_info
static void hcr_write_file_info(FILE *fp, GtHcrEncoder *hcr_enc)
{
  GtUword i;

  gt_xfwrite_one(&hcr_enc->num_of_files, fp);

  for (i = 0; i < hcr_enc->num_of_files; i++) {
    gt_xfwrite_one(&hcr_enc->seq_encoder->fileinfos[i].readnum, fp);
    gt_xfwrite_one(&hcr_enc->seq_encoder->fileinfos[i].readlength, fp);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x18976c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq (%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq (%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1896f3
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_write_seqdistrtab
static int hcr_write_seqdistrtab(FILE *fp, GtHcrEncoder *hcr_enc)
{
  WriteNodeInfo *info;
  int had_err = 0;
  GtUword numofleaves;

  info = gt_calloc((size_t) 1, sizeof (WriteNodeInfo));
  info->alpha = hcr_enc->seq_encoder->alpha;
  info->qual_offset = hcr_enc->seq_encoder->qual_offset;
  info->output = fp;

  numofleaves = gt_huffman_numofsymbols(hcr_enc->seq_encoder->huffman);
  gt_xfwrite_one(&numofleaves, fp);

  had_err = gt_huffman_iterate(hcr_enc->seq_encoder->huffman,
                               hcr_huffman_write_base_qual_freq,
                               info);
  gt_free(info);
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x1, %edi
movl $0x18, %esi
leaq 0x3cb544(%rip), %rdx    # 0x554ceb
movl $0x1f2, %ecx            # imm = 0x1F2
callq 0xe83c0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x48(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x192530
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x87d(%rip), %rsi       # 0x18a0b0
callq 0x191fe0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x3cb4a3(%rip), %rsi    # 0x554ceb
movl $0x1fd, %edx            # imm = 0x1FD
callq 0xe88c0
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movsd %xmm0, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18a8b2
movq 0x4b171f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b788(%rip), %rsi    # 0x516013
leaq 0x38fb24(%rip), %rdx    # 0x51a3b6
leaq 0x3cabd5(%rip), %rcx    # 0x55546e
leaq 0x3cabbb(%rip), %r8     # 0x55545b
movl $0x58, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18a8b4
jmp 0x18a8b6
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x18a8d3
movsd 0x38c974(%rip), %xmm0   # 0x517240
ucomisd (%rsp), %xmm0
jae 0x18a90b
movq 0x4b16c6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b72f(%rip), %rsi    # 0x516013
leaq 0x3caba8(%rip), %rdx    # 0x555493
leaq 0x3cab7c(%rip), %rcx    # 0x55546e
leaq 0x3cab62(%rip), %r8     # 0x55545b
movl $0x59, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18a90d
jmp 0x18a90f
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18a954
movq 0x4b167d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b6e6(%rip), %rsi    # 0x516013
leaq 0x3cabd4(%rip), %rdx    # 0x555508
leaq 0x3cab33(%rip), %rcx    # 0x55546e
leaq 0x3cab19(%rip), %r8     # 0x55545b
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18a956
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18a982
jp 0x18a982
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movsd 0x3caaa5(%rip), %xmm0   # 0x555420
movsd %xmm0, (%rax,%rcx,8)
jmp 0x18a99e
movsd (%rsp), %xmm0
callq 0x195c0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movsd %xmm0, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18aa06
movq 0x4b15cb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b634(%rip), %rsi    # 0x516013
leaq 0x38f9d0(%rip), %rdx    # 0x51a3b6
leaq 0x3caaf4(%rip), %rcx    # 0x5554e1
leaq 0x3caa67(%rip), %r8     # 0x55545b
movl $0x70, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18aa08
jmp 0x18aa0a
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x18aa27
movsd 0x38c820(%rip), %xmm0   # 0x517240
ucomisd (%rsp), %xmm0
jae 0x18aa5f
movq 0x4b1572(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b5db(%rip), %rsi    # 0x516013
leaq 0x3caa54(%rip), %rdx    # 0x555493
leaq 0x3caa9b(%rip), %rcx    # 0x5554e1
leaq 0x3caa0e(%rip), %r8     # 0x55545b
movl $0x71, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18aa61
jmp 0x18aa63
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18aaa8
movq 0x4b1529(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b592(%rip), %rsi    # 0x516013
leaq 0x3caa7b(%rip), %rdx    # 0x555503
leaq 0x3caa52(%rip), %rcx    # 0x5554e1
leaq 0x3ca9c5(%rip), %r8     # 0x55545b
movl $0x72, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18aaaa
jmp 0x18aaac
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18aaf1
movq 0x4b14e0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b549(%rip), %rsi    # 0x516013
leaq 0x3caa56(%rip), %rdx    # 0x555527
leaq 0x3caa09(%rip), %rcx    # 0x5554e1
leaq 0x3ca97c(%rip), %r8     # 0x55545b
movl $0x73, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18aaf3
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18ab27
jp 0x18ab27
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x8(%rsp), %ecx
movsd 0x3ca900(%rip), %xmm0   # 0x555420
movsd %xmm0, (%rax,%rcx,8)
jmp 0x18ab4b
movsd (%rsp), %xmm0
callq 0x195c0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x8(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x18aba7
movq 0x4b142a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b493(%rip), %rsi    # 0x516013
leaq 0x38f82f(%rip), %rdx    # 0x51a3b6
leaq 0x3caa09(%rip), %rcx    # 0x555597
leaq 0x3ca8c6(%rip), %r8     # 0x55545b
movl $0xac, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18aba9
jmp 0x18abab
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x18abca
movsd 0x38c67e(%rip), %xmm0   # 0x517240
ucomisd 0x10(%rsp), %xmm0
jae 0x18ac02
movq 0x4b13cf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b438(%rip), %rsi    # 0x516013
leaq 0x3ca8b1(%rip), %rdx    # 0x555493
leaq 0x3ca9ae(%rip), %rcx    # 0x555597
leaq 0x3ca86b(%rip), %r8     # 0x55545b
movl $0xad, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18ac04
jmp 0x18ac06
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18ac4b
movq 0x4b1386(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b3ef(%rip), %rsi    # 0x516013
leaq 0x3ca8dd(%rip), %rdx    # 0x555508
leaq 0x3ca965(%rip), %rcx    # 0x555597
leaq 0x3ca822(%rip), %r8     # 0x55545b
movl $0xae, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18ac4d
cmpl $0xfe, 0x18(%rsp)
jne 0x18ac68
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x18ac70
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x18acbe
movq 0x4b1313(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b37c(%rip), %rsi    # 0x516013
leaq 0x3ca919(%rip), %rdx    # 0x5555b7
leaq 0x3ca8f2(%rip), %rcx    # 0x555597
leaq 0x3ca7af(%rip), %r8     # 0x55545b
movl $0xb1, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18acc0
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18acf5
jp 0x18acf5
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x18(%rsp), %ecx
movsd 0x3ca732(%rip), %xmm0   # 0x555420
movsd %xmm0, (%rax,%rcx,8)
jmp 0x18ad1a
movsd 0x10(%rsp), %xmm0
callq 0x195c0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x18(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x18ad6d
movq 0x4b1264(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b2cd(%rip), %rsi    # 0x516013
leaq 0x38f669(%rip), %rdx    # 0x51a3b6
leaq 0x3ca768(%rip), %rcx    # 0x5554bc
leaq 0x3ca700(%rip), %r8     # 0x55545b
movl $0x64, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18ad6f
jmp 0x18ad71
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18adb6
movq 0x4b121b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b284(%rip), %rsi    # 0x516013
leaq 0x3ca772(%rip), %rdx    # 0x555508
leaq 0x3ca71f(%rip), %rcx    # 0x5554bc
leaq 0x3ca6b7(%rip), %r8     # 0x55545b
movl $0x65, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18adb8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0x3ca64e(%rip), %xmm1   # 0x555420
ucomisd %xmm1, %xmm0
jne 0x18ade5
jp 0x18ade5
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x18ae02
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
callq 0x19d40
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x18ae60
movq 0x4b1171(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b1da(%rip), %rsi    # 0x516013
leaq 0x38f576(%rip), %rdx    # 0x51a3b6
leaq 0x3ca702(%rip), %rcx    # 0x555549
leaq 0x3ca60d(%rip), %r8     # 0x55545b
movl $0x7e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18ae62
jmp 0x18ae64
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18aea9
movq 0x4b1128(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b191(%rip), %rsi    # 0x516013
leaq 0x3ca67a(%rip), %rdx    # 0x555503
leaq 0x3ca6b9(%rip), %rcx    # 0x555549
leaq 0x3ca5c4(%rip), %r8     # 0x55545b
movl $0x7f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18aeab
jmp 0x18aead
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18aef1
movq 0x4b10e0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b149(%rip), %rsi    # 0x516013
leaq 0x3ca656(%rip), %rdx    # 0x555527
leaq 0x3ca671(%rip), %rcx    # 0x555549
leaq 0x3ca57c(%rip), %r8     # 0x55545b
movl $0x80, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18aef3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0x3ca50c(%rip), %xmm1   # 0x555420
ucomisd %xmm1, %xmm0
jne 0x18af27
jp 0x18af27
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x18af4b
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
callq 0x19d40
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x18afa9
movq 0x4b1028(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38b091(%rip), %rsi    # 0x516013
leaq 0x38f42d(%rip), %rdx    # 0x51a3b6
leaq 0x3ca5db(%rip), %rcx    # 0x55556b
leaq 0x3ca4c4(%rip), %r8     # 0x55545b
movl $0x8b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18afab
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b0d6
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b03e
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x18ae10
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18b01f
jp 0x18b01f
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x18b02f
movsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x18b031
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x18afdc
cmpl $0x0, 0x14(%rsp)
je 0x18b0c4
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b0c2
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x18ae10
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18b0b3
jp 0x18b0b3
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movsd (%rsp), %xmm1
movsd 0x38c1a3(%rip), %xmm0   # 0x517240
subsd %xmm1, %xmm0
movl 0x14(%rsp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
callq 0x18a9b0
jmp 0x18b0b5
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x18b04d
jmp 0x18b0c4
jmp 0x18b0c6
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x18afb3
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x18b131
movq 0x4b0ea0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38af09(%rip), %rsi    # 0x516013
leaq 0x38f2a5(%rip), %rdx    # 0x51a3b6
leaq 0x3ca4c0(%rip), %rcx    # 0x5555d8
leaq 0x3ca33c(%rip), %r8     # 0x55545b
movl $0xbc, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18b133
jmp 0x18b135
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x18b17a
movq 0x4b0e57(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38aec0(%rip), %rsi    # 0x516013
leaq 0x3ca3ae(%rip), %rdx    # 0x555508
leaq 0x3ca477(%rip), %rcx    # 0x5555d8
leaq 0x3ca2f3(%rip), %r8     # 0x55545b
movl $0xbd, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18b17c
cmpl $0xfe, 0x10(%rsp)
jne 0x18b197
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x18b19f
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x18b1ed
movq 0x4b0de4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38ae4d(%rip), %rsi    # 0x516013
leaq 0x3ca3ea(%rip), %rdx    # 0x5555b7
leaq 0x3ca404(%rip), %rcx    # 0x5555d8
leaq 0x3ca280(%rip), %r8     # 0x55545b
movl $0xc0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18b1ef
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x10(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0x3ca20f(%rip), %xmm1   # 0x555420
ucomisd %xmm1, %xmm0
jne 0x18b224
jp 0x18b224
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x18b249
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x10(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
callq 0x19d40
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18b2a9
movq 0x4b0d28(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38ad91(%rip), %rsi    # 0x516013
leaq 0x38f12d(%rip), %rdx    # 0x51a3b6
leaq 0x3ca368(%rip), %rcx    # 0x5555f8
leaq 0x3ca1c4(%rip), %r8     # 0x55545b
movl $0xfc, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18b2ab
movq 0x10(%rsp), %rdi
callq 0x18b300
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x18b2c4
jmp 0x18b2eb
movq 0x10(%rsp), %rdi
callq 0x18b3a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x18b2dd
jmp 0x18b2eb
movq 0x10(%rsp), %rdi
callq 0x18b480
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_has_valid_initial_state_probs
static bool gt_hmm_has_valid_initial_state_probs(const GtHMM *hmm)
{
  unsigned int state;
  double sum_of_probabilities = 0.0;

  gt_assert(hmm);

  for (state = 0; state < hmm->num_of_states; state++)
    sum_of_probabilities += gt_hmm_get_initial_state_probability(hmm, state);

  return gt_double_equals_one(sum_of_probabilities);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18b351
movq 0x4b0c80(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38ace9(%rip), %rsi    # 0x516013
leaq 0x38f085(%rip), %rdx    # 0x51a3b6
leaq 0x3ca8a4(%rip), %rcx    # 0x555bdc
leaq 0x3ca11c(%rip), %r8     # 0x55545b
movl $0xcb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18b353
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b38d
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x18ad20
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x18b35b
movsd (%rsp), %xmm0
callq 0xec170
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_has_valid_emissions
static bool gt_hmm_has_valid_emissions(const GtHMM *hmm)
{
  unsigned int state, symbol;
  double sum_of_probabilities;

  gt_assert(hmm);

  for (state = 0; state < hmm->num_of_states; state++) {
    sum_of_probabilities = 0.0;
    for (symbol = 0; symbol < hmm->num_of_symbols; symbol++)
      sum_of_probabilities += gt_hmm_get_emission_probability(hmm,
                                                              state, symbol);
    if (!gt_double_equals_one(sum_of_probabilities))
      return false;
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x18b3e9
movq 0x4b0be8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38ac51(%rip), %rsi    # 0x516013
leaq 0x38efed(%rip), %rdx    # 0x51a3b6
leaq 0x3ca831(%rip), %rcx    # 0x555c01
leaq 0x3ca084(%rip), %r8     # 0x55545b
movl $0xd8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18b3eb
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b46f
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x18b44a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x18b0e0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x18b411
movsd 0x8(%rsp), %xmm0
callq 0xec170
testb $0x1, %al
jne 0x18b460
movb $0x0, 0x27(%rsp)
jmp 0x18b474
jmp 0x18b462
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x18b3f3
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_has_valid_states
static bool gt_hmm_has_valid_states(const GtHMM *hmm)
{
  unsigned int state_1, state_2;
  double sum_of_probabilities;

  gt_assert(hmm);

  for (state_1 = 0; state_1 < hmm->num_of_states; state_1++) {
    sum_of_probabilities = 0.0;
    for (state_2 = 0; state_2 < hmm->num_of_states; state_2++) {
      sum_of_probabilities += gt_hmm_get_transition_probability(hmm,state_1,
                                                             state_2);

    }
    if (!gt_double_equals_one(sum_of_probabilities))
      return false;
  }

  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x18b4c9
movq 0x4b0b08(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38ab71(%rip), %rsi    # 0x516013
leaq 0x38ef0d(%rip), %rdx    # 0x51a3b6
leaq 0x3ca76c(%rip), %rcx    # 0x555c1c
leaq 0x3c9fa4(%rip), %r8     # 0x55545b
movl $0xea, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18b4cb
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b54e
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b529
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x18ae10
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x18b4f1
movsd 0x8(%rsp), %xmm0
callq 0xec170
testb $0x1, %al
jne 0x18b53f
movb $0x0, 0x27(%rsp)
jmp 0x18b553
jmp 0x18b541
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x18b4d3
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/hmm.c
// Function: gt_hmm_forward
double gt_hmm_forward(const GtHMM* hmm, const unsigned int *emissions,
                   unsigned int num_of_emissions)
{
  unsigned int i;
  double **f, P;

  gt_assert(hmm && emissions && num_of_emissions);
  gt_array2dim_malloc(f, hmm->num_of_states, num_of_emissions);

  /* XXX: we do not need the full table here, the last column would suffice */
  compute_forward_table(f, hmm, emissions, num_of_emissions);

  /* compute P(x) */
  P = f[0][num_of_emissions-1];
  for (i = 1; i < hmm->num_of_states; i++) {
    /* XXX: replace the logsum() call with a tabulated version */
    P = gt_logsum(P, f[i][num_of_emissions-1]);
  }

  gt_array2dim_delete(f);
  return P;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x18bfc9
cmpq $0x0, 0x28(%rsp)
je 0x18bfc9
cmpl $0x0, 0x24(%rsp)
jne 0x18c001
movq 0x4affd0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38a039(%rip), %rsi    # 0x516013
leaq 0x3c9ce3(%rip), %rdx    # 0x555cc4
leaq 0x3c968c(%rip), %rcx    # 0x555674
leaq 0x3c946c(%rip), %r8     # 0x55545b
movl $0x1a1, %r9d            # imm = 0x1A1
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18c003
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x3c9444(%rip), %rsi    # 0x55545b
movl $0x1a2, %edx            # imm = 0x1A2
callq 0xe80f0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
movl 0x24(%rsp), %eax
imulq %rax, %rdi
leaq 0x3c9419(%rip), %rsi    # 0x55545b
movl $0x1a2, %edx            # imm = 0x1A2
callq 0xe80f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x1, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x18c0ac
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movl 0x24(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x18c060
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %eax
movl %eax, %ecx
callq 0x18c170
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x1, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18c130
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movl 0x20(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
callq 0xec050
movsd %xmm0, 0x10(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x18c0ea
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x3c931c(%rip), %rsi    # 0x55545b
movl $0x1ae, %edx            # imm = 0x1AE
callq 0xe88c0
movq 0x18(%rsp), %rdi
leaq 0x3c9306(%rip), %rsi    # 0x55545b
movl $0x1ae, %edx            # imm = 0x1AE
callq 0xe88c0
movsd 0x10(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x18d791
jmp 0x18d829
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x3c7cbb(%rip), %rsi    # 0x55545b
movl $0x2bf, %edx            # imm = 0x2BF
callq 0xe88c0
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
leaq 0x3c7c9f(%rip), %rsi    # 0x55545b
movl $0x2c0, %edx            # imm = 0x2C0
callq 0xe88c0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x3c7c86(%rip), %rsi    # 0x55545b
movl $0x2c0, %edx            # imm = 0x2C0
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x3c7c6a(%rip), %rsi    # 0x55545b
movl $0x2c1, %edx            # imm = 0x2C1
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x3c7c51(%rip), %rsi    # 0x55545b
movl $0x2c1, %edx            # imm = 0x2C1
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x3c7c3c(%rip), %rsi    # 0x55545b
movl $0x2c2, %edx            # imm = 0x2C2
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18dbbe
movq 0x4ae413(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x38847c(%rip), %rsi    # 0x516013
leaq 0x3c819f(%rip), %rdx    # 0x555d3d
leaq 0x3c81db(%rip), %rcx    # 0x555d80
leaq 0x3c8154(%rip), %r8     # 0x555d00
movl $0x126, %r9d            # imm = 0x126
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18dbc0
jmp 0x18dbc2
cmpq $0x0, 0x8(%rsp)
jne 0x18dc02
movq 0x4ae3cf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x388438(%rip), %rsi    # 0x516013
leaq 0x3b901d(%rip), %rdx    # 0x546bff
leaq 0x3c8197(%rip), %rcx    # 0x555d80
leaq 0x3c8110(%rip), %r8     # 0x555d00
movl $0x127, %r9d            # imm = 0x127
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18dc04
jmp 0x18dc06
movq 0x10(%rsp), %rax
cmpq $0x0, 0x68(%rax)
je 0x18dc4a
movq 0x4ae387(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3883f0(%rip), %rsi    # 0x516013
leaq 0x3c8190(%rip), %rdx    # 0x555dba
leaq 0x3c814f(%rip), %rcx    # 0x555d80
leaq 0x3c80c8(%rip), %r8     # 0x555d00
movl $0x128, %r9d            # imm = 0x128
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18dc4c
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x31(%rip), %rsi        # 0x18dca0
callq 0x129420
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x17(%rip), %rsi        # 0x18dca0
callq 0x1294a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x18e410
movq 0x4adbc1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x387c2a(%rip), %rsi    # 0x516013
leaq 0x3c794d(%rip), %rdx    # 0x555d3d
leaq 0x3c7c1f(%rip), %rcx    # 0x556016
leaq 0x3c7902(%rip), %r8     # 0x555d00
movl $0xd5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18e412
movq 0x8(%rsp), %rax
testb $0x1, 0xf8(%rax)
je 0x18e452
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x488d80
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0xc0(%rcx), %rdx
movzbl %al, %esi
andl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x18f9f0
movq 0x8(%rsp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x18e474
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18fc70
movl %eax, 0x14(%rsp)
jmp 0x18e476
cmpl $0x1, 0x14(%rsp)
jne 0x18e4b5
movq 0x4adb1c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x387b85(%rip), %rsi    # 0x516013
leaq 0x3c7bab(%rip), %rdx    # 0x556040
leaq 0x3c7b7a(%rip), %rcx    # 0x556016
leaq 0x3c785d(%rip), %r8     # 0x555d00
movl $0xdb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18e4b7
cmpl $0x0, 0x14(%rsp)
jne 0x18e4d7
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x80(%rax)
jmp 0x18e4ea
cmpl $0x2, 0x14(%rsp)
jne 0x18e4e8
movq 0x20(%rsp), %rdi
callq 0x488de0
jmp 0x18e4ea
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x18e550
movq 0x4ada81(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x387aea(%rip), %rsi    # 0x516013
leaq 0x3c780d(%rip), %rdx    # 0x555d3d
leaq 0x3c7b30(%rip), %rcx    # 0x556067
leaq 0x3c77c2(%rip), %r8     # 0x555d00
movl $0xe8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18e552
movq 0x8(%rsp), %rax
testb $0x1, 0xf8(%rax)
je 0x18e57c
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rdx
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x18f9f0
movq 0x8(%rsp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x18e59e
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18fc70
movl %eax, 0x14(%rsp)
jmp 0x18e5a0
cmpl $0x0, 0x14(%rsp)
je 0x18e5df
movq 0x4ad9f2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x387a5b(%rip), %rsi    # 0x516013
leaq 0x3c7ad3(%rip), %rdx    # 0x556092
leaq 0x3c7aa1(%rip), %rcx    # 0x556067
leaq 0x3c7733(%rip), %r8     # 0x555d00
movl $0xed, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18e5e1
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x88(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x18e6d8
movq 0x4ad8f9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x387962(%rip), %rsi    # 0x516013
leaq 0x3c7685(%rip), %rdx    # 0x555d3d
leaq 0x3c776e(%rip), %rcx    # 0x555e2d
leaq 0x3c763a(%rip), %r8     # 0x555d00
movl $0x156, %r9d            # imm = 0x156
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x18e6da
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x1295a0
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x2fa6e8(%rip), %rdx    # 0x488de0
callq 0xe0c40
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xe8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xd8(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xe0(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)