LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: evaluateallAStabcolumns
static GtMaxcoordvalue *evaluateallAStabcolumns(GtLinspaceManagement *space,
                                            const GtScoreHandler *scorehandler,
                                            const GtUchar *useq,
                                            GtUword ustart,
                                            GtUword ulen,
                                            const GtUchar *vseq,
                                            GtUword vstart,
                                            GtUword vlen)
{
  GtUword colindex;
  GtMaxcoordvalue *max;
  GtAffinealignDPentry *Atabcolumn;
  Starttabentry *Starttabcolumn;

  Atabcolumn = gt_linspace_management_get_valueTabspace(space);
  Starttabcolumn = gt_linspace_management_get_rTabspace(space);

  firstAStabcolumn(Atabcolumn, Starttabcolumn, scorehandler, ulen);

  max = gt_linspace_management_get_maxspace(space);
  for (colindex = 1UL; colindex <= vlen; colindex++)
  {
    nextAStabcolumn(Atabcolumn, Starttabcolumn, scorehandler, useq, ustart,
                    ulen, vseq[vstart+colindex-1], colindex, max);
  }
  return max;
}

// Assembly:
subq $0x68, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1a3720
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1a3750
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x1a1e30
movq 0x60(%rsp), %rdi
callq 0x1a3800
movq %rax, 0x28(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x78(%rsp), %rax
ja 0x1a014d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
movq 0x38(%rsp), %rax
movq 0x70(%rsp), %r10
addq 0x30(%rsp), %r10
subq $0x1, %r10
movb (%rax,%r10), %r11b
movq 0x30(%rsp), %r10
movq 0x28(%rsp), %rax
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1a2020
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1a00db
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: gt_linearalign_affinegapcost_compute_local
GtWord gt_linearalign_affinegapcost_compute_local(
                                             GtLinspaceManagement *spacemanager,
                                             GtAlignment *align,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen,
                                             GtWord matchscore,
                                             GtWord mismatchscore,
                                             GtWord gap_opening,
                                             GtWord gap_extension)
{
  GtWord score;

  GtScoreHandler *scorehandler = gt_scorehandler_new(matchscore,
                                                     mismatchscore,
                                                     gap_opening,
                                                     gap_extension);

  score = gt_linearalign_affinegapcost_compute_local_generic(spacemanager,
                                                            scorehandler, align,
                                                            useq, ustart, ulen,
                                                            vseq, vstart, vlen);
  gt_scorehandler_delete(scorehandler);
  return score;
}

// Assembly:
subq $0x58, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x1d0fb0
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r11
movq 0x60(%rsp), %r10
movq 0x68(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x19fc80
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1d1150
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: set_AffineCrosspointthreadinfo
static GtAffineCrosspointthreadinfo
              set_AffineCrosspointthreadinfo(GtLinspaceManagement *spacemanager,
                                             const GtScoreHandler *scorehandler,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen,
                                             GtUword *Ctab,
                                             GtUword rowoffset,
                                             GtAffineAlignEdge from_edge,
                                             GtAffineAlignEdge to_edge,
                                             GtUword *threadcount)
{
  GtAffineCrosspointthreadinfo threadinfo;
  threadinfo.spacemanager = spacemanager;
  threadinfo.scorehandler = scorehandler;
  threadinfo.useq = useq;
  threadinfo.ustart = ustart;
  threadinfo.ulen = ulen;
  threadinfo.vseq = vseq;
  threadinfo.vstart = vstart;
  threadinfo.vlen = vlen;
  threadinfo.Ctab = Ctab;
  threadinfo.rowoffset = rowoffset;
  threadinfo.from_edge = from_edge;
  threadinfo.to_edge = to_edge;
  threadinfo.threadcount = threadcount;

  return threadinfo;
}

// Assembly:
movq %rdi, %rax
movq 0x40(%rsp), %r10
movl 0x38(%rsp), %r10d
movl 0x30(%rsp), %r10d
movq 0x28(%rsp), %r10
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r10
movq 0x8(%rsp), %r10
movq %rsi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq %r9, -0x28(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, (%rdi)
movq -0x10(%rsp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x18(%rsp), %rcx
movq %rcx, 0x10(%rdi)
movq -0x20(%rsp), %rcx
movq %rcx, 0x20(%rdi)
movq -0x28(%rsp), %rcx
movq %rcx, 0x28(%rdi)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rdi)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rdi)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rdi)
movq 0x20(%rsp), %rcx
movq %rcx, 0x40(%rdi)
movq 0x28(%rsp), %rcx
movq %rcx, 0x48(%rdi)
movl 0x30(%rsp), %ecx
movl %ecx, 0x58(%rdi)
movl 0x38(%rsp), %ecx
movl %ecx, 0x5c(%rdi)
movq 0x40(%rsp), %rcx
movq %rcx, 0x50(%rdi)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: evaluateaffinecrosspoints_thread_caller
static void *evaluateaffinecrosspoints_thread_caller(void *data)
{
  GtAffineCrosspointthreadinfo *threadinfo =
                                         (GtAffineCrosspointthreadinfo *) data;
  (void) evaluateaffinecrosspoints(threadinfo->spacemanager,
                                   threadinfo->scorehandler,
                                   threadinfo->useq,
                                   threadinfo->ustart,
                                   threadinfo-> ulen,
                                   threadinfo->vseq,
                                   threadinfo->vstart,
                                   threadinfo->vlen,
                                   threadinfo->Ctab,
                                   threadinfo->rowoffset,
                                   threadinfo->from_edge,
                                   threadinfo->to_edge,
                                   threadinfo->threadcount);
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rsp), %rax
movq 0x28(%rax), %r8
movq 0x38(%rsp), %rax
movq 0x18(%rax), %r9
movq 0x38(%rsp), %rax
movq 0x30(%rax), %r12
movq 0x38(%rsp), %rax
movq 0x38(%rax), %r15
movq 0x38(%rsp), %rax
movq 0x40(%rax), %r14
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rbx
movq 0x38(%rsp), %rax
movl 0x58(%rax), %r11d
movq 0x38(%rsp), %rax
movl 0x5c(%rax), %r10d
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movl %r11d, 0x20(%rsp)
movl %r10d, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x19ece0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: firstAtabRtabentry
static inline void firstAtabRtabentry(GtAffinealignDPentry *Atabcolumn,
                                      GtUword gap_opening,
                                      GtAffineAlignEdge edge)
{
  Atabcolumn[0].Redge = Affine_X;
  Atabcolumn[0].Dedge = Affine_X;
  Atabcolumn[0].Iedge = Affine_X;

  switch (edge) {
  case Affine_R:
    Atabcolumn[0].Rvalue = 0;
    Atabcolumn[0].Dvalue = GT_WORD_MAX;
    Atabcolumn[0].Ivalue = GT_WORD_MAX;
    break;
  case Affine_D:
    Atabcolumn[0].Rvalue = GT_WORD_MAX;
    Atabcolumn[0].Dvalue = 0;
    Atabcolumn[0].Ivalue = GT_WORD_MAX;
    break;
  case Affine_I:
    Atabcolumn[0].Rvalue = GT_WORD_MAX;
    Atabcolumn[0].Dvalue = GT_WORD_MAX;
    Atabcolumn[0].Ivalue = 0;
    break;
  default:
    Atabcolumn[0].Rvalue = 0;
    Atabcolumn[0].Dvalue = gap_opening;
    Atabcolumn[0].Ivalue = gap_opening;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl $0x3, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x3, 0x24(%rax)
movq -0x8(%rsp), %rax
movl $0x3, 0x28(%rax)
movl -0x14(%rsp), %eax
movl %eax, -0x18(%rsp)
testl %eax, %eax
je 0x1a1c99
jmp 0x1a1c80
movl -0x18(%rsp), %eax
subl $0x1, %eax
je 0x1a1cd0
jmp 0x1a1c8b
movl -0x18(%rsp), %eax
subl $0x2, %eax
je 0x1a1d04
jmp 0x1a1d38
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, 0x10(%rax)
jmp 0x1a1d60
movq -0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, 0x10(%rax)
jmp 0x1a1d60
movq -0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x1a1d60
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linearalign_affinegapcost.c
// Function: get_Rtabentry
static inline GtAffineAlignRnode get_Rtabentry(const GtAffineAlignRtabentry
                                                *rtab, GtAffineAlignEdge edge)
{
  if (edge == Affine_R)
  {
    return rtab->val_R;
  }
  if (edge == Affine_D)
  {
    return rtab->val_D;
  }
  gt_assert(edge == Affine_I);
  return rtab->val_I;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1a1d9c
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1a1e16
cmpl $0x1, 0xc(%rsp)
jne 0x1a1dbc
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1a1e16
jmp 0x1a1dbe
cmpl $0x2, 0xc(%rsp)
je 0x1a1dfd
movq 0x49a1d4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x37423d(%rip), %rsi    # 0x516013
leaq 0x3b6abf(%rip), %rdx    # 0x55889c
leaq 0x3b6ac9(%rip), %rcx    # 0x5588ad
leaq 0x3b68b6(%rip), %r8     # 0x5586a1
movl $0x44, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a1dff
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movl 0x20(%rsp), %edx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_new
GtLinspaceManagement* gt_linspace_management_new()
{
  GtLinspaceManagement *spacemanager;
  spacemanager = gt_malloc(sizeof(*spacemanager));
  spacemanager->valueTabspace = NULL;
  spacemanager->rTabspace = NULL;
  spacemanager->crosspointTabspace = NULL;
  spacemanager->maxscoordvaluespace = NULL;
  spacemanager->valueTabsize = 0;
  spacemanager->rTabsize = 0;
  spacemanager->crosspointTabsize = 0;
  spacemanager->timesquarefactor = 1;
  spacemanager->ulen = 0;
  spacemanager->spacepeak = 0;
  return spacemanager;
}

// Assembly:
pushq %rax
movl $0x50, %edi
leaq 0x3b58ce(%rip), %rsi    # 0x5588bb
movl $0x28, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x1, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_delete
void gt_linspace_management_delete(GtLinspaceManagement *spacemanager)
{
  if (spacemanager != NULL)
  {
    gt_free(spacemanager->valueTabspace);
    gt_free(spacemanager->rTabspace);
    if (spacemanager->crosspointTabspace != NULL)
      gt_free(spacemanager->crosspointTabspace);
    gt_maxcoordvalue_delete(spacemanager->maxscoordvaluespace);
    gt_free(spacemanager);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x1a3103
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x3b5821(%rip), %rsi    # 0x5588bb
movl $0x3a, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x3b5808(%rip), %rsi    # 0x5588bb
movl $0x3b, %edx
callq 0xe88c0
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1a30e1
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x3b57e4(%rip), %rsi    # 0x5588bb
movl $0x3d, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x1ac490
movq (%rsp), %rdi
leaq 0x3b57c2(%rip), %rsi    # 0x5588bb
movl $0x3f, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_check
void gt_linspace_management_check(GtLinspaceManagement *spacemanager,
                                  GtUword ulen, GtUword vlen,
                                  size_t valuesize,
                                  size_t rtabsize,
                                  size_t crosspointsize)
{
  gt_linspace_management_check_generic(spacemanager,
                              ulen, vlen,
                              valuesize,
                              rtabsize,
                              crosspointsize,
                              false);
  spacemanager->ulen = ulen;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x1a31d0
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_check_local
void  gt_linspace_management_check_local(GtLinspaceManagement *spacemanager,
                                         GtUword ulen, GtUword vlen,
                                         size_t valuesize, size_t rstabsize)
{
  gt_linspace_management_check_generic(spacemanager,
                                       ulen, vlen,
                                       valuesize,
                                       rstabsize,
                                       0, true);
  spacemanager->ulen = ulen;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, (%rsp)
callq 0x1a31d0
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linspace_management.c
// Function: checksquare
static bool checksquare(GtLinspaceManagement *spacemanager,
                        GtUword ulen, GtUword vlen,
                        size_t valuesize, size_t rsize,
                        bool local)
{
  GtUword TSfactor;
  gt_assert(spacemanager);

  TSfactor = spacemanager->timesquarefactor;
  if ((ulen+1)*(vlen+1)*valuesize <= spacemanager->valueTabsize)
  {
    if (local)
      gt_maxcoordvalue_reset(spacemanager->maxscoordvaluespace);
    return true;
  }
  else if ((ulen+1)*(vlen+1) <= (spacemanager->ulen+1)*TSfactor)
  {
    if (!local)
    {
      gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                           vlen,valuesize,rsize,0,false);
    }
    else
    {
       gt_linspace_management_check_generic(spacemanager,(ulen+1)*(vlen+1)-1,
                                            vlen,valuesize,rsize,0,true);
    }
    return true;
  }
  return false;
}

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x1a3536
movq 0x498a9b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x372b04(%rip), %rsi    # 0x516013
leaq 0x3b4e5d(%rip), %rdx    # 0x558373
leaq 0x3b54f1(%rip), %rcx    # 0x558a0e
leaq 0x3b5397(%rip), %r8     # 0x5588bb
movl $0xa1, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a3538
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq 0x28(%rsp), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
imulq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x28(%rcx), %rax
ja 0x1a358c
testb $0x1, 0x17(%rsp)
je 0x1a3582
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x1acbe0
movb $0x1, 0x47(%rsp)
jmp 0x1a3655
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq 0x28(%rsp), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
movq 0x38(%rsp), %rcx
movq 0x18(%rcx), %rcx
addq $0x1, %rcx
imulq 0x8(%rsp), %rcx
cmpq %rcx, %rax
ja 0x1a364e
testb $0x1, 0x17(%rsp)
jne 0x1a3608
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
movq 0x28(%rsp), %rax
addq $0x1, %rax
imulq %rax, %rsi
subq $0x1, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x1a31d0
jmp 0x1a3647
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
movq 0x28(%rsp), %rax
addq $0x1, %rax
imulq %rax, %rsi
subq $0x1, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, (%rsp)
callq 0x1a31d0
movb $0x1, 0x47(%rsp)
jmp 0x1a3655
jmp 0x1a3650
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/linspace_management.c
// Function: gt_linspace_management_change_to_square
GtUword **gt_linspace_management_change_to_square(GtLinspaceManagement
                                                 *spacemanager,
                                                 GtUword ulen, GtUword vlen)
{
  GtUword **E;
  GtUword idx;
  gt_assert(gt_linspace_management_check_space(spacemanager, ulen, vlen));

  E = gt_linspace_management_get_rTabspace(spacemanager);
  *E = gt_linspace_management_get_valueTabspace(spacemanager);

  for (idx=1;idx<ulen+1;idx++)
    E[idx]=E[idx-1]+vlen+1;

  return E;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1a3920
testb $0x1, %al
jne 0x1a3893
movq 0x49873e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3727a7(%rip), %rsi    # 0x516013
leaq 0x3b50ed(%rip), %rdx    # 0x558960
leaq 0x3b5123(%rip), %rcx    # 0x55899d
leaq 0x3b503a(%rip), %r8     # 0x5588bb
movl $0x10c, %r9d            # imm = 0x10C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a3895
movq 0x20(%rsp), %rdi
callq 0x1a3750
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1a3720
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq $0x1, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1a390f
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1a38c1
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_class
const GtNodeStreamClass* gt_load_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtLoadStream),
                                   gt_load_stream_free,
                                   gt_load_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x49f40a(%rip)    # 0x642de8
jne 0x1a39ff
movl $0x30, %edi
leaq 0x24(%rip), %rsi        # 0x1a3a10
leaq 0xbd(%rip), %rdx        # 0x1a3ab0
callq 0x1b1ae0
movq %rax, 0x49f3e9(%rip)    # 0x642de8
callq 0x9f280
movq 0x49f3dd(%rip), %rax    # 0x642de8
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_free
static void gt_load_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtLoadStream *load_stream = gt_load_stream_cast(ns);
  for (i = load_stream->idx; i < gt_array_size(load_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(load_stream->nodes, i));
  }
  gt_array_delete(load_stream->nodes);
  gt_node_stream_delete(load_stream->in_stream);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x1a39d0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x81370
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a3a8e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x80b60
movq (%rax), %rdi
callq 0x173180
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1a3a3e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x81f80
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1b1cb0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/load_stream.c
// Function: gt_load_stream_new
GtNodeStream* gt_load_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns = gt_node_stream_create(gt_load_stream_class(), true);
  GtLoadStream *load_stream = gt_load_stream_cast(ns);
  gt_assert(in_stream);
  load_stream->in_stream = gt_node_stream_ref(in_stream);
  load_stream->full = false;
  load_stream->idx = 0;
  load_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x1a39d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x1b1b80
movq %rax, 0x8(%rsp)
callq 0x1a39d0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b20f0
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1a3d36
movq 0x49829b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x372304(%rip), %rsi    # 0x516013
leaq 0x37c70d(%rip), %rdx    # 0x520423
leaq 0x3b4cfd(%rip), %rcx    # 0x558a1a
leaq 0x3b4d09(%rip), %r8     # 0x558a2d
movl $0x6d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a3d38
movq 0x10(%rsp), %rdi
callq 0x1b1c50
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movb $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movl $0x8, %edi
callq 0x80990
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_class_new
const GtMatchClass* gt_match_class_new(size_t size,
                                       GtMatchFreeFunc free,
                                       GtMatchAcceptFunc accept)
{
  GtMatchClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->accept = accept;
  return c_class;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1a66c3
movq 0x49590e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f977(%rip), %rsi    # 0x516013
leaq 0x38e44d(%rip), %rdx    # 0x534af0
leaq 0x3b2c3b(%rip), %rcx    # 0x5592e5
leaq 0x3b2c47(%rip), %r8     # 0x5592f8
movl $0x22, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a66c5
movl $0x18, %edi
callq 0x481160
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_create
GtMatch* gt_match_create(const GtMatchClass *matchc,
                         GtUword start1, GtUword end1,
                         GtUword start2, GtUword end2,
                         const char *seqid1, const char *seqid2,
                         GtMatchDirection dir)
{
  GtMatch *match;
  gt_assert(matchc && matchc->size);
  match = gt_malloc(matchc->size);
  match->c_class = matchc;
  if (seqid1)
    match->seqid1 = gt_str_new_cstr(seqid1);
  else
    match->seqid1 = NULL;
  if (seqid2)
    match->seqid2 = gt_str_new_cstr(seqid2);
  else
    match->seqid2 = NULL;
  match->range_seq1.start = start1;
  match->range_seq1.end = end1;
  match->range_seq2.start = start2;
  match->range_seq2.end = end2;
  match->direction = dir;
  return match;
}

// Assembly:
subq $0x38, %rsp
movl 0x48(%rsp), %eax
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1a674e
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1a6786
movq 0x49584b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f8b4(%rip), %rsi    # 0x516013
leaq 0x3b2ba7(%rip), %rdx    # 0x55930d
leaq 0x3b2bb7(%rip), %rcx    # 0x559324
leaq 0x3b2b84(%rip), %r8     # 0x5592f8
movl $0x31, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6788
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x3b2b61(%rip), %rsi    # 0x5592f8
movl $0x32, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0x1a67d0
movq 0x8(%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1a67dc
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, 0x40(%rsp)
je 0x1a67fb
movq 0x40(%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1a6807
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movl 0x48(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x38(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_try_cast
void* gt_match_try_cast(GT_UNUSED const GtMatchClass *matchc, GtMatch *match)
{
  gt_assert(matchc && match);
  if (match->c_class == matchc)
    return match;
  return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1a68ec
cmpq $0x0, (%rsp)
jne 0x1a6924
movq 0x4956ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f716(%rip), %rsi    # 0x516013
leaq 0x3b2a6a(%rip), %rdx    # 0x55936e
leaq 0x3b2a73(%rip), %rcx    # 0x55937e
leaq 0x3b29e6(%rip), %r8     # 0x5592f8
movl $0x4c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6926
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x1a693f
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1a6948
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid1
void gt_match_set_seqid1(GtMatch *match, const char *seqid)
{
  gt_assert(match && seqid);
  if (!match->seqid1)
    match->seqid1 = gt_str_new_cstr(seqid);
  else {
    gt_str_reset(match->seqid1);
    gt_str_append_cstr(match->seqid1, seqid);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1a697e
cmpq $0x0, 0x8(%rsp)
jne 0x1a69b6
movq 0x49561b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f684(%rip), %rsi    # 0x516013
leaq 0x3b29fa(%rip), %rdx    # 0x559390
leaq 0x3b2a02(%rip), %rcx    # 0x55939f
leaq 0x3b2954(%rip), %r8     # 0x5592f8
movl $0x54, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a69b8
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a69dc
movq 0x8(%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1a69fd
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11e110
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11d550
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid2
void gt_match_set_seqid2(GtMatch *match, const char *seqid)
{
  gt_assert(match && seqid);
  if (!match->seqid2)
    match->seqid2 = gt_str_new_cstr(seqid);
  else {
    gt_str_reset(match->seqid2);
    gt_str_append_cstr(match->seqid2, seqid);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1a6a2e
cmpq $0x0, 0x8(%rsp)
jne 0x1a6a66
movq 0x49556b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f5d4(%rip), %rsi    # 0x516013
leaq 0x3b294a(%rip), %rdx    # 0x559390
leaq 0x3b2966(%rip), %rcx    # 0x5593b3
leaq 0x3b28a4(%rip), %r8     # 0x5592f8
movl $0x5f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6a68
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1a6a8c
movq 0x8(%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1a6aad
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11e110
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11d550
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid1_nt
void gt_match_set_seqid1_nt(GtMatch *match, const char *seqid,
                            GtUword len)
{
  gt_assert(match && seqid);
  if (!match->seqid1)
    match->seqid1 = gt_str_new();
  else
    gt_str_reset(match->seqid1);
  gt_str_append_cstr_nt(match->seqid1, seqid, len);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1a6ae2
cmpq $0x0, 0x8(%rsp)
jne 0x1a6b1a
movq 0x4954b7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f520(%rip), %rsi    # 0x516013
leaq 0x3b2896(%rip), %rdx    # 0x559390
leaq 0x3b28c6(%rip), %rcx    # 0x5593c7
leaq 0x3b27f0(%rip), %r8     # 0x5592f8
movl $0x6b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6b1c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a6b3b
callq 0x11d4a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1a6b49
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11e110
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x11d830
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_seqid2_nt
void gt_match_set_seqid2_nt(GtMatch *match, const char *seqid,
                            GtUword len)
{
  gt_assert(match && seqid);
  if (!match->seqid2)
    match->seqid2 = gt_str_new();
  else
    gt_str_reset(match->seqid2);
  gt_str_append_cstr_nt(match->seqid2, seqid, len);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1a6b92
cmpq $0x0, 0x8(%rsp)
jne 0x1a6bca
movq 0x495407(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f470(%rip), %rsi    # 0x516013
leaq 0x3b27e6(%rip), %rdx    # 0x559390
leaq 0x3b282d(%rip), %rcx    # 0x5593de
leaq 0x3b2740(%rip), %r8     # 0x5592f8
movl $0x76, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6bcc
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1a6beb
callq 0x11d4a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1a6bf9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11e110
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x11d830
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_range_seq1
void gt_match_set_range_seq1(GtMatch *match, GtUword start,
                             GtUword end)
{
  gt_assert(match);
  gt_assert(start <= end);
  match->range_seq1.start = start;
  match->range_seq1.end = end;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1a6e32
movq 0x49519f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f208(%rip), %rsi    # 0x516013
leaq 0x3b2566(%rip), %rdx    # 0x559378
leaq 0x3b2643(%rip), %rcx    # 0x55945c
leaq 0x3b24d8(%rip), %r8     # 0x5592f8
movl $0x9b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6e34
jmp 0x1a6e36
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x1a6e79
movq 0x495158(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f1c1(%rip), %rsi    # 0x516013
leaq 0x3959fc(%rip), %rdx    # 0x53c855
leaq 0x3b25fc(%rip), %rcx    # 0x55945c
leaq 0x3b2491(%rip), %r8     # 0x5592f8
movl $0x9c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6e7b
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_set_range_seq2
void gt_match_set_range_seq2(GtMatch *match, GtUword start,
                             GtUword end)
{
  gt_assert(match);
  gt_assert(start <= end);
  match->range_seq2.start = start;
  match->range_seq2.end = end;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1a6ef2
movq 0x4950df(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f148(%rip), %rsi    # 0x516013
leaq 0x3b24a6(%rip), %rdx    # 0x559378
leaq 0x3b259b(%rip), %rcx    # 0x559474
leaq 0x3b2418(%rip), %r8     # 0x5592f8
movl $0xa4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6ef4
jmp 0x1a6ef6
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x1a6f39
movq 0x495098(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f101(%rip), %rsi    # 0x516013
leaq 0x39593c(%rip), %rdx    # 0x53c855
leaq 0x3b2554(%rip), %rcx    # 0x559474
leaq 0x3b23d1(%rip), %r8     # 0x5592f8
movl $0xa5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a6f3b
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match.c
// Function: gt_match_delete
void gt_match_delete(GtMatch *match)
{
  if (!match) return;
  gt_assert(match->c_class);
  if (match->c_class->free)
    match->c_class->free(match);
  if (match->seqid1)
    gt_str_delete(match->seqid1);
  if (match->seqid2)
    gt_str_delete(match->seqid2);
  gt_free(match);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1a6fc1
jmp 0x1a706b
jmp 0x1a6fc3
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1a7005
movq 0x494fcc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36f035(%rip), %rsi    # 0x516013
leaq 0x3b24be(%rip), %rdx    # 0x5594a3
leaq 0x3b24c6(%rip), %rcx    # 0x5594b2
leaq 0x3b2305(%rip), %r8     # 0x5592f8
movl $0xb3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a7007
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a7026
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a703e
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1a7056
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq (%rsp), %rdi
leaq 0x3b2297(%rip), %rsi    # 0x5592f8
movl $0xba, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_class
const GtMatchClass* gt_match_blast_class()
{
  static const GtMatchClass *matchc = NULL;
  gt_class_alloc_lock_enter();
  if (!matchc) {
    matchc = gt_match_class_new(sizeof (GtMatchBlast),
                                NULL,
                                match_blast_accept);
  }
  gt_class_alloc_lock_leave();
  return matchc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x49bd72(%rip)    # 0x642df0
jne 0x1a709c
movl $0x70, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x20(%rip), %rdx        # 0x1a70b0
callq 0x1a6670
movq %rax, 0x49bd54(%rip)    # 0x642df0
callq 0x9f280
movq 0x49bd48(%rip), %rax    # 0x642df0
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match_blast.c
// Function: match_blast_accept
static int match_blast_accept(GtMatch *match, GtMatchVisitor *mv, GtError *err)
{
  GtMatchBlast *mb;
  gt_assert(match && mv);
  gt_error_check(err);
  mb = gt_match_blast_cast(match);
  return gt_match_visitor_visit_match_blast(mv, mb, err);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1a70d3
cmpq $0x0, 0x18(%rsp)
jne 0x1a710b
movq 0x494ec6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36ef2f(%rip), %rsi    # 0x516013
leaq 0x3b254c(%rip), %rdx    # 0x559637
leaq 0x3b2551(%rip), %rcx    # 0x559643
leaq 0x3b23e3(%rip), %r8     # 0x5594dc
movl $0x32, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a710d
jmp 0x1a710f
cmpq $0x0, 0x10(%rsp)
je 0x1a715f
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1a7127
jmp 0x1a715f
movq 0x494e72(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36eedb(%rip), %rsi    # 0x516013
leaq 0x36f080(%rip), %rdx    # 0x5161bf
leaq 0x3b24fd(%rip), %rcx    # 0x559643
leaq 0x3b238f(%rip), %r8     # 0x5594dc
movl $0x33, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a7161
callq 0x1a7070
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1a6850
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1ac1b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_new
GtMatch* gt_match_blast_new(char *seqid1,
                            char *seqid2,
                            GtUword start_seq1,
                            GtUword end_seq1,
                            GtUword start_seq2,
                            GtUword end_seq2,
                            double evalue,
                            float bitscore,
                            GtUword length,
                            double similarity,
                            GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchBlast *matchb;
  match = gt_match_create(gt_match_blast_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchb = gt_match_blast_cast(match);
  matchb->evalue = evalue;
  matchb->bitscore = bitscore;
  matchb->ali_length = length;
  matchb->similarity = similarity;
  matchb->mm_num = 0;
  matchb->gap_open_num = 0;
  return match;
}

// Assembly:
subq $0x68, %rsp
movl 0x78(%rsp), %eax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movss %xmm1, 0x2c(%rsp)
movsd %xmm2, 0x20(%rsp)
callq 0x1a7070
movq %rax, %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x60(%rsp), %r9
movq 0x58(%rsp), %r10
movl 0x78(%rsp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x1a6710
movq %rax, 0x18(%rsp)
callq 0x1a7070
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1a6850
movq %rax, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movss 0x2c(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x48(%rax)
movq 0x70(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movsd 0x20(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x68(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match_blast.c
// Function: gt_match_blast_new_extended
GtMatch* gt_match_blast_new_extended(char *seqid1,
                                     char *seqid2,
                                     GtUword start_seq1,
                                     GtUword end_seq1,
                                     GtUword start_seq2,
                                     GtUword end_seq2,
                                     double evalue,
                                     float bitscore,
                                     GtUword length,
                                     double similarity,
                                     GtUword mm_num,
                                     GtUword gap_open_num,
                                     GtMatchDirection dir)
{
  GtMatch *match;
  GtMatchBlast *matchb;
  match = gt_match_create(gt_match_blast_class(), start_seq1, end_seq1,
                          start_seq2, end_seq2, seqid1, seqid2, dir);
  matchb = gt_match_blast_cast(match);
  matchb->evalue = evalue;
  matchb->bitscore = bitscore;
  matchb->ali_length = length;
  matchb->similarity = similarity;
  matchb->mm_num = mm_num;
  matchb->gap_open_num = gap_open_num;
  return match;
}

// Assembly:
subq $0x68, %rsp
movl 0x88(%rsp), %eax
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movss %xmm1, 0x2c(%rsp)
movsd %xmm2, 0x20(%rsp)
callq 0x1a7070
movq %rax, %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x60(%rsp), %r9
movq 0x58(%rsp), %r10
movl 0x88(%rsp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x1a6710
movq %rax, 0x18(%rsp)
callq 0x1a7070
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1a6850
movq %rax, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movss 0x2c(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x48(%rax)
movq 0x70(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movsd 0x20(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x68(%rax)
movq 0x78(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x80(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_create
GtMatchIterator* gt_match_iterator_create(const GtMatchIteratorClass *mpc)
{
  GtMatchIterator *mp;
  gt_assert(mpc && mpc->size);
  mp = gt_calloc(1, mpc->size);
  mp->c_class = mpc;
  return mp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1a78dc
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1a7914
movq 0x4946bd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36e726(%rip), %rsi    # 0x516013
leaq 0x3b1d62(%rip), %rdx    # 0x559656
leaq 0x3b1d6c(%rip), %rcx    # 0x559667
leaq 0x3b1d7e(%rip), %r8     # 0x559680
movl $0x27, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a7916
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0x3b1d56(%rip), %rdx    # 0x559680
movl $0x28, %ecx
callq 0xe83c0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_next
GtMatchIteratorStatus gt_match_iterator_next(GtMatchIterator *mp,
                                             GtMatch **match, GtError *err)
{
  gt_assert(mp);
  if (mp->c_class->next)
    return mp->c_class->next(mp, match, err);
  return GT_MATCHER_STATUS_END;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1a79a3
movq 0x49462e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36e697(%rip), %rsi    # 0x516013
leaq 0x38ad4a(%rip), %rdx    # 0x5326cd
leaq 0x3b1d14(%rip), %rcx    # 0x55969e
leaq 0x3b1cef(%rip), %r8     # 0x559680
movl $0x30, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1a79a5
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a79d7
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq *%rax
movl %eax, 0x24(%rsp)
jmp 0x1a79df
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/match_iterator.c
// Function: gt_match_iterator_delete
void gt_match_iterator_delete(GtMatchIterator *mp)
{
  if (!mp) return;
  if (mp->c_class->free)
    mp->c_class->free(mp);
  gt_free(mp);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1a7a7e
jmp 0x1a7ab2
movq (%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x1a7a9d
movq (%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rdi
leaq 0x3b1bd8(%rip), %rsi    # 0x559680
movl $0x42, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop