LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_kmer_iter_reset
static void gt_diagbandseed_kmer_iter_reset(GtDiagbandseedKmerIterator *ki)
{
  gt_assert(ki != NULL);
  ki->at_list_end = false;
  if (ki->original != NULL) /* list based */
  {
    if (ki->section.encode_info != NULL)
    {
      ki->listptr_uword = ki->original->spaceGtUword;
      ki->section.spaceGtUword = ki->original->spaceGtUword;
      ki->listptr_struct = ki->section.spaceGtDiagbandseedKmerPos;
    } else
    {
      ki->listptr_struct = ki->original->spaceGtDiagbandseedKmerPos;
      ki->section.spaceGtDiagbandseedKmerPos
        = ki->original->spaceGtDiagbandseedKmerPos;
    }
    if (gt_kmerpos_list_num_entries(ki->original) == 0)
    {
      ki->at_list_end = true;
    }
  } else /* file based */
  {
    if (ki->section.encode_info != NULL)
    {
      ki->kmerstream_uword.nextread = ki->kmerstream_uword.nextfree = 0;
      fseek(ki->kmerstream_uword.fp,sizeof (GtLongestCodeRunType),SEEK_SET);
      if (gt_readnextfromstream_GtUword(&ki->buffer_uword,
                                        &ki->kmerstream_uword) != 1)
      {
        ki->at_list_end = true;
      }
    } else
    {
      ki->kmerstream_struct.nextread = ki->kmerstream_struct.nextfree = 0;
      fseek(ki->kmerstream_struct.fp,sizeof (GtLongestCodeRunType),SEEK_SET);
      if (gt_readnextfromstream_GtDiagbandseedKmerPos(ki->listptr_struct,
                                                      &ki->kmerstream_struct)
                                                      != 1)
      {
        ki->at_list_end = true;
      }
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19d360
movq %rdi, %rbx
movb $0x0, 0x30(%rdi)
movq 0x28(%rdi), %rax
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x19d2dd
testq %rax, %rax
je 0x19d312
movq 0x8(%rdi), %rax
movq %rax, 0x58(%rbx)
movq %rax, 0x8(%rbx)
movq (%rbx), %rax
movq %rax, 0x48(%rbx)
jmp 0x19d31c
testq %rax, %rax
je 0x19d332
leaq 0x78(%rbx), %r14
movq $0x0, 0x78(%rbx)
movq 0x88(%rbx), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x17890
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x19fd6f
jmp 0x19d35a
movq (%rdi), %rax
movq %rax, 0x48(%rbx)
movq %rax, (%rbx)
callq 0x19cb36
testq %rax, %rax
jne 0x19d32a
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x60(%rbx), %r14
movq $0x0, 0x60(%rbx)
movq 0x70(%rbx), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x17890
movq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x19fde2
testl %eax, %eax
jne 0x19d32a
jmp 0x19d326
callq 0x5e812
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_seedpairlist_length
static GtUword gt_seedpairlist_length(const GtSeedpairlist *seedpairlist)
{
  gt_assert(seedpairlist != NULL);
  if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_STRUCT)
  {
    gt_assert(seedpairlist->mlist_struct != NULL);
    return seedpairlist->mlist_struct->nextfreeGtDiagbandseedSeedPair;
  } else
  {
    if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
    {
      gt_assert(seedpairlist->mlist_ulong != NULL);
      return seedpairlist->mlist_ulong->nextfreeGtUword;
    } else
    {
      gt_assert(seedpairlist->mlist_bytestring != NULL &&
                (seedpairlist->mlist_bytestring->nextfreeuint8_t %
                 seedpairlist->bytes_seedpair == 0));
      return seedpairlist->mlist_bytestring->nextfreeuint8_t/
             seedpairlist->bytes_seedpair;
    }
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x19d86f
movl 0x18(%rdi), %eax
cmpl $0x1, %eax
je 0x19d843
testl %eax, %eax
jne 0x19d852
movq (%rdi), %rax
testq %rax, %rax
jne 0x19d84c
callq 0x5ea4c
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x19d879
movq 0x10(%rax), %rax
jmp 0x19d86d
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x19d874
movq 0x10(%rax), %rax
xorl %edx, %edx
divq 0x90(%rdi)
testq %rdx, %rdx
jne 0x19d874
popq %rcx
retq
callq 0x5eabe
callq 0x5ea85
callq 0x5ea13
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_seedpairlist_delete
static void gt_seedpairlist_delete(GtSeedpairlist *seedpairlist)
{
  if (seedpairlist != NULL)
  {
    if (seedpairlist->mlist_struct != NULL)
    {
      GT_FREEARRAY(seedpairlist->mlist_struct, GtDiagbandseedSeedPair);
      gt_free(seedpairlist->mlist_struct);
    }
    if (seedpairlist->mlist_ulong != NULL)
    {
      GT_FREEARRAY(seedpairlist->mlist_ulong, GtUword);
      gt_free(seedpairlist->mlist_ulong);
    }
    if (seedpairlist->mlist_bytestring != NULL)
    {
      GT_FREEARRAY(seedpairlist->mlist_bytestring, uint8_t);
      gt_free(seedpairlist->mlist_bytestring);
    }
    gt_free(seedpairlist);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x19dd2c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x19dc85
movq (%rax), %rdi
testq %rdi, %rdi
je 0x19dc71
leaq 0x20b476(%rip), %rsi    # 0x3a90cc
movl $0x60b, %edx            # imm = 0x60B
callq 0x109670
movq (%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rdi
leaq 0x20b451(%rip), %rsi    # 0x3a90cc
movl $0x60c, %edx            # imm = 0x60C
callq 0x109670
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x19dcce
movq (%rax), %rdi
testq %rdi, %rdi
je 0x19dcb9
leaq 0x20b42f(%rip), %rsi    # 0x3a90cc
movl $0x610, %edx            # imm = 0x610
callq 0x109670
movq 0x8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
leaq 0x20b408(%rip), %rsi    # 0x3a90cc
movl $0x611, %edx            # imm = 0x611
callq 0x109670
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x19dd17
movq (%rax), %rdi
testq %rdi, %rdi
je 0x19dd02
leaq 0x20b3e6(%rip), %rsi    # 0x3a90cc
movl $0x615, %edx            # imm = 0x615
callq 0x109670
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x10(%rbx), %rdi
leaq 0x20b3bf(%rip), %rsi    # 0x3a90cc
movl $0x616, %edx            # imm = 0x616
callq 0x109670
leaq 0x20b3ae(%rip), %rsi    # 0x3a90cc
movq %rbx, %rdi
movl $0x618, %edx            # imm = 0x618
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_seedpairlist_sort
static void gt_diagbandseed_seedpairlist_sort(GtSeedpairlist *seedpairlist)
{
  GtUword mlistlen = gt_seedpairlist_length(seedpairlist);

  if (mlistlen > 0)
  {
    if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_STRUCT)
    {
      gt_assert(seedpairlist->mlist_struct != NULL);
      gt_radixsort_inplace_Gtuint64keyPair(
            (Gtuint64keyPair *) seedpairlist->mlist_struct
                                            ->spaceGtDiagbandseedSeedPair,
            mlistlen);
    } else
    {
      if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
      {
        gt_assert(seedpairlist->mlist_ulong != NULL);
        gt_radixsort_inplace_ulong(seedpairlist->mlist_ulong->spaceGtUword,
                                   mlistlen);
      } else
      {
        gt_assert(seedpairlist->mlist_bytestring != NULL);
        gt_radixsort_inplace_flba(seedpairlist->mlist_bytestring->spaceuint8_t,
                                  gt_seedpairlist_length(seedpairlist),
                                  seedpairlist->bytes_seedpair);
      }
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x19d824
testq %rax, %rax
je 0x19fe90
movl 0x18(%rbx), %ecx
cmpl $0x1, %ecx
je 0x19fe98
testl %ecx, %ecx
jne 0x19feb3
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x19fee0
movq (%rcx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x115391
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x19fee5
movq (%rcx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x114e0b
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x19feea
movq (%rax), %r14
movq %rbx, %rdi
callq 0x19d824
movq 0x90(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1153d3
callq 0x5f2a0
callq 0x5f267
callq 0x5f2d9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_seedpairlist_at
static void gt_seedpairlist_at(GtDiagbandseedSeedPair *seedpair,
                               const GtSeedpairlist *seedpairlist,
                               GtUword spidx)
{
  if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_STRUCT)
  {
    *seedpair = seedpairlist->mlist_struct->spaceGtDiagbandseedSeedPair[spidx];
  } else
  {
    if (seedpairlist->splt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
    {
      GtDiagbandseedPosition apos, bpos;

      seedpair->aseqnum
        = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_aseqnum);
      seedpair->bseqnum
        = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_bseqnum);
      apos = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_apos),
      bpos = gt_seedpairlist_extract_ulong_at(seedpairlist,spidx,idx_bpos);
      GT_DIAGBANDSEED_SETPOS(seedpair,apos,bpos); /* set for ulong */
    } else
    {
      gt_diagbandseed_decode_seedpair(seedpair,seedpairlist,
                                      spidx * seedpairlist->bytes_seedpair);
    }
  }
}

// Assembly:
movl 0x18(%rsi), %eax
cmpl $0x1, %eax
je 0x19ff0d
testl %eax, %eax
jne 0x19ff5d
movq (%rsi), %rax
movq (%rax), %rax
shlq $0x4, %rdx
movups (%rax,%rdx), %xmm0
movups %xmm0, (%rdi)
retq
movq 0x8(%rsi), %rax
movq (%rax), %rax
movq (%rax,%rdx,8), %rax
movb 0x98(%rsi), %cl
movq %rax, %rdx
shrq %cl, %rdx
andl 0x20(%rsi), %edx
movl %edx, 0x4(%rdi)
movb 0x9c(%rsi), %cl
movq %rax, %rdx
shrq %cl, %rdx
andl 0x28(%rsi), %edx
movl %edx, (%rdi)
movb 0xa4(%rsi), %cl
movq %rax, %rdx
shrq %cl, %rdx
movb 0xa0(%rsi), %cl
andl 0x38(%rsi), %edx
shrq %cl, %rax
andl 0x30(%rsi), %eax
movl %eax, 0xc(%rdi)
movl %edx, 0x8(%rdi)
retq
imulq 0x90(%rsi), %rdx
jmp 0x19ff67
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_decode_seedpair
static void gt_diagbandseed_decode_seedpair(GtDiagbandseedSeedPair *seedpair,
                                            const GtSeedpairlist *seedpairlist,
                                            GtUword offset)
{
  GtUword transfer, value_seqnums, value_positions;
  GtDiagbandseedPosition apos, bpos;
  const uint8_t *bytestring = seedpairlist->mlist_bytestring->spaceuint8_t +
                              offset;

  value_seqnums
    = gt_diagbandseed_bytestring2GtUword(bytestring,sizeof (GtUword));
  seedpair->aseqnum = (GtDiagbandseedSeqnum)
                      ((value_seqnums >>
                        seedpairlist->bits_left_adjust[idx_aseqnum]) &
                       seedpairlist->mask_tab[idx_aseqnum]);
  seedpair->bseqnum = (GtDiagbandseedSeqnum)
                      ((value_seqnums >>
                        seedpairlist->bits_left_adjust[idx_bseqnum]) &
                       seedpairlist->mask_tab[idx_bseqnum]);
  transfer = value_seqnums & seedpairlist->transfer_mask;
  value_positions
    = gt_diagbandseed_bytestring2GtUword(bytestring + sizeof (GtUword),
                                         seedpairlist->bytes_seedpair -
                                         sizeof (GtUword));
  value_positions >>= seedpairlist->bits_unused_in2GtUwords;
  value_positions |= (transfer << seedpairlist->transfer_shift);
  apos = (GtDiagbandseedPosition) (value_positions &
                                   seedpairlist->mask_tab[idx_apos]);
  bpos = (GtDiagbandseedPosition) (value_positions >>
                                   seedpairlist->bits_values[idx_apos]);
  GT_DIAGBANDSEED_SETPOS(seedpair,apos,bpos); /* for splt bytestring */
}

// Assembly:
pushq %rbx
movq 0x10(%rsi), %rax
addq (%rax), %rdx
movl $0x38, %ecx
xorl %eax, %eax
movq %rdx, %r8
movzbl (%r8), %r9d
shlq %cl, %r9
orq %r9, %rax
addq $-0x8, %rcx
incq %r8
cmpq $-0x8, %rcx
jne 0x19ff79
movb 0x86(%rsi), %cl
movq %rax, %r8
shrq %cl, %r8
andl 0x20(%rsi), %r8d
movl %r8d, 0x4(%rdi)
movb 0x88(%rsi), %cl
movq %rax, %r8
shrq %cl, %r8
andl 0x28(%rsi), %r8d
movl %r8d, (%rdi)
movq 0x40(%rsi), %r8
movq 0x90(%rsi), %r10
cmpq $0x8, %r10
je 0x19ffee
movl $0x38, %ecx
movl $0x8, %r11d
xorl %r9d, %r9d
movzbl (%rdx,%r11), %ebx
shlq %cl, %rbx
orq %rbx, %r9
addl $-0x8, %ecx
incq %r11
cmpq %r11, %r10
jne 0x19ffd6
jmp 0x19fff1
xorl %r9d, %r9d
andq %rax, %r8
movb 0xac(%rsi), %cl
shrq %cl, %r9
movb 0xa8(%rsi), %cl
shlq %cl, %r8
movb 0x80(%rsi), %cl
orq %r9, %r8
movl 0x38(%rsi), %eax
andl %r8d, %eax
shrq %cl, %r8
movl %r8d, 0xc(%rdi)
movl %eax, 0x8(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_segment_reject_register_match
static void gt_segment_reject_register_match(GtSegmentRejectInfo
                                                *segment_reject_info,
                                             GtUword bseqnum)
{
  GtUword idx;

  gt_assert(segment_reject_info !=NULL);
  idx = bseqnum - segment_reject_info->b_firstseq;
  gt_assert(bseqnum >= segment_reject_info->b_firstseq &&
            idx < segment_reject_info->b_numsequences &&
            !GT_ISIBITSET(segment_reject_info->b_bitsequence,idx));
  GT_SETIBIT(segment_reject_info->b_bitsequence,idx);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1a0c19
subq (%rdi), %rsi
jb 0x1a0c14
cmpq 0x8(%rdi), %rsi
jae 0x1a0c14
movq 0x10(%rdi), %rax
movq %rsi, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rdi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movl %esi, %ecx
shrq %cl, %r8
testq %r8, %rdi
jne 0x1a0c14
orq %r8, %rdi
movq %rdi, (%rax,%rdx,8)
popq %rax
retq
callq 0x5f54c
callq 0x5f585
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_set_sequence
static void gt_diagbandseed_set_sequence(GtSeqorEncseq *seqorencseq,
                                         const GtSequencePartsInfo *seqranges,
                                         const GtUchar *bytesequence,
                                         GtUword first_seqstartpos,
                                         GtUword seqnum,
                                         const GtUchar *characters,
                                         GtUchar wildcardshow,
                                         bool haswildcards,
                                         const GtEncseq *encseq_for_seq_desc)
{
  const GtUword
    seqstartpos = gt_sequence_parts_info_seqstartpos(seqranges,seqnum),
    seqendpos = gt_sequence_parts_info_seqendpos(seqranges,seqnum),
    b_off = seqstartpos - first_seqstartpos;
  const char *seqdescptr;
  if (encseq_for_seq_desc != NULL)
  {
    GtUword desclen;
    seqdescptr = gt_encseq_description(encseq_for_seq_desc,
                                       &desclen,
                                       seqnum);
  } else
  {
    seqdescptr = "Unknown";
  }
  GT_SEQORENCSEQ_INIT_SEQ(seqorencseq,bytesequence + b_off,seqdescptr,
                          seqendpos - seqstartpos + 1,characters,
                          wildcardshow,
                          haswildcards);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r14
movq %rsi, %rdi
movq %r8, %rsi
callq 0x1eb7dc
movq %rax, %r13
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x1eb802
movq 0x60(%rsp), %rdi
movq %rax, %rbp
testq %rdi, %rdi
je 0x1a0c75
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0xf079f
jmp 0x1a0c7c
leaq 0x209e82(%rip), %rax    # 0x3aaafe
subq %r13, %rbp
subq %r12, %r13
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
addq %r13, %r15
movq %r15, (%r14)
movq %rax, 0x10(%r14)
incq %rbp
movq %rbp, 0x20(%r14)
movq %rcx, 0x18(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%r14)
movb 0x50(%rsp), %al
movb %al, 0x30(%r14)
movb 0x58(%rsp), %al
movb %al, 0x31(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_bstart_ldesc_compare_mems
static int gt_diagbandseed_bstart_ldesc_compare_mems(const void *vl,
                                                     const void *vr)
{
  GtDiagbandseedMaximalmatch *l = (GtDiagbandseedMaximalmatch *) vl,
                             *r = (GtDiagbandseedMaximalmatch *) vr;
  GtDiagbandseedPosition lapos = l->apos + 1 - l->len,
                         lbpos = l->bpos + 1 - l->len,
                         rapos = r->apos + 1 - r->len,
                         rbpos = r->bpos + 1 - r->len;
  if (lbpos < rbpos)
  {
    return -1;
  }
  if (lbpos > rbpos)
  {
    return 1;
  }
  if (l->len < r->len)
  {
    return 1;
  }
  if (l->len > r->len)
  {
    return -1;
  }
  if (lapos < rapos)
  {
    return -1;
  }
  if (lapos > rapos)
  {
    return 1;
  }
  gt_assert(false);
  return 0;
}

// Assembly:
movl 0x8(%rdi), %ecx
movl 0x4(%rdi), %r8d
subl %ecx, %r8d
incl %r8d
movl 0x8(%rsi), %edx
movl 0x4(%rsi), %r9d
subl %edx, %r9d
incl %r9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r9d, %r8d
jae 0x1a0e37
retq
cmpl %edx, %ecx
jb 0x1a0e69
cmpl %r9d, %r8d
ja 0x1a0e69
movl (%rdi), %edi
subl %ecx, %edi
incl %edi
movl (%rsi), %esi
subl %edx, %esi
incl %esi
cmpl %edx, %ecx
seta %cl
cmpl %esi, %edi
setb %dl
orb %cl, %dl
jne 0x1a0e36
movl $0x1, %eax
cmpl %esi, %edi
ja 0x1a0e36
pushq %rax
callq 0x5f5f7
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_chain_out
static void gt_diagbandseed_chain_out(void *data,
                                      const GtChain2Dimmatchtable *matchtable,
                                      const GtChain2Dim *chain)
{
  GtUword idx, chainlength;
  const GtDiagbandseedSequencePair *sequencepair
    = (const GtDiagbandseedSequencePair *) data;

  gt_assert(chain != NULL);
  chainlength = gt_chain_chainlength(chain);
  printf("# chain of length " GT_WU " with score " GT_WD "\n",
         chainlength,gt_chain_chainscore(chain));

  gt_assert(!gt_chain_storedinreverseorder(chain));
  for (idx = 0; idx < chainlength; idx++)
  {
    GtChain2Dimmatchvalues value;

    gt_chain_extractchainelem(&value, matchtable, chain, idx);
    gt_assert(value.startpos[0] <= value.endpos[0] &&
              value.weight >= 0 &&
              value.endpos[0] - value.startpos[0] + 1
                        == (GtUword) value.weight &&
              value.startpos[1] <= value.endpos[1] &&
              value.endpos[1] - value.startpos[1] + 1
                        == (GtUword) value.weight);

    gt_diagbandseed_printchainelem(stdout,
                                   sequencepair->aseqnum,
                                   value.startpos[0],
                                   sequencepair->bseqnum,
                                   value.startpos[1],
                                   (GtUword) value.weight);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdx, %rdx
je 0x1a0f63
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x19691e
movq %rax, %r12
movq %rbx, %rdi
callq 0x196919
leaq 0x209ea8(%rip), %rdi    # 0x3aad51
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq %rbx, %rdi
callq 0x196923
testb %al, %al
jne 0x1a0f68
testq %r12, %r12
je 0x1a0f4f
leaq 0x208355(%rip), %rbp    # 0x3a922b
xorl %r13d, %r13d
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x196927
movq (%rsp), %r8
movq 0x10(%rsp), %rax
subq %r8, %rax
jb 0x1a0f5e
movq 0x20(%rsp), %rdx
testq %rdx, %rdx
js 0x1a0f5e
incq %rax
cmpq %rdx, %rax
jne 0x1a0f5e
movq 0x8(%rsp), %r10
movq 0x18(%rsp), %rax
subq %r10, %rax
jb 0x1a0f5e
incq %rax
cmpq %rdx, %rax
jne 0x1a0f5e
movq 0x322fc0(%rip), %rax    # 0x4c3ee8
movq (%rax), %rdi
movl (%r15), %ecx
movl 0x4(%r15), %r11d
movq %rbp, %rsi
movq %rdx, %r9
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x17ab0
addq $0x10, %rsp
incq %r13
cmpq %r13, %r12
jne 0x1a0ed9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5f630
callq 0x5f6a2
callq 0x5f669
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/echoseq.c
// Function: gt_symbolstring2fasta
void gt_symbolstring2fasta(FILE *fpout,
                        const char *desc,
                        const GtAlphabet *alpha,
                        const GtUchar *w,
                        GtUword wlen,
                        GtUword width)
{
  GtUword i, j;
  GtUchar currentchar;

  gt_assert(width > 0);
  if (desc == NULL)
  {
    fprintf(fpout,">\n");
  } else
  {
    fprintf(fpout,">%s\n",desc);
  }
  for (i = 0, j = 0; ; i++)
  {
    currentchar = w[i];
    if (currentchar == (GtUchar) GT_SEPARATOR)
    {
      fprintf(fpout,"\n>\n");
      j = 0;
    } else
    {
      gt_alphabet_echo_pretty_symbol(alpha,fpout,currentchar);
    }
    if (i == wlen - 1)
    {
      fprintf(fpout,"\n");
      break;
    }
    if (currentchar != (GtUchar) GT_SEPARATOR)
    {
      j++;
      if (j >= width)
      {
        fprintf(fpout,"\n");
        j = 0;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %r9, 0x8(%rsp)
testq %r9, %r9
je 0x1a1051
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %rdx
movq %rdi, %r12
testq %rsi, %rsi
je 0x1a0fb5
leaq 0x1b223a(%rip), %rsi    # 0x3531e3
movq %r12, %rdi
xorl %eax, %eax
callq 0x17ab0
jmp 0x1a0fce
leaq 0x20a2a6(%rip), %rdi    # 0x3ab262
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x17fa0
decq %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
movb (%r15,%rbp), %r13b
cmpb $-0x1, %r13b
je 0x1a0ff2
movzbl %r13b, %edx
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xd3aa3
jmp 0x1a100d
movl $0x3, %esi
movl $0x1, %edx
leaq 0x20a25e(%rip), %rdi    # 0x3ab261
movq %r12, %rcx
callq 0x17fa0
xorl %ebx, %ebx
cmpq %rbp, %r14
je 0x1a1036
cmpb $-0x1, %r13b
je 0x1a1031
incq %rbx
cmpq 0x8(%rsp), %rbx
jb 0x1a1031
movl $0xa, %edi
movq %r12, %rsi
callq 0x17980
xorl %ebx, %ebx
incq %rbp
jmp 0x1a0fd5
movl $0xa, %edi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17980
callq 0x5f6db
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/echoseq.c
// Function: gt_encseq2symbolstring
void gt_encseq2symbolstring(FILE *fpout,
                            const GtEncseq *encseq,
                            GtReadmode readmode,
                            GtUword start,
                            GtUword wlen,
                            GtUword width)
{
  GtUword j, idx, lastpos;
  GtUchar currentchar;
  GtEncseqReader *esr;
  const GtAlphabet *alpha;

  esr = gt_encseq_create_reader_with_readmode(encseq, readmode, start);
  gt_assert(width > 0);
  lastpos = start + wlen - 1;
  alpha = gt_encseq_alphabet(encseq);
  for (idx = start, j = 0; /* Nothing */ ; idx++)
  {
    currentchar = gt_encseq_reader_next_encoded_char(esr);
    if (currentchar == (GtUchar) GT_SEPARATOR)
    {
      fprintf(fpout,"\n>\n");
      j = 0;
    } else
    {
      gt_alphabet_echo_pretty_symbol(alpha,fpout,currentchar);
    }
    if (idx == lastpos)
    {
      fprintf(fpout,"\n");
      break;
    }
    if (currentchar != (GtUchar) GT_SEPARATOR)
    {
      j++;
      if (j >= width)
      {
        fprintf(fpout,"\n");
        j = 0;
      }
    }
  }
  gt_encseq_reader_delete(esr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0xed76d
movq %rbx, (%rsp)
testq %rbx, %rbx
je 0x1a111b
movq %rax, %r12
movq %r13, %rdi
callq 0xf02da
movq %rax, %r13
decq %r14
xorl %ebx, %ebx
movq %r12, %rdi
callq 0xec7be
movl %eax, %ebp
cmpb $-0x1, %al
je 0x1a10b9
movzbl %bpl, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0xd3aa3
jmp 0x1a10d4
movl $0x3, %esi
movl $0x1, %edx
leaq 0x20a197(%rip), %rdi    # 0x3ab261
movq %r15, %rcx
callq 0x17fa0
xorl %ebx, %ebx
subq $0x1, %r14
jb 0x1a10f8
cmpb $-0x1, %bpl
je 0x1a109a
incq %rbx
cmpq (%rsp), %rbx
jb 0x1a109a
movl $0xa, %edi
movq %r15, %rsi
callq 0x17980
jmp 0x1a1098
movl $0xa, %edi
movq %r15, %rsi
callq 0x17980
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xed7bf
callq 0x5f712
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/echoseq.c
// Function: gt_fprintfencseq
void gt_fprintfencseq(FILE *fpout,
                      const GtEncseq *encseq,
                      GtUword start,
                      GtUword wlen)
{
  GtUword idx;
  GtUchar currentchar;
  const GtAlphabet *alpha;

  alpha = gt_encseq_alphabet(encseq);
  for (idx = start; idx < start + wlen; idx++)
  {
    currentchar = gt_encseq_get_encoded_char(encseq,
                                                    idx,
                                                    GT_READMODE_FORWARD);
    gt_assert(GT_ISNOTSPECIAL(currentchar));
    gt_alphabet_echo_pretty_symbol(alpha,fpout,currentchar);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0xf02da
movq %rax, %r13
leaq (%rbx,%r14), %rax
cmpq %r14, %rax
jbe 0x1a1170
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xec1f8
cmpb $-0x2, %al
jae 0x1a117a
movzbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0xd3aa3
incq %r14
decq %rbx
jne 0x1a1149
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5f749
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/echoseq.c
// Function: gt_encseq2fastaoutput
void gt_encseq2fastaoutput(FILE *fpout,
                           const char *desc,
                           const GtEncseq *encseq,
                           GtReadmode readmode,
                           GtUword start,
                           GtUword wlen,
                           GtUword width)
{
  gt_assert(width > 0);
  if (desc == NULL)
  {
    fprintf(fpout,">\n");
  } else
  {
    fprintf(fpout,">%s\n",desc);
  }
  gt_encseq2symbolstring(fpout,
                         encseq,
                         readmode,
                         start,
                         wlen,
                         width);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsp), %r15
testq %r15, %r15
je 0x1a11fa
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %r13
testq %rsi, %rsi
je 0x1a11bd
leaq 0x1b2032(%rip), %rsi    # 0x3531e3
movq %r13, %rdi
xorl %eax, %eax
callq 0x17ab0
jmp 0x1a11d6
leaq 0x20a09e(%rip), %rdi    # 0x3ab262
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x17fa0
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
movq %r15, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a1056
callq 0x5f782
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/echoseq.c
// Function: gt_echodescriptionandsequence
int gt_echodescriptionandsequence(const GtStrArray *filenametab,GtError *err)
{
  GtSeqIterator *seqit;
  char *desc = NULL;
  const GtUchar *sequence;
  GtUword seqlen;
  bool haserr = false;
  int retval;

  seqit = gt_seq_iterator_sequence_buffer_new(filenametab, err);
  if (!seqit)
    return -1;
  while (true)
  {
    retval = gt_seq_iterator_next(seqit,
                                 &sequence,
                                 &seqlen,
                                 &desc,
                                 err);
    if (retval < 0)
    {
      haserr = true;
      break;
    }
    if (retval == 0)
    {
      break;
    }
    gt_symbolstring2fasta(stdout,desc,NULL,sequence,seqlen,70UL);
  }
  gt_seq_iterator_delete(seqit);
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq $0x0, (%rsp)
callq 0x11a648
testq %rax, %rax
je 0x1a129a
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
movq %rax, %rdi
movq %r14, %r8
callq 0x119a11
testl %eax, %eax
jle 0x1a128b
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq 0x322c93(%rip), %rax    # 0x4c3ee8
movq (%rax), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movl $0x46, %r9d
xorl %edx, %edx
callq 0x1a0f70
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x119a11
testl %eax, %eax
jg 0x1a124e
movl %eax, %ebp
movq %rbx, %rdi
callq 0x119a53
sarl $0x1f, %ebp
jmp 0x1a129f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_availBWTSeq
BWTSeq *
gt_availBWTSeq(const struct bwtParam *params, GtLogger *verbosity,
            GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  Suffixarray suffixArray;
  GtUword len;
  gt_assert(params && err);
  gt_error_check(err);
  if (streamsuffixarray(&suffixArray, SARR_SUFTAB | SARR_BWTTAB
                        | SARR_ESQTAB, gt_str_get(params->projectName),
                        verbosity, err))
  {
    gt_error_unset(err);
    if (streamsuffixarray(&suffixArray, SARR_SUFTAB | SARR_ESQTAB,
                          gt_str_get(params->projectName), verbosity, err))
    {
      GtEncseqMetadata *emd = NULL;
      gt_error_unset(err);
      emd = gt_encseq_metadata_new(gt_str_get(params->projectName), err);
      if (emd == NULL)
        return NULL;
      len = gt_encseq_metadata_total_length(emd);
      gt_encseq_metadata_delete(emd);
    } else {
      len = gt_encseq_total_length(suffixArray.encseq) + 1;
    }
  } else {
    len = gt_encseq_total_length(suffixArray.encseq) + 1;
  }
  bwtSeq = gt_availBWTSeqFromSA(params, &suffixArray, len, err);
  gt_freesuffixarray(&suffixArray);
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
testq %rdi, %rdi
je 0x1a13c2
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1a13c2
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1a13c7
movq 0x20(%r14), %rdi
callq 0x120d23
leaq 0x8(%rsp), %rdi
movl $0xb, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a9f52
testl %eax, %eax
je 0x1a1374
movq %rbx, %rdi
callq 0x101aac
movq 0x20(%r14), %rdi
callq 0x120d23
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a9f52
testl %eax, %eax
je 0x1a1374
movq %rbx, %rdi
callq 0x101aac
movq 0x20(%r14), %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1000e4
movq %rax, %r12
testq %rax, %rax
je 0x1a1386
movq %r12, %rdi
callq 0x100d3c
movq %rax, %r15
movq %r12, %rdi
callq 0x100e07
jmp 0x1a1386
movq 0x8(%rsp), %rdi
callq 0xec1d8
movq %rax, %r15
incq %r15
jmp 0x1a138b
testq %r12, %r12
je 0x1a13be
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1a13cc
movq %rax, %rbx
movq %r12, %rdi
callq 0x1a9e1c
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x1a13ac
callq 0x5f7bb
callq 0x5f7f2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_availBWTSeqFromSA
BWTSeq *
gt_availBWTSeqFromSA(const struct bwtParam *params, Suffixarray *sa,
                  GtUword totalLen, GtError *err)
{
  BWTSeq *bwtSeq;
  gt_assert(sa && params && err);
  gt_error_check(err);
  /* try loading index */
  bwtSeq = gt_loadBWTSeqForSA(gt_str_get(params->projectName),
                              params->seqParams.encType,
                              params->seqParams.EISFeatureSet,
                              gt_encseq_alphabet(sa->encseq), err);
  /* if loading didn't work try on-demand creation */
  if (!bwtSeq)
  {
    gt_error_unset(err);
    bwtSeq = gt_createBWTSeqFromSA(params, sa, totalLen, err);
  }
  else
  {
    fputs("Using pre-computed sequence index.\n", stderr);
  }
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a1483
movq %rsi, %r15
testq %rsi, %rsi
je 0x1a1483
movq %rcx, %rbx
testq %rcx, %rcx
je 0x1a1483
movq %rdi, %r12
movq %rdx, (%rsp)
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1a1488
movq 0x20(%r12), %rdi
callq 0x120d23
movq %rax, %r13
movl (%r12), %ebp
movl 0x4(%r12), %r14d
movq (%r15), %rdi
callq 0xf02da
movq %r13, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rax, %rcx
movq %rbx, %r8
callq 0x1a15e9
testq %rax, %rax
jne 0x1a1469
movq %rbx, %rdi
callq 0x101aac
movq %r12, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a1576
movq %rax, %r13
callq 0x5f860
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5f829
callq 0x5f876
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_trSuftab2BWTSeq
BWTSeq *
gt_trSuftab2BWTSeq(const struct bwtParam *params, GtLogger *verbosity,
                GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  Suffixarray suffixArray;
  GtUword len;
  gt_assert(params && err);
  gt_error_check(err);
  do
  {
    if (streamsuffixarray(&suffixArray,
                          SARR_SUFTAB | SARR_BWTTAB | SARR_ESQTAB,
                          gt_str_get(params->projectName), verbosity, err))
    {
      gt_error_unset(err);
      if (streamsuffixarray(&suffixArray, SARR_SUFTAB | SARR_ESQTAB,
                            gt_str_get(params->projectName), verbosity, err))
      {
        gt_error_set(err, "suffix array project %s does not hold required "
                     "suffix array (.suf) and encoded sequence (.esq) "
                     "information!", gt_str_get(params->projectName));
        break;
      }
    }
    len = gt_encseq_total_length(suffixArray.encseq) + 1;
    bwtSeq = gt_createBWTSeqFromSA(params, &suffixArray, len, err);
    gt_freesuffixarray(&suffixArray);
  } while (0);
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
testq %rdi, %rdi
je 0x1a156c
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1a156c
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1a1571
movq 0x20(%r14), %rdi
callq 0x120d23
movq %rsp, %rdi
movl $0xb, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a9f52
testl %eax, %eax
je 0x1a1534
movq %rbx, %rdi
callq 0x101aac
movq 0x20(%r14), %rdi
callq 0x120d23
movq %rsp, %rdi
movl $0x3, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1a9f52
testl %eax, %eax
je 0x1a1534
movq 0x20(%r14), %rdi
callq 0x120d23
leaq 0x209de1(%rip), %rsi    # 0x3ab303
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
jmp 0x1a155c
movq %rsp, %r15
movq (%r15), %rdi
callq 0xec1d8
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1a1576
movq %rax, %r14
movq %r15, %rdi
callq 0x1a9e1c
movq %r14, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
callq 0x5f8ad
callq 0x5f8e4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSA
BWTSeq *
gt_createBWTSeqFromSA(const struct bwtParam *params, Suffixarray *sa,
                   GtUword totalLen, GtError *err)
{
  BWTSeq *bwtSeq = NULL;
  if (!sa->longest.defined)
  {
    gt_log_log("error: position of null-rotation/longest suffix not available"
               " for project %s\n", gt_str_get(params->projectName));
  }
  else
  {
    SuffixarrayFileInterface sai;
    gt_initSuffixarrayFileInterface(&sai, totalLen, sa);
    bwtSeq = gt_createBWTSeqFromSAI(params, &sai, err);
    gt_destructSuffixarrayFileInterface(&sai);
  }
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %r14
cmpb $0x0, 0x38(%rsi)
je 0x1a15bd
movq %rcx, %rbx
movq %rsi, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1a7419
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1a173f
movq %rax, %rbx
movq %r15, %rdi
callq 0x1a76ce
jmp 0x1a15d9
movq 0x20(%r14), %rdi
callq 0x120d23
leaq 0x209e31(%rip), %rdi    # 0x3ab3fe
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x108e02
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_loadBWTSeqForSA
BWTSeq *
gt_loadBWTSeqForSA(const char *projectName, enum seqBaseEncoding encType,
                   int BWTOptFlags, const GtAlphabet *gtalphabet,
                   GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  EISeq *seqIdx = NULL;
  MRAEnc *alphabet = NULL;
  gt_assert(projectName && gtalphabet && err);
  alphabet = gt_SANewMRAEnc(gtalphabet);
  seqIdx = gt_loadEncIdxSeqForSA(gtalphabet, projectName, encType,
                                 gt_convertBWTOptFlags2EISFeatures(BWTOptFlags),
                                 err);
  if (seqIdx != NULL)
  {
    bwtSeq = gt_newBWTSeq(seqIdx, alphabet,
                          GTAlphabetRangeSort[GT_ALPHABETHANDLING_DEFAULT]);
  }
  if (!bwtSeq)
  {
    gt_MRAEncDelete(alphabet);
    if (seqIdx)
    {
      gt_deleteEncIdxSeq(seqIdx);
    }
  }
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a168c
movq %rcx, %r15
testq %rcx, %rcx
je 0x1a168c
movq %r8, %r14
testq %r8, %r8
je 0x1a168c
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r12
movq %r15, %rdi
callq 0x1a7872
movq %rax, %rbx
movl %r13d, %edi
callq 0x1a3ca2
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %eax, %ecx
movq %r14, %r8
callq 0x1a5636
movq %rax, %r14
testq %rax, %rax
je 0x1a165d
leaq 0x209e63(%rip), %rdx    # 0x3ab4b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a4074
movq %rax, %r15
jmp 0x1a1660
xorl %r15d, %r15d
testq %r15, %r15
jne 0x1a167a
movq %rbx, %rdi
callq 0x1a6aec
testq %r14, %r14
je 0x1a167a
movq %r14, %rdi
callq 0x1a574c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5f91b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_loadBWTSeq
BWTSeq *
gt_loadBWTSeq(const char *projectName, int BWTOptFlags,
              GT_UNUSED GtLogger *verbosity, GtError *err)
{
  struct BWTSeq *bwtSeq = NULL;
  GtEncseq *encseq;
  GtEncseqLoader *el;
  gt_assert(projectName && err);
  gt_error_check(err);

  el = gt_encseq_loader_new();
  gt_encseq_loader_do_not_require_sds_tab(el);
  gt_encseq_loader_do_not_require_des_tab(el);
  gt_encseq_loader_do_not_require_ssp_tab(el);
  encseq = gt_encseq_loader_load(el, projectName, err);
  gt_encseq_loader_delete(el);

  if (encseq == NULL)
    return NULL;
  bwtSeq = gt_loadBWTSeqForSA(projectName, BWT_ON_BLOCK_ENC, BWTOptFlags,
                           gt_encseq_alphabet(encseq), err);
  gt_encseq_delete(encseq);
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1a1735
movq %rcx, %rbx
testq %rcx, %rcx
je 0x1a1735
movl %esi, %ebp
movq %rdi, %r14
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1a173a
callq 0xf36ef
movq %rax, %r12
movq %rax, %rdi
callq 0xf6a49
movq %r12, %rdi
callq 0xf69ed
movq %r12, %rdi
callq 0xf6a1a
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf374b
movq %rax, %r15
movq %r12, %rdi
callq 0xf424d
testq %r15, %r15
je 0x1a172a
movq %r15, %rdi
callq 0xf02da
movq %r14, %rdi
movl $0x2, %esi
movl %ebp, %edx
movq %rax, %rcx
movq %rbx, %r8
callq 0x1a15e9
movq %rax, %rbx
movq %r15, %rdi
callq 0xee90c
movq %rbx, %rax
jmp 0x1a172c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5f954
callq 0x5f98d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSAI
BWTSeq *
gt_createBWTSeqFromSAI(const struct bwtParam *params,
                    SuffixarrayFileInterface *sai,
                    GtError *err)
{
  BWTSeq *bwtSeq;
  SpecialsRankLookup *sprTable = NULL;
  const enum rangeSortMode *rangeSort;
  gt_assert(sai && err && params);
  buildSpRTable(params, SAIGetLength(sai), SAIGetEncSeq(sai),
                SAIGetGtReadmode(sai), &sprTable, &rangeSort);
  bwtSeq = gt_createBWTSeqFromSASS(params, SAI2SASS(sai), sprTable, rangeSort,
                                err);
  if (sprTable)
    gt_deleteSpecialsRankLookup(sprTable);
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1a17d6
movq %rsi, %r14
testq %rsi, %rsi
je 0x1a17d6
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1a17d6
movq %rdi, %r15
testb $0x4, 0x10(%rdi)
jne 0x1a176e
xorl %r12d, %r12d
jmp 0x1a17a2
movq 0xd0(%r14), %rax
movq (%rax), %r12
movl 0x48(%rax), %ebp
movl 0x18(%r15), %edx
cmpl $-0x1, %edx
jne 0x1a1795
movq (%r14), %rdi
callq 0x2f9d41
movl %eax, %edi
callq 0x2f9d04
movl %eax, %edx
movq %r12, %rdi
movl %ebp, %esi
callq 0x1a709c
movq %rax, %r12
leaq 0x209d0f(%rip), %rcx    # 0x3ab4b8
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x1a17db
movq %rax, %rbx
testq %r12, %r12
je 0x1a17ca
movq %r12, %rdi
callq 0x1a730e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5f9c6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSASS
static BWTSeq *
gt_createBWTSeqFromSASS(const struct bwtParam *params, SASeqSrc *src,
                     SpecialsRankLookup *sprTable,
                     const enum rangeSortMode *rangeSort,
                     GtError *err)
{
  EISeq *seqIdx = NULL;
  BWTSeq *bwtSeq = NULL;
  seqIdx = gt_createBWTSeqGeneric(params, gt_createEncIdxSeqGen, src,
                               rangeSort, sprTable, err);
  if (seqIdx)
  {
    MRAEnc *alphabet = SASSNewMRAEnc(src);
    bwtSeq = gt_newBWTSeq(seqIdx, alphabet, rangeSort);
    if (!bwtSeq)
    {
      gt_deleteEncIdxSeq(seqIdx);
      gt_MRAEncDelete(alphabet);
    }
  }
  return bwtSeq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r9
movq %rcx, %rbx
movq %rdx, %r8
movq %rsi, %r15
leaq 0x3e1b(%rip), %rsi      # 0x1a560e
movq %r15, %rdx
callq 0x1a254c
testq %rax, %rax
je 0x1a1835
movq %rax, %r14
movq %r15, %rdi
callq *0x40(%r15)
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1a4074
movq %rax, %rbx
testq %rax, %rax
jne 0x1a1837
movq %r14, %rdi
callq 0x1a574c
movq %r15, %rdi
callq 0x1a6aec
jmp 0x1a1837
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: gt_createBWTSeqFromSfxI
BWTSeq *
gt_createBWTSeqFromSfxI(const struct bwtParam *params, sfxInterface *sfxi,
                     GtError *err)
{
  BWTSeq *bwtSeq;
  SpecialsRankLookup *sprTable = NULL;
  const enum rangeSortMode *rangeSort;
  gt_assert(sfxi && params && err);
  buildSpRTable(params, gt_SfxIGetLength(sfxi), gt_SfxIGetEncSeq(sfxi),
                gt_SfxIGetReadmode(sfxi), &sprTable, &rangeSort);
  bwtSeq = gt_createBWTSeqFromSASS(params, gt_SfxI2SASS(sfxi), sprTable,
                                   rangeSort,
                                   err);
  if (sprTable)
    gt_deleteSpecialsRankLookup(sprTable);
  return bwtSeq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a1904
movq %rsi, %r15
testq %rsi, %rsi
je 0x1a1904
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1a1904
movq %rdi, %r14
movq %r15, %rdi
callq 0x1a7f9f
movq %rax, %r13
movq %r15, %rdi
callq 0x1a7fc4
movq %rax, %r12
movq %r15, %rdi
callq 0x1a7fcc
testb $0x4, 0x10(%r14)
jne 0x1a1899
xorl %r12d, %r12d
jmp 0x1a18c2
movl %eax, %ebp
movl 0x18(%r14), %edx
cmpl $-0x1, %edx
jne 0x1a18b5
movq %r13, %rdi
callq 0x2f9d41
movl %eax, %edi
callq 0x2f9d04
movl %eax, %edx
movq %r12, %rdi
movl %ebp, %esi
callq 0x1a709c
movq %rax, %r12
movq %r15, %rdi
callq 0x1a789c
leaq 0x209be7(%rip), %rcx    # 0x3ab4b8
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x1a17db
movq %rax, %rbx
testq %r12, %r12
je 0x1a18f2
movq %r12, %rdi
callq 0x1a730e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5f9ff
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_newBWTSeqContextRetrieverFactory
BWTSeqContextRetrieverFactory *
gt_newBWTSeqContextRetrieverFactory(GtUword seqLen, short mapIntervalLog2)
{
  BWTSeqContextRetrieverFactory *newFactory;
  newFactory = gt_malloc(sizeof (*newFactory));
  initBWTSeqContextRetrieverFactory(newFactory, seqLen, mapIntervalLog2);
  return newFactory;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movl %esi, %ebp
movq %rdi, %r14
leaq 0x209c31(%rip), %rsi    # 0x3ab592
movl $0x30, %edi
movl $0x64, %edx
callq 0x1092b2
movq %rax, %rbx
cmpw $-0x3, %bp
ja 0x1a19ac
testw %bp, %bp
js 0x1a1aa8
movzwl %bp, %r15d
movq %r14, %rdi
callq 0x2f9d41
movl $0x40, %ecx
cmpl $0x3f, %eax
ja 0x1a19a3
movq %r14, %rdi
callq 0x2f9d41
movslq %eax, %rcx
cmpq %r15, %rcx
jbe 0x1a1aa8
cmpw $-0x1, %bp
jne 0x1a19c3
movq %r14, %rdi
callq 0x2f9d41
movl %eax, %edi
callq 0x2f9d04
movl %eax, %ebp
movq %r14, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %eax
notl %eax
movq %rax, 0x10(%rbx)
movw %bp, 0x1a(%rbx)
movb $0x0, 0x18(%rbx)
callq 0x1208f8
movq %rax, 0x28(%rbx)
leaq 0x209b9d(%rip), %rdx    # 0x3ab592
movq %rax, %rdi
movl $0x5, %esi
movl $0x4e, %ecx
callq 0x1021c2
movl $0x1, %edx
movl %ebp, %ecx
shll %cl, %edx
movq %rax, %r15
movq %rax, 0x20(%rbx)
movslq %edx, %rax
leaq (%r14,%rax), %r12
decq %r12
shrq %cl, %r12
movq %rsp, %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x173a0
cmpq $0x401, %r12            # imm = 0x401
jl 0x1a1a66
movl $0x400, %r13d           # imm = 0x400
movq %rsp, %r14
movl $0x8, %esi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %r15, %rcx
callq 0x125658
addq $0x400, %r13            # imm = 0x400
cmpq %r12, %r13
jl 0x1a1a45
leaq 0x3ff(%r12), %rax
testq %r12, %r12
cmovnsq %r12, %rax
andq $-0x400, %rax           # imm = 0xFC00
subq %rax, %r12
je 0x1a1a93
movl %r12d, %edx
movq %rsp, %rdi
movl $0x8, %esi
movq %r15, %rcx
callq 0x125658
movq %rbx, %rax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5fa38
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_BWTSCRFReadAdvance
GtUword
gt_BWTSCRFReadAdvance(BWTSeqContextRetrieverFactory *factory,
                   GtUword chunkSize,
                   SeqDataReader readSfxIdx)
{
  GtUword buf[BLOCK_IO_SIZE], sfxIdxLeft = chunkSize;
  gt_assert(factory);
  while (sfxIdxLeft)
  {
    GtUword len = GT_MIN(BLOCK_IO_SIZE, sfxIdxLeft);
    if (SDRRead(readSfxIdx, buf, len)
        != len)
    {
      fputs("error: short read when building context retriever!\n", stderr);
      abort();
    }
    gt_BWTSCRFMapAdvance(factory, buf, len);
    sfxIdxLeft -= len;
  }
  return chunkSize - sfxIdxLeft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
testq %rdi, %rdi
je 0x1a1b5b
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x1a1b3f
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %r13
movq 0x8(%rsp), %r14
movl $0x400, %eax            # imm = 0x400
cmpq %rax, %r14
movl $0x400, %ebp            # imm = 0x400
cmovbq %r14, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq *%rbx
cmpq %rbp, %rax
jne 0x1a1b56
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1a1b60
subq %rbp, %r14
jne 0x1a1b0b
movq 0x8(%rsp), %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5fa6f
callq 0x5fa8b