LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_new_from_sa
GtAlignedSegment *gt_aligned_segment_new_from_sa(GtSamAlignment *sa,
    GtSamfileEncseqMapping *sem)
{
  GtAlignedSegment *as;
  size_t dlen;
  as = gt_malloc(sizeof (GtAlignedSegment));
  gt_assert(sa != NULL);
  as->r_reverse = gt_sam_alignment_is_reverse(sa);
  as->has_indels = false;
  if (gt_sam_alignment_is_unmapped(sa))
    gt_aligned_segment_init_from_unmapped_sa(as, sa);
  else
    gt_aligned_segment_init_from_mapped_sa(as, sa, sem);
  dlen = strlen(gt_sam_alignment_identifier(sa)) + 1UL;
  as->d = gt_malloc(sizeof (*as->d) * dlen);
  (void)memcpy(as->d, gt_sam_alignment_identifier(sa), sizeof (*as->d) * dlen);
  as->s_edited = false;
  as->r_edited = false;
  as->s_orig = NULL;
  as->mapq = gt_sam_alignment_mapping_quality(sa);
  as->orig_seqlen = gt_sam_alignment_read_length(sa);
  return as;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x58, %edi
leaq 0x129a66(%rip), %rsi    # 0x5b16f0
movl $0xc3, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x487cd9
movq 0x1b42f8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8e361(%rip), %rsi     # 0x516013
leaq 0x100500(%rip), %rdx    # 0x5881b9
leaq 0x129a4f(%rip), %rcx    # 0x5b170f
leaq 0x129a29(%rip), %r8     # 0x5b16f0
movl $0xc4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x487cdb
movq 0x20(%rsp), %rdi
callq 0x1cec90
movb %al, %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x38(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x39(%rax)
movq 0x20(%rsp), %rdi
callq 0x1ceb90
testb $0x1, %al
jne 0x487d0b
jmp 0x487d1c
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x487e00
jmp 0x487d30
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x487ef0
movq 0x20(%rsp), %rdi
callq 0x1ce2e0
movq %rax, %rdi
callq 0x192b0
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
shlq $0x0, %rdi
leaq 0x129995(%rip), %rsi    # 0x5b16f0
movl $0xcc, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x1ce2e0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x8(%rsp), %rdx
shlq $0x0, %rdx
callq 0x19610
movq 0x10(%rsp), %rax
movb $0x0, 0x3a(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x3b(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x20(%rsp), %rdi
callq 0x1ce1e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x20(%rsp), %rdi
callq 0x1ce180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_init_from_unmapped_sa
static void gt_aligned_segment_init_from_unmapped_sa(GtAlignedSegment *as,
    GtSamAlignment *sa)
{
  as->r_left = GT_UNDEF_UWORD;
  as->r_right = GT_UNDEF_UWORD;
  as->alen = gt_sam_alignment_read_length(sa);
  as->s = gt_malloc(sizeof (*as->s) * (as->alen + 1UL));
  as->q = gt_malloc(sizeof (*as->q) * (as->alen + 1UL));
  as->r = NULL;
  as->s[as->alen] = 0;
  as->q[as->alen] = 0;
  gt_aligned_segment_fetch_s_and_q_from_sa(as, sa);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq $-0x1, 0x28(%rax)
movq 0x10(%rsp), %rax
movq $-0x1, 0x30(%rax)
movq 0x8(%rsp), %rdi
callq 0x1ce180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x12989a(%rip), %rsi    # 0x5b16f0
movl $0xa4, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x12986d(%rip), %rsi    # 0x5b16f0
movl $0xa5, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4890e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_init_from_mapped_sa
static void gt_aligned_segment_init_from_mapped_sa(GtAlignedSegment *as,
    GtSamAlignment *sa, GtSamfileEncseqMapping *sem)
{
  as->r_left = gt_samfile_encseq_mapping_seqpos(sem,
      gt_sam_alignment_ref_num(sa), gt_sam_alignment_pos(sa));
  as->r_right = gt_samfile_encseq_mapping_seqpos(sem,
      gt_sam_alignment_ref_num(sa), gt_sam_alignment_rightmost_pos(sa));
  as->alen = gt_aligned_segment_cigar2alen(sa);
  as->s = gt_malloc(sizeof (*as->s) * (as->alen + 1UL));
  as->q = gt_malloc(sizeof (*as->q) * (as->alen + 1UL));
  as->r = gt_malloc(sizeof (*as->r) * (as->alen + 1UL));
  as->s[as->alen] = 0;
  as->q[as->alen] = 0;
  as->r[as->alen] = 0;
  gt_aligned_segment_fetch_s_and_q_from_sa(as, sa);
  gt_aligned_segment_align_using_cigar(as, sa);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ce340
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ce120
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x1cf6b0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ce340
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ce240
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq %rax, %rdx
callq 0x1cf6b0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rdi
callq 0x4892f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x129743(%rip), %rsi    # 0x5b16f0
movl $0xb4, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x129716(%rip), %rsi    # 0x5b16f0
movl $0xb5, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x1296e8(%rip), %rsi    # 0x5b16f0
movl $0xb6, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x20(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x20(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x20(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4890e0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4893f0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_enable_edit_tracking
void gt_aligned_segment_enable_edit_tracking(GtAlignedSegment *as)
{
  gt_assert(as != NULL);
  gt_assert(as->s_orig == NULL);
  as->s_orig = gt_malloc(sizeof (*as->s_orig) * (as->alen + 1UL));
  memcpy(as->s_orig, as->s, (size_t)(as->alen + 1UL));
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x4880d4
movq 0x1b3efd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8df66(%rip), %rsi     # 0x516013
leaq 0x925e6(%rip), %rdx     # 0x51a69a
leaq 0x129673(%rip), %rcx    # 0x5b172e
leaq 0x12962e(%rip), %r8     # 0x5b16f0
movl $0xd8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4880d6
jmp 0x4880d8
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x48811b
movq 0x1b3eb6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8df1f(%rip), %rsi     # 0x516013
leaq 0x12965b(%rip), %rdx    # 0x5b1756
leaq 0x12962c(%rip), %rcx    # 0x5b172e
leaq 0x1295e7(%rip), %r8     # 0x5b16f0
movl $0xd9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48811d
movq (%rsp), %rax
movq 0x20(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
leaq 0x1295bc(%rip), %rsi    # 0x5b16f0
movl $0xda, %edx
callq 0xe80f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
movq (%rsp), %rax
movq 0x20(%rax), %rdx
addq $0x1, %rdx
callq 0x19610
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_offset_for_refpos
GtUword gt_aligned_segment_offset_for_refpos(const GtAlignedSegment *as,
    GtUword refpos)
{
  GtUword r_offset, pos, ungapped_pos;
  gt_assert(as != NULL);
  if (refpos < as->r_left || refpos > as->r_right)
    return GT_UNDEF_UWORD;
  r_offset = refpos - as->r_left;
  pos = 0;
  ungapped_pos = 0;
  while (ungapped_pos < r_offset)
  {
    if (as->r[pos] != '-')
      ungapped_pos++;
    pos++;
  }
  gt_assert(pos <= as->alen);
  return pos;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x48849e
movq 0x1b3b33(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8db9c(%rip), %rsi     # 0x516013
leaq 0x9221c(%rip), %rdx     # 0x51a69a
leaq 0x1293f1(%rip), %rcx    # 0x5b1876
leaq 0x129264(%rip), %r8     # 0x5b16f0
movl $0x118, %r9d            # imm = 0x118
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4884a0
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x4884c0
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x4884ce
movq $-0x1, 0x30(%rsp)
jmp 0x48858a
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq 0x28(%rcx), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x488534
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x488524
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4884f3
jmp 0x488536
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x48857e
movq 0x1b3a53(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8dabc(%rip), %rsi     # 0x516013
leaq 0x1293a0(%rip), %rdx    # 0x5b18fe
leaq 0x129311(%rip), %rcx    # 0x5b1876
leaq 0x129184(%rip), %r8     # 0x5b16f0
movl $0x124, %r9d            # imm = 0x124
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x488580
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_ungap_refregion
void gt_aligned_segment_ungap_refregion(GtAlignedSegment *as)
{
  GtUword pos, srcpos;
  gt_assert(as != NULL);
  gt_assert(as->r != NULL);
  for (srcpos = 0, pos = 0; srcpos < as->alen; srcpos++)
  {
    if (as->r[srcpos] != '-')
    {
      if (pos != srcpos)
      {
        gt_assert(pos < srcpos);
        as->r[pos] = as->r[srcpos];
      }
      pos++;
    }
  }
  gt_assert(pos <= as->alen + 1UL);
  if (pos <= as->alen)
    as->r[pos] = '\0';
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x488819
movq 0x1b37b8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8d821(%rip), %rsi     # 0x516013
leaq 0x91ea1(%rip), %rdx     # 0x51a69a
leaq 0x12910e(%rip), %rcx    # 0x5b190e
leaq 0x128ee9(%rip), %r8     # 0x5b16f0
movl $0x14c, %r9d            # imm = 0x14C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48881b
jmp 0x48881d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x488861
movq 0x1b3770(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8d7d9(%rip), %rsi     # 0x516013
leaq 0x1290f0(%rip), %rdx    # 0x5b1931
leaq 0x1290c6(%rip), %rcx    # 0x5b190e
leaq 0x128ea1(%rip), %r8     # 0x5b16f0
movl $0x14d, %r9d            # imm = 0x14D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x488863
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x488935
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x488922
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x488914
jmp 0x4888ae
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jb 0x4888f1
movq 0x1b36e0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8d749(%rip), %rsi     # 0x516013
leaq 0x12906e(%rip), %rdx    # 0x5b193f
leaq 0x129036(%rip), %rcx    # 0x5b190e
leaq 0x128e11(%rip), %r8     # 0x5b16f0
movl $0x154, %r9d            # imm = 0x154
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4888f3
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x488924
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x488874
jmp 0x488937
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x488986
movq 0x1b364b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8d6b4(%rip), %rsi     # 0x516013
leaq 0x128fe6(%rip), %rdx    # 0x5b194c
leaq 0x128fa1(%rip), %rcx    # 0x5b190e
leaq 0x128d7c(%rip), %r8     # 0x5b16f0
movl $0x15a, %r9d            # imm = 0x15A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x488988
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
ja 0x4889aa
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_delete
void gt_aligned_segment_delete(GtAlignedSegment *as)
{
  if (as != NULL)
  {
    gt_free(as->s);
    gt_free(as->q);
    gt_free(as->r);
    gt_free(as->d);
    gt_free(as->s_orig);
    gt_free(as);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x488e81
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x1288f2(%rip), %rsi    # 0x5b16f0
movl $0x1a1, %edx            # imm = 0x1A1
callq 0xe88c0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x1288d9(%rip), %rsi    # 0x5b16f0
movl $0x1a2, %edx            # imm = 0x1A2
callq 0xe88c0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x1288c0(%rip), %rsi    # 0x5b16f0
movl $0x1a3, %edx            # imm = 0x1A3
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x1288a7(%rip), %rsi    # 0x5b16f0
movl $0x1a4, %edx            # imm = 0x1A4
callq 0xe88c0
movq (%rsp), %rax
movq 0x40(%rax), %rdi
leaq 0x12888e(%rip), %rsi    # 0x5b16f0
movl $0x1a5, %edx            # imm = 0x1A5
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x128879(%rip), %rsi    # 0x5b16f0
movl $0x1a6, %edx            # imm = 0x1A6
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_assign_refregion_chars
void gt_aligned_segment_assign_refregion_chars(GtAlignedSegment *as,
    GtEncseq *encseq)
{
  GtUword i, pos;
  gt_assert(as != NULL);
  gt_assert(as->r != NULL);
  for (pos = as->r_left, i = 0; i < as->alen; i++)
  {
    if (as->r[i] == '?')
    {
      as->r[i] = gt_encseq_get_decoded_char(encseq, pos, GT_READMODE_FORWARD);
    }
    if (as->r[i] != '-')
      pos++;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x488ede
movq 0x1b30f3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8d15c(%rip), %rsi     # 0x516013
leaq 0x917dc(%rip), %rdx     # 0x51a69a
leaq 0x128bab(%rip), %rcx    # 0x5b1a70
leaq 0x128824(%rip), %r8     # 0x5b16f0
movl $0x1ae, %r9d            # imm = 0x1AE
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x488ee0
jmp 0x488ee2
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x488f26
movq 0x1b30ab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8d114(%rip), %rsi     # 0x516013
leaq 0x128a2b(%rip), %rdx    # 0x5b1931
leaq 0x128b63(%rip), %rcx    # 0x5b1a70
leaq 0x1287dc(%rip), %r8     # 0x5b16f0
movl $0x1af, %r9d            # imm = 0x1AF
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x488f28
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x488fc4
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3f, %eax
jne 0x488f8a
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xaa4b0
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x488faf
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x488fb1
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x488f3f
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_show
void gt_aligned_segment_show(GtAlignedSegment *as, GtFile *outfp)
{
  gt_assert(as != NULL);
  if (as->d != NULL)
    gt_file_xprintf(outfp, "D: %s\n", as->d);
  if (as->r != NULL)
    gt_file_xprintf(outfp, "R: %s\n", as->r);
  if (as->s_orig != NULL)
    gt_file_xprintf(outfp, "O: %s\n", as->s_orig);
  gt_file_xprintf(outfp, "S: %s\n", as->s);
  gt_file_xprintf(outfp, "Q: %s\n", as->q);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x48901e
movq 0x1b2fb3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8d01c(%rip), %rsi     # 0x516013
leaq 0x9169c(%rip), %rdx     # 0x51a69a
leaq 0x128a95(%rip), %rcx    # 0x5b1a9a
leaq 0x1286e4(%rip), %r8     # 0x5b16f0
movl $0x1bd, %r9d            # imm = 0x1BD
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x489020
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x489048
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x128a71(%rip), %rsi    # 0x5b1ab2
movb $0x0, %al
callq 0xddca0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x489070
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x128a50(%rip), %rsi    # 0x5b1ab9
movb $0x0, %al
callq 0xddca0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x489098
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdx
leaq 0x128a2f(%rip), %rsi    # 0x5b1ac0
movb $0x0, %al
callq 0xddca0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
leaq 0xb3650(%rip), %rsi     # 0x53c6fc
movb $0x0, %al
callq 0xddca0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x1289ff(%rip), %rsi    # 0x5b1ac7
movb $0x0, %al
callq 0xddca0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/aligned_segment.c
// Function: gt_aligned_segment_cigar2alen
static GtUword gt_aligned_segment_cigar2alen(GtSamAlignment *sa)
{
  GtUword alen;
  uint16_t clen, opnum;
  unsigned char opcode;
  alen = 0;
  clen = gt_sam_alignment_cigar_length(sa);
  for (opnum = 0; opnum < clen; opnum++)
  {
    opcode = gt_sam_alignment_cigar_i_operation(sa, opnum);
    /* ignore hard clipping and padding operations */
    if (opcode != (unsigned char)'H' || opcode != (unsigned char)'P')
      alen += (GtUword)gt_sam_alignment_cigar_i_length(sa, opnum);
  }
  gt_assert(alen >= gt_sam_alignment_read_length(sa));
  return alen;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1ce850
movw %ax, 0x16(%rsp)
movw $0x0, 0x14(%rsp)
movzwl 0x14(%rsp), %eax
movzwl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jge 0x48937a
movq 0x20(%rsp), %rdi
movzwl 0x14(%rsp), %esi
callq 0x1ce940
movb %al, 0x13(%rsp)
movzbl 0x13(%rsp), %eax
cmpl $0x48, %eax
jne 0x48934d
movzbl 0x13(%rsp), %eax
cmpl $0x50, %eax
je 0x489368
movq 0x20(%rsp), %rdi
movzwl 0x14(%rsp), %esi
callq 0x1ce8b0
movl %eax, %eax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x48936a
movw 0x14(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x14(%rsp)
jmp 0x489318
jmp 0x48937c
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1ce180
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4893d5
movq 0x1b2bfc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8cc65(%rip), %rsi     # 0x516013
leaq 0x1287c5(%rip), %rdx    # 0x5b1b7a
leaq 0x12879c(%rip), %rcx    # 0x5b1b58
leaq 0x12832d(%rip), %r8     # 0x5b16f0
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4893d7
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_new
GtBitInStream *gt_bitinstream_new(const char* path,
                                  size_t offset,
                                  GtUword pages_to_map)
{
  GtBitInStream *bitstream = gt_malloc(sizeof (*bitstream));

  bitstream->pagesize = gt_pagesize();
  bitstream->last_chunk = false;
  gt_safe_assign(bitstream->filesize, gt_file_estimate_size(path));
  bitstream->path = gt_cstr_dup(path);
  bitstream->pages_to_map = pages_to_map;

  if ((GtUword) bitstream->filesize <
      (bitstream->pages_to_map * bitstream->pagesize))
    bitstream->pages_to_map =
      (GtUword) ((bitstream->filesize / bitstream->pagesize) + 1);

  bitstream->bitseqbuffer = NULL;
  bitstream->read_bits = 0;
  gt_bitinstream_reinit(bitstream,
                        offset);

  bitstream->bufferlength = (bitstream->pages_to_map * bitstream->pagesize) /
                            sizeof (*bitstream->bitseqbuffer);
  return bitstream;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x50, %edi
leaq 0x12821e(%rip), %rsi    # 0x5b1bdd
movl $0x31, %edx
callq 0xe80f0
movq %rax, 0x18(%rsp)
callq 0xa2640
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x4c(%rax)
movq 0x30(%rsp), %rdi
callq 0xdf1d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x489a43
cmpq $0x1, 0x10(%rsp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x1, 0x8(%rsp)
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x489a43
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x489a4d
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0x489a4d
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x489a89
movq 0x1b253e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8e5b9(%rip), %rsi     # 0x518025
leaq 0x12816a(%rip), %rdx    # 0x5b1bdd
movl $0x35, %ecx
movb $0x0, %al
callq 0x199f0
movl $0x1, %edi
callq 0x19890
jmp 0x489a8b
movq 0x30(%rsp), %rdi
callq 0xa2db0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x18(%rsp), %rdx
imulq 0x28(%rdx), %rcx
cmpq %rcx, %rax
jae 0x489af4
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
divq 0x28(%rcx)
movq %rax, %rcx
addq $0x1, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x489b50
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x18(%rsp), %rax
imulq 0x28(%rax), %rcx
shrq $0x3, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_reinit
void gt_bitinstream_reinit(GtBitInStream *bitstream,
                           size_t offset)
{
  size_t mapsize = (size_t) (bitstream->pagesize * bitstream->pages_to_map);

  gt_assert(offset < bitstream->filesize);
  gt_assert((offset % bitstream->pagesize) == 0);

  bitstream->cur_filepos = offset;

  gt_fa_xmunmap(bitstream->bitseqbuffer);

  if (bitstream->cur_filepos + mapsize > bitstream->filesize) {
    mapsize = bitstream->filesize - bitstream->cur_filepos;
    bitstream->bufferlength = (GtUword)  mapsize /
                                sizeof (*bitstream->bitseqbuffer);
    bitstream->last_chunk = true;
  }
  bitstream->bitseqbuffer =
    gt_fa_xmmap_read_range(bitstream->path,
                           mapsize,
                           offset);

  gt_assert(bitstream->bitseqbuffer != NULL);

  bitstream->cur_bit = 0;
  bitstream->cur_bitseq = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rcx
imulq 0x20(%rcx), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x489bbd
movq 0x1b2414(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8c47d(%rip), %rsi     # 0x516013
leaq 0x12805b(%rip), %rdx    # 0x5b1bf8
leaq 0x128071(%rip), %rcx    # 0x5b1c15
leaq 0x128032(%rip), %r8     # 0x5b1bdd
movl $0x4d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x489bbf
jmp 0x489bc1
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
divq 0x28(%rcx)
cmpq $0x0, %rdx
je 0x489c0f
movq 0x1b23c2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8c42b(%rip), %rsi     # 0x516013
leaq 0x12803c(%rip), %rdx    # 0x5b1c2b
leaq 0x12801f(%rip), %rcx    # 0x5b1c15
leaq 0x127fe0(%rip), %r8     # 0x5b1bdd
movl $0x4e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x489c11
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xdb2a0
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x489c72
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
subq (%rcx), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
shrq $0x3, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x4c(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x127f52(%rip), %rcx    # 0x5b1bdd
movl $0x5d, %r8d
callq 0xdb010
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x489ce6
movq 0x1b22eb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8c354(%rip), %rsi     # 0x516013
leaq 0x127f89(%rip), %rdx    # 0x5b1c4f
leaq 0x127f48(%rip), %rcx    # 0x5b1c15
leaq 0x127f09(%rip), %r8     # 0x5b1bdd
movl $0x5f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x489ce8
movq 0x10(%rsp), %rax
movl $0x0, 0x48(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_get_next_bit
int gt_bitinstream_get_next_bit(GtBitInStream *bitstream,
                                bool * bit)
{
  const int eof = 0, more_to_read = 1;
  if (bitstream->cur_bit == GT_INTWORDSIZE) {
    if (bitstream->cur_bitseq < bitstream->bufferlength - 1) {
      bitstream->cur_bit = 0;
      bitstream->cur_bitseq++;
    }
    else {
      if (bitstream->last_chunk) {
        return eof;
      }
      else {
        gt_bitinstream_reinit(bitstream,
                              bitstream->cur_filepos +
                                bitstream->pagesize *
                                bitstream->pages_to_map);
      }
    }
  }
  gt_assert(bitstream->cur_bitseq != bitstream->bufferlength);
  *bit = GT_ISBITSET(bitstream->bitseqbuffer[bitstream->cur_bitseq],
                     bitstream->cur_bit++) != 0;
  bitstream->read_bits++;
  return more_to_read;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x40, 0x48(%rax)
jne 0x489db7
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x489d73
movq 0x18(%rsp), %rax
movl $0x0, 0x48(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x489db5
movq 0x18(%rsp), %rax
testb $0x1, 0x4c(%rax)
je 0x489d8b
movl $0x0, 0x24(%rsp)
jmp 0x489e69
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rsp), %rcx
imulq 0x20(%rcx), %rax
addq %rax, %rsi
callq 0x489b50
jmp 0x489db5
jmp 0x489db7
jmp 0x489db9
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x489e05
movq 0x1b21cc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8c235(%rip), %rsi     # 0x516013
leaq 0x127e8a(%rip), %rdx    # 0x5b1c6f
leaq 0x127eb4(%rip), %rcx    # 0x5b1ca0
leaq 0x127dea(%rip), %r8     # 0x5b1bdd
movl $0x7a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x489e07
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rsp), %rdx
movl 0x48(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x48(%rdx)
movl %ecx, %ecx
shlq %cl, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
cmpq $0x0, %rax
setne %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitinstream.c
// Function: gt_bitinstream_delete
void gt_bitinstream_delete(GtBitInStream *bitstream)
{
  if (bitstream != NULL) {
    gt_log_log("read "GT_WU" bits", bitstream->read_bits);
    gt_fa_xmunmap(bitstream->bitseqbuffer);
    gt_free(bitstream->path);
    gt_free(bitstream);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x489edd
movq (%rsp), %rax
movq 0x30(%rax), %rsi
leaq 0x127e21(%rip), %rdi    # 0x5b1cbc
movb $0x0, %al
callq 0xe7740
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xdb2a0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x127d1f(%rip), %rsi    # 0x5b1bdd
movl $0x86, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x127d0a(%rip), %rsi    # 0x5b1bdd
movl $0x87, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_new
GtBitOutStream* gt_bitoutstream_new(FILE *fp)
{
  GtBitOutStream *bitstream;
  gt_assert(fp);

  bitstream = gt_calloc((size_t) 1, sizeof (GtBitOutStream));
  bitstream->bits_left = GT_INTWORDSIZE;
  bitstream->fp = fp;
  bitstream->bitseqbuffer = 0;
  bitstream->written_bits = 0;
  bitstream->pagesize = gt_pagesize();
  return bitstream;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x489f29
movq 0x1b20a8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8c111(%rip), %rsi     # 0x516013
leaq 0xcb842(%rip), %rdx     # 0x55574b
leaq 0x127dba(%rip), %rcx    # 0x5b1cca
leaq 0x127dc7(%rip), %r8     # 0x5b1cde
movl $0x25, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x489f2b
movl $0x1, %edi
movl $0x28, %esi
leaq 0x127da2(%rip), %rdx    # 0x5b1cde
movl $0x27, %ecx
callq 0xe83c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x40, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
callq 0xa2640
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_append
void gt_bitoutstream_append(GtBitOutStream *bitstream,
                            GtBitsequence code,
                            unsigned bits_to_write)
{
  if ((unsigned) bitstream->bits_left < bits_to_write) {
    unsigned overhang = bits_to_write - bitstream->bits_left;
    bitstream->bitseqbuffer |= code >> overhang;
    gt_xfwrite(&bitstream->bitseqbuffer,
               sizeof (GtBitsequence),
               (size_t) 1, bitstream->fp);
    bitstream->bitseqbuffer = 0;
    bitstream->bits_left = GT_INTWORDSIZE - overhang;
    bitstream->written_bits += GT_INTWORDSIZE;
  }
  else {
    bitstream->bits_left -= bits_to_write;
  }
  bitstream->bitseqbuffer |= code << bitstream->bits_left;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
cmpl 0x4(%rsp), %eax
jae 0x48a03a
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rax
movl (%rsp), %ecx
shrq %cl, %rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
orq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movl $0x40, %ecx
subl (%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x8(%rax)
jmp 0x48a04b
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x20(%rcx), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
orq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_append_bittab
void gt_bitoutstream_append_bittab(GtBitOutStream *bitstream,
                                   GtBittab *tab) {
  GtUword j,
                size = gt_bittab_size(tab);
  for (j = 0; j < size; j++) {
    if (bitstream->bits_left == 0) {
      gt_xfwrite(&bitstream->bitseqbuffer,
                 sizeof (GtBitsequence),
                 (size_t) 1, bitstream->fp);
      bitstream->bitseqbuffer = 0;
      bitstream->bits_left = GT_INTWORDSIZE;
      bitstream->written_bits += GT_INTWORDSIZE;
    }
    bitstream->bits_left--;
    if (gt_bittab_bit_is_set(tab, j))
      bitstream->bitseqbuffer |= ((GtBitsequence) 1) << (bitstream->bits_left);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8a9b0
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x48a155
movq 0x20(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x48a0fb
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movl $0x40, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8a780
testb $0x1, %al
jne 0x48a11e
jmp 0x48a140
movq 0x20(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq 0x20(%rsp), %rax
orq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0x48a142
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x48a096
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_flush
void gt_bitoutstream_flush(GtBitOutStream *bitstream)
{
  gt_assert(bitstream);
  gt_xfwrite(&bitstream->bitseqbuffer, sizeof (GtBitsequence),
             (size_t) 1, bitstream->fp);
  bitstream->written_bits += (GT_INTWORDSIZE - bitstream->bits_left);

  bitstream->bitseqbuffer = 0;
  bitstream->bits_left = GT_INTWORDSIZE;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x48a1a4
movq 0x1b1e2d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8be96(%rip), %rsi     # 0x516013
leaq 0x127b76(%rip), %rdx    # 0x5b1cfa
leaq 0x127b79(%rip), %rcx    # 0x5b1d04
leaq 0x127b4c(%rip), %r8     # 0x5b1cde
movl $0x59, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48a1a6
movq (%rsp), %rdi
addq $0x18, %rdi
movq (%rsp), %rax
movq (%rax), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq (%rsp), %rcx
movl $0x40, %eax
subl 0x20(%rcx), %eax
movslq %eax, %rcx
movq (%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movl $0x40, 0x20(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/bitoutstream.c
// Function: gt_bitoutstream_flush_advance
void gt_bitoutstream_flush_advance(GtBitOutStream *bitstream)
{
  GtWord fpos;
  bool is_not_at_pageborder = (ftell(bitstream->fp) % bitstream->pagesize) != 0;

  gt_assert(bitstream);

  gt_bitoutstream_flush(bitstream);

  if (is_not_at_pageborder) {
    fpos = (ftell(bitstream->fp) / bitstream->pagesize + 1) *
           bitstream->pagesize;
    gt_xfseek(bitstream->fp, fpos, SEEK_SET);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x19030
movq 0x10(%rsp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
cmpq $0x0, %rdx
setne %al
andb $0x1, %al
movb %al, 0x7(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x48a26e
movq 0x1b1d63(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8bdcc(%rip), %rsi     # 0x516013
leaq 0x127aac(%rip), %rdx    # 0x5b1cfa
leaq 0x127ac5(%rip), %rcx    # 0x5b1d1a
leaq 0x127a82(%rip), %r8     # 0x5b1cde
movl $0x67, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48a270
movq 0x10(%rsp), %rdi
callq 0x48a160
testb $0x1, 0x7(%rsp)
je 0x48a2c0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x19030
movq 0x10(%rsp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
addq $0x1, %rax
movq 0x10(%rsp), %rcx
imulq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x126ca0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/chain.c
// Function: gt_chain_set_fragnum
void gt_chain_set_fragnum(GtChain *chain, GtUword idx,
                          GtUword fragnum)
{
  GtUword *fragments;
  gt_assert(chain);
  gt_assert(idx < gt_array_size(chain->fragments));
  fragments = gt_array_get_space(chain->fragments);
  fragments[idx] = fragnum;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x48b913
movq 0x1b06be(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8a727(%rip), %rsi     # 0x516013
leaq 0x8be04(%rip), %rdx     # 0x5176f7
leaq 0x1267bc(%rip), %rcx    # 0x5b20b6
leaq 0x126756(%rip), %r8     # 0x5b2057
movl $0x41, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48b915
jmp 0x48b917
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x81370
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x48b971
movq 0x1b0660(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8a6c9(%rip), %rsi     # 0x516013
leaq 0x12677a(%rip), %rdx    # 0x5b20cb
leaq 0x12675e(%rip), %rcx    # 0x5b20b6
leaq 0x1266f8(%rip), %r8     # 0x5b2057
movl $0x42, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48b973
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x81080
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/clustered_set.c
// Function: gt_clustered_set_create
GtClusteredSet* gt_clustered_set_create(const GtClusteredSetClass *csc)
{
  GtClusteredSet *cs;
  gt_assert(csc && csc->size);
  cs = gt_calloc(1, csc->size) ;
  cs->c_class = csc;
  return cs;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x48bbcc
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x48bc04
movq 0x1b03cd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x8a436(%rip), %rsi     # 0x516013
leaq 0x126530(%rip), %rdx    # 0x5b2114
leaq 0x12653a(%rip), %rcx    # 0x5b2125
leaq 0x12654b(%rip), %r8     # 0x5b213d
movl $0x2e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48bc06
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0x126523(%rip), %rdx    # 0x5b213d
movl $0x2f, %ecx
callq 0xe83c0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/clustered_set.c
// Function: gt_clustered_set_delete
void gt_clustered_set_delete(GtClusteredSet *cs, GtError *err)
{
 if (!cs) return;
 if (cs->c_class->free)
  cs->c_class->free(cs, err);
 gt_free(cs);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x48bc58
jmp 0x48bc95
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x48bc7f
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq 0x10(%rsp), %rdi
leaq 0x1264b2(%rip), %rsi    # 0x5b213d
movl $0x39, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/clustered_set.c
// Function: gt_clustered_set_iterator_next
GtClusteredSetIteratorStatus
gt_clustered_set_iterator_next(GtClusteredSetIterator *cs_i,
                               GtUword *elm,
                               GT_UNUSED GtError *err)
{
  if (cs_i->curpos >= cs_i->length)
    return GT_CLUSTERED_SET_ITERATOR_STATUS_END;
  *elm = cs_i->elems[cs_i->curpos];
  cs_i->curpos++;
  return GT_CLUSTERED_SET_ITERATOR_STATUS_OK;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x48bdec
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x48be20
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/clustered_set.c
// Function: gt_clustered_set_iterator_delete
void gt_clustered_set_iterator_delete(GtClusteredSetIterator *cs_i,
                                      GT_UNUSED GtError *err)
{
  if (!cs_i)
    return;
  gt_free(cs_i->elems);
  gt_free(cs_i);
  return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x48be48
jmp 0x48be78
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x1262e5(%rip), %rsi    # 0x5b213d
movl $0x6e, %edx
callq 0xe88c0
movq 0x10(%rsp), %rdi
leaq 0x1262cf(%rip), %rsi    # 0x5b213d
movl $0x6f, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_delete
void gt_clustered_set_union_find_delete(GtClusteredSet *cs,
                                        GT_UNUSED GtError *err)
{
  if (!cs) return;
  GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs;
  gt_free(cs_uf->cluster_elems);
  gt_array_delete(cs_uf->cluster_info);
  gt_bittab_delete(cs_uf->in_cluster);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x48c0b8
jmp 0x48c0f4
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x1260b3(%rip), %rsi    # 0x5b2183
movl $0xbb, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x81f80
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8af40
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_cluster_num
GtUword gt_clustered_set_union_find_cluster_num(GtClusteredSet *cs,
                                                      GtUword e,
                                                      GT_UNUSED GtError *err
                                                      )
{
  gt_assert(cs);
  GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs;
  if (SINGLETON(e))
    return CLUSTERNIL;
  else
    return cs_uf->cluster_elems[e].cluster_num;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x48c233
movq 0x1afd9e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x89e07(%rip), %rsi     # 0x516013
leaq 0xea4e5(%rip), %rdx     # 0x5766f8
leaq 0x125fe1(%rip), %rcx    # 0x5b21fb
leaq 0x125f62(%rip), %r8     # 0x5b2183
movl $0xd5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x48c235
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x8a780
testb $0x1, %al
jne 0x48c263
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x48c27f
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/clustered_set_uf.c
// Function: gt_clustered_set_union_find_make_new_cluster
static void
gt_clustered_set_union_find_make_new_cluster(GtClusteredSetUF *cs_uf,
                                             GtUword elem1,
                                             GtUword elem2,
                                             GT_UNUSED GtError *err)
{
  GtUword cluster_num;
  cluster_num = cs_uf->next_free_cluster_info++;

  cs_uf->cluster_elems[elem1].cluster_num = cluster_num;
  cs_uf->cluster_elems[elem2].cluster_num = cluster_num;
  cs_uf->cluster_elems[elem1].next_elem = elem2;
  cs_uf->cluster_elems[elem2].next_elem = cs_uf->num_of_elems;

  GtClusteredSetUFClusterInfo cluster_info;
  cluster_info.cluster_size = (GtUword) 2;
  cluster_info.first_elem = elem1;
  cluster_info.last_elem = elem2;

  gt_array_add(cs_uf->cluster_info, cluster_info);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rcx
movq 0x30(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rcx)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq $0x2, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x81100
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)