LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: readBS2Map
static inline void
readBS2Map(BWTSeqContextRetrieverFactory *factory,
           BWTSeqContextRetriever *gt_newBWTSeqCR)
{
  FILE *fp = factory->mapTableDiskBackingStore;
  GtUword buf[BLOCK_IO_SIZE];
  off_t i, numFullBlocks, lastBlockLen;
  BitString revMap =  gt_newBWTSeqCR->revMap;
  BitOffset storePos = 0;
  unsigned bitsPerUlong = gt_newBWTSeqCR->bitsPerUlong;
  {
    off_t numEntries  = numMapEntries(factory->seqLen,
                                      factory->mapIntervalLog2);
    numFullBlocks = numEntries / BLOCK_IO_SIZE;
    lastBlockLen = numEntries % BLOCK_IO_SIZE;
  }
  if (fseeko(fp, 0, SEEK_SET) == -1)
    die("failed seek in backing store");
  for (i = 0; i < numFullBlocks; ++i )
  {
    readBlock2Buf(fp, buf, BLOCK_IO_SIZE, revMap, storePos, bitsPerUlong);
    storePos += bitsPerUlong * BLOCK_IO_SIZE;
  }
  readBlock2Buf(fp, buf, lastBlockLen, revMap, storePos, bitsPerUlong);
}

// Assembly:
subq $0x2058, %rsp           # imm = 0x2058
movq %rdi, 0x2050(%rsp)
movq %rsi, 0x2048(%rsp)
movq 0x2050(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x2040(%rsp)
movq 0x2048(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x2048(%rsp), %rax
movzwl 0x2a(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x2050(%rsp), %rax
movq (%rax), %rdi
movq 0x2050(%rsp), %rax
movzwl 0x1a(%rax), %esi
callq 0x220c10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x400, %ecx            # imm = 0x400
cqto
idivq %rcx
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movl $0x400, %ecx            # imm = 0x400
cqto
idivq %rcx
movq %rdx, 0x28(%rsp)
movq 0x2040(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x19c10
cmpl $-0x1, %eax
jne 0x2201fe
leaq 0x3545f4(%rip), %rdi    # 0x5747e1
leaq 0x3543fe(%rip), %rsi    # 0x5745f2
movl $0x101, %edx            # imm = 0x101
callq 0x220c50
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0x22025f
movq 0x2040(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl 0x14(%rsp), %eax
movl $0x400, %edx            # imm = 0x400
movzwl %ax, %r9d
callq 0x220cc0
movl 0x14(%rsp), %eax
shll $0xa, %eax
movl %eax, %eax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x220207
movq 0x2040(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl 0x14(%rsp), %eax
movzwl %ax, %r9d
callq 0x220cc0
addq $0x2058, %rsp           # imm = 0x2058
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-context-siop.h
// Function: BWTSeqCRNextMark
static inline struct SeqMark
BWTSeqCRNextMark(const BWTSeqContextRetriever *bwtSeqCR, GtUword pos)
{
  GtUword seqLen, mapMask;
  struct SeqMark nextMark;
  gt_assert(bwtSeqCR);
  seqLen = BWTSeqLength(bwtSeqCR->bwtSeq);
  gt_assert(pos < seqLen);
  mapMask = bwtSeqCR->mapMask;
  /* rounds up to next multiple of mapInterval */
  nextMark.textPos = (pos + mapMask) & ~mapMask;
  if (nextMark.textPos < seqLen)
  {
    nextMark.bwtPos
      = gt_bsGetUlong(bwtSeqCR->revMap,
                    (nextMark.textPos >> bwtSeqCR->mapIntervalLog2)
                    * bwtSeqCR->bitsPerUlong, bwtSeqCR->bitsPerUlong);
  }
  else
  {
    nextMark.textPos = seqLen - 1;
    nextMark.bwtPos = BWTSeqTerminatorPos(bwtSeqCR->bwtSeq);
  }
  return nextMark;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x22080e
movq 0x41b7c3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f582c(%rip), %rsi    # 0x516013
leaq 0x353ed5(%rip), %rdx    # 0x5746c3
leaq 0x35407f(%rip), %rcx    # 0x574874
leaq 0x354089(%rip), %r8     # 0x574885
movl $0x2a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x220810
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2204a0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x220867
movq 0x41b76a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f57d3(%rip), %rsi    # 0x516013
leaq 0x3540a2(%rip), %rdx    # 0x5748e9
leaq 0x354026(%rip), %rcx    # 0x574874
leaq 0x354030(%rip), %r8     # 0x574885
movl $0x2c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x220869
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
movq 0x8(%rsp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x2208de
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rax
movzwl 0x28(%rax), %eax
movl %eax, %eax
movl %eax, %ecx
shrq %cl, %rsi
movq 0x20(%rsp), %rax
movzwl 0x2a(%rax), %eax
imulq %rax, %rsi
movq 0x20(%rsp), %rax
movzwl 0x2a(%rax), %edx
callq 0x476ec0
movq %rax, 0x30(%rsp)
jmp 0x2208ff
movq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x220dc0
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-context-param.h
// Function: ctxMapILogIsValid
static inline bool
ctxMapILogIsValid(GtUword seqLen, short mapIntervalLog2)
{
  return (mapIntervalLog2 == CTX_MAP_ILOG_NOMAP
          || mapIntervalLog2 == CTX_MAP_ILOG_AUTOSIZE
          || (mapIntervalLog2 >= 0
              && mapIntervalLog2
              < GT_MIN(requiredUlongBits(seqLen),
                    sizeof (GtUword) * CHAR_BIT)));
}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
movswl 0x1e(%rsp), %ecx
movb $0x1, %al
cmpl $-0x2, %ecx
movb %al, 0x1d(%rsp)
je 0x220bf9
movswl 0x1e(%rsp), %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
movb %al, 0x1d(%rsp)
je 0x220bf9
movswl 0x1e(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x1c(%rsp)
jl 0x220bf1
movswq 0x1e(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x46ec80
cltq
cmpq $0x40, %rax
jae 0x220bd1
movq 0x20(%rsp), %rdi
callq 0x46ec80
cltq
movq %rax, 0x8(%rsp)
jmp 0x220bdd
movl $0x40, %eax
movq %rax, 0x8(%rsp)
jmp 0x220bdd
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, 0x1c(%rsp)
movb 0x1c(%rsp), %al
movb %al, 0x1d(%rsp)
movb 0x1d(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-context.c
// Function: readBlock2Buf
static inline void
readBlock2Buf(FILE *fp,
              GtUword *buf,
              size_t len,
              BitString bitstring,
              BitOffset offset,
              unsigned short bitsPerUlong)
{
  if (fread(buf, sizeof (buf[0]), len, fp) != len)
    die("short read when reading backing store");
  gt_bsStoreUniformUlongArray(bitstring, offset, bitsPerUlong, len,
#if defined (_LP64) || defined (_WIN64)
                             (uint64_t*) buf);
#else
                             (uint32_t*) buf);
#endif
}

// Assembly:
subq $0x38, %rsp
movw %r9w, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl $0x8, %esi
callq 0x19a70
cmpq 0x20(%rsp), %rax
je 0x220d1e
leaq 0x353af1(%rip), %rdi    # 0x5747fe
leaq 0x3538de(%rip), %rsi    # 0x5745f2
movl $0xe7, %edx
callq 0x220c50
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movzwl 0xe(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x4780f0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-mrangealphabet-siop.h
// Function: MRAEncGetRangeOfSymbol
static inline AlphabetRangeID
MRAEncGetRangeOfSymbol(const MRAEnc *mralpha, Symbol sym)
{
  AlphabetRangeID range = 0;
  gt_assert(mralpha && sym < gt_MRAEncGetSize(mralpha));
  while (sym >= mralpha->rangeEndIndices[range])
    ++range;
  return range;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x220ea1
movzbl 0xf(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x22aeb0
movw %ax, %cx
movl 0x4(%rsp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jl 0x220ed9
movq 0x41b0f8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f5161(%rip), %rsi    # 0x516013
leaq 0x353b8a(%rip), %rdx    # 0x574a43
leaq 0x353bae(%rip), %rcx    # 0x574a6e
leaq 0x353bbe(%rip), %r8     # 0x574a85
movl $0x6e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x220edb
jmp 0x220edd
movzbl 0xf(%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl 0x8(%rsp), %edx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jl 0x220f04
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x220edd
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-mrangealphabet-siop.h
// Function: MRAEncGetRangeBase
static inline Symbol
MRAEncGetRangeBase(const MRAEnc *mralpha, AlphabetRangeID range)
{
  gt_assert(mralpha && mralpha->numRanges > range);
  if (range == 0)
    return 0;
  else
    return mralpha->rangeEndIndices[range - 1];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x221123
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x4(%rsp), %eax
ja 0x22115b
movq 0x41ae76(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f4edf(%rip), %rsi    # 0x516013
leaq 0x353a36(%rip), %rdx    # 0x574b71
leaq 0x353a55(%rip), %rcx    # 0x574b97
leaq 0x35393c(%rip), %r8     # 0x574a85
movl $0x30, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22115d
cmpl $0x0, 0x4(%rsp)
jne 0x22116b
movb $0x0, 0x17(%rsp)
jmp 0x221185
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movw (%rax,%rcx,2), %ax
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: writeLocateInfoHeader
static int
writeLocateInfoHeader(FILE *fp, void *cbData)
{
  struct locateHeader headerData;
  Definedunsignedlong rot0Pos;
  const struct locateHeaderWriteInfo *headerSrc = cbData;
  gt_assert(cbData);
  headerData.locateInterval = headerSrc->locateInterval;
  rot0Pos = SASSGetRot0Pos(headerSrc->src);
  if (!rot0Pos.defined)
  {
    fputs("Invalid index construction: position of suffix 0 unknown!\n",
          stderr);
    abort();
  }
  headerData.rot0Pos = rot0Pos.valueunsignedlong;
  headerData.featureToggles = headerSrc->featureToggles;
  gt_xfwrite(&headerData, sizeof (headerData), 1, fp);
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x221bc8
movq 0x41a409(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f4472(%rip), %rsi    # 0x516013
leaq 0x35336f(%rip), %rdx    # 0x574f17
leaq 0x35336f(%rip), %rcx    # 0x574f1e
leaq 0x3530de(%rip), %r8     # 0x574c94
movl $0x3f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x221bca
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x224100
movb %al, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
testb $0x1, 0x18(%rsp)
jne 0x221c20
movq 0x41a394(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x35331e(%rip), %rdi    # 0x574f34
callq 0x19810
callq 0x19370
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movl $0x10, %esi
movl $0x1, %edx
callq 0x126d30
movl $0x1, %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: writeRankSortHeader
static int
writeRankSortHeader(FILE *fp, void *cbData)
{
  struct sortModeHeader *headerData = cbData;
  gt_assert(cbData);
  gt_xfwrite(&headerData->bitsPerOrigRank, sizeof (headerData->bitsPerOrigRank),
             1, fp);
  {
    size_t i, numRanges = MRAEncGetNumRanges(headerData->alphabet);
    for (i = 0; i < numRanges; ++i)
    {
      int16_t mode = headerData->rangeSort[i];
      gt_xfwrite(&mode, sizeof (mode), 1, fp);
    }
  }
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x221cb8
movq 0x41a319(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f4382(%rip), %rsi    # 0x516013
leaq 0x35327f(%rip), %rdx    # 0x574f17
leaq 0x3532d0(%rip), %rcx    # 0x574f6f
leaq 0x352fee(%rip), %r8     # 0x574c94
movl $0x6e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x221cba
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2240f0
movl %eax, %eax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x221d3c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movw %ax, 0xe(%rsp)
movq 0x30(%rsp), %rcx
leaq 0xe(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x221cf1
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: sortModeHeaderNeeded
static inline int
sortModeHeaderNeeded(const MRAEnc *alphabet,
                     const enum rangeSortMode *rangeSort,
                     const SpecialsRankLookup *sprTable)
{
  bool hasRankSortedRanges = false;
  AlphabetRangeID i, numRanges = MRAEncGetNumRanges(alphabet);
  for (i = 0; i < numRanges; ++i)
    hasRankSortedRanges |= (rangeSort[i] == SORTMODE_RANK?1:0);
  return (hasRankSortedRanges && sprTable);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2240f0
movl %eax, 0x4(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x221e45
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x2, %edx
cmovel %eax, %ecx
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x221dfe
xorl %eax, %eax
testb $0x1, 0xf(%rsp)
movb %al, 0x3(%rsp)
je 0x221e5f
cmpq $0x0, 0x10(%rsp)
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: gt_BWTSeqPosHasLocateInfo
int
gt_BWTSeqPosHasLocateInfo(const BWTSeq *bwtSeq, GtUword pos,
                       struct extBitsRetrieval *extBits)
{
  if (bwtSeq->featureToggles & BWTLocateBitmap)
  {
    EISRetrieveExtraBits(bwtSeq->seqIdx, pos, EBRF_RETRIEVE_CWBITS, extBits,
                         bwtSeq->hint);
    return gt_bsGetBit(extBits->cwPart,
                       extBits->cwOffset + pos - extBits->start);
  }
  else if (bwtSeq->featureToggles & BWTLocateCount)
  {
    BitOffset markOffset = searchLocateCountMark(bwtSeq, pos, extBits);
    return markOffset != 0;
  }
#ifndef NDEBUG
  else
  {
    fputs("Trying to locate in BWT sequence index without locate information.",
          stderr);
    abort();
  }
#endif
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x222f0f
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %r8
xorl %edx, %edx
callq 0x222f70
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
subq 0x10(%rax), %rsi
callq 0x222fc0
movl %eax, 0x24(%rsp)
jmp 0x222f65
movq 0x18(%rsp), %rax
movl 0x40(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x222f4a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x223070
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x222f65
movq 0x41904f(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x351de5(%rip), %rdi    # 0x574d40
callq 0x19810
callq 0x19370
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: gt_BWTSeqGetRankSort
GtUword
gt_BWTSeqGetRankSort(const BWTSeq *bwtSeq, GtUword pos,
                  AlphabetRangeID range, struct extBitsRetrieval *extBits)
{
  BitOffset locVarBits;
  AlphabetRangeSize rSize;
  gt_assert(bwtSeq->rangeSort[range] == SORTMODE_RANK);
  EISRetrieveExtraBits(bwtSeq->seqIdx, pos, EBRF_RETRIEVE_CWBITS
                       | EBRF_RETRIEVE_VARBITS, extBits, bwtSeq->hint);
  locVarBits = locateVarBits(bwtSeq, extBits);
  rSize = MRAEncGetRangeSize(EISGetAlphabet(bwtSeq->seqIdx), range);
  {
    GtUword ranks[rSize * 2];
    GtUword BWTRankTotal = 0;
    AlphabetRangeSize i;
    EISPosPairRangeRank(bwtSeq->seqIdx, range, extBits->start, pos, ranks,
                        bwtSeq->hint);
    for (i = 0; i < rSize; ++i)
      BWTRankTotal += ranks[i + rSize] - ranks[i];
    return gt_bsGetUlong(extBits->varPart, extBits->varOffset + locVarBits
                       + bwtSeq->bitsPerOrigRank * BWTRankTotal,
                       bwtSeq->bitsPerOrigRank);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x14(%rbp), %ecx
cmpl $0x2, (%rax,%rcx,4)
je 0x2239e0
movq 0x4185f1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f265a(%rip), %rsi    # 0x516013
leaq 0x3514a2(%rip), %rdx    # 0x574e62
leaq 0x3514c5(%rip), %rcx    # 0x574e8c
leaq 0x3512c6(%rip), %r8     # 0x574c94
movl $0x327, %r9d            # imm = 0x327
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2239e2
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq (%rax), %rdi
movq 0x18(%rax), %r8
movl $0x2, %edx
callq 0x222f70
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x223b00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x223cf0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x223c40
movw %ax, -0x2a(%rbp)
movzwl -0x2a(%rbp), %ecx
movl %ecx, %eax
addl %eax, %eax
movq %rsp, %rdx
movq %rdx, -0x38(%rbp)
shll $0x4, %ecx
movq %rsp, %r8
subq %rcx, %r8
movq %r8, -0x58(%rbp)
movq %r8, %rsp
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r9
callq 0x223d40
movw $0x0, -0x4a(%rbp)
movzwl -0x4a(%rbp), %eax
movzwl -0x2a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x223abd
movq -0x58(%rbp), %rcx
movzwl -0x4a(%rbp), %eax
movzwl -0x2a(%rbp), %edx
addl %edx, %eax
cltq
movq (%rcx,%rax,8), %rax
movzwl -0x4a(%rbp), %edx
subq (%rcx,%rdx,8), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movw -0x4a(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x4a(%rbp)
jmp 0x223a7f
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
imulq -0x48(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x44(%rax), %edx
callq 0x476ec0
movq -0x38(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: locateVarBits
static inline BitOffset
locateVarBits(const BWTSeq *bwtSeq, struct extBitsRetrieval *extBits)
{
  BitOffset numLocBits = 0;
  unsigned bitsPerBWTPos = requiredUlongBits(extBits->len - 1),
    bitsPerOrigPos = requiredUlongBits(
      ((bwtSeq->featureToggles & BWTReversiblySorted) ?
       (BWTSeqLength(bwtSeq) - 1) / bwtSeq->locateSampleInterval :
       BWTSeqLength(bwtSeq) - 1));
  if (bwtSeq->featureToggles & BWTLocateBitmap)
  {
    unsigned numMarks = gt_bs1BitsCount(extBits->cwPart, extBits->cwOffset,
                                     extBits->len);
    numLocBits = numMarks * bitsPerOrigPos;
  }
  else if (bwtSeq->featureToggles & BWTLocateCount)
  {
    BitOffset markOffset = extBits->varOffset;
    unsigned bitsPerCount = requiredUlongBits(extBits->len);
    unsigned numMarks = gt_bsGetUlong(extBits->varPart, markOffset,
                                    bitsPerCount);
    numLocBits = bitsPerCount + numMarks * (bitsPerBWTPos + bitsPerOrigPos);
  }
  return numLocBits;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
subq $0x1, %rdi
callq 0x46ec80
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movl 0x40(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x223b5f
movq 0x40(%rsp), %rdi
callq 0x223960
subq $0x1, %rax
movq 0x40(%rsp), %rcx
movl 0x20(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x8(%rsp)
jmp 0x223b72
movq 0x40(%rsp), %rdi
callq 0x223960
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x46ec80
movl %eax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x223bc5
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x38(%rsp), %rax
movq (%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x4707b0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
imull 0x28(%rsp), %eax
movl %eax, %eax
movq %rax, 0x30(%rsp)
jmp 0x223c2e
movq 0x40(%rsp), %rax
movl 0x40(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x223c2c
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x46ec80
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x476ec0
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
movl 0x10(%rsp), %ecx
movl 0x2c(%rsp), %edx
addl 0x28(%rsp), %edx
imull %edx, %ecx
addl %ecx, %eax
movl %eax, %eax
movq %rax, 0x30(%rsp)
jmp 0x223c2e
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: gt_BWTSeqInitLocateHandling
void
gt_BWTSeqInitLocateHandling(BWTSeq *bwtSeq,
                         const enum rangeSortMode *defaultRangeSort)
{
  struct encIdxSeq *seqIdx;
  struct locateHeader locHeader;
  gt_assert(bwtSeq);
  seqIdx = bwtSeq->seqIdx;
  if (!readLocateInfoHeader(seqIdx, &locHeader)
      || !locHeader.locateInterval)
  {
    gt_log_log("Index does not contain locate information.\n"
            "Localization of matches will not be supported!");
    bwtSeq->locateSampleInterval = 0;
    bwtSeq->featureToggles = BWTBaseFeatures;
  }
  else
  {
    bwtSeq->locateSampleInterval = locHeader.locateInterval;
    bwtSeq->rot0Pos = locHeader.rot0Pos;
    /* FIXME: this really deserves its own header */
    bwtSeq->featureToggles = locHeader.featureToggles;

    if (readRankSortHeader(seqIdx, &bwtSeq->bitsPerOrigRank,
                           bwtSeq->alphabet, bwtSeq->rangeSort))
      ;
    else
    {
      AlphabetRangeID numRanges = MRAEncGetNumRanges(bwtSeq->alphabet);
      bwtSeq->bitsPerOrigRank = 0;
      memcpy(bwtSeq->rangeSort, defaultRangeSort,
             numRanges * sizeof (defaultRangeSort[0]));
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x223dee
movq 0x4181e3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f224c(%rip), %rsi    # 0x516013
leaq 0x351808(%rip), %rdx    # 0x5755d6
leaq 0x3510cc(%rip), %rcx    # 0x574ea1
leaq 0x350eb8(%rip), %r8     # 0x574c94
movl $0x340, %r9d            # imm = 0x340
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x223df0
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x223ee0
cmpl $0x0, %eax
je 0x223e18
cmpl $0x0, 0x18(%rsp)
jne 0x223e43
leaq 0x35109e(%rip), %rdi    # 0x574ebd
movb $0x0, %al
callq 0xe7740
movq 0x30(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x40(%rax)
jmp 0x223ed2
movl 0x18(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movl 0x1c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x44, %rsi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rcx
callq 0x223fa0
cmpl $0x0, %eax
je 0x223e95
jmp 0x223ed0
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2240f0
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x19610
jmp 0x223ed2
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: readLocateInfoHeader
static inline int
readLocateInfoHeader(EISeq *seqIdx, struct locateHeader *headerData)
{
  FILE *fp;
  gt_assert(seqIdx && headerData);
  if (!(fp = EISSeekToHeader(seqIdx, LOCATE_INFO_IN_INDEX_HEADERID, NULL)))
    return 0;
  if (fread(headerData, sizeof (*headerData), 1, fp) != 1)
    return 0;
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x223efe
cmpq $0x0, 0x10(%rsp)
jne 0x223f36
movq 0x41809b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f2104(%rip), %rsi    # 0x516013
leaq 0x351102(%rip), %rdx    # 0x575018
leaq 0x351110(%rip), %rcx    # 0x57502d
leaq 0x350d70(%rip), %r8     # 0x574c94
movl $0x55, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x223f38
movq 0x18(%rsp), %rdi
movl $0x457, %esi            # imm = 0x457
xorl %eax, %eax
movl %eax, %edx
callq 0x224b50
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x223f60
movl $0x0, 0x24(%rsp)
jmp 0x223f91
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x10, %esi
movl $0x1, %edx
callq 0x19a70
cmpq $0x1, %rax
je 0x223f89
movl $0x0, 0x24(%rsp)
jmp 0x223f91
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: readRankSortHeader
static inline int
readRankSortHeader(EISeq *seqIdx, uint32_t *bitsPerOrigRank,
                   const MRAEnc *alphabet,
                   enum rangeSortMode *rangeSort)
{
  FILE *fp;
  gt_assert(seqIdx && alphabet && bitsPerOrigRank && rangeSort);
  if (!(fp = EISSeekToHeader(seqIdx, RANK_SORT_HEADERID, NULL)))
    return 0;
  if (fread(bitsPerOrigRank, sizeof (*bitsPerOrigRank), 1, fp) != 1)
    return 0;
  {
    uint16_t mode;
    size_t i, numRanges = MRAEncGetNumRanges(alphabet);
    for (i = 0; i < numRanges; ++i)
    {
      if (fread(&mode, sizeof (mode), 1, fp) != 1)
        return 0;
      rangeSort[i] = mode;
    }
  }
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x223fd8
cmpq $0x0, 0x28(%rsp)
je 0x223fd8
cmpq $0x0, 0x30(%rsp)
je 0x223fd8
cmpq $0x0, 0x20(%rsp)
jne 0x224010
movq 0x417fc1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f202a(%rip), %rsi    # 0x516013
leaq 0x351062(%rip), %rdx    # 0x575052
leaq 0x35108e(%rip), %rcx    # 0x575085
leaq 0x350c96(%rip), %r8     # 0x574c94
movl $0x82, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x224012
movq 0x38(%rsp), %rdi
movl $0x458, %esi            # imm = 0x458
xorl %eax, %eax
movl %eax, %edx
callq 0x224b50
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0x22403d
movl $0x0, 0x44(%rsp)
jmp 0x2240dd
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x19a70
cmpq $0x1, %rax
je 0x224066
movl $0x0, 0x44(%rsp)
jmp 0x2240dd
movq 0x28(%rsp), %rdi
callq 0x2240f0
movl %eax, %eax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0x2240d5
movq 0x18(%rsp), %rcx
leaq 0x16(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x19a70
cmpq $0x1, %rax
je 0x2240b3
movl $0x0, 0x44(%rsp)
jmp 0x2240dd
movzwl 0x16(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x22407f
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-mrangealphabet-siop.h
// Function: MRAEncSymbolHasValidMapping
static inline int
MRAEncSymbolHasValidMapping(const MRAEnc *mralpha, Symbol sym)
{
  switch (mralpha->encType)
  {
  case sourceUInt8:
    return mralpha->rangeEndIndices[mralpha->numRanges - 1] == UINT8_MAX
      || (constMRAEnc2MRAEncUInt8(mralpha)->mappings[(uint8_t)sym]
          != UNDEF_UCHAR);
  default:
    abort();
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
jne 0x2241a4
jmp 0x22414e
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movzwl (%rax,%rcx,2), %ecx
movb $0x1, %al
cmpl $0xff, %ecx
movb %al, 0xe(%rsp)
je 0x224196
movq 0x10(%rsp), %rdi
callq 0x2241f0
movzbl 0xf(%rsp), %ecx
movzbl 0x18(%rax,%rcx), %eax
cmpl $0xff, %eax
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
callq 0x19370
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: bitsPerPosUpperBound
static inline unsigned
bitsPerPosUpperBound(struct addLocateInfoState *state)
{
  unsigned bitsPerPos = bitsPerPosUpperBoundWithoutSegmentAggregates(state);
  if (state->featureToggles & BWTLocateCount)
    /* +1 to account for the contribution to count value (which will
     * actually use log(blockLen) instead of blockLen bits, i.e. less
     * than 1 bit per position) */
    bitsPerPos += 1;
  return bitsPerPos;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x224710
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x58(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x224702
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-extinfo.c
// Function: bitsPerPosUpperBoundWithoutSegmentAggregates
static inline unsigned
bitsPerPosUpperBoundWithoutSegmentAggregates(struct addLocateInfoState *state)
{
  unsigned bitsPerPos = 0;
  if (state->featureToggles & BWTLocateCount)
    /* bitsPerUlong is actually an upper bound of log(segmentLen) to
     * identify each locate mark */
    bitsPerPos += state->bitsPerUlong;
  bitsPerPos += state->bitsPerOrigPos; /* stored for every position */
  /* rank sorting data if needed */
  bitsPerPos += state->bitsPerOrigRank;
  return bitsPerPos;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x58(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x22473d
movq -0x8(%rsp), %rax
movl 0x48(%rax), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x44(%rax), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x4c(%rax), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-param.c
// Function: gt_computePackedIndexDefaults
void
gt_computePackedIndexDefaults(struct bwtOptions *paramOutput, int extraToggles)
{
  if (gt_option_is_set(paramOutput->useLocateBitmapOption))
    paramOutput->final.featureToggles
      |= (paramOutput->useLocateBitmap?BWTLocateBitmap:BWTLocateCount);
  else
    paramOutput->final.featureToggles
      |= estimateBestLocateTypeFeature(paramOutput);
  if (paramOutput->final.sourceRankInterval >= 0
      || paramOutput->useSourceRank)
    paramOutput->final.featureToggles |= BWTReversiblySorted;
  paramOutput->final.featureToggles |= extraToggles;
  paramOutput->final.seqParams.EISFeatureSet
    = gt_convertBWTOptFlags2EISFeatures(paramOutput->defaultOptimizationFlags);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x224d41
jmp 0x224d66
movq 0x10(%rsp), %rax
movb 0x2c(%rax), %dl
movl $0x2, %ecx
movl $0x1, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
movq 0x10(%rsp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x224d7d
movq 0x10(%rsp), %rdi
callq 0x224dd0
movl %eax, %ecx
movq 0x10(%rsp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jge 0x224d93
movq 0x10(%rsp), %rax
testb $0x1, 0x2d(%rax)
je 0x224da1
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x10(%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %edi
callq 0x224e50
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-param.c
// Function: estimateBestLocateTypeFeature
static int
estimateBestLocateTypeFeature(const struct bwtOptions *paramOutput)
{
  if (!paramOutput->final.locateInterval)
    return BWTBaseFeatures;
  {
    /* two cases: we store 1 bit per position or log(segmentlen) for
     * each marked position plus one to note the number of marked positions */
    unsigned segmentLen = gt_estimateSegmentSize(&paramOutput->final.seqParams);
    if (segmentLen > (segmentLen + 1) * gt_requiredUIntBits(segmentLen)
                     / paramOutput->final.locateInterval)
      return BWTLocateCount;
    else
      return BWTLocateBitmap;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x224dee
movl $0x0, 0x24(%rsp)
jmp 0x224e47
movq 0x18(%rsp), %rdi
callq 0x22a750
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %edi
callq 0x46ec00
movl %eax, %ecx
movl 0xc(%rsp), %eax
imull %ecx, %eax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
divl 0x14(%rcx)
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jbe 0x224e3f
movl $0x2, 0x24(%rsp)
jmp 0x224e47
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-param.c
// Function: gt_convertBWTOptFlags2EISFeatures
int
gt_convertBWTOptFlags2EISFeatures(int BWTOptFlags)
{
  int EISFeatureSet = EIS_FEATURE_NONE;
  if (BWTOptFlags & BWTDEFOPT_LOW_RAM_OVERHEAD)
  {
    EISFeatureSet &= ~EIS_FEATURE_REGION_SUMS;
  }
  if (BWTOptFlags & BWTDEFOPT_FAST_RANK)
  {
    EISFeatureSet |= EIS_FEATURE_REGION_SUMS;
  }
  return EISFeatureSet;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
movl -0x4(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x224e73
movl -0x8(%rsp), %eax
andl $-0x2, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x224e8a
movl -0x8(%rsp), %eax
orl $0x1, %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-sass.c
// Function: gt_BWTSeqNewSASeqSrc
SASeqSrc *
gt_BWTSeqNewSASeqSrc(const BWTSeq *bwtSeq, const BWTSeqContextRetriever *ctxMap)
{
  struct BWTSASeqSrc *newBWTSASeqSrc;
  gt_assert(bwtSeq);
  newBWTSASeqSrc = gt_malloc(sizeof (*newBWTSASeqSrc));
  {
    RandomSeqAccessor origSeqAccess;
    if (ctxMap)
    {
      origSeqAccess.accessFunc = BWTSASSAccessOrigSeq;
      origSeqAccess.state = (void *)ctxMap;
    }
    else
    {
      origSeqAccess.accessFunc = NULL;
      origSeqAccess.state = NULL;
    }
    initSASeqSrc(&newBWTSASeqSrc->baseClass,
                 BWTSeqLength(bwtSeq),
                 NULL,
                 BWTSASSCreateReader,
                 BWTSASSGetRot0Pos,
                 NULL,
                 origSeqAccess,
                 gt_deleteBWTSeqSASS,
                 BWTSASSNewMRAEnc,
                 NULL, NULL);   /* since BWTSeq can regenerate
                                 * arbitrary portions of all
                                 * associated data (when reversibly
                                 * sorted) no generator is necessary
                                 * and all readers just keep their state
                                 */
  }
  newBWTSASeqSrc->ctxMap = ctxMap;
  newBWTSASeqSrc->bwtSeq = bwtSeq;
  newBWTSASeqSrc->readerStateList = NULL;
  return &newBWTSASeqSrc->baseClass;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x224edf
movq 0x4170f2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f115b(%rip), %rsi    # 0x516013
leaq 0x350717(%rip), %rdx    # 0x5755d6
leaq 0x350465(%rip), %rcx    # 0x57532b
leaq 0x350473(%rip), %r8     # 0x575340
movl $0x6b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x224ee1
movl $0xd8, %edi
leaq 0x350453(%rip), %rsi    # 0x575340
movl $0x6c, %edx
callq 0xe80f0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x224f1c
leaq 0xe5(%rip), %rax        # 0x224ff0
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x224f2e
movq $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
callq 0x225290
movq 0x30(%rsp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %r9d
leaq 0x35a(%rip), %rcx       # 0x2252b0
leaq 0x4a3(%rip), %r8        # 0x225400
leaq 0x38(%rsp), %r11
leaq 0x4d7(%rip), %r10       # 0x225440
leaq 0x560(%rip), %rax       # 0x2254d0
movq %r9, %rdx
movq (%r11), %rbx
movq %rbx, (%rsp)
movq 0x8(%r11), %r11
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
callq 0x225080
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0xc8(%rax)
movq 0x58(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0xc0(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0xd0(%rax)
movq 0x48(%rsp), %rax
addq $0x60, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-sass.c
// Function: BWTSASSAccessOrigSeq
static size_t
BWTSASSAccessOrigSeq(const void *state,
                     Symbol *dest,
                     GtUword pos,
                     size_t len)
{
  const BWTSeqContextRetriever *ctxMap = state;
  gt_assert(state);
  gt_BWTSeqCRAccessSubseq(ctxMap, pos, len, dest);
  return len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x225051
movq 0x416f80(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f0fe9(%rip), %rsi    # 0x516013
leaq 0x340f9d(%rip), %rdx    # 0x565fce
leaq 0x350324(%rip), %rcx    # 0x57535c
leaq 0x350301(%rip), %r8     # 0x575340
movl $0x56, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x225053
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x220530
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-sass.c
// Function: BWTSASSCreateReader
static SeqDataReader
BWTSASSCreateReader(SASeqSrc *src, enum sfxDataRequest rtype)
{
  struct seqDataReader reader = { NULL, NULL};
  BWTSASeqSrc *bwtSASeqSrc;
  gt_assert(src);
  bwtSASeqSrc = SASS2BWTSASS(src);
  switch (rtype)
  {
  case SFX_REQUEST_SUFTAB:
    reader = BWTSASSMakeSufTabReader(bwtSASeqSrc,
                                     BWTSeqSASSAddReaderState(bwtSASeqSrc));
    break;
  case SFX_REQUEST_BWTTAB:
    reader = BWTSASSMakeBWTReader(bwtSASeqSrc,
                                  BWTSeqSASSAddReaderState(bwtSASeqSrc));
    break;
  default:
    fprintf(stderr, "error: unimplemented request: %d, %s: %d!\n", rtype,
            __FILE__, __LINE__);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  return reader;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19360
cmpq $0x0, 0x50(%rsp)
jne 0x22530e
movq 0x416cc3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f0d2c(%rip), %rsi    # 0x516013
leaq 0x30a15f(%rip), %rdx    # 0x52f44d
leaq 0x350138(%rip), %rcx    # 0x57542d
leaq 0x350044(%rip), %r8     # 0x575340
movl $0xd1, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x225310
movq 0x50(%rsp), %rdi
callq 0x2255c0
movq %rax, 0x40(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x1c(%rsp)
subl $0x1, %eax
je 0x22533c
jmp 0x22532e
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0x22537d
jmp 0x2253be
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2256a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x225670
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x2253f1
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2256a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x225750
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x2253f1
movq 0x416bdb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movl 0x4c(%rsp), %edx
leaq 0x35006e(%rip), %rsi    # 0x575441
leaq 0x34ff66(%rip), %rcx    # 0x575340
movl $0xdf, %r8d
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rdx
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-sa-common-siop.h
// Function: destructSASeqSrc
static inline void
destructSASeqSrc(SASeqSrc *src)
{
  if (src->alphabet)
    gt_MRAEncDelete(src->alphabet);
  gt_destructSATaggedXltorStateList(&src->xltorStates);
  gt_destructSeqReaderSet(&src->readerSet);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x22559d
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x22b660
movq (%rsp), %rdi
addq $0xb0, %rdi
callq 0x22b990
movq (%rsp), %rdi
addq $0x50, %rdi
callq 0x22bc00
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-sass.c
// Function: BWTSeqSASSAddReaderState
static BWTSeqReaderState *
BWTSeqSASSAddReaderState(BWTSASeqSrc *bwtSASeqSrc)
{
  BWTSeqReaderState *newReader = gt_malloc(sizeof (*newReader));
  gt_assert(bwtSASeqSrc);
  newReader->backLink = bwtSASeqSrc;
  newReader->nextReadPos = 0;
  newReader->next = bwtSASeqSrc->readerStateList;
  bwtSASeqSrc->readerStateList = newReader;
  return newReader;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x18, %edi
leaq 0x34fc8b(%rip), %rsi    # 0x575340
movl $0xc3, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x225704
movq 0x4168cd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f0936(%rip), %rsi    # 0x516013
leaq 0x34fd9a(%rip), %rdx    # 0x57547e
leaq 0x34fd9f(%rip), %rcx    # 0x57548a
leaq 0x34fc4e(%rip), %r8     # 0x575340
movl $0xc4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x225706
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-sass.c
// Function: BWTSASSReadSufTab
static size_t
BWTSASSReadSufTab(SeqDataSrc src, void *dest, size_t len)
{
  const BWTSeq *bwtSeq;
  struct extBitsRetrieval extBits;
  gt_assert(src);
  initExtBitsRetrieval(&extBits);
  bwtSeq = ((BWTSeqReaderState *)src)->backLink->bwtSeq;
  size_t i;
  GtUword pos = ((BWTSeqReaderState *)src)->nextReadPos;
  for (i = 0; i < len; ++i)
    ((GtUword *)dest)[i] = gt_BWTSeqLocateMatch(bwtSeq,
                                                      pos + i,
                                                      &extBits);
  ((BWTSeqReaderState *)src)->nextReadPos = pos + len;
  destructExtBitsRetrieval(&extBits);
  return len;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x2257d3
movq 0x4167fe(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f0867(%rip), %rsi    # 0x516013
leaq 0x309c9a(%rip), %rdx    # 0x52f44d
leaq 0x34fcb2(%rip), %rcx    # 0x57546c
leaq 0x34fb7f(%rip), %r8     # 0x575340
movl $0x94, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2257d5
leaq 0x10(%rsp), %rdi
callq 0x225880
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x22584f
movq 0x48(%rsp), %rdi
movq (%rsp), %rsi
addq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x223230
movq %rax, %rdx
movq 0x58(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x22580a
movq (%rsp), %rcx
addq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x10(%rax)
leaq 0x10(%rsp), %rdi
callq 0x2258a0
movq 0x50(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-encidxseq-siop.h
// Function: destructExtBitsRetrieval
static inline void
destructExtBitsRetrieval(struct extBitsRetrieval *r)
{
  if ((r->flags & EBRF_PERSISTENT_CWBITS) && r->cwPart)
    gt_free(r->cwPart);
  if ((r->flags & EBRF_PERSISTENT_VARBITS) && r->varPart)
    gt_free(r->varPart);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x30(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2258d8
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2258d8
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x34f116(%rip), %rsi    # 0x5749e4
movl $0x87, %edx
callq 0xe88c0
movq (%rsp), %rax
movl 0x30(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x22590b
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x22590b
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x34f0e3(%rip), %rsi    # 0x5749e4
movl $0x89, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-sass.c
// Function: BWTSASSReadBWT
static size_t
BWTSASSReadBWT(SeqDataSrc src, void *dest, size_t len)
{
  const BWTSeq *bwtSeq;
  gt_assert(src);
  bwtSeq = ((BWTSeqReaderState *)src)->backLink->bwtSeq;
  size_t i;
  GtUword pos = ((BWTSeqReaderState *)src)->nextReadPos;
  for (i = 0; i < len; ++i)
    ((Symbol *)dest)[i] = BWTSeqGetSym(bwtSeq, pos + i);
  ((BWTSeqReaderState *)src)->nextReadPos = pos + len;
  return len;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x225963
movq 0x41666e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f06d7(%rip), %rsi    # 0x516013
leaq 0x309b0a(%rip), %rdx    # 0x52f44d
leaq 0x34fb59(%rip), %rcx    # 0x5754a3
leaq 0x34f9ef(%rip), %r8     # 0x575340
movl $0xae, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x225965
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2259d0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq 0x10(%rsp), %rsi
callq 0x2259f0
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x225991
movq 0x8(%rsp), %rcx
addq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)