LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_matchtable_delete
void gt_chain_matchtable_delete(GtChain2Dimmatchtable *matchtable)
{
  if (matchtable != NULL)
  {
    gt_free(matchtable->matches);
    gt_free(matchtable->previouscount);
    gt_free(matchtable->previousbound);
    gt_free(matchtable->previoustab);
    gt_free(matchtable);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x207654
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x369f1e(%rip), %rsi    # 0x571508
movl $0x99, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x369f05(%rip), %rsi    # 0x571508
movl $0x9a, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x369eec(%rip), %rsi    # 0x571508
movl $0x9b, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x40(%rax), %rdi
leaq 0x369ed3(%rip), %rsi    # 0x571508
movl $0x9c, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x369ebe(%rip), %rsi    # 0x571508
movl $0x9d, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_fillthegapvalues
void gt_chain_fillthegapvalues(GtChain2Dimmatchtable *matchtable)
{
  Matchchaininfo *fiptr;

  for (fiptr = matchtable->matches;
       fiptr < matchtable->matches + matchtable->nextfree;
       fiptr++)
  {
    fiptr->initialgap
      = (GtChain2Dimscoretype) (fiptr->startpos[0] + fiptr->startpos[1]);
    fiptr->terminalgap
      = (GtChain2Dimscoretype) (matchtable->largestdim0 - fiptr->endpos[0] +
                                matchtable->largestdim1 - fiptr->endpos[1]);
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
movq -0x8(%rsp), %rdx
imulq $0x50, 0x18(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x207928
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
subq 0x10(%rax), %rcx
movq -0x8(%rsp), %rax
addq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
subq 0x18(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rsp), %rax
addq $0x50, %rax
movq %rax, -0x10(%rsp)
jmp 0x2078b2
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_applyweight
void gt_chain_applyweight(double weightfactor,
                          GtChain2Dimmatchtable *matchtable)
{
  if (!gt_double_equals_double(weightfactor, 1.0))
  {
    Matchchaininfo *fiptr;

    for (fiptr = matchtable->matches;
         fiptr < matchtable->matches + matchtable->nextfree;
         fiptr++)
    {
      fiptr->weight *= weightfactor;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x30f8f3(%rip), %xmm1   # 0x517240
callq 0xec260
testb $0x1, %al
jne 0x2079ad
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rsp), %rdx
imulq $0x50, 0x18(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x2079ab
movsd 0x10(%rsp), %xmm1
movq (%rsp), %rax
cvtsi2sdq 0x30(%rax), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
addq $0x50, %rax
movq %rax, (%rsp)
jmp 0x207962
jmp 0x2079ad
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: assignchaingapcostfunction
static GtChain2Dimgapcostfunction assignchaingapcostfunction(
                                                      GtChain2Dimkind chainkind,
                                                      bool gapsL1)
{
  if (chainkind == GLOBALCHAININGWITHOVERLAPS)
  {
    return gt_chain2dim_overlapcost;
  }
  if (chainkind != GLOBALCHAININGALLCHAINS && chainkind != GLOBALCHAINING)
  {
    if (gapsL1)
    {
      return gapcostL1;
    }
    return gapcostCc;
  }
  return NULL;
}

// Assembly:
movb %sil, %al
movl %edi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
cmpl $0x2, -0xc(%rsp)
jne 0x207bd2
leaq 0x1825(%rip), %rax      # 0x2093f0
movq %rax, -0x8(%rsp)
jmp 0x207c0c
cmpl $0x3, -0xc(%rsp)
je 0x207c03
cmpl $0x0, -0xc(%rsp)
je 0x207c03
testb $0x1, -0xd(%rsp)
je 0x207bf5
leaq 0x18f2(%rip), %rax      # 0x2094e0
movq %rax, -0x8(%rsp)
jmp 0x207c0c
leaq 0x1954(%rip), %rax      # 0x209550
movq %rax, -0x8(%rsp)
jmp 0x207c0c
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: fastchainingscores
static void fastchainingscores(const GtChain2Dimmode *chainmode,
                               GtChain2Dimmatchtable *matchtable,
                               GtChain2DimMatchstore *matchstore,
                               unsigned int presortdim,
                               bool gapsL1)
{
  matchstore->endpointperm
    = gt_malloc(sizeof (*matchstore->endpointperm) *
                matchtable->nextfree);
  makesortedendpointpermutation(matchstore->endpointperm,
                                matchtable,
                                presortdim);
  mergestartandendpoints(chainmode,
                         matchtable,
                         matchstore,
                         gapsL1,
                         presortdim);
  gt_free(matchstore->endpointperm);
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
andb $0x1, %al
movb %al, 0xb(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
shlq $0x3, %rdi
leaq 0x368ea4(%rip), %rsi    # 0x571508
movl $0x592, %edx            # imm = 0x592
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x209990
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movb 0xb(%rsp), %al
movl 0xc(%rsp), %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0x209ac0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x368e45(%rip), %rsi    # 0x571508
movl $0x59b, %edx            # imm = 0x59B
callq 0xe88c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_chainingboundarycases
static void gt_chain2dim_chainingboundarycases(const GtChain2Dimmode *chainmode,
                                  GtChain2Dim *chain,
                                  const GtChain2Dimmatchtable *matchtable)
{
  chain->storedinreverseorder = false;
  if (matchtable->nextfree == 0)
  {
    chain->scoreofchain = 0;
    chain->chainedmatches.nextfreeGtChain2Dimref = 0;
  } else
  {
    if (matchtable->nextfree == 1UL)
    {
      chain->scoreofchain = matchtable->matches[0].weight;
      if (chainmode->chainkind == GLOBALCHAININGWITHGAPCOST)
      {
        chain->scoreofchain -= (GT_CHAIN2DIM_INITIALGAP(0)
                                  + GT_CHAIN2DIM_TERMINALGAP(0));
      }
      chain->chainedmatches.nextfreeGtChain2Dimref = 0;
      GT_STOREINARRAY(&chain->chainedmatches,GtChain2Dimref,32UL,0);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x208a57
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x208bd9
movq 0x10(%rsp), %rax
cmpq $0x1, 0x18(%rax)
jne 0x208bd7
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x208aae
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq 0x40(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x208abd
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x0, %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x208b68
movq $0x20, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
jbe 0x208b23
movq 0x4334ae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30d517(%rip), %rsi    # 0x516013
leaq 0x3106a4(%rip), %rdx    # 0x5191a7
leaq 0x369019(%rip), %rcx    # 0x571b23
leaq 0x3689f7(%rip), %r8     # 0x571508
movl $0x195, %r9d            # imm = 0x195
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x208b25
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
leaq 0x3689b5(%rip), %rdx    # 0x571508
movl $0x195, %ecx            # imm = 0x195
callq 0xe8540
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x208b6a
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x208bad
movq 0x433424(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30d48d(%rip), %rsi    # 0x516013
leaq 0x368e9e(%rip), %rdx    # 0x571a2b
leaq 0x368f8f(%rip), %rcx    # 0x571b23
leaq 0x36896d(%rip), %r8     # 0x571508
movl $0x195, %r9d            # imm = 0x195
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x208baf
jmp 0x208bb1
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdx
movq 0x10(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rdx)
movq $0x0, (%rax,%rcx,8)
jmp 0x208bd7
jmp 0x208bd9
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_possiblysortmatches
void gt_chain_possiblysortmatches(GtLogger *logger,
                                    GtChain2Dimmatchtable *matchtable,
                                    unsigned int presortdim)
{
  if (matchtable->nextfree > 1UL)
  {
    Qsortcomparefunction qsortcomparefunction;
    Matchchaininfo *fptr;
    bool matchesaresorted = true;

    gt_assert(presortdim <= 1U);
    qsortcomparefunction
      = (presortdim == 0) ? cmpMatchchaininfo0 : cmpMatchchaininfo1;
    for (fptr = matchtable->matches;
         fptr < matchtable->matches + matchtable->nextfree - 1;
         fptr++)
    {
      if (qsortcomparefunction((const void *) fptr,
                               (const void *) (fptr+1)) == 1)
      {
        matchesaresorted = false;
        break;
      }
    }
    if (!matchesaresorted)
    {
      gt_logger_log(logger,"input matches are not yet sorted => sort them");
      qsort(matchtable->matches,(size_t) matchtable->nextfree,
            sizeof (*matchtable->matches),qsortcomparefunction);
    } else
    {
      gt_logger_log(logger,"matches are already sorted w.r.t. dimension %u",
                    presortdim);
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x1, 0x18(%rax)
jbe 0x208d1e
movb $0x1, 0xf(%rsp)
cmpl $0x1, 0x24(%rsp)
jbe 0x208c46
movq 0x43338b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30d3f4(%rip), %rsi    # 0x516013
leaq 0x3689c0(%rip), %rdx    # 0x5715e6
leaq 0x368a0d(%rip), %rcx    # 0x57163a
leaq 0x3688d4(%rip), %r8     # 0x571508
movl $0x631, %r9d            # imm = 0x631
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x208c48
movl 0x24(%rsp), %edx
leaq 0x12d(%rip), %rax       # 0x208d80
leaq 0xd6(%rip), %rcx        # 0x208d30
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movq 0x28(%rsp), %rdx
imulq $0x50, 0x18(%rdx), %rdx
addq %rdx, %rcx
addq $-0x50, %rcx
cmpq %rcx, %rax
jae 0x208cc9
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x50, %rsi
callq *%rax
cmpl $0x1, %eax
jne 0x208cb7
movb $0x0, 0xf(%rsp)
jmp 0x208cc9
jmp 0x208cb9
movq 0x10(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x10(%rsp)
jmp 0x208c73
testb $0x1, 0xf(%rsp)
jne 0x208d05
movq 0x30(%rsp), %rdi
leaq 0x36897b(%rip), %rsi    # 0x571657
movb $0x0, %al
callq 0xe7cd0
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rcx
movl $0x50, %edx
callq 0x19e70
jmp 0x208d1c
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
leaq 0x368970(%rip), %rsi    # 0x571685
movb $0x0, %al
callq 0xe7cd0
jmp 0x208d1e
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: cmpMatchchaininfo0
static int cmpMatchchaininfo0(const void *keya,const void *keyb)
{
  if (((const Matchchaininfo *) keya)->startpos[0] <
      ((const Matchchaininfo *) keyb)->startpos[0])
  {
    return -1;
  }
  if (((const Matchchaininfo *) keya)->startpos[0] >
      ((const Matchchaininfo *) keyb)->startpos[0])
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x208d56
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x208d7a
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x208d72
movl $0x1, -0x4(%rsp)
jmp 0x208d7a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: cmpMatchchaininfo1
static int cmpMatchchaininfo1(const void *keya,const void *keyb)
{
  if (((const Matchchaininfo *) keya)->startpos[1] <
      ((const Matchchaininfo *) keyb)->startpos[1])
  {
    return -1;
  }
  if (((const Matchchaininfo *) keya)->startpos[1] >
      ((const Matchchaininfo *) keyb)->startpos[1])
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x208da8
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x208dce
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x208dc6
movl $0x1, -0x4(%rsp)
jmp 0x208dce
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_chainmode_new
GtChain2Dimmode *gt_chain_chainmode_new(GtUword maxgap,
                                        bool globalset,
                                        const char *globalargs,
                                        bool localset,
                                        const char *localargs,
                                        GtError *err)
{
  GtChain2Dimmode *chainmode;
  bool haserr = false;

  gt_assert(!(globalset && localset));
  chainmode = gt_malloc(sizeof (*chainmode));
  chainmode->chainkind = GLOBALCHAINING;
  chainmode->maxgapwidth = (GtChain2Dimpostype) maxgap;
  if (localset)
  {
    if (localargs == NULL)
    {
      chainmode->chainkind = LOCALCHAININGMAX;
    } else
    {
      if (parselocalchainingparameter(chainmode, "local", localargs, err) != 0)
      {
        haserr = true;
      }
    }
  }
  if (globalset)
  {
    if (globalargs == NULL)
    {
      chainmode->chainkind = GLOBALCHAINING;
    } else
    {
      if (parseglobalchainingparameter(chainmode, "global", globalargs,
                                       err) != 0)
      {
        haserr = true;
      }
    }
  }
  if (haserr)
  {
    gt_free(chainmode);
    return NULL;
  }
  return chainmode;
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, 0x38(%rsp)
andb $0x1, %cl
movb %cl, 0x37(%rsp)
movq %rdx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movb $0x0, 0x7(%rsp)
testb $0x1, 0x37(%rsp)
je 0x208e55
testb $0x1, 0x27(%rsp)
je 0x208e55
movq 0x43317c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30d1e5(%rip), %rsi    # 0x516013
leaq 0x36887f(%rip), %rdx    # 0x5716b4
leaq 0x368891(%rip), %rcx    # 0x5716cd
leaq 0x3686c5(%rip), %r8     # 0x571508
movl $0x699, %r9d            # imm = 0x699
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x208e57
movl $0x28, %edi
leaq 0x3686a5(%rip), %rsi    # 0x571508
movl $0x69a, %edx            # imm = 0x69A
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
testb $0x1, 0x27(%rsp)
je 0x208ed0
cmpq $0x0, 0x18(%rsp)
jne 0x208ea7
movq 0x8(%rsp), %rax
movl $0x4, (%rax)
jmp 0x208ece
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x35e1b6(%rip), %rsi    # 0x567073
callq 0x208f60
cmpl $0x0, %eax
je 0x208ecc
movb $0x1, 0x7(%rsp)
jmp 0x208ece
jmp 0x208ed0
testb $0x1, 0x37(%rsp)
je 0x208f15
cmpq $0x0, 0x28(%rsp)
jne 0x208eec
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x208f13
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x30e432(%rip), %rsi    # 0x517334
callq 0x209050
cmpl $0x0, %eax
je 0x208f11
movb $0x1, 0x7(%rsp)
jmp 0x208f13
jmp 0x208f15
testb $0x1, 0x7(%rsp)
je 0x208f3d
movq 0x8(%rsp), %rdi
leaq 0x3685e0(%rip), %rsi    # 0x571508
movl $0x6ba, %edx            # imm = 0x6BA
callq 0xe88c0
movq $0x0, 0x40(%rsp)
jmp 0x208f47
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: parselocalchainingparameter
static int parselocalchainingparameter(GtChain2Dimmode *chainmode,
                                       const char *option,
                                       const char *lparam,
                                       GtError *err)
{
  Qualifiedinteger *qualint;

  qualint = gt_parsequalifiedinteger(option,lparam,err);
  if (qualint == NULL)
  {
    return -1;
  }
  switch (qualint->qualtag)
  {
    case Qualbestof:
      chainmode->chainkind = LOCALCHAININGBEST;
      chainmode->howmanybest = qualint->integervalue;
      break;
    case Qualpercentaway:
      chainmode->chainkind = LOCALCHAININGPERCENTAWAY;
      chainmode->percentawayfrombest = qualint->integervalue;
      break;
    case Qualabsolute:
      chainmode->chainkind = LOCALCHAININGTHRESHOLD;
      chainmode->minimumscore = (GtChain2Dimscoretype) qualint->integervalue;
      break;
  }
  gt_free(qualint);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x263520
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x208fa6
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x209046
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x20900b
jmp 0x208fb7
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x208fec
jmp 0x208fc2
movl 0x4(%rsp), %eax
subl $0x2, %eax
jne 0x209028
jmp 0x208fcd
movq 0x28(%rsp), %rax
movl $0x6, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x209028
movq 0x28(%rsp), %rax
movl $0x7, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x209028
movq 0x28(%rsp), %rax
movl $0x5, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
leaq 0x3684d4(%rip), %rsi    # 0x571508
movl $0x667, %edx            # imm = 0x667
callq 0xe88c0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: parseglobalchainingparameter
static int parseglobalchainingparameter(GtChain2Dimmode *chainmode,
                                        const char *option,
                                        const char *gparam,
                                        GtError *err)
{
  if (strcmp(gparam,GT_CHAIN2DIM_GAPCOSTSWITCH) == 0)
  {
    chainmode->chainkind = GLOBALCHAININGWITHGAPCOST;
    return 0;
  }
  if (strcmp(gparam,GT_CHAIN2DIM_OVERLAPSWITCH) == 0)
  {
    chainmode->chainkind = GLOBALCHAININGWITHOVERLAPS;
    return 0;
  }
  if (strcmp(gparam,GT_CHAIN2DIM_ALLSWITCH) == 0)
  {
    chainmode->chainkind = GLOBALCHAININGALLCHAINS;
    return 0;
  }
  if (err != NULL)
  {
    gt_error_set(err,"argument of option -%s must be %s or %s: ",
                      option,
                      GT_CHAIN2DIM_GAPCOSTSWITCH,
                      GT_CHAIN2DIM_OVERLAPSWITCH);
  } else
  {
    fprintf(stderr,"argument of option -%s must be %s or %s: ",
                   option,
                   GT_CHAIN2DIM_GAPCOSTSWITCH,
                   GT_CHAIN2DIM_OVERLAPSWITCH);
  }
  return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x38ed82(%rip), %rsi    # 0x597df5
callq 0x19980
cmpl $0x0, %eax
jne 0x209095
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x20914f
movq 0x8(%rsp), %rdi
leaq 0x30e62c(%rip), %rsi    # 0x5176cd
callq 0x19980
cmpl $0x0, %eax
jne 0x2090c3
movq 0x18(%rsp), %rax
movl $0x2, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x20914f
movq 0x8(%rsp), %rdi
leaq 0x34346e(%rip), %rsi    # 0x54c53d
callq 0x19980
cmpl $0x0, %eax
jne 0x2090ee
movq 0x18(%rsp), %rax
movl $0x3, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x20914f
cmpq $0x0, (%rsp)
je 0x20911c
movq (%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x368a41(%rip), %rsi    # 0x571b46
leaq 0x38ece9(%rip), %rcx    # 0x597df5
leaq 0x30e5ba(%rip), %r8     # 0x5176cd
movb $0x0, %al
callq 0xd88c0
jmp 0x209147
movq 0x432e7d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x368a14(%rip), %rsi    # 0x571b46
leaq 0x38ecbc(%rip), %rcx    # 0x597df5
leaq 0x30e58d(%rip), %r8     # 0x5176cd
movb $0x0, %al
callq 0x199f0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_extractchainelem
void gt_chain_extractchainelem(GtChain2Dimmatchvalues *value,
                               const GtChain2Dimmatchtable *matchtable,
                               const GtChain2Dim *chain,GtUword idx)
{
  const Matchchaininfo *fiptr;

  gt_assert(idx <  gt_chain_chainlength(chain) &&
            chain->chainedmatches.spaceGtChain2Dimref[idx] <
            matchtable->nextfree);
  fiptr = matchtable->matches +
          chain->chainedmatches.spaceGtChain2Dimref[idx];
  value->startpos[0] = fiptr->startpos[0];
  value->startpos[1] = fiptr->startpos[1];
  value->endpos[0] = fiptr->endpos[0];
  value->endpos[1] = fiptr->endpos[1];
  value->weight = fiptr->weight;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x209260
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2092d5
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x20930d
movq 0x432cc4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30cd2d(%rip), %rsi    # 0x516013
leaq 0x3683f7(%rip), %rdx    # 0x5716e4
leaq 0x36845b(%rip), %rcx    # 0x57174f
leaq 0x36820d(%rip), %r8     # 0x571508
movl $0x6f1, %r9d            # imm = 0x6F1
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20930f
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x18(%rsp), %rdx
imulq $0x50, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_printchainelem
void gt_chain_printchainelem(FILE *outfp,const GtChain2Dimmatchvalues *value)
{
  fprintf(outfp,GT_WU " " GT_WU " " GT_WU " " GT_WU " " GT_WD "\n",
          value->startpos[0],
          value->endpos[0],
          value->startpos[1],
          value->endpos[1],
          value->weight);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r8
movq 0x8(%rsp), %rax
movq 0x18(%rax), %r9
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
leaq 0x368393(%rip), %rsi    # 0x571769
movq %rax, (%rsp)
movb $0x0, %al
callq 0x199f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_overlapcost
static GtChain2Dimscoretype gt_chain2dim_overlapcost(
                                    const GtChain2Dimmatchtable *matchtable,
                                    GtUword i,
                                    GtUword j)
{
  GtChain2Dimpostype overlaplength = 0;

  /* add overlap in first dimension */
  if (GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0, j)
        <= GT_CHAIN2DIM_GETSTOREDENDPOINT(0, i))
  {
    overlaplength += GT_CHAIN2DIM_GETSTOREDENDPOINT(0, i)
                       - GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0, j) + 1;
  }

  /* add overlap in second dimension */
  if (GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1, j)
        <= GT_CHAIN2DIM_GETSTOREDENDPOINT(1, i))
  {
    overlaplength += GT_CHAIN2DIM_GETSTOREDENDPOINT(1, i)
                       - GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1, j) + 1;
  }
  return (GtChain2Dimscoretype) overlaplength;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x18(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x10(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
ja 0x20946a
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x18(%rsp), %rdx
addq %rdx, %rcx
subq (%rcx), %rax
addq $0x1, %rax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x18(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x10(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x18(%rcx), %rax
ja 0x2094ce
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x18(%rsp), %rdx
addq %rdx, %rcx
subq 0x8(%rcx), %rax
addq $0x1, %rax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gapcostL1
static GtChain2Dimscoretype gapcostL1(const GtChain2Dimmatchtable *matchtable,
                                  GtUword i,
                                  GtUword j)
{
  return (GtChain2Dimscoretype)
         ((GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0,j)
             - GT_CHAIN2DIM_GETSTOREDENDPOINT(0,i)) +
          (GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1,j)
             - GT_CHAIN2DIM_GETSTOREDENDPOINT(1,i)));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x18(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x10(%rsp), %rdx
addq %rdx, %rcx
subq 0x10(%rcx), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x18(%rsp), %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rsp), %rdx
movq (%rdx), %rdx
imulq $0x50, -0x10(%rsp), %rsi
addq %rsi, %rdx
subq 0x18(%rdx), %rcx
addq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gapcostCc
static GtChain2Dimscoretype gapcostCc(const GtChain2Dimmatchtable *matchtable,
                                  GtUword i,GtUword j)
{
  GtChain2Dimpostype value1, value2;

  gt_assert(GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0,j)
              > GT_CHAIN2DIM_GETSTOREDENDPOINT(0,i) &&
            GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1,j)
              > GT_CHAIN2DIM_GETSTOREDENDPOINT(1,i));
  value1 = GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0,j)
             - GT_CHAIN2DIM_GETSTOREDENDPOINT(0,i) - 1,
  value2 = GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1,j)
             - GT_CHAIN2DIM_GETSTOREDENDPOINT(1,i) - 1;
  return (GtChain2Dimscoretype) GT_MAX(value1,value2);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x20(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, 0x28(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2095ba
movq 0x30(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, 0x28(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x18(%rcx), %rax
ja 0x2095f2
movq 0x4329df(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30ca48(%rip), %rsi    # 0x516013
leaq 0x3681ac(%rip), %rdx    # 0x57177e
leaq 0x368240(%rip), %rcx    # 0x571819
leaq 0x367f28(%rip), %r8     # 0x571508
movl $0x16c, %r9d            # imm = 0x16C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2095f4
movq 0x30(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x20(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, 0x28(%rsp), %rdx
addq %rdx, %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, 0x28(%rsp), %rdx
addq %rdx, %rcx
subq 0x18(%rcx), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x209671
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x20967b
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_checkmaxgapwidth
static bool gt_chain2dim_checkmaxgapwidth(const GtChain2Dimmatchtable
                                                                    *matchtable,
                                          GtChain2Dimpostype maxgapwidth,
                                          GtUword leftmatch,
                                          GtUword rightmatch)
{
  GtChain2Dimpostype gapwidth, startpoint, endpoint;

  startpoint = GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0,rightmatch);
  endpoint = GT_CHAIN2DIM_GETSTOREDENDPOINT(0,leftmatch);
  if (startpoint <= endpoint)
  {
    gapwidth = 0;
  } else
  {
    gapwidth = startpoint - endpoint - 1;
  }
  if (gapwidth > maxgapwidth)
  {
    return false;
  }
  startpoint = GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1,rightmatch);
  endpoint = GT_CHAIN2DIM_GETSTOREDENDPOINT(1,leftmatch);
  if (startpoint <= endpoint)
  {
    gapwidth = 0;
  } else
  {
    gapwidth = startpoint - endpoint - 1;
  }
  if (gapwidth > maxgapwidth)
  {
    return false;
  }
  return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x28(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x40(%rsp), %rax
ja 0x2096ee
movq $0x0, -0x30(%rsp)
jmp 0x209701
movq -0x38(%rsp), %rax
subq -0x40(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x18(%rsp), %rax
jbe 0x209714
movb $0x0, -0x1(%rsp)
jmp 0x20978a
movq -0x10(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x28(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x40(%rsp), %rax
ja 0x20975f
movq $0x0, -0x30(%rsp)
jmp 0x209772
movq -0x38(%rsp), %rax
subq -0x40(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x18(%rsp), %rax
jbe 0x209785
movb $0x0, -0x1(%rsp)
jmp 0x20978a
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_ovl_colinear
static bool gt_chain2dim_ovl_colinear(const GtChain2Dimmatchtable *matchtable,
                                      GtUword i,
                                      GtUword j)
{
  return (GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0, i)
            < GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0, j) &&
          GT_CHAIN2DIM_GETSTOREDENDPOINT(0, i)
            < GT_CHAIN2DIM_GETSTOREDENDPOINT(0, j)   &&
          GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1, i)
            < GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1, j) &&
          GT_CHAIN2DIM_GETSTOREDENDPOINT(1, i)
            < GT_CHAIN2DIM_GETSTOREDENDPOINT(1, j)) ? true : false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rdx
imulq $0x50, -0x18(%rsp), %rax
addq %rax, %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x19(%rsp)
jae 0x209878
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rdx
imulq $0x50, -0x18(%rsp), %rax
addq %rax, %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x19(%rsp)
jae 0x209878
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rdx
imulq $0x50, -0x18(%rsp), %rax
addq %rax, %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x19(%rsp)
jae 0x209878
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x18(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x18(%rcx), %rax
setb %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_overlapping
static bool gt_chain2dim_overlapping(const GtChain2Dimmatchtable *matchtable,
                                     GtUword i,
                                     GtUword j)
{
  return (GT_CHAIN2DIM_GETSTOREDENDPOINT(0,i)
            >= GT_CHAIN2DIM_GETSTOREDSTARTPOINT(0,j) ||
          GT_CHAIN2DIM_GETSTOREDENDPOINT(1,i)
            >= GT_CHAIN2DIM_GETSTOREDSTARTPOINT(1,j)) ? true : false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rdx
imulq $0x50, -0x18(%rsp), %rax
addq %rax, %rdx
movb $0x1, %al
cmpq (%rdx), %rcx
movb %al, -0x19(%rsp)
jae 0x209911
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x18(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
setae %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: makesortedendpointpermutation
static void makesortedendpointpermutation(GtUword *perm,
                                          GtChain2Dimmatchtable *matchtable,
                                          unsigned int presortdim)
{
  GtUword temp, *iptr, *jptr, i;

  for (i = 0; i < matchtable->nextfree; i++)
  {
    perm[i] = i;
  }
  for (iptr = perm + 1UL; iptr < perm + matchtable->nextfree; iptr++)
  {
    for (jptr = iptr; jptr > perm; jptr--)
    {
      if (GT_CHAIN2DIM_GETSTOREDENDPOINT(presortdim,*(jptr-1)) <=
          GT_CHAIN2DIM_GETSTOREDENDPOINT(presortdim,*jptr))
      {
        break;
      }
      temp = *(jptr-1);
      *(jptr-1) = *jptr;
      *jptr = temp;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x2099da
movq -0x38(%rsp), %rdx
movq -0x8(%rsp), %rax
movq -0x38(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x2099a7
movq -0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rdx
movq 0x18(%rdx), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x209ab4
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x8(%rsp), %rax
jbe 0x209a9f
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x30(%rsp), %rcx
imulq $0x50, -0x8(%rcx), %rcx
addq %rcx, %rax
movl -0x14(%rsp), %ecx
movq 0x10(%rax,%rcx,8), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq -0x30(%rsp), %rdx
imulq $0x50, (%rdx), %rdx
addq %rdx, %rcx
movl -0x14(%rsp), %edx
cmpq 0x10(%rcx,%rdx,8), %rax
ja 0x209a60
jmp 0x209a9f
movq -0x30(%rsp), %rax
movq -0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x30(%rsp), %rax
movq (%rax), %rcx
movq -0x30(%rsp), %rax
movq %rcx, -0x8(%rax)
movq -0x20(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rsp)
jmp 0x209a15
jmp 0x209aa1
movq -0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rsp)
jmp 0x2099e8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_cmpendMatchpoint2
static int gt_chain2dim_cmpendMatchpoint2(const void* keya,
                                          const void* keyb,
                                          GT_UNUSED void *info)
{
  if (((GtChain2DimMatchpoint *) keya)->fpposition <
      ((GtChain2DimMatchpoint *) keyb)->fpposition)
  {
    return -1;
  }
  if (((GtChain2DimMatchpoint *) keya)->fpposition >
      ((GtChain2DimMatchpoint *) keyb)->fpposition)
  {
    return 1;
  }
  if (FRAGIDENT((GtChain2DimMatchpoint *) keya) <
      FRAGIDENT((GtChain2DimMatchpoint *) keyb))
  {
    return -1;
  }
  if (FRAGIDENT((GtChain2DimMatchpoint *) keya) >
      FRAGIDENT((GtChain2DimMatchpoint *) keyb))
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x209d4d
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x209dab
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x209d6b
movl $0x1, -0x4(%rsp)
jmp 0x209dab
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x209d87
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x209dab
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x209da3
movl $0x1, -0x4(%rsp)
jmp 0x209dab
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: comparestartandend
static int comparestartandend(const Matchchaininfo *sortedstartpoints,
                              const Matchchaininfo *sortedendpoints,
                              unsigned int presortdim)
{
  if (sortedstartpoints->startpos[presortdim] <
      sortedendpoints->endpos[presortdim])
  {
    return -1;
  }
  if (sortedstartpoints->startpos[presortdim] >
      sortedendpoints->endpos[presortdim])
  {
    return 1;
  }
  return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq -0x18(%rsp), %rcx
movl -0x1c(%rsp), %edx
cmpq 0x10(%rcx,%rdx,8), %rax
jae 0x209de5
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x209e14
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq -0x18(%rsp), %rcx
movl -0x1c(%rsp), %edx
cmpq 0x10(%rcx,%rdx,8), %rax
jbe 0x209e0c
movl $0x1, -0x4(%rsp)
jmp 0x209e14
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: makeactivationpoint
static GtChain2DimMatchpoint *makeactivationpoint(
                                       const GtChain2Dimmatchtable *matchtable,
                                       GtUword fpident,
                                       unsigned int postsortdim)
{
  GtChain2DimMatchpoint *fpptr;

  fpptr = gt_malloc(sizeof (*fpptr));
  gt_assert(fpptr != NULL);
  fpptr->fpident = MAKEENDPOINT(fpident);
  fpptr->fpposition = GT_CHAIN2DIM_GETSTOREDENDPOINT(postsortdim,fpident);
  return fpptr;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0x10, %edi
leaq 0x36726a(%rip), %rsi    # 0x571508
movl $0x4cf, %edx            # imm = 0x4CF
callq 0xe80f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x20a2ed
movq 0x431ce4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30bd4d(%rip), %rsi    # 0x516013
leaq 0x36762c(%rip), %rdx    # 0x5718f9
leaq 0x367633(%rip), %rcx    # 0x571907
leaq 0x36722d(%rip), %r8     # 0x571508
movl $0x4d0, %r9d            # imm = 0x4D0
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20a2ef
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x18(%rsp), %rcx
addq %rcx, %rax
movl 0x14(%rsp), %ecx
movq 0x10(%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_evalpriority
static GtChain2Dimscoretype gt_chain2dim_evalpriority(bool addterminal,
                                     const GtChain2Dimmatchtable *matchtable,
                                     GtUword matchnum)
{
  if (addterminal)
  {
    return matchtable->matches[matchnum].score
             - GT_CHAIN2DIM_TERMINALGAP(matchnum);
  }
  return matchtable->matches[matchnum].score;
}

// Assembly:
movb %dil, %al
andb $0x1, %al
movb %al, -0x9(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
testb $0x1, -0x9(%rsp)
je 0x20a37b
movq -0x18(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x20(%rsp), %rdx
addq %rdx, %rcx
subq 0x40(%rcx), %rax
movq %rax, -0x8(%rsp)
jmp 0x20a395
movq -0x18(%rsp), %rax
movq (%rax), %rax
imulq $0x50, -0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_insertintodict
static void gt_chain2dim_insertintodict(bool addterminal,
                                        const GtChain2Dimmatchtable *matchtable,
                                        GtChain2DimMatchstore *matchstore,
                                        GtChain2DimMatchpoint *qmatch2)
{
  GtChain2DimMatchpoint *retval2;
  bool nodecreated;

  retval2 = (GtChain2DimMatchpoint *) gt_rbtree_search(matchstore->dictroot,
                                                       qmatch2,
                                                       &nodecreated);
  gt_assert(retval2 != NULL);
  if (!nodecreated)
  {
    if (gt_chain2dim_evalpriority(addterminal,matchtable,FRAGIDENT(retval2)) <
        gt_chain2dim_evalpriority(addterminal,matchtable,FRAGIDENT(qmatch2)))
    {
      gt_assert(retval2->fpposition == qmatch2->fpposition);
      retval2->fpident = qmatch2->fpident;
    }
  }
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x1b8790
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x20a418
movq 0x431bb9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30bc22(%rip), %rsi    # 0x516013
leaq 0x3674aa(%rip), %rdx    # 0x5718a2
leaq 0x3674b3(%rip), %rcx    # 0x5718b2
leaq 0x367102(%rip), %r8     # 0x571508
movl $0x34f, %r9d            # imm = 0x34F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20a41a
testb $0x1, 0xf(%rsp)
jne 0x20a4cd
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x20a330
movq %rax, (%rsp)
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x20a330
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jge 0x20a4cb
jmp 0x20a46d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0x20a4b9
movq 0x431b18(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30bb81(%rip), %rsi    # 0x516013
leaq 0x367435(%rip), %rdx    # 0x5718ce
leaq 0x367412(%rip), %rcx    # 0x5718b2
leaq 0x367061(%rip), %r8     # 0x571508
movl $0x355, %r9d            # imm = 0x355
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20a4bb
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x20a4cd
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: chain2dim_chainkind_global
static bool chain2dim_chainkind_global(GtChain2Dimkind chainkind)
{
  return (chainkind == GLOBALCHAINING ||
          chainkind == GLOBALCHAININGWITHGAPCOST ||
          chainkind == GLOBALCHAININGWITHOVERLAPS ||
          chainkind == GLOBALCHAININGALLCHAINS) ? true : false;
}

// Assembly:
movl %edi, -0x4(%rsp)
movb $0x1, %al
cmpl $0x0, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x20a517
movb $0x1, %al
cmpl $0x1, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x20a517
movb $0x1, %al
cmpl $0x2, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x20a517
cmpl $0x3, -0x4(%rsp)
sete %al
movb %al, -0x5(%rsp)
movb -0x5(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)