LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: assignbcktabmapspecification
static void assignbcktabmapspecification(GtMapspec *mapspec,
                                         void *data,
                                         bool writemode)
{
  GtBcktab *bcktab = (GtBcktab *) data;

  if (bcktab->useulong)
  {
    gt_mapspec_add_ulong(mapspec, bcktab->leftborder.ulongbounds,
                         (GtUword) (bcktab->numofallcodes+1));
  } else
  {
    gt_mapspec_add_uint32(mapspec, bcktab->leftborder.uintbounds,
                          (GtUword) (bcktab->numofallcodes+1));
  }
  if (bcktab->withspecialsuffixes)
  {
    if (bcktab->useulong)
    {
      gt_mapspec_add_ulong(mapspec, bcktab->ulongcountspecialcodes,
                           (GtUword) bcktab->numofspecialcodes);
    } else
    {
      gt_mapspec_add_uint32(mapspec, bcktab->uintcountspecialcodes,
                            (GtUword) bcktab->numofspecialcodes);
    }
    if (bcktab->numofdistpfxidxcounters > 0)
    {
      if (!writemode)
      {
        if (bcktab->useulong)
        {
          bcktab->ulongdistpfxidx = gt_malloc(sizeof (void *) *
                                              (bcktab->prefixlength-1));
        } else
        {
          bcktab->uintdistpfxidx = gt_malloc(sizeof (void *) *
                                             (bcktab->prefixlength-1));
        }
      }
      if (bcktab->useulong)
      {
        gt_mapspec_add_ulong(mapspec, bcktab->ulongdistpfxidx[0],
                             bcktab->numofdistpfxidxcounters);
      } else
      {
        gt_mapspec_add_uint32(mapspec, bcktab->uintdistpfxidx[0],
                              bcktab->numofdistpfxidxcounters);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xa2(%rsi)
jne 0x134b1d
leaq 0x8(%r14), %rsi
movq 0x58(%r14), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x94a45
jmp 0x134b2f
movq 0x58(%r14), %rdx
incq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x94c2f
cmpb $0x1, 0xa1(%r14)
jne 0x134bcb
movq 0x60(%r14), %rdx
cmpb $0x1, 0xa2(%r14)
jne 0x134b59
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x94a45
jmp 0x134b65
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x94c2f
cmpq $0x0, 0x40(%r14)
je 0x134bcb
testb %bpl, %bpl
jne 0x134ba7
movzbl 0xa2(%r14), %r15d
movl 0x48(%r14), %edi
decl %edi
shlq $0x3, %rdi
movl %r15d, %eax
xorb $0x1, %al
movzbl %al, %eax
leal 0x228(,%rax,4), %edx
shll $0x4, %r15d
leaq 0x209ae9(%rip), %rsi    # 0x33e686
callq 0x93160
movq %rax, 0x18(%r15,%r14)
movq 0x40(%r14), %rdx
cmpb $0x1, 0xa2(%r14)
jne 0x134bd6
movq 0x28(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x94a45
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x94c2f
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_checkcountspecialcodes
void gt_bcktab_checkcountspecialcodes(const GtBcktab *bcktab)
{
  GtCodetype code;
  GtUword *count;

  if (bcktab->prefixlength >= 2U)
  {
    count = gt_malloc(sizeof (*count) * bcktab->prefixlength);
    for (code=0; code<bcktab->numofallcodes; code++)
    {
      pfxidxpartialsums(count, code, bcktab);
    }
    gt_free(count);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x48(%rdi), %edi
cmpq $0x2, %rdi
jb 0x134d05
shlq $0x3, %rdi
leaq 0x209a74(%rip), %rsi    # 0x33e686
movl $0x2a9, %edx            # imm = 0x2A9
callq 0x93160
movq %rax, %r15
xorl %r14d, %r14d
cmpq 0x58(%rbx), %r14
jae 0x134d14
movl 0x48(%rbx), %edx
shlq $0x3, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x17380
movl 0x48(%rbx), %ebp
addl $-0x2, %ebp
xorl %r12d, %r12d
movq 0x78(%rbx), %rdi
testl %ebp, %ebp
je 0x134c82
movl %ebp, %r13d
movq (%rdi,%r13,8), %rcx
movq %r14, %rax
subq %rcx, %rax
jb 0x134c82
incq %rcx
xorl %edx, %edx
divq %rcx
decl %ebp
testq %rdx, %rdx
jne 0x134c4a
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x134fa8
movq %rax, (%r15,%r13,8)
addq %rax, %r12
jmp 0x134c46
movl 0x48(%rbx), %ecx
leal -0x1(%rcx), %esi
movq (%rdi,%rsi,8), %rdi
movq %r14, %rax
subq %rdi, %rax
jae 0x134c98
xorl %edi, %edi
jmp 0x134cc9
incq %rdi
xorl %edx, %edx
divq %rdi
movl $0x0, %edi
testq %rdx, %rdx
jne 0x134cc9
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x134cb9
movq (%rdx,%rax,8), %rdi
jmp 0x134cc9
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x134d94
movl (%rdx,%rax,4), %edi
movq %rdi, %rax
subq %r12, %rax
jb 0x134d36
movq %rax, (%r15,%rsi,8)
cmpl $0x3, %ecx
jb 0x134cfd
addl $-0x2, %ecx
movq %rcx, %rax
subq $0x1, %rax
jb 0x134cf4
movq 0x10(%r15,%rax,8), %rdx
addq %rdx, (%r15,%rcx,8)
movq %rax, %rcx
jmp 0x134ce0
movq 0x8(%r15), %r8
cmpq %r8, %rdi
jne 0x134d6e
incq %r14
jmp 0x134c22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20996b(%rip), %rsi    # 0x33e686
movq %r15, %rdi
movl $0x2ae, %edx            # imm = 0x2AE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x936f9
movq 0x30322b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b02cc(%rip), %rsi    # 0x2e5013
leaq 0x209e36(%rip), %rdx    # 0x33eb84
leaq 0x209e47(%rip), %rcx    # 0x33eb9c
leaq 0x20992a(%rip), %r8     # 0x33e686
movl $0x28f, %r9d            # imm = 0x28F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3031f3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x209e2f(%rip), %rsi    # 0x33ebae
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
movq 0x3031cd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b026e(%rip), %rsi    # 0x2e5013
leaq 0x209b3e(%rip), %rdx    # 0x33e8ea
leaq 0x209e22(%rip), %rcx    # 0x33ebd5
leaq 0x2098cc(%rip), %r8     # 0x33e686
movl $0x26b, %r9d            # imm = 0x26B
jmp 0x134d62
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_map
GtBcktab *gt_bcktab_map(const char *indexname,
                        unsigned int numofchars,
                        unsigned int prefixlength,
                        GtUword maxvalue,
                        bool withspecialsuffixes,
                        GtError *err)
{
  GtBcktab *bcktab;

  bcktab = gt_bcktab_new_withinit(numofchars,prefixlength,maxvalue,
                                  withspecialsuffixes);
  bcktab->allocated = false;
  if (fillbcktabmapspecstartptr(bcktab, indexname, err) != 0)
  {
    gt_bcktab_delete(bcktab);
    return NULL;
  }
  if (withspecialsuffixes)
  {
    if (bcktab->ulongdistpfxidx != NULL)
    {
      ulong_setdistpfxidxptrs(bcktab->ulongdistpfxidx,
                              bcktab->ulongdistpfxidx[0],
                              bcktab->basepower,bcktab->prefixlength);
    } else
    {
      if (bcktab->uintdistpfxidx != NULL)
      {
        uint_setdistpfxidxptrs(bcktab->uintdistpfxidx,
                               bcktab->uintdistpfxidx[0],
                               bcktab->basepower,bcktab->prefixlength);
      }
    }
#ifdef CHECKCOUNTSPECIALCODES
    gt_bcktab_checkcountspecialcodes(bcktab);
#endif
  }
  return bcktab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %ebp
movq %rdi, %r15
movl %esi, %edi
movl %edx, %esi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x1346f6
movq %rax, %rbx
movb $0x0, 0xa0(%rax)
testq %r14, %r14
je 0x134e00
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x134eae
movq %r15, %rdi
callq 0xacbd1
movq %rax, %r15
leaq 0x209df8(%rip), %rsi    # 0x33ec0a
movq %rax, %rdi
callq 0xacbfb
movq %r15, %rdi
callq 0xad1fa
movq 0x30(%rbx), %rcx
movq %rbx, %r8
addq $0xa8, %r8
leaq -0x347(%rip), %rdi      # 0x134af0
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %r9
callq 0x9430d
movl %eax, %r14d
movq %r15, %rdi
callq 0xae103
testl %r14d, %r14d
je 0x134e61
movq %rbx, %rdi
callq 0x13484d
xorl %ebx, %ebx
jmp 0x134ea0
testb %bpl, %bpl
je 0x134ea0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x134e80
movq (%rdi), %rsi
movq 0x70(%rbx), %rdx
movl 0x48(%rbx), %ecx
callq 0x134ee6
jmp 0x134e98
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x134e98
movq (%rdi), %rsi
movq 0x70(%rbx), %rdx
movl 0x48(%rbx), %ecx
callq 0x134f05
movq %rbx, %rdi
callq 0x134bec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3030b3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0154(%rip), %rsi    # 0x2e5013
leaq 0x1b02f9(%rip), %rdx    # 0x2e51bf
leaq 0x209d23(%rip), %rcx    # 0x33ebf0
leaq 0x2097b2(%rip), %r8     # 0x33e686
movl $0x24a, %r9d            # imm = 0x24A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: ulong_setdistpfxidxptrs
static void ulong_setdistpfxidxptrs(GtUword **ulongdistpfxidx,
                                    GtUword *ptr,
                                    const GtCodetype *basepower,
                                    unsigned int prefixlength)
{
  unsigned int idx;

  ulongdistpfxidx[0] = ptr;
  for (idx=1U; idx<prefixlength-1; idx++)
  {
    ulongdistpfxidx[idx] = ulongdistpfxidx[idx-1] + basepower[idx];
  }
}

// Assembly:
movq %rsi, (%rdi)
decl %ecx
pushq $0x1
popq %rax
cmpq %rcx, %rax
jae 0x134f04
movq (%rdx,%rax,8), %r8
leaq (%rsi,%r8,8), %rsi
movq %rsi, (%rdi,%rax,8)
incq %rax
jmp 0x134eee
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: uint_setdistpfxidxptrs
static void uint_setdistpfxidxptrs(uint32_t **uintdistpfxidx,
                                   uint32_t *ptr,
                                   const GtCodetype *basepower,
                                   unsigned int prefixlength)
{
  unsigned int idx;

  uintdistpfxidx[0] = ptr;
  for (idx=1U; idx<prefixlength-1; idx++)
  {
    uintdistpfxidx[idx] = uintdistpfxidx[idx-1] + basepower[idx];
  }
}

// Assembly:
movq %rsi, (%rdi)
decl %ecx
pushq $0x1
popq %rax
cmpq %rcx, %rax
jae 0x134f23
movq (%rdx,%rax,8), %r8
leaq (%rsi,%r8,4), %rsi
movq %rsi, (%rdi,%rax,8)
incq %rax
jmp 0x134f0d
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_show
void gt_bcktab_show(const GtBcktab *bcktab)
{
  unsigned int prefixindex;

  for (prefixindex=1U; prefixindex < bcktab->prefixlength-1; prefixindex++)
  {
    GtCodetype code;
    GtUword sum = 0, value;
    for (code = 0; code < bcktab->basepower[prefixindex]; code++)
    {
      value = gt_bcktab_distpfxidx_get(bcktab,prefixindex-1,code);
      sum += value;
      printf("distpfxidx[%u]["GT_WU"]="GT_WU"\n",prefixindex,code,value);
    }
    printf("sum "GT_WU"\n",sum);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
leaq 0x209887(%rip), %r15    # 0x33e7c4
movl 0x48(%rbx), %eax
decl %eax
cmpq %rax, %r14
jae 0x134f99
leal -0x1(%r14), %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x70(%rbx), %rax
cmpq (%rax,%r14,8), %r12
jae 0x134f83
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x134fa8
addq %rax, %r13
movq %r15, %rdi
movl %r14d, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x17070
incq %r12
jmp 0x134f51
leaq 0x209853(%rip), %rdi    # 0x33e7dd
movq %r13, %rsi
xorl %eax, %eax
callq 0x17070
incq %r14
jmp 0x134f3d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_distpfxidx_get
static GtUword gt_bcktab_distpfxidx_get(const GtBcktab *bcktab,
                                              unsigned int prefixindex,
                                              GtCodetype ordercode)
{
  if (bcktab->ulongdistpfxidx != NULL)
  {
    return bcktab->ulongdistpfxidx[prefixindex][ordercode];
  }
  gt_assert(bcktab->uintdistpfxidx != NULL);
  return (GtUword) bcktab->uintdistpfxidx[prefixindex][ordercode];
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x134fbc
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movq (%rax,%rdx,8), %rax
retq
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x134fcf
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl (%rax,%rdx,4), %eax
retq
pushq %rax
movq 0x302f91(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0032(%rip), %rsi    # 0x2e5013
leaq 0x209c27(%rip), %rdx    # 0x33ec0f
leaq 0x209c3f(%rip), %rcx    # 0x33ec2e
leaq 0x209690(%rip), %r8     # 0x33e686
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_leftborder_show
void gt_bcktab_leftborder_show(const GtBcktab *bcktab)
{
  GtCodetype idx;

  for (idx=0; idx<bcktab->numofallcodes; idx++)
  {
    printf("leftborder[" FormatGtCodetype "]="GT_WU,idx,
                                    gt_bcktab_get_leftborder(bcktab,idx));
    if (idx > 0)
    {
      printf(" size " GT_WU,gt_bcktab_get_leftborder(bcktab,idx) -
                            gt_bcktab_get_leftborder(bcktab,idx-1));
    }
    printf("\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2097cb(%rip), %r14    # 0x33e7e6
pushq $0xa
popq %rbp
leaq 0x1f03c4(%rip), %r15    # 0x3253e9
xorl %r12d, %r12d
cmpq 0x58(%rbx), %r12
jae 0x135085
movq %rbx, %rdi
movq %r12, %rsi
callq 0x134141
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
testq %r12, %r12
je 0x135079
movq %rbx, %rdi
movq %r12, %rsi
callq 0x134141
movq %rax, %r13
leaq -0x1(%r12), %rsi
movq %rbx, %rdi
callq 0x134141
subq %rax, %r13
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x17070
movl %ebp, %edi
callq 0x179c0
incq %r12
jmp 0x135028
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_addfinalspecials
void gt_bcktab_addfinalspecials(GtBcktab *bcktab,
                                GtUword specialcharacters)
{
  if (bcktab->withspecialsuffixes)
  {
    GtCodetype specialcode;

    gt_assert(bcktab->filltable[0] >= (GtCodetype) (bcktab->numofchars-1));
    specialcode = GT_FROMCODE2SPECIALCODE(bcktab->filltable[0],
                                          bcktab->numofchars);
    if (bcktab->ulongcountspecialcodes != NULL)
    {
      bcktab->ulongcountspecialcodes[specialcode]
        += (GtUword) (specialcharacters + 1);
    } else
    {
      gt_assert(bcktab->uintcountspecialcodes != NULL);
      bcktab->uintcountspecialcodes[specialcode]
        += (uint32_t) (specialcharacters + 1);
    }
  }
}

// Assembly:
pushq %rax
cmpb $0x1, 0xa1(%rdi)
jne 0x13535a
movq 0x78(%rdi), %rax
movq (%rax), %rax
movl 0x4c(%rdi), %r8d
leal -0x1(%r8), %edx
movq %rax, %rcx
subq %rdx, %rcx
jb 0x13535c
cmpl $0x4, %r8d
jne 0x135326
shrq $0x2, %rax
jmp 0x13532e
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x135347
movq (%rcx,%rax,8), %rdx
addq %rsi, %rdx
incq %rdx
movq %rdx, (%rcx,%rax,8)
jmp 0x13535a
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x13538a
movl (%rcx,%rax,4), %edx
addl %esi, %edx
incl %edx
movl %edx, (%rcx,%rax,4)
popq %rax
retq
movq 0x302c05(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1afca6(%rip), %rsi    # 0x2e5013
leaq 0x20959c(%rip), %rdx    # 0x33e910
leaq 0x2095d1(%rip), %rcx    # 0x33e94c
leaq 0x209304(%rip), %r8     # 0x33e686
movl $0x390, %r9d            # imm = 0x390
jmp 0x1353b6
movq 0x302bd7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1afc78(%rip), %rsi    # 0x2e5013
leaq 0x209548(%rip), %rdx    # 0x33e8ea
leaq 0x2095a3(%rip), %rcx    # 0x33e94c
leaq 0x2092d6(%rip), %r8     # 0x33e686
movl $0x399, %r9d            # imm = 0x399
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_calcboundaries
void gt_bcktab_calcboundaries(GtBucketspecification *bucketspec,
                              const GtBcktab *bcktab,
                              GtCodetype code)
{
  gt_assert(code != bcktab->numofallcodes);
  (void) gt_bcktab_calcboundsparts(bucketspec,
                                   bcktab,
                                   code,
                                   bcktab->numofallcodes, /*code<numofallcodes*/
                                   0,  /* not necessary */
                                   bcktab->withspecialsuffixes
                                    ? (unsigned int) (code % bcktab->numofchars)
                                    : 0);
}

// Assembly:
movq 0x58(%rsi), %rcx
cmpq %rdx, %rcx
je 0x135566
movq %rdx, %r8
xorl %r9d, %r9d
cmpb $0x1, 0xa1(%rsi)
jne 0x13555b
movl 0x4c(%rsi), %r9d
movq %r8, %rax
xorl %edx, %edx
divq %r9
movq %rdx, %r9
movq %r8, %rdx
xorl %r8d, %r8d
jmp 0x1353c2
pushq %rax
movq 0x3029fa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1afa9b(%rip), %rsi    # 0x2e5013
leaq 0x209421(%rip), %rdx    # 0x33e9a0
leaq 0x209438(%rip), %rcx    # 0x33e9be
leaq 0x2090f9(%rip), %r8     # 0x33e686
movl $0x3db, %r9d            # imm = 0x3DB
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_determinemaxsize
void gt_bcktab_determinemaxsize(GtBcktab *bcktab,
                                GtCodetype mincode,
                                GtCodetype maxcode,
                                GtUword partwidth)
{
  unsigned int rightchar = (unsigned int) (mincode % bcktab->numofchars);
  GtBucketspecification bucketspec;
  GtCodetype code;

#ifdef SKDEBUG
  printf("mincode="GT_WU",maxcode="GT_WU",partwidth="GT_WU",totallength="
         GT_WU"\n", (GtUword) mincode,(GtUword) maxcode, partwidth,totallength);
#endif
  bcktab->maxbucketinfo.specialsmaxbucketsize = 1UL;
  bcktab->maxbucketinfo.nonspecialsmaxbucketsize = 1UL;
  bcktab->maxbucketinfo.maxbucketsize = 1UL;
  for (code = mincode; code <= maxcode; code++)
  {
    rightchar = gt_bcktab_calcboundsparts(&bucketspec,
                                          bcktab,
                                          code,
                                          maxcode,
                                          partwidth,
                                          rightchar);
    if (bucketspec.nonspecialsinbucket >
        bcktab->maxbucketinfo.nonspecialsmaxbucketsize)
    {
      bcktab->maxbucketinfo.nonspecialsmaxbucketsize
        = bucketspec.nonspecialsinbucket;
    }
    if (bucketspec.specialsinbucket >
        bcktab->maxbucketinfo.specialsmaxbucketsize)
    {
      bcktab->maxbucketinfo.specialsmaxbucketsize = bucketspec.specialsinbucket;
    }
    if (bucketspec.nonspecialsinbucket + bucketspec.specialsinbucket
        > bcktab->maxbucketinfo.maxbucketsize)
    {
      bcktab->maxbucketinfo.maxbucketsize = bucketspec.nonspecialsinbucket +
                                            bucketspec.specialsinbucket;
    }
  }
  /*
  gt_logger_log(logger,"maxbucket (specials)="GT_WU"",
              bcktab->maxbucketinfo.specialsmaxbucketsize);
  gt_logger_log(logger,"maxbucket (nonspecials)="GT_WU"",
              bcktab->maxbucketinfo.nonspecialsmaxbucketsize);
  gt_logger_log(logger,"maxbucket (all)="GT_WU"",
              bcktab->maxbucketinfo.maxbucketsize);
  */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x4c(%rdi), %ecx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
pushq $0x1
popq %rcx
movq %rcx, 0x90(%rdi)
movq %rcx, 0x88(%rdi)
movq %rcx, 0x98(%rdi)
leaq 0x8(%rsp), %r13
cmpq %r14, %r15
ja 0x13568b
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl %eax, %r9d
callq 0x1353c2
movq 0x10(%rsp), %rcx
cmpq 0x88(%r12), %rcx
jbe 0x13565a
movq %rcx, 0x88(%r12)
movq 0x18(%rsp), %rdx
cmpq 0x90(%r12), %rdx
jbe 0x135671
movq %rdx, 0x90(%r12)
addq %rcx, %rdx
cmpq 0x98(%r12), %rdx
jbe 0x135686
movq %rdx, 0x98(%r12)
incq %r15
jmp 0x135627
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_singletonmaxprefixindex
unsigned int gt_bcktab_singletonmaxprefixindex(const GtBcktab *bcktab,
                                               GtCodetype code)
{
  if (bcktab->prefixlength > 2U)
  {
    GtCodetype ordercode, divisor;
    unsigned int prefixindex;

    for (prefixindex=bcktab->prefixlength-2; prefixindex>=1U; prefixindex--)
    {
      if (code >= bcktab->filltable[prefixindex])
      {
        ordercode = code - bcktab->filltable[prefixindex];
        divisor = bcktab->filltable[prefixindex] + 1;
        if (ordercode % divisor == 0)
        {
          ordercode /= divisor;
          if (gt_bcktab_distpfxidx_get(bcktab,prefixindex-1,ordercode) > 0)
          {
            return prefixindex;
          }
        }
      } else
      {
        break;
      }
    }
  }
  return bcktab->prefixlength-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x48(%rdi), %ebx
cmpl $0x3, %ebx
jb 0x135703
movq %rsi, %r15
movq %rdi, %r14
addl $-0x2, %ebx
movl %ebx, %ebp
testl %ebp, %ebp
je 0x1356ff
movl %ebp, %ebx
movq 0x78(%r14), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rcx
movq %r15, %rax
subq %rcx, %rax
jb 0x1356ff
incq %rcx
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x1356fb
leal -0x1(%rbx), %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x134fa8
testq %rax, %rax
je 0x1356bf
jmp 0x135705
decl %ebx
jmp 0x1356bd
movl 0x48(%r14), %ebx
decl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_distpfxidxpartialsums
GtUword gt_bcktab_distpfxidxpartialsums(const GtBcktab *bcktab,
                                              GtCodetype code,
                                              unsigned int lowerbound)
{
  GtCodetype ordercode, divisor;
  GtUword sum = 0;
  unsigned int prefixindex;

  for (prefixindex=bcktab->prefixlength-2; prefixindex>lowerbound;
       prefixindex--)
  {
    if (code >= bcktab->filltable[prefixindex])
    {
      ordercode = code - bcktab->filltable[prefixindex];
      divisor = bcktab->filltable[prefixindex] + 1;
      if (ordercode % divisor == 0)
      {
        ordercode /= divisor;
        sum += gt_bcktab_distpfxidx_get(bcktab,prefixindex-1,ordercode);
      }
    } else
    {
      break;
    }
  }
  return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x48(%rdi), %ebp
addl $-0x2, %ebp
xorl %r12d, %r12d
cmpl %ebx, %ebp
jbe 0x135762
movq 0x78(%r15), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rcx
movq %r14, %rax
subq %rcx, %rax
jb 0x135762
incq %rcx
xorl %edx, %edx
divq %rcx
decl %ebp
testq %rdx, %rdx
jne 0x13572b
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x134fa8
addq %rax, %r12
jmp 0x13572b
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_leftborderpartialsums
GtUword gt_bcktab_leftborderpartialsums(
                             GtUword *saved_bucketswithoutwholeleaf,
                             GtUword *numofsuffixestosort,
                             GtBcktab *bcktab)
{
  GtUword code, largestbucketsize, sumbuckets, saved = 0, currentsize;

  gt_assert(bcktab->numofallcodes > 0);
  largestbucketsize = sumbuckets = gt_bcktab_get_leftborder(bcktab,0);
  for (code = 1UL; code < bcktab->numofallcodes; code++)
  {
    currentsize = gt_bcktab_get_leftborder(bcktab,code);
    sumbuckets += currentsize;
    if (largestbucketsize < currentsize)
    {
      largestbucketsize = currentsize;
    }
    gt_bcktab_leftborder_assign(&bcktab->leftborder,code,sumbuckets);
  }
  gt_bcktab_leftborder_assign(&bcktab->leftborder,bcktab->numofallcodes,
                              sumbuckets);
  if (saved_bucketswithoutwholeleaf != NULL)
  {
    *saved_bucketswithoutwholeleaf = saved;
  }
  if (numofsuffixestosort != NULL)
  {
    *numofsuffixestosort = sumbuckets;
  }
  return largestbucketsize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x58(%rdx)
je 0x135a7b
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
xorl %esi, %esi
callq 0x134141
movq %rax, %r15
pushq $0x1
popq %rbp
movq %rax, %r13
movq 0x58(%r12), %rsi
cmpq %rsi, %rbp
jae 0x135a4d
movq %r12, %rdi
movq %rbp, %rsi
callq 0x134141
addq %rax, %r15
cmpq %rax, %r13
cmovbeq %rax, %r13
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x13408c
incq %rbp
jmp 0x135a1b
movq %r12, %rdi
movq %r15, %rdx
callq 0x13408c
testq %r14, %r14
je 0x135a61
andq $0x0, (%r14)
testq %rbx, %rbx
je 0x135a69
movq %r15, (%rbx)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3024e6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1af587(%rip), %rsi    # 0x2e5013
leaq 0x208fcc(%rip), %rdx    # 0x33ea5f
leaq 0x208fdf(%rip), %rcx    # 0x33ea79
leaq 0x208be5(%rip), %r8     # 0x33e686
movl $0x501, %r9d            # imm = 0x501
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_transformcode
static GtUword gt_bcktab_transformcode(GtUword code,
                                             const void *data)
{
  unsigned int numofchars, *numofcharptr = (unsigned int *) data;

  numofchars = *numofcharptr;
  if (code >= (GtUword) (numofchars - 1))
  {
    return GT_FROMCODE2SPECIALCODE(code,numofchars);
  } else
  {
    return 0;
  }
}

// Assembly:
movl (%rsi), %esi
leal -0x1(%rsi), %edx
movq %rdi, %rcx
subq %rdx, %rcx
jae 0x135c7c
xorl %eax, %eax
retq
cmpl $0x4, %esi
jne 0x135c89
movq %rdi, %rax
shrq $0x2, %rax
retq
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_matchtable_new
GtChain2Dimmatchtable *gt_chain_matchtable_new(GtUword numberofmatches)
{
  GtChain2Dimmatchtable *matchtable = gt_malloc(sizeof (*matchtable));
  matchtable->matches = gt_malloc(sizeof (*matchtable->matches) *
                                  numberofmatches);
  matchtable->nextfree = 0;
  matchtable->allocated = numberofmatches;
  matchtable->largestdim0 = matchtable->largestdim1 = 0;
  matchtable->previouscount = NULL;
  matchtable->previousbound = NULL;
  matchtable->previoustab = NULL;
  matchtable->allprevious = 0;
  return matchtable;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x208d25(%rip), %r14    # 0x33ed78
pushq $0x48
popq %rdi
movq %r14, %rsi
movl $0x88, %edx
callq 0x93160
movq %rax, %r15
imulq $0x50, %rbx, %rdi
movq %r14, %rsi
movl $0x8a, %edx
callq 0x93160
movq %rax, (%r15)
andq $0x0, 0x18(%r15)
movq %rbx, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x38(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x13610b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x208cc4(%rip), %r14    # 0x33ed78
movq %r14, %rsi
movl $0x99, %edx
callq 0x936f9
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x9a, %edx
callq 0x936f9
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x9b, %edx
callq 0x936f9
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x9c, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_matchtable_add
void gt_chain_matchtable_add(GtChain2Dimmatchtable *matchtable,
                             const GtChain2Dimmatchvalues *inmatch)
{
  Matchchaininfo *matchchaininfo;

  gt_assert(matchtable->nextfree < matchtable->allocated);
  gt_assert(inmatch->startpos[0] <= inmatch->endpos[0]);
  gt_assert(inmatch->startpos[1] <= inmatch->endpos[1]);
  matchchaininfo = matchtable->matches + matchtable->nextfree++;
  matchchaininfo->startpos[0] = inmatch->startpos[0];
  matchchaininfo->startpos[1] = inmatch->startpos[1];
  matchchaininfo->endpos[0] = inmatch->endpos[0];
  matchchaininfo->endpos[1] = inmatch->endpos[1];
  matchchaininfo->weight = inmatch->weight;
  if (matchtable->largestdim0 < (GtChain2Dimscoretype) inmatch->endpos[0])
  {
    matchtable->largestdim0 = (GtChain2Dimscoretype) inmatch->endpos[0];
  }
  if (matchtable->largestdim1 < (GtChain2Dimscoretype) inmatch->endpos[1])
  {
    matchtable->largestdim1 = (GtChain2Dimscoretype) inmatch->endpos[1];
  }
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jae 0x1361d5
movq (%rsi), %rcx
cmpq 0x10(%rsi), %rcx
ja 0x136203
movq 0x8(%rsi), %rcx
cmpq 0x18(%rsi), %rcx
ja 0x136231
movq (%rdi), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rdi)
imulq $0x50, %rax, %rax
movq (%rsi), %rdx
movq %rdx, (%rcx,%rax)
movq 0x8(%rsi), %rdx
movq %rdx, 0x8(%rcx,%rax)
movq 0x10(%rsi), %rdx
movq %rdx, 0x10(%rcx,%rax)
movq 0x18(%rsi), %rdx
movq %rdx, 0x18(%rcx,%rax)
movq 0x20(%rsi), %rdx
movq %rdx, 0x30(%rcx,%rax)
movq 0x10(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jge 0x1361c5
movq %rax, 0x8(%rdi)
movq 0x18(%rsi), %rax
cmpq %rax, 0x10(%rdi)
jge 0x1361d3
movq %rax, 0x10(%rdi)
popq %rax
retq
movq 0x301d8c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1aee2d(%rip), %rsi    # 0x2e5013
leaq 0x208bce(%rip), %rdx    # 0x33edbb
leaq 0x208bf4(%rip), %rcx    # 0x33ede8
leaq 0x208b7d(%rip), %r8     # 0x33ed78
movl $0xad, %r9d
jmp 0x13625d
movq 0x301d5e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1aedff(%rip), %rsi    # 0x2e5013
leaq 0x208be5(%rip), %rdx    # 0x33ee00
leaq 0x208bc6(%rip), %rcx    # 0x33ede8
leaq 0x208b4f(%rip), %r8     # 0x33ed78
movl $0xae, %r9d
jmp 0x13625d
movq 0x301d30(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1aedd1(%rip), %rsi    # 0x2e5013
leaq 0x208be2(%rip), %rdx    # 0x33ee2b
leaq 0x208b98(%rip), %rcx    # 0x33ede8
leaq 0x208b21(%rip), %r8     # 0x33ed78
movl $0xaf, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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), %rax
imulq $0x50, 0x18(%rdi), %rcx
addq %rax, %rcx
cmpq %rcx, %rax
jae 0x1362a1
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
addq (%rax), %rdx
movq %rdx, 0x38(%rax)
movq 0x8(%rdi), %rdx
addq 0x10(%rdi), %rdx
addq 0x18(%rax), %rsi
subq %rsi, %rdx
movq %rdx, 0x40(%rax)
addq $0x50, %rax
jmp 0x136274
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movsd 0x1aff70(%rip), %xmm1   # 0x2e6228
callq 0x955a5
movsd 0x8(%rsp), %xmm1
testb %al, %al
je 0x1362cd
addq $0x10, %rsp
popq %rbx
retq
movq (%rbx), %rax
imulq $0x50, 0x18(%rbx), %rcx
addq %rax, %rcx
cmpq %rcx, %rax
jae 0x1362c7
cvtsi2sdq 0x30(%rax), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, 0x30(%rax)
addq $0x50, %rax
jmp 0x1362d8
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x2, 0x18(%rsi)
jb 0x1374a9
movl %edx, %ebp
cmpl $0x2, %edx
jae 0x1374cd
movq %rsi, %rbx
movq %rdi, %r14
testl %ebp, %ebp
leaq 0xbb(%rip), %rax        # 0x137505
leaq 0xc6(%rip), %r15        # 0x137517
cmoveq %rax, %r15
movq (%rsi), %rdi
movq (%rbx), %rax
imulq $0x50, 0x18(%rbx), %rcx
addq %rcx, %rax
addq $-0x50, %rax
cmpq %rax, %rdi
jae 0x1374b2
leaq 0x50(%rdi), %r12
movq %r12, %rsi
callq *%r15
movq %r12, %rdi
cmpl $0x1, %eax
jne 0x137458
leaq 0x207a42(%rip), %rsi    # 0x33eec7
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
pushq $0x50
popq %rdx
movq %r15, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17ed0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x207a3c(%rip), %rsi    # 0x33eef5
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x92e71
movq 0x300a94(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1adb35(%rip), %rsi    # 0x2e5013
leaq 0x207971(%rip), %rdx    # 0x33ee56
leaq 0x2079be(%rip), %rcx    # 0x33eeaa
leaq 0x207885(%rip), %r8     # 0x33ed78
movl $0x631, %r9d            # imm = 0x631
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq %rcx, 0x10(%rdx)
jbe 0x1377ce
movq (%rdx), %rax
movq (%rax,%rcx,8), %rax
cmpq 0x18(%rsi), %rax
jae 0x1377ce
movq (%rsi), %rcx
imulq $0x50, %rax, %rax
movq (%rcx,%rax), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx,%rax), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x10(%rdi)
movq 0x18(%rcx,%rax), %rdx
movq %rdx, 0x18(%rdi)
movq 0x30(%rcx,%rax), %rax
movq %rax, 0x20(%rdi)
retq
pushq %rax
movq 0x300792(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ad833(%rip), %rsi    # 0x2e5013
leaq 0x20776d(%rip), %rdx    # 0x33ef54
leaq 0x2077d1(%rip), %rcx    # 0x33efbf
leaq 0x207583(%rip), %r8     # 0x33ed78
movl $0x6f1, %r9d            # imm = 0x6F1
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rax
movq 0x10(%rsi), %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %r8
movq 0x18(%rsi), %r9
movq 0x20(%rsi), %rax
movq %rax, (%rsp)
leaq 0x2077b3(%rip), %rsi    # 0x33efd9
xorl %eax, %eax
callq 0x17a50
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rdi), %rdi
imulq $0x50, %rdx, %rax
movq (%rdi,%rax), %rcx
imulq $0x50, %rsi, %rsi
movq 0x10(%rdi,%rsi), %rdx
cmpq %rdx, %rcx
jbe 0x1378c9
addq %rdi, %rax
addq %rdi, %rsi
addq $0x10, %rsi
movq 0x8(%rax), %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, %rax
jbe 0x1378c9
notq %rdx
addq %rdx, %rcx
notq %rsi
addq %rsi, %rax
cmpq %rax, %rcx
cmovaq %rcx, %rax
retq
pushq %rax
movq 0x300697(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ad738(%rip), %rsi    # 0x2e5013
leaq 0x20770c(%rip), %rdx    # 0x33efee
leaq 0x2077a0(%rip), %rcx    # 0x33f089
leaq 0x207488(%rip), %r8     # 0x33ed78
movl $0x16c, %r9d            # imm = 0x16C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2070d3(%rip), %rsi    # 0x33ed78
pushq $0x10
popq %rdi
movl $0x4cf, %edx            # imm = 0x4CF
callq 0x93160
testq %rax, %rax
je 0x137cd2
movq %r15, (%rax)
imulq $0x50, %r15, %rcx
addq (%r14), %rcx
movl %ebx, %edx
movq 0x10(%rcx,%rdx,8), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0x30028f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ad330(%rip), %rsi    # 0x2e5013
leaq 0x20747f(%rip), %rdx    # 0x33f169
leaq 0x207486(%rip), %rcx    # 0x33f177
leaq 0x207080(%rip), %r8     # 0x33ed78
movl $0x4d0, %r9d            # imm = 0x4D0
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_retrievemaximalscore
static bool gt_chain2dim_retrievemaximalscore(GtChain2Dimscoretype *maxscore,
                                              const GtChain2Dimmode *chainmode,
                                              const GtChain2Dimmatchtable
                                                *matchtable)
{
  GtUword matchnum;
  GtChain2Dimscoretype tgap;
  bool maxscoredefined = false;

  *maxscore = 0;
  for (matchnum=0; matchnum<matchtable->nextfree; matchnum++)
  {
    if (gt_chain2dim_isrightmaximal_chain(matchtable,matchnum))
    {
      if (chainmode->chainkind == GLOBALCHAININGWITHGAPCOST)
      {
        tgap = GT_CHAIN2DIM_TERMINALGAP(matchnum);
      } else
      {
        tgap = 0;
      }
      if (!maxscoredefined ||
          *maxscore < matchtable->matches[matchnum].score - tgap)
      {
        *maxscore = matchtable->matches[matchnum].score - tgap;
        maxscoredefined = true;
      }
    }
  }
  return maxscoredefined;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
andq $0x0, (%rdi)
pushq $0x48
popq %rbp
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq 0x18(%rbx), %r13
jae 0x137d7e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x137d94
testb %al, %al
je 0x137d75
cmpl $0x1, (%r14)
movq (%rbx), %rax
jne 0x137d54
movq -0x8(%rax,%rbp), %rcx
jmp 0x137d56
xorl %ecx, %ecx
movq (%rax,%rbp), %rax
subq %rcx, %rax
testb $0x1, %r12b
je 0x137d68
cmpq %rax, %r15
jge 0x137d75
movq (%rsp), %rcx
movq %rax, (%rcx)
movb $0x1, %r12b
movq %rax, %r15
incq %r13
addq $0x50, %rbp
jmp 0x137d2f
andb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_retrace_previousinchain
static void gt_chain2dim_retrace_previousinchain(GtChain2Dim *chain,
                                   const GtChain2Dimmatchtable *matchtable,
                                   GtUword retracestart)
{
  GtUword matchnum, lengthofchain;

  chain->storedinreverseorder = false;
  for (lengthofchain = 0, matchnum = retracestart;
       matchnum != GT_CHAIN2DIM_UNDEFPREVIOUS; lengthofchain++)
  {
    /* Use previousinchain */
    matchnum = matchtable->matches[matchnum].previousinchain;
  }
  MINARRAYSPACE(&chain->chainedmatches,GtChain2Dimref,lengthofchain);
  chain->chainedmatches.nextfreeGtChain2Dimref = lengthofchain;
  for (matchnum = retracestart;
       matchnum != GT_CHAIN2DIM_UNDEFPREVIOUS;
       /* Use previousinchain */
       matchnum = matchtable->matches[matchnum].previousinchain)
  {
    gt_assert(lengthofchain > 0);
    lengthofchain--;
    chain->chainedmatches.spaceGtChain2Dimref[lengthofchain] = matchnum;
  }
  gt_assert(lengthofchain == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb $0x0, 0x20(%rdi)
movq 0x18(%rsi), %rax
xorl %esi, %esi
movq %rdx, %rcx
xorl %r12d, %r12d
cmpq %rax, %rcx
je 0x137e11
movq (%rbx), %rdx
imulq $0x50, %rcx, %rcx
movq 0x28(%rdx,%rcx), %rcx
incq %r12
addq $0x8, %rsi
jmp 0x137df7
cmpq 0x8(%r15), %r12
jae 0x137e1c
movq (%r15), %rax
jmp 0x137e37
movq %r12, 0x8(%r15)
movq (%r15), %rdi
leaq 0x206f4e(%rip), %rdx    # 0x33ed78
movl $0x1a7, %ecx            # imm = 0x1A7
callq 0x93472
movq %rax, (%r15)
testq %rax, %rax
je 0x137ea7
movq %r12, 0x10(%r15)
cmpq 0x18(%rbx), %r14
je 0x137e5e
subq $0x1, %r12
jb 0x137e6f
movq %r14, (%rax,%r12,8)
movq (%rbx), %rcx
imulq $0x50, %r14, %rdx
movq 0x28(%rcx,%rdx), %r14
jmp 0x137e40
testq %r12, %r12
jne 0x137ed5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3000f2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ad193(%rip), %rsi    # 0x2e5013
leaq 0x20746f(%rip), %rdx    # 0x33f2f6
leaq 0x207443(%rip), %rcx    # 0x33f2d1
leaq 0x206ee3(%rip), %r8     # 0x33ed78
movl $0x1ae, %r9d            # imm = 0x1AE
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3000ba(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ad15b(%rip), %rsi    # 0x2e5013
leaq 0x2073dc(%rip), %rdx    # 0x33f29b
leaq 0x20740b(%rip), %rcx    # 0x33f2d1
leaq 0x206eab(%rip), %r8     # 0x33ed78
movl $0x1a7, %r9d            # imm = 0x1A7
jmp 0x137e9b
movq 0x30008c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ad12d(%rip), %rsi    # 0x2e5013
leaq 0x20741b(%rip), %rdx    # 0x33f308
leaq 0x2073dd(%rip), %rcx    # 0x33f2d1
leaq 0x206e7d(%rip), %r8     # 0x33ed78
movl $0x1b2, %r9d            # imm = 0x1B2
jmp 0x137e9b
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/cutendpfx.c
// Function: gt_newbucketenumerator
Bucketenumerator *gt_newbucketenumerator(const GtBcktab *bcktab,
                                      unsigned int prefixlength,
                                      const GtUchar *demandprefix,
                                      unsigned int demandprefixlength)
{
  Bucketenumerator *bucketenumerator;
  GT_UNUSED unsigned int firstspecial;

  bucketenumerator = gt_malloc(sizeof *bucketenumerator);
  bucketenumerator->bcktab = bcktab;
  bucketenumerator->prefixlength = prefixlength;
  bucketenumerator->demandprefixlength = demandprefixlength;
  firstspecial = prefixqgram2code(&bucketenumerator->currentcode,
                                  gt_bcktab_multimappower(bcktab),
                                  prefixlength,
                                  demandprefixlength,
                                  demandprefix);
  gt_assert(firstspecial == prefixlength);
  bucketenumerator->lastcode
    = bucketenumerator->currentcode
      + gt_bcktab_filltable(bcktab,demandprefixlength);
  return bucketenumerator;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20734b(%rip), %rsi    # 0x33f447
pushq $0x38
popq %rdi
pushq $0x46
popq %rdx
callq 0x93160
movq %rax, %r15
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movq %r14, %rdi
callq 0x1359d4
testl %ebx, %ebx
je 0x13818a
cmpl %ebx, %ebp
jbe 0x1381b4
movl %ebx, %ecx
xorl %r13d, %r13d
leaq -0x1(%rcx), %rdx
testl %edx, %edx
js 0x138157
movl %edx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movzbl (%r12,%rsi), %edi
cmpq $0xfd, %rdi
ja 0x13815d
movq (%rax,%rsi,8), %rcx
addq (%rcx,%rdi,8), %r13
movq %rdx, %rcx
jmp 0x13812c
movq %r13, 0x28(%r15)
jmp 0x138167
incl %ebp
cmpl %ecx, %ebp
jne 0x1381de
movq 0x28(%r15), %r13
movq %r14, %rdi
movl %ebx, %esi
callq 0x1359d9
addq %r13, %rax
movq %rax, 0x30(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ffdd7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ace78(%rip), %rsi    # 0x2e5013
leaq 0x2072ef(%rip), %rdx    # 0x33f491
leaq 0x2072f9(%rip), %rcx    # 0x33f4a2
leaq 0x207297(%rip), %r8     # 0x33f447
pushq $0x2f
jmp 0x138206
movq 0x2ffdad(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ace4e(%rip), %rsi    # 0x2e5013
leaq 0x2072e7(%rip), %rdx    # 0x33f4b3
leaq 0x2072cf(%rip), %rcx    # 0x33f4a2
leaq 0x20726d(%rip), %r8     # 0x33f447
pushq $0x30
jmp 0x138206
movq 0x2ffd83(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ace24(%rip), %rsi    # 0x2e5013
leaq 0x207267(%rip), %rdx    # 0x33f45d
leaq 0x20727d(%rip), %rcx    # 0x33f47a
leaq 0x207243(%rip), %r8     # 0x33f447
pushq $0x4f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390