LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_has_overlap_with_previous_match
static bool gt_diagbandseed_has_overlap_with_previous_match(
     const GtArrayGtDiagbandseedRectangle *previous_extensions,
     GtUword previous_match_a_start,
     GtUword previous_match_a_end,
     GtUword previous_match_b_start,
     GtUword previous_match_b_end,
     GtUword apos,
     GtUword bpos,
     GtUword matchlength,
     bool debug)
{
  GtDiagbandseedRectangle maxmatch;

  if (debug)
  {
    printf("# overlap of " GT_WU " " GT_WU " " GT_WU " " GT_WU " "
                           GT_WU " " GT_WU " " GT_WU " " GT_WU "?\n",
           apos + 1 - matchlength,apos,bpos + 1 - matchlength,bpos,
           previous_match_a_start,
           previous_match_a_end,
           previous_match_b_start,
           previous_match_b_end);
  }

  maxmatch.a_start = apos + 1 - matchlength;
  maxmatch.a_end = apos;
  maxmatch.b_start = bpos + 1 - matchlength;
  maxmatch.b_end = bpos;

  if (debug)
  {
    gt_rectangle_store_show(previous_extensions);
  }
  if (gt_rectangle_overlap(previous_extensions,&maxmatch))
  {
    if (debug)
    {
      printf("# overlap with previous_ext (both dim) => return true\n");
    }
    return true;
  } else
  {
    if (debug)
    {
      printf("# not overlap with previous_ext (both dim) => return false\n");
    }
    return false;
  }
}

// Assembly:
subq $0x68, %rsp
movb 0x80(%rsp), %al
movq 0x78(%rsp), %r10
movq 0x70(%rsp), %r10
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x21d9f6
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
subq 0x78(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x70(%rsp), %rcx
addq $0x1, %rcx
subq 0x78(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0x50(%rsp), %r9
movq 0x48(%rsp), %r11
movq 0x40(%rsp), %r10
movq 0x38(%rsp), %rax
leaq 0x355f4d(%rip), %rdi    # 0x57392e
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x19070
movq 0x30(%rsp), %rax
addq $0x1, %rax
subq 0x78(%rsp), %rax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movl %eax, 0x20(%rsp)
movq 0x70(%rsp), %rax
addq $0x1, %rax
subq 0x78(%rsp), %rax
movl %eax, 0x24(%rsp)
movq 0x70(%rsp), %rax
movl %eax, 0x28(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x21da3d
movq 0x58(%rsp), %rdi
callq 0x2a99a0
movq 0x58(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x2a98f0
testb $0x1, %al
jne 0x21da52
jmp 0x21da6e
testb $0x1, 0x2f(%rsp)
je 0x21da67
leaq 0x355efd(%rip), %rdi    # 0x57395d
movb $0x0, %al
callq 0x19070
movb $0x1, 0x67(%rsp)
jmp 0x21da88
testb $0x1, 0x2f(%rsp)
je 0x21da83
leaq 0x355f18(%rip), %rdi    # 0x573994
movb $0x0, %al
callq 0x19070
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq 0x80(%rsp), %rax
movb 0x78(%rsp), %al
movb 0x70(%rsp), %r10b
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2af760
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2af7e0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
subq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x80(%rsp)
je 0x21db39
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0xb1b40
movq %rax, 0x10(%rsp)
jmp 0x21db45
leaq 0x35608b(%rip), %rax    # 0x573bcb
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x50(%rsp), %rcx
addq 0x18(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
subq 0x28(%rsp), %rcx
addq $0x1, %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x60(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x38(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x28(%rax)
movb 0x70(%rsp), %cl
movq 0x60(%rsp), %rax
movb %cl, 0x30(%rax)
movb 0x37(%rsp), %cl
movq 0x60(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x31(%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movq 0x18(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movq 0x18(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movq 0x10(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movq 0x10(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, (%rsp)
movl 0x8(%rsp), %eax
cmpl (%rsp), %eax
jae 0x21df11
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x21dfc1
movl 0x8(%rsp), %eax
cmpl (%rsp), %eax
jbe 0x21df27
movl $0x1, 0x34(%rsp)
jmp 0x21dfc1
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x21df43
movl $0x1, 0x34(%rsp)
jmp 0x21dfc1
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jbe 0x21df5f
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x21dfc1
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x21df73
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x21dfc1
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jbe 0x21df87
movl $0x1, 0x34(%rsp)
jmp 0x21dfc1
jmp 0x21df89
movq 0x41e010(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f8079(%rip), %rsi    # 0x516013
leaq 0x33adc2(%rip), %rdx    # 0x558d63
leaq 0x355e24(%rip), %rcx    # 0x573dcc
leaq 0x353fe5(%rip), %r8     # 0x571f94
movl $0xb58, %r9d            # imm = 0xB58
movb $0x0, %al
callq 0x199f0
callq 0x19370
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_plainsequence_delete
static void gt_diagbandseed_plainsequence_delete(
                         GtDiagbandSeedPlainSequence *ps)
{
  if (ps->b_byte_sequence != NULL && ps->b_differs_from_a)
  {
    gt_free(ps->b_byte_sequence);
  }
  if (ps->a_byte_sequence != NULL)
  {
    gt_free(ps->a_byte_sequence);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x90(%rax)
je 0x21e1f8
movq (%rsp), %rax
testb $0x1, (%rax)
je 0x21e1f8
movq (%rsp), %rax
movq 0x90(%rax), %rdi
leaq 0x353da6(%rip), %rsi    # 0x571f94
movl $0xa45, %edx            # imm = 0xA45
callq 0xe88c0
movq (%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x21e222
movq (%rsp), %rax
movq 0x88(%rax), %rdi
leaq 0x353d7c(%rip), %rsi    # 0x571f94
movl $0xa49, %edx            # imm = 0xA49
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
ja 0x21e292
movq 0x41dd3f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f7da8(%rip), %rsi    # 0x516013
leaq 0x39955a(%rip), %rdx    # 0x5b77cc
leaq 0x35601a(%rip), %rcx    # 0x574293
leaq 0x356029(%rip), %r8     # 0x5742a9
movl $0x23, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21e294
cmpq $0x0, 0x38(%rsp)
jne 0x21e2b1
movq 0x40(%rsp), %rdi
leaq 0x356016(%rip), %rsi    # 0x5742be
movb $0x0, %al
callq 0x199f0
jmp 0x21e2c9
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x2fcf5a(%rip), %rsi    # 0x51b21c
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0xff, %eax
jne 0x21e316
movq 0x40(%rsp), %rdi
leaq 0x355fb9(%rip), %rsi    # 0x5742bd
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x8(%rsp)
jmp 0x21e32a
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movzbl 0x7(%rsp), %edx
callq 0x7f0f0
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x21e352
movq 0x40(%rsp), %rdi
leaq 0x374f2a(%rip), %rsi    # 0x593273
movb $0x0, %al
callq 0x199f0
jmp 0x21e3ab
movzbl 0x7(%rsp), %eax
cmpl $0xff, %eax
je 0x21e396
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jb 0x21e394
movq 0x40(%rsp), %rdi
leaq 0x374eef(%rip), %rsi    # 0x593273
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x8(%rsp)
jmp 0x21e396
jmp 0x21e398
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x21e2db
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %esi
movq 0x48(%rsp), %rdx
callq 0xac380
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x38(%rsp)
ja 0x21e429
movq 0x41dba8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f7c11(%rip), %rsi    # 0x516013
leaq 0x3993c3(%rip), %rdx    # 0x5b77cc
leaq 0x355eb1(%rip), %rcx    # 0x5742c1
leaq 0x355e92(%rip), %r8     # 0x5742a9
movl $0x54, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21e42b
movq 0x48(%rsp), %rax
addq 0x40(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0xb0f00
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0xaae30
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0xff, %eax
jne 0x21e498
movq 0x60(%rsp), %rdi
leaq 0x355e37(%rip), %rsi    # 0x5742bd
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x30(%rsp)
jmp 0x21e4ac
movq 0x8(%rsp), %rdi
movq 0x60(%rsp), %rsi
movzbl 0x1f(%rsp), %edx
callq 0x7f0f0
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x21e4cd
movq 0x60(%rsp), %rdi
leaq 0x374daf(%rip), %rsi    # 0x593273
movb $0x0, %al
callq 0x199f0
jmp 0x21e526
movzbl 0x1f(%rsp), %eax
cmpl $0xff, %eax
je 0x21e511
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jb 0x21e50f
movq 0x60(%rsp), %rdi
leaq 0x374d74(%rip), %rsi    # 0x593273
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x30(%rsp)
jmp 0x21e511
jmp 0x21e513
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x21e460
movq 0x10(%rsp), %rdi
callq 0xac3f0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb0f00
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x21e609
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x21e5e1
movq 0x41d9f0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f7a59(%rip), %rsi    # 0x516013
leaq 0x355d17(%rip), %rdx    # 0x5742d8
leaq 0x355d2d(%rip), %rcx    # 0x5742f5
leaq 0x355cda(%rip), %r8     # 0x5742a9
movl $0x83, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21e5e3
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
movzbl 0xf(%rsp), %edx
callq 0x7f0f0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x21e570
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
ja 0x21e676
movq 0x41d95b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f79c4(%rip), %rsi    # 0x516013
leaq 0x399176(%rip), %rdx    # 0x5b77cc
leaq 0x355ca9(%rip), %rcx    # 0x574306
leaq 0x355c45(%rip), %r8     # 0x5742a9
movl $0x90, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21e678
cmpq $0x0, 0x28(%rsp)
jne 0x21e695
movq 0x30(%rsp), %rdi
leaq 0x355c32(%rip), %rsi    # 0x5742be
movb $0x0, %al
callq 0x199f0
jmp 0x21e6ad
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x2fcb76(%rip), %rsi    # 0x51b21c
movb $0x0, %al
callq 0x199f0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq 0x40(%rsp), %r9
callq 0x21e3b0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x113240
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x21e725
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x21e7a9
jmp 0x21e727
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %r8
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x111ab0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x21e757
movb $0x1, 0xf(%rsp)
jmp 0x21e78a
cmpl $0x0, 0x8(%rsp)
jne 0x21e760
jmp 0x21e78a
movq 0x41d7d1(%rip), %rax    # 0x63bf38
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
xorl %eax, %eax
movl %eax, %edx
movl $0x46, %r9d
callq 0x21e230
jmp 0x21e727
movq 0x28(%rsp), %rdi
callq 0x111c10
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x21ea30
cmpq $0x0, 0x30(%rsp)
je 0x21ea30
cmpq $0x0, 0x18(%rsp)
jne 0x21ea68
movq 0x41d569(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f75d2(%rip), %rsi    # 0x516013
leaq 0x355983(%rip), %rdx    # 0x5743cb
leaq 0x355990(%rip), %rcx    # 0x5743df
leaq 0x3558d5(%rip), %r8     # 0x57432b
movl $0x66, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21ea6a
jmp 0x21ea6c
cmpq $0x0, 0x18(%rsp)
je 0x21eabc
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x21ea84
jmp 0x21eabc
movq 0x41d515(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f757e(%rip), %rsi    # 0x516013
leaq 0x2f7723(%rip), %rdx    # 0x5161bf
leaq 0x35593c(%rip), %rcx    # 0x5743df
leaq 0x355881(%rip), %r8     # 0x57432b
movl $0x67, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21eabe
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0xb0f00
movq (%rsp), %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq %rax, %rcx
movq 0x18(%rsp), %r8
callq 0x21ee10
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x21eb44
movq 0x18(%rsp), %rdi
callq 0xd8ac0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x21ed50
movq %rax, 0x10(%rsp)
jmp 0x21eb5a
movq 0x41d455(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x35589f(%rip), %rdi    # 0x5743f4
callq 0x19810
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq $0x0, 0x118(%rsp)
cmpq $0x0, 0x130(%rsp)
je 0x21ebb1
cmpq $0x0, 0x120(%rsp)
jne 0x21ebe9
movq 0x41d3e8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f7451(%rip), %rsi    # 0x516013
leaq 0x355808(%rip), %rdx    # 0x5743d1
leaq 0x35577c(%rip), %rcx    # 0x57434c
leaq 0x355754(%rip), %r8     # 0x57432b
movl $0x48, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21ebeb
jmp 0x21ebed
cmpq $0x0, 0x120(%rsp)
je 0x21ec43
movq 0x120(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x21ec0b
jmp 0x21ec43
movq 0x41d38e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f73f7(%rip), %rsi    # 0x516013
leaq 0x2f759c(%rip), %rdx    # 0x5161bf
leaq 0x355722(%rip), %rcx    # 0x57434c
leaq 0x3556fa(%rip), %r8     # 0x57432b
movl $0x49, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21ec45
jmp 0x21ec47
movq 0x130(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq %rax, %rdx
movq 0x128(%rsp), %rcx
movq 0x120(%rsp), %r8
leaq 0x18(%rsp), %rdi
movl $0xb, %esi
callq 0x233500
cmpl $0x0, %eax
je 0x21ecfc
movq 0x120(%rsp), %rdi
callq 0xd8ac0
movq 0x130(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq %rax, %rdx
movq 0x128(%rsp), %rcx
movq 0x120(%rsp), %r8
leaq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x233500
cmpl $0x0, %eax
je 0x21ecfa
movq 0x120(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x130(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x35566e(%rip), %rsi    # 0x57435f
movb $0x0, %al
callq 0xd88c0
jmp 0x21ed40
jmp 0x21ecfc
movq 0x18(%rsp), %rdi
callq 0xa9d00
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x130(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x120(%rsp), %rcx
leaq 0x18(%rsp), %rsi
callq 0x21ed50
movq %rax, 0x118(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x233320
movq 0x118(%rsp), %rax
addq $0x138, %rsp            # imm = 0x138
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq $0x0, 0xe0(%rsp)
movq 0xf8(%rsp), %rax
testb $0x1, 0x38(%rax)
jne 0x21edb5
movq 0x100(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq %rax, %rsi
leaq 0x3556ae(%rip), %rdi    # 0x57445a
movb $0x0, %al
callq 0xe7740
jmp 0x21edf5
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq %rsp, %rdi
callq 0x22d190
movq 0x100(%rsp), %rdi
movq 0xe8(%rsp), %rdx
movq %rsp, %rsi
callq 0x21f0c0
movq %rax, 0xe0(%rsp)
movq %rsp, %rdi
callq 0x22d740
movq 0xe0(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x21ee5e
cmpq $0x0, 0x40(%rsp)
je 0x21ee5e
cmpq $0x0, 0x38(%rsp)
jne 0x21ee96
movq 0x41d13b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f71a4(%rip), %rsi    # 0x516013
leaq 0x3555b0(%rip), %rdx    # 0x574426
leaq 0x3555ca(%rip), %rcx    # 0x574447
leaq 0x3554a7(%rip), %r8     # 0x57432b
movl $0xa6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21ee98
movq 0x40(%rsp), %rdi
callq 0x22dcb0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x48(%rsp), %edi
callq 0x224e50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl %eax, %ecx
movq 0x38(%rsp), %r8
callq 0x229330
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x21ef0e
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x35560c(%rip), %rdx    # 0x574510
callq 0x225ba0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x21ef34
movq 0x20(%rsp), %rdi
callq 0x22b660
cmpq $0x0, 0x28(%rsp)
je 0x21ef32
movq 0x28(%rsp), %rdi
callq 0x229620
jmp 0x21ef34
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x21ef70
cmpq $0x0, 0x30(%rsp)
jne 0x21efa8
movq 0x41d029(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f7092(%rip), %rsi    # 0x516013
leaq 0x356b11(%rip), %rdx    # 0x575a99
leaq 0x355489(%rip), %rcx    # 0x574418
leaq 0x355395(%rip), %r8     # 0x57432b
movl $0x8c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21efaa
jmp 0x21efac
cmpq $0x0, 0x30(%rsp)
je 0x21effc
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x21efc4
jmp 0x21effc
movq 0x41cfd5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f703e(%rip), %rsi    # 0x516013
leaq 0x2f71e3(%rip), %rdx    # 0x5161bf
leaq 0x355435(%rip), %rcx    # 0x574418
leaq 0x355341(%rip), %r8     # 0x57432b
movl $0x8d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21effe
callq 0xb7a40
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xbaa10
movq 0x18(%rsp), %rdi
callq 0xba820
movq 0x18(%rsp), %rdi
callq 0xba910
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xb7aa0
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
callq 0xb7e50
cmpq $0x0, 0x20(%rsp)
jne 0x21f05c
movq $0x0, 0x50(%rsp)
jmp 0x21f0ac
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb0f00
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movq %rax, %rcx
movq 0x30(%rsp), %r8
movl $0x2, %esi
callq 0x21ee10
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
callq 0xae070
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x21f0f4
cmpq $0x0, 0x40(%rsp)
je 0x21f0f4
cmpq $0x0, 0x50(%rsp)
jne 0x21f12c
movq 0x41cea5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f6f0e(%rip), %rsi    # 0x516013
leaq 0x35539c(%rip), %rdx    # 0x5744a8
leaq 0x3553aa(%rip), %rcx    # 0x5744bd
leaq 0x355211(%rip), %r8     # 0x57432b
movl $0xf4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21f12e
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x21f290
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x21f2b0
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x21f2d0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %eax, %ecx
leaq 0x30(%rsp), %r8
leaq 0x28(%rsp), %r9
callq 0x21f1e0
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
callq 0x21f3b0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0x21f2f0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x21f1c7
movq 0x30(%rsp), %rdi
callq 0x22cd50
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-construct.c
// Function: buildSpRTable
static inline void
buildSpRTable(const struct bwtParam *params,
              GtUword totalLen,
              const GtEncseq *encseq,
              GtReadmode readmode,
              SpecialsRankLookup **sprTable,
              const enum rangeSortMode **rangeSort)
{
  if (params->featureToggles & BWTReversiblySorted)
  {
    int sampleIntervalLog2 = params->sourceRankInterval;
    if (sampleIntervalLog2 == -1)
    {
      sampleIntervalLog2
        = gt_requiredUIntBits(requiredUlongBits(totalLen));
    }
    *sprTable = gt_newSpecialsRankLookup(encseq, readmode, sampleIntervalLog2);
  }
  *rangeSort = GTAlphabetRangeSort[sprTable?
                                   GT_ALPHABETHANDLING_W_RANK:
                                   GT_ALPHABETHANDLING_DEFAULT];
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x21f256
movq 0x30(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x21f239
movq 0x28(%rsp), %rdi
callq 0x46ec80
movl %eax, %edi
callq 0x46ec00
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x22c750
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
cltq
leaq 0x35529e(%rip), %rcx    # 0x574510
shlq $0x3, %rax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x20(%rsp), %r9
leaq 0x9e31(%rip), %rsi      # 0x229170
callq 0x2213d0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x21f397
movq 0x38(%rsp), %rdi
callq 0x21f500
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x225ba0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x21f395
movq 0x18(%rsp), %rdi
callq 0x229620
movq 0x8(%rsp), %rdi
callq 0x22b660
jmp 0x21f397
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x21f3f4
cmpq $0x0, 0x50(%rsp)
je 0x21f3f4
cmpq $0x0, 0x40(%rsp)
jne 0x21f42c
movq 0x41cba5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f6c0e(%rip), %rsi    # 0x516013
leaq 0x3550c8(%rip), %rdx    # 0x5744d4
leaq 0x3550d7(%rip), %rcx    # 0x5744ea
leaq 0x354f11(%rip), %r8     # 0x57432b
movl $0x105, %r9d            # imm = 0x105
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21f42e
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x22edf0
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x22ee80
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x22eea0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %eax, %ecx
leaq 0x30(%rsp), %r8
leaq 0x28(%rsp), %r9
callq 0x21f1e0
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
callq 0x22dea0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0x21f2f0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x21f4c7
movq 0x30(%rsp), %rdi
callq 0x22cd50
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdx, 0x2038(%rsp)
movq %rcx, 0x2040(%rsp)
movq %rdi, 0x2030(%rsp)
movq %rsi, 0x2028(%rsp)
movq 0x2028(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x2030(%rsp)
jne 0x21f8a7
movq 0x41c72a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f6793(%rip), %rsi    # 0x516013
leaq 0x354d8a(%rip), %rdx    # 0x574611
leaq 0x354d8b(%rip), %rcx    # 0x574619
leaq 0x354d5d(%rip), %r8     # 0x5745f2
movl $0x8d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21f8a9
jmp 0x21f8ab
cmpq $0x0, 0x18(%rsp)
je 0x21f952
movl $0x400, %eax            # imm = 0x400
cmpq 0x18(%rsp), %rax
jae 0x21f8cf
movl $0x400, %eax            # imm = 0x400
movq %rax, 0x8(%rsp)
jmp 0x21f8d9
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x2038(%rsp), %rdi
movq 0x2040(%rsp), %rsi
callq 0x21f970
cmpq 0x10(%rsp), %rax
je 0x21f924
movq 0x41c690(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x354d15(%rip), %rdi    # 0x57462f
callq 0x19810
callq 0x19370
movq 0x2030(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x21f9b0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x21f8ab
movq 0x2028(%rsp), %rax
subq 0x18(%rsp), %rax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_BWTSCRFMapAdvance
size_t
gt_BWTSCRFMapAdvance(BWTSeqContextRetrieverFactory *factory,
                  const GtUword *src,
                  size_t len)
{
  GtUword currentSfxPos;
  gt_assert(factory);
  currentSfxPos = factory->currentSfxPos;
  {
    size_t i;
    GtUword mask = factory->moduloMask,
      seqLen = factory->seqLen;
    for (i = 0; i < len; ++i)
    {
      if (!(((src[i] + seqLen - 1)%seqLen) & mask))
        addMapVal(factory, currentSfxPos + i, ((src[i] + seqLen - 1)%seqLen));
    }
  }
  factory->currentSfxPos = currentSfxPos + len;
  return len;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x21fa03
movq 0x41c5ce(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f6637(%rip), %rsi    # 0x516013
leaq 0x354c2e(%rip), %rdx    # 0x574611
leaq 0x354c79(%rip), %rcx    # 0x574663
leaq 0x354c01(%rip), %r8     # 0x5745f2
movl $0xa3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21fa05
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x21faaf
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq (%rsp), %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq (%rsp)
andq 0x8(%rsp), %rdx
cmpq $0x0, %rdx
jne 0x21fa9d
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq (%rsp), %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq (%rsp)
callq 0x21fad0
jmp 0x21fa9f
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x21fa36
movq 0x18(%rsp), %rcx
addq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: addMapVal
static inline void
addMapVal(BWTSeqContextRetrieverFactory *factory,
          GtUword currentSfxPos, GtUword origPos)
{
  off_t mapPos = ((off_t)origPos >> factory->mapIntervalLog2)
    * sizeof (GtUword);
  GtUword mapVal = currentSfxPos;
  FILE *fp = factory->mapTableDiskBackingStore;
  if (fseeko(fp, mapPos, SEEK_SET) == -1)
    die("failed to seek in backing store");
  gt_xfwrite(&mapVal, sizeof (mapVal), 1, fp);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movzwl 0x1a(%rcx), %ecx
movl %ecx, %ecx
sarq %cl, %rax
shlq $0x3, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x19c10
cmpl $-0x1, %eax
jne 0x21fb45
leaq 0x354c70(%rip), %rdi    # 0x5747a4
leaq 0x354ab7(%rip), %rsi    # 0x5745f2
movl $0x80, %edx
callq 0x220c50
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: gt_BWTSCRFGet
BWTSeqContextRetriever *
gt_BWTSCRFGet(BWTSeqContextRetrieverFactory *factory,
              const BWTSeq *bwtSeq,
              const char *projectName)
{
  unsigned short bitsPerUlong, mapIntervalLog2;
  BWTSeqContextRetriever *gt_newBWTSeqCR;
  gt_assert(factory && projectName);
  bitsPerUlong = requiredUlongBits(factory->seqLen - 1);
  gt_newBWTSeqCR = gt_malloc(sizeof (*gt_newBWTSeqCR));
  gt_newBWTSeqCR->mapIntervalLog2 = mapIntervalLog2 = factory->mapIntervalLog2;
  gt_newBWTSeqCR->bitsPerUlong = bitsPerUlong;
  gt_newBWTSeqCR->bwtSeq = bwtSeq;
  gt_newBWTSeqCR->mapInterval = 1 << factory->mapIntervalLog2;
  gt_newBWTSeqCR->mapMask = gt_newBWTSeqCR->mapInterval - 1;
  if (!BWTSeqCRMapOpen(mapIntervalLog2, bitsPerUlong, factory->seqLen,
                       projectName, true, gt_newBWTSeqCR))
  {
    gt_free(gt_newBWTSeqCR);
    return NULL;
  }
  readBS2Map(factory, gt_newBWTSeqCR);
  return gt_newBWTSeqCR;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x21fbb3
cmpq $0x0, 0x18(%rsp)
jne 0x21fbeb
movq 0x41c3e6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f644f(%rip), %rsi    # 0x516013
leaq 0x354aad(%rip), %rdx    # 0x574678
leaq 0x354abd(%rip), %rcx    # 0x57468f
leaq 0x354a19(%rip), %r8     # 0x5745f2
movl $0xcc, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21fbed
movq 0x28(%rsp), %rax
movq (%rax), %rdi
subq $0x1, %rdi
callq 0x46ec80
movw %ax, 0x16(%rsp)
movl $0x30, %edi
leaq 0x3549e3(%rip), %rsi    # 0x5745f2
movl $0xce, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movw 0x1a(%rax), %cx
movw %cx, 0x14(%rsp)
movq 0x8(%rsp), %rax
movw %cx, 0x28(%rax)
movw 0x16(%rsp), %cx
movq 0x8(%rsp), %rax
movw %cx, 0x2a(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movzwl 0x1a(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movw 0x14(%rsp), %si
movw 0x16(%rsp), %ax
movq 0x28(%rsp), %rcx
movq (%rcx), %rdx
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %r9
movl $0x1, %r8d
movzwl %si, %edi
movzwl %ax, %esi
callq 0x21fd00
testb $0x1, %al
jne 0x21fcd3
movq 0x8(%rsp), %rdi
leaq 0x354934(%rip), %rsi    # 0x5745f2
movl $0xd7, %edx
callq 0xe88c0
movq $0x0, 0x30(%rsp)
jmp 0x21fcec
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x220130
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)