LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_delete
void gt_match_iterator_delete(GtMatchIterator *mp)
{
  if (!mp) return;
  if (mp->c_class->free)
    mp->c_class->free(mp);
  gt_free(mp);
}

// Assembly:
testq %rdi, %rdi
je 0x15de95
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x15de80
movq %rbx, %rdi
callq *%rax
leaq 0x229079(%rip), %rsi    # 0x386f00
movq %rbx, %rdi
movl $0x42, %edx
popq %rbx
jmp 0x1045eb
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_file_new
GtMatchIterator* gt_match_iterator_blast_file_new(const char *matchfile,
                                                  GtError *err)
{
  GtMatchIterator *mp;
  GtMatchIteratorBlast *mpb;
  mp = gt_match_iterator_create(gt_match_iterator_blast_class());
  mpb = gt_match_iterator_blast_cast(mp);
  mpb->pvt = gt_calloc(1, sizeof (GtMatchIteratorBlastMembers));
  GtFileMode mode;

  if (gt_file_exists(matchfile)) {
    mode = gt_file_mode_determine(matchfile);
    if (mode == GT_FILE_MODE_UNCOMPRESSED) {
      mpb->pvt->matchfilep = fopen(matchfile, "r");
      mpb->pvt->gtmatchfilep = NULL;
      if (!mpb->pvt->matchfilep) {
        gt_error_set(err, "could not open %s", matchfile);
        gt_match_iterator_delete(mp);
        return NULL;
      }
    } else {
      mpb->pvt->gtmatchfilep = gt_file_open(mode, matchfile, "r", err);
      mpb->pvt->matchfilep = NULL;
      if (!mpb->pvt->gtmatchfilep) {
        gt_match_iterator_delete(mp);
        return NULL;
      }
    }
    mpb->pvt->matchfile = matchfile;
    mpb->pvt->process = false;
    return mp;
  } else {
    gt_error_set(err, "no such file or directory %s", matchfile);
    gt_match_iterator_delete(mp);
    return NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x15df92
movq %rax, %rdi
callq 0x15ddfd
movq %rax, %rbx
callq 0x15df92
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15de4d
movq %rax, %r12
leaq 0x229098(%rip), %rdx    # 0x386f68
movl $0x1, %edi
movl $0x28, %esi
movl $0xb9, %ecx
callq 0x10436a
movq %rax, 0x8(%r12)
movq %r14, %rdi
callq 0xff28c
testb %al, %al
je 0x15df2d
movq %r14, %rdi
callq 0xfe990
testl %eax, %eax
je 0x15df4d
leaq 0x1fcf4d(%rip), %rdx    # 0x35ae55
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rcx
callq 0xfead5
movq 0x8(%r12), %rcx
movq %rax, 0x10(%rcx)
movq $0x0, 0x8(%rcx)
testq %rax, %rax
jne 0x15df72
jmp 0x15df41
leaq 0x22906a(%rip), %rsi    # 0x386f9e
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfcb67
movq %rbx, %rdi
callq 0x15de66
xorl %ebx, %ebx
jmp 0x15df7a
leaq 0x1fcf01(%rip), %rsi    # 0x35ae55
movq %r14, %rdi
callq 0x178b0
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
movq $0x0, 0x10(%rcx)
testq %rax, %rax
je 0x15df89
movq %r14, 0x18(%rcx)
movb $0x0, 0x20(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x228ffc(%rip), %rsi    # 0x386f8c
jmp 0x15df34
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_class
const GtMatchIteratorClass* gt_match_iterator_blast_class(void)
{
  static const GtMatchIteratorClass *mpc;
  gt_class_alloc_lock_enter();
  if (!mpc) {
    mpc = gt_match_iterator_class_new(sizeof (GtMatchIteratorBlast),
                                      gt_match_iterator_blast_next,
                                      gt_match_iterator_blast_free);
  }
  gt_class_alloc_lock_leave();
  return mpc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x3607f8(%rip)    # 0x4be798
jne 0x15dfc1
leaq 0x5c3(%rip), %rsi       # 0x15e56c
leaq 0x8ca(%rip), %rdx       # 0x15e87a
movl $0x10, %edi
callq 0x15ddd4
movq %rax, 0x3607d7(%rip)    # 0x4be798
callq 0xe2545
movq 0x3607cb(%rip), %rax    # 0x4be798
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_process_new
GtMatchIterator *gt_match_iterator_blast_process_new(GtBlastProcessCall *call,
                                                     GtError *err)
{
  GtMatchIterator *mp;
  GtMatchIteratorBlast *mpb;
  mp = gt_match_iterator_create(gt_match_iterator_blast_class());
  mpb = gt_match_iterator_blast_cast(mp);
  mpb->pvt = gt_calloc(1, sizeof (GtMatchIteratorBlastMembers));
  mpb->pvt->matchfile = "stdin";
  mpb->pvt->process = true;

  gt_blast_process_call_set_outfmt_tabular(call);

  mpb->pvt->matchfilep = gt_blast_process_call_run(call, err);
  if (mpb->pvt->matchfilep == NULL)
    return NULL;
  mpb->pvt->gtmatchfilep = NULL;
  return mp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x15df92
movq %rax, %rdi
callq 0x15ddfd
movq %rax, %rbx
callq 0x15df92
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15de4d
movq %rax, %r12
leaq 0x228f61(%rip), %rdx    # 0x386f68
movl $0x1, %edi
movl $0x28, %esi
movl $0xdf, %ecx
callq 0x10436a
movq %rax, 0x8(%r12)
leaq 0x1e7eda(%rip), %rcx    # 0x345f01
movq %rcx, 0x18(%rax)
movb $0x1, 0x20(%rax)
movq %r15, %rdi
callq 0x127ed7
movq %r15, %rdi
movq %r14, %rsi
callq 0x127f33
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
testq %rax, %rax
je 0x15e05a
movq $0x0, 0x10(%rcx)
jmp 0x15e05c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blastallp_process_new
GtMatchIterator* gt_match_iterator_blastallp_process_new(const char *query,
                                                         const char *db_name,
                                                         double evalue,
                                                         int word_size,
                                                         int gapopen,
                                                         int gapextend,
                                                         int xdrop_gap_final,
                                                         GtError *err)
{
  GtBlastProcessCall *call = gt_blast_process_call_new_all_prot();

  gt_blast_process_call_set_query(call, query);
  gt_blast_process_call_set_db(call, db_name);
  if (evalue != GT_UNDEF_DOUBLE)
    gt_blast_process_call_set_evalue(call, evalue);
  if (word_size != GT_UNDEF_INT)
    gt_blast_process_call_set_wordsize(call, word_size);
  if (gapopen != GT_UNDEF_INT)
    gt_blast_process_call_set_gapopen(call, gapopen);
  if (gapextend != GT_UNDEF_INT)
    gt_blast_process_call_set_gapextend(call, gapextend);
  if (xdrop_gap_final != GT_UNDEF_INT)
    gt_blast_process_call_set_xdrop_gap_final(call, xdrop_gap_final);

  return gt_match_iterator_blast_process_new(call, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x127b40
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x127b84
movq %r14, %rdi
movq %rbx, %rsi
callq 0x127bce
movsd 0x8(%rsp), %xmm0
ucomisd 0x1e9aca(%rip), %xmm0   # 0x347d10
jne 0x15e24a
jnp 0x15e252
movq %r14, %rdi
callq 0x127c18
movl %r13d, %eax
negl %eax
jo 0x15e264
movq %r14, %rdi
movl %r13d, %esi
callq 0x127c6b
movl %r12d, %eax
negl %eax
jo 0x15e276
movq %r14, %rdi
movl %r12d, %esi
callq 0x127cb3
movl %r15d, %eax
negl %eax
jo 0x15e288
movq %r14, %rdi
movl %r15d, %esi
callq 0x127cfb
movl 0x4(%rsp), %ecx
movl %ecx, %eax
negl %eax
jo 0x15e2a1
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movq %r14, %rdi
callq 0x127e31
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15dfcf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blastp_process_new
GtMatchIterator* gt_match_iterator_blastp_process_new(const char *query,
                                                      const char *db_name,
                                                      double evalue,
                                                      int word_size,
                                                      int gapopen,
                                                      int gapextend,
                                                      int num_threads,
                                                      double xdrop_gap_final,
                                                      GtError *err)
{
  GtBlastProcessCall *call = gt_blast_process_call_new_all_prot();

  gt_blast_process_call_set_query(call, query);
  gt_blast_process_call_set_db(call, db_name);
  if (evalue != GT_UNDEF_DOUBLE)
    gt_blast_process_call_set_evalue(call, evalue);
  if (word_size != GT_UNDEF_INT)
    gt_blast_process_call_set_wordsize(call, word_size);
  if (gapopen != GT_UNDEF_INT)
    gt_blast_process_call_set_gapopen(call, gapopen);
  if (gapextend != GT_UNDEF_INT)
    gt_blast_process_call_set_gapextend(call, gapextend);
  if (num_threads != GT_UNDEF_INT)
    gt_blast_process_call_set_num_threads(call, num_threads);
  if (xdrop_gap_final != GT_UNDEF_DOUBLE)
    gt_blast_process_call_set_xdrop_gap_final(call, xdrop_gap_final);

  return gt_match_iterator_blast_process_new(call, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x20(%rsp)
movl %r9d, 0xc(%rsp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x127b40
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x127b84
movq %r14, %rdi
movq %rbx, %rsi
callq 0x127bce
movsd 0x10(%rsp), %xmm0
ucomisd 0x1e982d(%rip), %xmm0   # 0x347d10
jne 0x15e4e7
jnp 0x15e4ef
movq %r14, %rdi
callq 0x127c18
movl %r13d, %eax
negl %eax
jo 0x15e501
movq %r14, %rdi
movl %r13d, %esi
callq 0x127c6b
movl %r12d, %eax
negl %eax
jo 0x15e513
movq %r14, %rdi
movl %r12d, %esi
callq 0x127cb3
movl %r15d, %eax
negl %eax
jo 0x15e525
movq %r14, %rdi
movl %r15d, %esi
callq 0x127cfb
movl 0xc(%rsp), %esi
movl %esi, %eax
negl %eax
jo 0x15e537
movq %r14, %rdi
callq 0x127de9
movsd 0x20(%rsp), %xmm0
ucomisd 0x1e97cb(%rip), %xmm0   # 0x347d10
jne 0x15e549
jnp 0x15e551
movq %r14, %rdi
callq 0x127e31
movq %r14, %rdi
movq 0x18(%rsp), %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15dfcf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_blast.c
// Function: gt_match_iterator_blast_free
static void gt_match_iterator_blast_free(GtMatchIterator *mp)
{
  GtMatchIteratorBlast *mpb;
  if (!mp) return;
  mpb = gt_match_iterator_blast_cast(mp);
  if (mpb->pvt->matchfilep) {
    if (mpb->pvt->process) {
      pclose(mpb->pvt->matchfilep);
    } else {
      fclose(mpb->pvt->matchfilep);
    }
    mpb->pvt->matchfilep = NULL;
  }
  if (mpb->pvt->gtmatchfilep != NULL)
    gt_file_delete(mpb->pvt->gtmatchfilep);
  gt_free(mpb->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x15e8b3
pushq %rbx
movq %rdi, %rbx
callq 0x15df92
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15de4d
movq %rax, %rbx
movq 0x8(%rax), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x15e8c8
cmpb $0x1, 0x20(%rdi)
jne 0x15e8b4
movq %rax, %rdi
callq 0x17a70
jmp 0x15e8bc
retq
movq %rax, %rdi
callq 0x17800
movq 0x8(%rbx), %rdi
movq $0x0, 0x8(%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x15e8dd
movq %rax, %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
leaq 0x228684(%rip), %rsi    # 0x386f68
movl $0x197, %edx            # imm = 0x197
popq %rbx
jmp 0x1045eb
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_last.c
// Function: gt_match_iterator_last_class
const GtMatchIteratorClass* gt_match_iterator_last_class(void)
{
  static const GtMatchIteratorClass *mpc;
  gt_class_alloc_lock_enter();
  if (!mpc) {
    mpc = gt_match_iterator_class_new(sizeof (GtMatchIteratorLast),
                               gt_match_iterator_last_next,
                               gt_match_iterator_last_free);
  }
  gt_class_alloc_lock_leave();
  return mpc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35fab7(%rip)    # 0x4be7a0
jne 0x15ed0a
leaq 0x26(%rip), %rsi        # 0x15ed18
leaq 0x848(%rip), %rdx       # 0x15f541
movl $0x10, %edi
callq 0x15ddd4
movq %rax, 0x35fa96(%rip)    # 0x4be7a0
callq 0xe2545
movq 0x35fa8a(%rip), %rax    # 0x4be7a0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_last.c
// Function: gt_match_iterator_last_free
static void gt_match_iterator_last_free(GtMatchIterator *mp)
{
  GtMatchIteratorLast *mil;
  if (!mp) return;
  mil = gt_match_iterator_last_cast(mp);
  gt_file_delete(mil->pvt->matchfile);
  gt_str_delete(mil->pvt->matchfilename);
  gt_str_delete(mil->pvt->idxfilename);
  gt_str_delete(mil->pvt->queryfilename);
  gt_str_delete(mil->pvt->linebuf);
  gt_encseq_delete(mil->pvt->es1);
  gt_encseq_delete(mil->pvt->es2);
  gt_hashmap_delete(mil->pvt->desc_to_seqno);
  gt_free(mil->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x15f5de
pushq %rbx
movq %rdi, %rbx
callq 0x15ecdb
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15de4d
movq %rax, %rbx
movq 0x8(%rax), %rax
movq 0x60(%rax), %rdi
callq 0xff22c
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rax
movq 0x40(%rax), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rax
movq 0x58(%rax), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0xea375
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xea375
movq 0x8(%rbx), %rax
movq 0x68(%rax), %rdi
callq 0x10109b
movq 0x8(%rbx), %rdi
leaq 0x227b56(%rip), %rsi    # 0x387129
movl $0x204, %edx            # imm = 0x204
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_last.c
// Function: get_index_parameterization
static int get_index_parameterization(GtMatchIteratorLast *mil, GtStr *out,
                                GT_UNUSED GtError *err)
{
  int had_err = 0;
  gt_assert(mil);
  gt_error_check(err);
  gt_str_reset(out);
  gt_str_append_cstr(out, mil->pvt->tmpdir);
  gt_str_append_cstr(out, "/");
  gt_str_append_cstr(out, gt_encseq_indexname(mil->pvt->es1));
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x15f5fa
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x15f63f
movq %rbx, %rdi
callq 0x11b132
movq 0x8(%r14), %rax
movq 0x38(%rax), %rsi
movq %rbx, %rdi
callq 0x11acf3
leaq 0x1ffb89(%rip), %rsi    # 0x35f1a2
movq %rbx, %rdi
callq 0x11acf3
movq 0x8(%r14), %rax
movq (%rax), %rdi
callq 0xe8e24
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11acf3
callq 0x4c523
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_open.c
// Function: gt_match_iterator_open_new
GtMatchIterator* gt_match_iterator_open_new(const char *matchfile, GtError *err)
{
  GtMatchIterator *mp;
  GtMatchIteratorOpen *mpo;
  mp = gt_match_iterator_create(gt_match_iterator_open_class());
  mpo = (GtMatchIteratorOpen*) mp;
  mpo->pvt = gt_calloc(1, sizeof (GtMatchIteratorOpenMembers));
  GtFileMode mode;
  if (gt_file_exists(matchfile)) {
    mode = gt_file_mode_determine(matchfile);
    if (mode == GT_FILE_MODE_UNCOMPRESSED) {
      mpo->pvt->matchfilep = fopen(matchfile, "r");
      mpo->pvt->gtmatchfilep = NULL;
      if (!mpo->pvt->matchfilep) {
        gt_error_set(err, "Could not open %s", matchfile);
        return NULL;
      }
    } else {
      mpo->pvt->gtmatchfilep = gt_file_open(mode, matchfile, "r", err);
      mpo->pvt->matchfilep = NULL;
      if (!mpo->pvt->gtmatchfilep)
        return NULL;
    }
    mpo->pvt->matchfile = matchfile;
    return mp;
  } else {
    gt_error_set(err, "No such file or directory %s", matchfile);
    return NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x15f8e9
movq %rax, %rdi
callq 0x15ddfd
movq %rax, %rbx
leaq 0x227bd2(%rip), %rdx    # 0x38740c
movl $0x1, %edi
movl $0x20, %esi
movl $0x9e, %ecx
callq 0x10436a
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0xff28c
testb %al, %al
je 0x15f897
movq %r14, %rdi
callq 0xfe990
testl %eax, %eax
je 0x15f8af
leaq 0x1fb5e4(%rip), %rdx    # 0x35ae55
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rcx
callq 0xfead5
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq $0x0, 0x8(%rcx)
testq %rax, %rax
jne 0x15f8d3
xorl %ebx, %ebx
jmp 0x15f8d7
leaq 0x227ba3(%rip), %rsi    # 0x387441
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0x15f8d7
leaq 0x1fb59f(%rip), %rsi    # 0x35ae55
movq %r14, %rdi
callq 0x178b0
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq $0x0, 0x10(%rcx)
testq %rax, %rax
je 0x15f8e0
movq %r14, 0x18(%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x227b48(%rip), %rsi    # 0x38742f
jmp 0x15f89e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_open.c
// Function: gt_match_iterator_open_class
const GtMatchIteratorClass* gt_match_iterator_open_class(void)
{
  static const GtMatchIteratorClass *mpc;
  gt_class_alloc_lock_enter();
  if (!mpc) {
    mpc = gt_match_iterator_class_new(sizeof (GtMatchIteratorOpen),
                               gt_match_iterator_open_next,
                               gt_match_iterator_open_free);
  }
  gt_class_alloc_lock_leave();
  return mpc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35eeb1(%rip)    # 0x4be7a8
jne 0x15f918
leaq 0x26(%rip), %rsi        # 0x15f926
leaq 0x2a0(%rip), %rdx       # 0x15fba7
movl $0x10, %edi
callq 0x15ddd4
movq %rax, 0x35ee90(%rip)    # 0x4be7a8
callq 0xe2545
movq 0x35ee84(%rip), %rax    # 0x4be7a8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_open.c
// Function: gt_match_iterator_open_free
static void gt_match_iterator_open_free(GtMatchIterator *mp)
{
  GtMatchIteratorOpen *mpo;
  if (!mp) return;
  mpo = gt_match_iterator_open_cast(mp);
  if (mpo->pvt->matchfilep != NULL)
    fclose(mpo->pvt->matchfilep);
  if (mpo->pvt->gtmatchfilep != NULL)
    gt_file_delete(mpo->pvt->gtmatchfilep);
  gt_free(mpo->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x15fc03
pushq %rbx
movq %rdi, %rbx
callq 0x15f8e9
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15de4d
movq %rax, %rbx
movq 0x8(%rax), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x15fbdc
movq %rax, %rdi
callq 0x17800
movq 0x8(%rbx), %rdi
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x15fbf1
movq %rax, %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
leaq 0x227814(%rip), %rsi    # 0x38740c
movl $0xc0, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_sw.c
// Function: gt_match_iterator_sw_new
GtMatchIterator* gt_match_iterator_sw_new(GtEncseq *es1, GtEncseq *es2,
                                          GtScoreFunction *sf,
                                          GtUword min_len,
                                          GtUword max_edist,
                                          GT_UNUSED GtError *err)
{
  GtMatchIterator *mi;
  GtMatchIteratorSW *mis;
  gt_assert(es1 && es2 && sf);
  gt_error_check(err);

  mi = gt_match_iterator_create(gt_match_iterator_sw_class());
  mis = (GtMatchIteratorSW*) mi;
  mis->pvt = gt_calloc(1, sizeof (GtMatchIteratorSWMembers));
  mis->pvt->es1 = gt_encseq_ref(es1);
  mis->pvt->es2 = gt_encseq_ref(es2);
  mis->pvt->sf = gt_score_function_ref(sf);
  mis->pvt->min_len = min_len;
  mis->pvt->max_edist = max_edist;
  mis->pvt->firstali = true;
  return mi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15fcf0
movq %rsi, %r12
testq %rsi, %rsi
je 0x15fcf0
movq %rdx, %r15
testq %rdx, %rdx
je 0x15fcf0
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r13
testq %r9, %r9
je 0x15fc4e
movq %r9, %rdi
callq 0xfcc32
testb %al, %al
jne 0x15fcf5
movq 0x35eb5b(%rip), %rdi    # 0x4be7b0
testq %rdi, %rdi
jne 0x15fc7c
leaq 0xcb(%rip), %rsi        # 0x15fd2c
leaq 0x442(%rip), %rdx       # 0x1600aa
movl $0x10, %edi
callq 0x15ddd4
movq %rax, %rdi
movq %rax, 0x35eb34(%rip)    # 0x4be7b0
callq 0x15ddfd
movq %rax, %rbp
leaq 0x227874(%rip), %rdx    # 0x3874ff
movl $0x1, %edi
movl $0x40, %esi
movl $0x85, %ecx
callq 0x10436a
movq %rax, 0x8(%rbp)
movq %r13, %rdi
callq 0xea9be
movq 0x8(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %r12, %rdi
callq 0xea9be
movq 0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %r15, %rdi
callq 0x113321
movq 0x8(%rbp), %rcx
movq %rax, (%rcx)
movq %r14, 0x28(%rcx)
movq %rbx, 0x30(%rcx)
movb $0x1, 0x38(%rcx)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4c603
callq 0x4c63c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_sw.c
// Function: gt_match_iterator_sw_class
const GtMatchIteratorClass* gt_match_iterator_sw_class(void)
{
  static const GtMatchIteratorClass *mic;

  if (!mic) {
    mic = gt_match_iterator_class_new(sizeof (GtMatchIteratorSW),
                                      gt_match_iterator_sw_next,
                                      gt_match_iterator_sw_free);
  }
  return mic;
}

// Assembly:
movq 0x35eaaf(%rip), %rax    # 0x4be7b0
testq %rax, %rax
je 0x15fd07
retq
pushq %rax
leaq 0x1d(%rip), %rsi        # 0x15fd2c
leaq 0x394(%rip), %rdx       # 0x1600aa
movl $0x10, %edi
callq 0x15ddd4
movq %rax, 0x35ea89(%rip)    # 0x4be7b0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_iterator_sw.c
// Function: gt_match_iterator_sw_free
static void gt_match_iterator_sw_free(GtMatchIterator *mi)
{
  GtMatchIteratorSW *mis;
  if (!mi) return;
  mis = gt_match_iterator_sw_cast(mi);
  gt_encseq_delete(mis->pvt->es1);
  gt_encseq_delete(mis->pvt->es2);
  gt_score_function_delete(mis->pvt->sf);
  gt_free(mis->pvt);
}

// Assembly:
testq %rdi, %rdi
je 0x160128
pushq %rbx
movq %rdi, %rbx
movq 0x35e6f6(%rip), %rdi    # 0x4be7b0
testq %rdi, %rdi
jne 0x1600e1
leaq -0x39a(%rip), %rsi      # 0x15fd2c
leaq -0x23(%rip), %rdx       # 0x1600aa
movl $0x10, %edi
callq 0x15ddd4
movq %rax, %rdi
movq %rax, 0x35e6cf(%rip)    # 0x4be7b0
movq %rbx, %rsi
callq 0x15de4d
movq %rax, %rbx
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xea375
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0xea375
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x113372
movq 0x8(%rbx), %rdi
leaq 0x2273e2(%rip), %rsi    # 0x3874ff
movl $0x97, %edx
popq %rbx
jmp 0x1045eb
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_last.c
// Function: gt_match_last_class
const GtMatchClass* gt_match_last_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchLAST),
                                NULL,
                                NULL);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35e67e(%rip)    # 0x4be7b8
jne 0x160151
movl $0x58, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15d7e0
movq %rax, 0x35e667(%rip)    # 0x4be7b8
callq 0xe2545
movq 0x35e65b(%rip), %rax    # 0x4be7b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_last.c
// Function: gt_match_last_new
GtMatch* gt_match_last_new(const char *seqid1,
                           const char *seqid2,
                           GtUword score,
                           GtUword seqno1,
                           GtUword seqno2,
                           GtUword start_seq1,
                           GtUword start_seq2,
                           GtUword end_seq1,
                           GtUword end_seq2,
                           GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchLAST *matchs;
  match = gt_match_create(gt_match_last_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchs = gt_match_last_cast(match);
  matchs->seqno1 = seqno1;
  matchs->seqno2 = seqno2;
  matchs->score = score;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbp
callq 0x16012c
movq %rax, %rdi
movq %r12, %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %r8
movq %rbp, %r9
movl 0x58(%rsp), %eax
pushq %rax
pushq %r13
callq 0x15d813
addq $0x10, %rsp
movq %rax, %r12
callq 0x16012c
movq %rax, %rdi
movq %r12, %rsi
callq 0x15d8b8
movq %r15, 0x40(%rax)
movq %rbx, 0x48(%rax)
movq %r14, 0x50(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_open.c
// Function: gt_match_open_class
const GtMatchClass* gt_match_open_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchOpen),
                                NULL,
                                match_open_accept);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35e5a6(%rip)    # 0x4be7c0
jne 0x160236
leaq 0x21(%rip), %rdx        # 0x160244
movl $0x48, %edi
xorl %esi, %esi
callq 0x15d7e0
movq %rax, 0x35e58a(%rip)    # 0x4be7c0
callq 0xe2545
movq 0x35e57e(%rip), %rax    # 0x4be7c0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_open.c
// Function: match_open_accept
static int match_open_accept(GtMatch *match, GtMatchVisitor *mv, GtError *err)
{
  GtMatchOpen *mo;
  gt_assert(match && mv);
  gt_error_check(err);
  mo = gt_match_open_cast(match);
  return gt_match_visitor_visit_match_open(mv, mo, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x160290
movq %rsi, %r14
testq %rsi, %rsi
je 0x160290
movq %rdx, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x16026d
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x160295
callq 0x16020c
movq %rax, %rdi
movq %r15, %rsi
callq 0x15d8b8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x160501
callq 0x4c751
callq 0x4c788
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_open.c
// Function: gt_match_open_new
GtMatch* gt_match_open_new(char *seqid1,
                           char *seqid2,
                           GtUword start_seq1,
                           GtUword end_seq1,
                           GtUword start_seq2,
                           GtUword end_seq2,
                           GtWord weight,
                           GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchOpen *matcho;
  match = gt_match_create(gt_match_open_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matcho = gt_match_open_cast(match);
  matcho->weight = weight;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x16020c
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rbp, %r9
movl 0x48(%rsp), %eax
pushq %rax
pushq %r13
callq 0x15d813
addq $0x10, %rsp
movq %rax, %rbx
callq 0x16020c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15d8b8
movq 0x40(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_sw.c
// Function: gt_match_sw_class
const GtMatchClass* gt_match_sw_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchSW),
                                NULL,
                                NULL);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35e48e(%rip)    # 0x4be7c8
jne 0x160351
movl $0x60, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15d7e0
movq %rax, 0x35e477(%rip)    # 0x4be7c8
callq 0xe2545
movq 0x35e46b(%rip), %rax    # 0x4be7c8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_sw.c
// Function: gt_match_sw_new
GtMatch* gt_match_sw_new(const char *seqid1,
                         const char *seqid2,
                         GtUword seqno1,
                         GtUword seqno2,
                         GtUword length,
                         GtUword edist,
                         GtUword start_seq1,
                         GtUword start_seq2,
                         GtUword end_seq1,
                         GtUword end_seq2,
                         GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchSW *matchs;
  match = gt_match_create(gt_match_sw_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchs = gt_match_sw_cast(match);
  matchs->alilen = length;
  matchs->seqno1 = seqno1;
  matchs->seqno2 = seqno2;
  matchs->edist = edist;
  return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x16032c
movq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x58(%rsp), %r8
movq %rbp, %r9
movl 0x60(%rsp), %eax
pushq %rax
pushq %r13
callq 0x15d813
addq $0x10, %rsp
movq %rax, %r13
callq 0x16032c
movq %rax, %rdi
movq %r13, %rsi
callq 0x15d8b8
movq %r15, 0x58(%rax)
movq %r12, 0x40(%rax)
movq %r14, 0x48(%rax)
movq %rbx, 0x50(%rax)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_visitor.c
// Function: gt_match_visitor_class_new
const GtMatchVisitorClass*
gt_match_visitor_class_new(size_t size,
                           GtMatchVisitorFreeFunc free,
                           GtMatchVisitorBlastFunc match_blast,
                           GtMatchVisitorOpenFunc match_open)
{
  GtMatchVisitorClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->match_blast = match_blast;
  c_class->match_open = match_open;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16045e
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x2f7c10
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4c909
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_visitor.c
// Function: gt_match_visitor_create
GtMatchVisitor* gt_match_visitor_create(const GtMatchVisitorClass *mvc)
{
  GtMatchVisitor *mv;
  gt_assert(mvc && mvc->size);
  mv = gt_calloc(1, mvc->size);
  mv->c_class = mvc;
  return mv;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x16048f
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x16048f
leaq 0x227228(%rip), %rdx    # 0x3876a3
movl $0x1, %edi
movl $0x33, %ecx
callq 0x10436a
movq %rbx, (%rax)
popq %rbx
retq
callq 0x4c940
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/match_visitor.c
// Function: gt_match_visitor_delete
void gt_match_visitor_delete(GtMatchVisitor *mv)
{
  if (!mv) return;
  gt_assert(mv->c_class);
  if (mv->c_class->free)
    mv->c_class->free(mv);
  gt_free(mv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x160589
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x16058b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x160574
movq %rbx, %rdi
callq *%rax
leaq 0x227128(%rip), %rsi    # 0x3876a3
movq %rbx, %rdi
movl $0x55, %edx
popq %rbx
jmp 0x1045eb
popq %rbx
retq
callq 0x4ca8a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_coord_update
void gt_maxcoordvalue_coord_update(GtMaxcoordvalue *max,
                                   GtWord value,
                                   GtUwordPair start,
                                   GtUword enda, GtUword endb)
{
  gt_assert(max != NULL);

  gt_maxcoordvalue_set_value(max, value);
  gt_maxcoordvalue_set_start_with_pair(max, start);
  gt_maxcoordvalue_set_end(max, enda, endb);
}

// Assembly:
testq %rdi, %rdi
je 0x16064f
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %r9, 0x20(%rdi)
retq
pushq %rax
callq 0x4cbd4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_get_row_length
GtUword gt_maxcoordvalue_get_row_length(const GtMaxcoordvalue *max)
{
  gt_assert(max != NULL);

  GtUword end = (gt_maxcoordvalue_get_end(max)).a;
  GtUword start = (gt_maxcoordvalue_get_start(max)).a;

  gt_assert(end >= start);
  return end-start;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x16067e
movq 0x18(%rdi), %rax
subq 0x8(%rdi), %rax
jb 0x160683
popq %rcx
retq
callq 0x4cc7b
callq 0x4cc42
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_get_col_length
GtUword gt_maxcoordvalue_get_col_length(const GtMaxcoordvalue *max)
{
  gt_assert(max != NULL);

  GtUword end = (gt_maxcoordvalue_get_end(max)).b;
  GtUword start = (gt_maxcoordvalue_get_start(max)).b;

  gt_assert(end >= start);
  return end-start;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x16069a
movq 0x20(%rdi), %rax
subq 0x10(%rdi), %rax
jb 0x16069f
popq %rcx
retq
callq 0x4cced
callq 0x4ccb4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/maxcoordvalue.c
// Function: gt_maxcoordvalue_get_length_safe
bool gt_maxcoordvalue_get_length_safe(const GtMaxcoordvalue *max)
{
  if (gt_maxcoordvalue_get_end(max).a == gt_maxcoordvalue_get_start(max).a &&
      gt_maxcoordvalue_get_end(max).b == gt_maxcoordvalue_get_start(max).b  )
    return false;
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x160622
movq %rax, %r14
movq %rbx, %rdi
callq 0x1605fa
cmpq %rax, %r14
jne 0x1606dc
movq %rbx, %rdi
callq 0x160622
movq %rdx, %r14
movq %rbx, %rdi
callq 0x1605fa
cmpq %rdx, %r14
jne 0x1606dc
xorl %eax, %eax
jmp 0x1606de
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: gt_md5_to_id_visitor_class
const GtNodeVisitorClass* gt_md5_to_id_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtMD5ToSeqidsVisitor),
                                    md5_to_id_visitor_free,
                                    NULL,
                                    md5_to_id_visitor_feature_node,
                                    md5_to_id_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x35e09a(%rip)    # 0x4be7d0
jne 0x16076b
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x160779
leaq 0x53(%rip), %rcx        # 0x1607a1
leaq 0xa2(%rip), %r8         # 0x1607f7
movl $0x18, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x35e065(%rip)    # 0x4be7d0
callq 0xe2545
movq 0x35e059(%rip), %rax    # 0x4be7d0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: md5_to_id_visitor_free
static void md5_to_id_visitor_free(GtNodeVisitor *nv)
{
  GtMD5ToSeqidsVisitor *md5_to_id_visitor =
    md5_to_id_visitor_cast(nv);
  gt_assert(md5_to_id_visitor);
  gt_region_mapping_delete(md5_to_id_visitor->region_mapping);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x160728
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x16079c
movq 0x10(%rax), %rdi
popq %rbx
jmp 0x16d652
callq 0x4cd96
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: gt_md5_to_id_visitor_new
GtNodeVisitor* gt_md5_to_id_visitor_new(GtRegionMapping *region_mapping)
{
  GtNodeVisitor *nv;
  GtMD5ToSeqidsVisitor *md5_to_id_visitor;
  nv = gt_node_visitor_create(gt_md5_to_id_visitor_class());
  md5_to_id_visitor = md5_to_id_visitor_cast(nv);
  md5_to_id_visitor->region_mapping = region_mapping;
  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x160728
movq %rax, %rdi
callq 0x163080
movq %rax, %r14
callq 0x160728
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rbx, 0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5_to_id_visitor.c
// Function: md5_to_seqid
static int md5_to_seqid(GtGenomeNode *gn, GtRegionMapping *region_mapping,
                        GtError *err)
{
  GtStr *seqid;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(gn);
  seqid = gt_genome_node_get_seqid(gn);
  if (gt_md5_seqid_has_prefix(gt_str_get(seqid))) {
    GtStr *new_seqid = gt_str_new();
    /* seqid is a MD5 seqid -> change id */
    if (gt_str_length(seqid) > GT_MD5_SEQID_TOTAL_LEN)
      gt_str_append_cstr(new_seqid, gt_str_get(seqid) + GT_MD5_SEQID_TOTAL_LEN);
    else {
      /* for backward compatibility */
      GtStr *desc = gt_str_new();
      if (!region_mapping) {
        gt_error_set(err, "no region mapping defined");
        had_err = -1;
      }
      if (!had_err) {
        had_err = gt_region_mapping_get_description(region_mapping, desc, seqid,
                                                    err);
      }
      if (!had_err)
        gt_regular_seqid_save(new_seqid, desc);
      gt_str_delete(desc);
    }
    if (!had_err) {
      if (gt_feature_node_try_cast(gn)) {
        M2IChangeSeqidInfo info;
        info.new_seqid = new_seqid;
        info.region_mapping = region_mapping;
        had_err = gt_feature_node_traverse_children((GtFeatureNode*) gn, &info,
                                                    m2i_change_seqid, true,
                                                    err);
      }
      else
        gt_genome_node_change_seqid(gn, new_seqid);
    }
    gt_str_delete(new_seqid);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
testq %rdx, %rdx
je 0x1608ac
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1609c2
testq %r14, %r14
je 0x1609bd
movq %r14, %rdi
callq 0x144635
movq %rax, %r13
movq %rax, %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0x106990
xorl %ebp, %ebp
testb %al, %al
je 0x1609ac
callq 0x11ac6c
movq %rax, %r15
movq %r13, %rdi
callq 0x11b0ca
cmpq $0x26, %rax
jb 0x160938
movq %r13, %rdi
callq 0x11b0a1
leaq 0x25(%rax), %rsi
movq %r15, %rdi
callq 0x11acf3
movq %r14, %rdi
callq 0x143cab
testq %rax, %rax
je 0x160974
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %r12, 0x8(%rsi)
leaq 0xa3(%rip), %rdx        # 0x1609c7
movq %r14, %rdi
movl $0x1, %ecx
movq %rbx, %r8
callq 0x142d9d
movl %eax, %ebp
jmp 0x1609a4
callq 0x11ac6c
movq %rax, %rbp
testq %r12, %r12
je 0x160983
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x16e0cf
movq %rbp, %r13
movl %eax, %ebp
testl %eax, %eax
jne 0x16099c
movq %r15, %rdi
movq %r13, %rsi
callq 0x16ede8
movq %r13, %rdi
callq 0x11bdbf
jmp 0x160904
movq %r14, %rdi
movq %r15, %rsi
callq 0x144709
xorl %ebp, %ebp
jmp 0x1609a4
leaq 0x22705e(%rip), %rsi    # 0x3879e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movq %rbp, %r13
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r13, %rdi
callq 0x11bdbf
movq %r15, %rdi
callq 0x11bdbf
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4ce76
callq 0x4ce3f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5set.c
// Function: gt_md5set_new
GtMD5Set *gt_md5set_new(GtUword nof_elements)
{
  GtMD5Set *md5set;
  md5set = gt_malloc(sizeof (GtMD5Set));
  md5set->fill = 0;
  md5set->alloc = 0;
  md5set->table = NULL;
  md5set_alloc_table(md5set,
                     md5set_get_size(nof_elements + (nof_elements >> 2)));
  gt_assert(nof_elements < md5set->maxfill);
  md5set->buffer = NULL;
  md5set->bufsize = 0;
  return md5set;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x226e14(%rip), %rsi    # 0x387a4a
movl $0x30, %edi
movl $0xc7, %edx
callq 0x104226
movq %rax, %rbx
movq %r14, %rdi
shrq $0x2, %rdi
addq %r14, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
callq 0x160d8e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x160c8d
cmpq %r14, 0x18(%rbx)
jbe 0x160c88
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4cf54
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5set.c
// Function: md5set_alloc_table
static void md5set_alloc_table(GtMD5Set *set, GtUword newsize)
{
  md5_t *oldtable;
  GtUword oldsize;

  oldsize = set->alloc;
  oldtable = set->table;
  set->alloc = newsize;
  set->maxfill =
    (GtUword)((double)newsize * MD5SET_MAX_LOAD_FACTOR);
  set->table = gt_calloc((size_t)newsize, sizeof (md5_t));
  if (oldtable != NULL) {
    gt_log_log("rehashing " GT_WU " elements; old size: " GT_WU ", new size: "
               GT_WU "\n", set->fill, oldsize, newsize);
    md5set_rehash(set, oldtable, oldsize);
    gt_free(oldtable);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
movq %rsi, %xmm0
punpckldq 0x1e6c35(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movq 0x8(%rdi), %r15
subpd 0x1e6c39(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x1ed4fd(%rip), %xmm1   # 0x34e1c8
movq %rsi, 0x8(%rdi)
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x1e7041(%rip), %xmm1   # 0x347d20
cvttsd2si %xmm1, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x18(%rdi)
leaq 0x226d51(%rip), %rdx    # 0x387a4a
movl $0x10, %esi
movq %r12, %rdi
movl $0xbb, %ecx
callq 0x10436a
movq %rax, (%r14)
testq %rbx, %rbx
je 0x160d82
movq 0x10(%r14), %rsi
leaq 0x226da4(%rip), %rdi    # 0x387ac2
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x103d72
movq $0x0, 0x10(%r14)
testq %r15, %r15
je 0x160d63
leaq 0x8(%rbx), %r12
movq -0x8(%r12), %rsi
movq (%r12), %rdx
movq %rsi, %rax
orq %rdx, %rax
je 0x160d5a
movq %r14, %rdi
movl $0x1, %ecx
callq 0x161000
addq $0x10, %r12
decq %r15
jne 0x160d3c
leaq 0x226ce0(%rip), %rsi    # 0x387a4a
movq %rbx, %rdi
movl $0xc0, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5set.c
// Function: md5set_get_size
static GtUword md5set_get_size(GtUword n)
{
  GtUint64 u, l, i, k, k_i;

  k = (GtUint64)n;
  if (k > GT_MD5SET_LARGEST_PRIME) {
    fprintf(stderr, MD5SET_TOO_LARGE, k);
    exit(1);
  }
  if (k < gt_md5set_primes[0])
    return (GtUword)gt_md5set_primes[0];
  l = 0;
  u = GT_MD5SET_NOFPRIMES - 1;
  do {
    i = (l + u) >> 1;
    gt_assert(u >= l);
    if (u - l == 1) {
      return (gt_md5set_primes[l] == k)
          ? (GtUword)k
          : (GtUword)gt_md5set_primes[u];
    }
    k_i = gt_md5set_primes[i];
    if (k < k_i) {
      u = i;
    }
    else if (k > k_i) {
      l = i;
    }
    else {
      return (GtUword)k_i;
    }
  } while (1);
  return 0;
}

// Assembly:
pushq %rax
movabsq $0x7fc0002764, %rax     # imm = 0x7FC0002764
cmpq %rax, %rdi
jae 0x160dff
movl $0x100007, %eax         # imm = 0x100007
cmpq $0x100007, %rdi         # imm = 0x100007
jb 0x160dfd
movl $0x97f, %ecx            # imm = 0x97F
movl $0x4bf, %r8d            # imm = 0x4BF
xorl %esi, %esi
leaq 0x226e20(%rip), %rdx    # 0x387be0
movq %rcx, %rax
subq %rsi, %rax
cmpq $0x1, %rax
je 0x160df0
movq (%rdx,%r8,8), %rax
cmpq %rdi, %rax
jbe 0x160dda
movq %r8, %rcx
jmp 0x160ddf
movq %r8, %rsi
jae 0x160dfd
leaq (%rcx,%rsi), %r8
shrq %r8
cmpq %rsi, %rcx
jae 0x160dc0
callq 0x4cf8d
movq %rdi, %rax
cmpq %rdi, (%rdx,%rsi,8)
je 0x160dfd
movq (%rdx,%rcx,8), %rax
popq %rcx
retq
callq 0x4cfc4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5set.c
// Function: gt_md5set_delete
void gt_md5set_delete(GtMD5Set *set)
{
  if (set != NULL) {
    gt_free(set->table);
    gt_free(set->buffer);
    gt_free(set);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x160e4f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x226c30(%rip), %r14    # 0x387a4a
movq %r14, %rsi
movl $0xd6, %edx
callq 0x1045eb
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0xd7, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0xd8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/md5set.c
// Function: md5set_search
static bool md5set_search(GtMD5Set *set, md5_t k, bool insert_if_not_found)
{
  GtUword i, c;
#ifndef NDEBUG
  GtUword first_i;
#endif
  enum MD5SetSearchResult retval;

  i = (GtUword) MD5SET_H1(k, set->alloc);
  retval = md5set_search_pos(set, k, insert_if_not_found, i);
  if (retval != GT_MD5SET_COLLISION)
    return retval == GT_MD5SET_EMPTY ? false : true;

  /* open addressing by double hashing */
  c = (GtUword) MD5SET_H2(k, set->alloc);
  gt_assert(c > 0);
#ifndef NDEBUG
  first_i = i;
#endif
  while (1) {
    i = (i + c) % set->alloc;
    gt_assert(i != first_i);
    retval = md5set_search_pos(set, k, insert_if_not_found, i);
    if (retval != GT_MD5SET_COLLISION)
      return retval == GT_MD5SET_EMPTY ? false : true;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r8
movq 0x8(%rdi), %rdi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %r12
movq %rdx, %rax
shlq $0x4, %rax
leaq (%r8,%rax), %rdx
movq (%r8,%rax), %rax
testq %rax, %rax
jne 0x161043
cmpq $0x0, 0x8(%rdx)
je 0x161100
cmpq %r14, %rax
jne 0x161054
movb $0x1, %al
cmpq %rbx, 0x8(%rdx)
je 0x16114d
leaq -0x1(%rdi), %rsi
movq %rbx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %rsi
leaq (%rdx,%r12), %rax
incq %rax
xorl %edx, %edx
divq %rdi
cmpq %r12, %rdx
je 0x1610b3
movq %rdx, %r13
incq %rsi
movq %r13, %rdx
shlq $0x4, %rdx
leaq (%r8,%rdx), %rax
movq (%r8,%rdx), %rdx
testq %rdx, %rdx
jne 0x161095
cmpq $0x0, 0x8(%rax)
je 0x1610bf
cmpq %r14, %rdx
jne 0x1610a0
cmpq %rbx, 0x8(%rax)
je 0x1610b8
addq %rsi, %r13
movq %r13, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %r13
cmpq %r12, %rdx
jne 0x16107a
callq 0x4d0ca
movb $0x1, %al
jmp 0x16114d
testb %cl, %cl
je 0x16114b
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
incq %rax
movq %rax, 0x10(%r15)
cmpq %rcx, %rax
jbe 0x1610f6
incq %rdi
callq 0x160d8e
movq %r15, %rdi
movq %rax, %rsi
callq 0x160c8d
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
cmpq %rcx, %rax
jbe 0x16113b
callq 0x4d093
testb %cl, %cl
je 0x16114b
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
incq %rax
movq %rax, 0x10(%r15)
cmpq %rcx, %rax
jbe 0x161133
incq %rdi
callq 0x160d8e
movq %r15, %rdi
movq %rax, %rsi
callq 0x160c8d
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movq %r12, %r13
cmpq %rcx, %rax
ja 0x161157
movq (%r15), %rax
shlq $0x4, %r13
movq %r14, (%rax,%r13)
movq %rbx, 0x8(%rax,%r13)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4d103