LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_write_hplengths
void gt_reads2twobit_write_hplengths(const GtReads2Twobit *r2t, FILE *out_fp)
{
  gt_assert(r2t != NULL);
  gt_assert(r2t->hplengths != NULL);
  gt_assert(out_fp != NULL);
  gt_hplstore_save(r2t->hplengths, out_fp);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2a511e
movq 0x396eb3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x270f1c(%rip), %rsi    # 0x516013
leaq 0x2dfecb(%rip), %rdx    # 0x584fc9
leaq 0x2e04c0(%rip), %rcx    # 0x5855c5
leaq 0x2dfea4(%rip), %r8     # 0x584fb0
movl $0x905, %r9d            # imm = 0x905
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a5120
jmp 0x2a5122
movq 0x10(%rsp), %rax
cmpq $0x0, 0xc0(%rax)
jne 0x2a5169
movq 0x396e68(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x270ed1(%rip), %rsi    # 0x516013
leaq 0x2e049c(%rip), %rdx    # 0x5855e5
leaq 0x2e0475(%rip), %rcx    # 0x5855c5
leaq 0x2dfe59(%rip), %r8     # 0x584fb0
movl $0x906, %r9d            # imm = 0x906
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a516b
jmp 0x2a516d
cmpq $0x0, 0x8(%rsp)
jne 0x2a51ad
movq 0x396e24(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x270e8d(%rip), %rsi    # 0x516013
leaq 0x2e046f(%rip), %rdx    # 0x5855fc
leaq 0x2e0431(%rip), %rcx    # 0x5855c5
leaq 0x2dfe15(%rip), %r8     # 0x584fb0
movl $0x907, %r9d            # imm = 0x907
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a51af
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x4d1b30
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_enable_descs
void gt_reads2twobit_enable_descs(GtReads2Twobit *r2t, bool clipped,
                                  bool membased)
{
  gt_assert(r2t != NULL);
  r2t->clipdes = clipped;
  if (membased)
  {
    r2t->descs = gt_desc_buffer_new();
    if (clipped)
      gt_desc_buffer_set_clip_at_whitespace(r2t->descs);
  }
  else
  {
    r2t->descsfp = gt_xtmpfp_generic(NULL, GT_TMPFP_AUTOREMOVE);
  }
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x10(%rsp)
andb $0x1, %cl
movb %cl, 0xf(%rsp)
andb $0x1, %al
movb %al, 0xe(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2a524b
movq 0x396d86(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x270def(%rip), %rsi    # 0x516013
leaq 0x2dfd9e(%rip), %rdx    # 0x584fc9
leaq 0x2e03d9(%rip), %rcx    # 0x58560b
leaq 0x2dfd77(%rip), %r8     # 0x584fb0
movl $0x914, %r9d            # imm = 0x914
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a524d
movb 0xf(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0xa8(%rax)
testb $0x1, 0xe(%rsp)
je 0x2a5294
callq 0xa4110
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x98(%rax)
testb $0x1, 0xf(%rsp)
je 0x2a5292
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0xa41e0
jmp 0x2a52bd
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
leaq 0x2dfd0c(%rip), %rdx    # 0x584fb0
movl $0x91e, %ecx            # imm = 0x91E
callq 0xd9e50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xa0(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_encode_unpaired_fasta_library
static void gt_reads2twobit_encode_unpaired_fasta_library(
    GtReads2TwobitEncodeState *state, GtReadsLibraryInfo *rli, FILE *file,
    char *line)
{
  char *fgetsretval = NULL;
  do {
    if (line[0] == '>')
    {
      if (state->current.nofseqs > rli->first_seqnum)
      {
        if (!state->invalid_mode)
          gt_reads2twobit_process_sequence_end(state);
        gt_reads2twobit_finalize_descriptions(state);
      }
      gt_reads2twobit_process_desc_line(state, line, false, false);
      GT_READS2TWOBIT_HANDLE_LONG_DESCRIPTIONS(line, file, fgetsretval,
          true, state, false);
      gt_reads2twobit_prepare_for_new_sequence(state);
    }
    else if (!state->invalid_mode)
    {
      gt_reads2twobit_process_sequence_line(state, line);
    }
  } while ((fgetsretval = fgets(line, (int)GT_READS2TWOBIT_READBUFFER_SIZE,
            file)) == line);
  gt_reads2twobit_finalize_descriptions(state);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x2a5420
movq 0x30(%rsp), %rax
movq 0x860(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x2a537b
movq 0x30(%rsp), %rax
testb $0x1, 0x8f1(%rax)
jne 0x2a5371
movq 0x30(%rsp), %rdi
callq 0x2a57b0
movq 0x30(%rsp), %rdi
callq 0x2a5b50
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2a5c70
movq 0x18(%rsp), %rdi
callq 0x192b0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0xff, %rcx
movb %al, 0xf(%rsp)
jne 0x2a53ce
movq 0x18(%rsp), %rax
movsbl 0xfe(%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0xf(%rsp)
je 0x2a53ce
cmpq $0x0, 0x10(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2a53d8
jmp 0x2a5414
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x19b60
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2a540f
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2a5c70
jmp 0x2a538e
movq 0x30(%rsp), %rdi
callq 0x2a5d20
jmp 0x2a543f
movq 0x30(%rsp), %rax
testb $0x1, 0x8f1(%rax)
jne 0x2a543d
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2a5db0
jmp 0x2a543f
jmp 0x2a5441
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x19b60
movq %rax, 0x10(%rsp)
cmpq 0x18(%rsp), %rax
je 0x2a5331
movq 0x30(%rsp), %rdi
callq 0x2a5b50
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_close_file
static int gt_reads2twobit_close_file(FILE *file, GtStr *filename, GtError *err)
{
  int had_err = 0;
  gt_assert(file != NULL);
  if (ferror(file) != 0)
  {
    gt_error_set(err, "Error by reading file %s: %s", gt_str_get(filename),
        strerror(errno));
    had_err = -1;
  }
  gt_fa_fclose(file);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2a5adb
movq 0x3964f6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x27055f(%rip), %rsi    # 0x516013
leaq 0x2e4fb1(%rip), %rdx    # 0x58aa6c
leaq 0x2dffd9(%rip), %rcx    # 0x585a9b
leaq 0x2df4e7(%rip), %r8     # 0x584fb0
movl $0x284, %r9d            # imm = 0x284
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a5add
movq 0x30(%rsp), %rdi
callq 0x19e10
cmpl $0x0, %eax
je 0x2a5b34
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
callq 0x19060
movl (%rax), %edi
callq 0x19200
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x2dff91(%rip), %rsi    # 0x585ab6
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rdi
callq 0xd9390
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_finalize_descriptions
static void gt_reads2twobit_finalize_descriptions(
    GtReads2TwobitEncodeState *state)
{
  if (state->descs != NULL || state->descsfp != NULL)
  {
    if (state->invalid_mode)
    {
      gt_str_reset(state->dbuf);
      gt_str_reset(state->dbuf2);
    }
    else if (state->descs != NULL)
    {
      gt_assert(state->descsfp == NULL);
      gt_reads2twobit_finalize_descriptions_membased(state);
    }
    else
    {
      gt_assert(state->descsfp != NULL);
      gt_reads2twobit_finalize_descriptions_diskbased(state);
    }
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x990(%rax)
jne 0x2a5b75
movq (%rsp), %rax
cmpq $0x0, 0x998(%rax)
je 0x2a5c61
movq (%rsp), %rax
testb $0x1, 0x8f1(%rax)
je 0x2a5ba7
movq (%rsp), %rax
movq 0x948(%rax), %rdi
callq 0x11e110
movq (%rsp), %rax
movq 0x950(%rax), %rdi
callq 0x11e110
jmp 0x2a5c5f
movq (%rsp), %rax
cmpq $0x0, 0x990(%rax)
je 0x2a5c0a
jmp 0x2a5bb7
movq (%rsp), %rax
cmpq $0x0, 0x998(%rax)
je 0x2a5bfd
movq 0x3963d4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x27043d(%rip), %rsi    # 0x516013
leaq 0x2dfb10(%rip), %rdx    # 0x5856ed
leaq 0x2dfb20(%rip), %rcx    # 0x585704
leaq 0x2df3c5(%rip), %r8     # 0x584fb0
movl $0x2e9, %r9d            # imm = 0x2E9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a5bff
movq (%rsp), %rdi
callq 0x2a61a0
jmp 0x2a5c5d
jmp 0x2a5c0c
movq (%rsp), %rax
cmpq $0x0, 0x998(%rax)
jne 0x2a5c52
movq 0x39637f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2703e8(%rip), %rsi    # 0x516013
leaq 0x2dfaf8(%rip), %rdx    # 0x58572a
leaq 0x2dfacb(%rip), %rcx    # 0x585704
leaq 0x2df370(%rip), %r8     # 0x584fb0
movl $0x2ee, %r9d            # imm = 0x2EE
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a5c54
movq (%rsp), %rdi
callq 0x2a6410
jmp 0x2a5c5f
jmp 0x2a5c61
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_process_desc_line
static inline void gt_reads2twobit_process_desc_line(
    GtReads2TwobitEncodeState *state, char *line, bool second_in_pair,
    bool long_line)
{
  GtStr *dbuf;
  if (state->descs == NULL && state->descsfp == NULL)
    return;
  dbuf = second_in_pair ? state->dbuf2 : state->dbuf;
  gt_str_append_cstr(dbuf, long_line ? line : line + 1UL);
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %cl
movb %cl, 0x27(%rsp)
andb $0x1, %al
movb %al, 0x26(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x990(%rax)
jne 0x2a5caf
movq 0x30(%rsp), %rax
cmpq $0x0, 0x998(%rax)
jne 0x2a5caf
jmp 0x2a5d1b
testb $0x1, 0x27(%rsp)
je 0x2a5cc9
movq 0x30(%rsp), %rax
movq 0x950(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2a5cda
movq 0x30(%rsp), %rax
movq 0x948(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x26(%rsp)
je 0x2a5d00
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
jmp 0x2a5d0d
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11d550
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_prepare_for_new_sequence
static inline void gt_reads2twobit_prepare_for_new_sequence(
    GtReads2TwobitEncodeState *state)
{
  GT_READS2TWOBIT_COPY_ENCODE_INFO(state->current, state->backup);
  state->current.nofseqs++;
  state->seqlen = 0;
  state->seqlen_mate = 0;
  state->invalid_mode = false;
  state->exp_qlen = 0;
  state->prevcode = GT_READS2TWOBIT_CODE_UNDEF;
  state->hplength = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x888, %rdi            # imm = 0x888
movq (%rsp), %rsi
addq $0x820, %rsi            # imm = 0x820
movl $0x68, %edx
callq 0x19610
movq (%rsp), %rax
movq 0x860(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x860(%rax)
movq (%rsp), %rax
movq $0x0, 0x808(%rax)
movq (%rsp), %rax
movq $0x0, 0x810(%rax)
movq (%rsp), %rax
movb $0x0, 0x8f1(%rax)
movq (%rsp), %rax
movq $0x0, 0x818(%rax)
movq (%rsp), %rax
movq $-0x1, 0x968(%rax)
movq (%rsp), %rax
movb $0x0, 0x978(%rax)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_clip_str
static void gt_reads2twobit_clip_str(GtStr *str)
{
  GtUword i;
  for (i = 0; i < gt_str_length(str); i++)
  {
    if (isspace(gt_str_get(str)[i]))
    {
      gt_str_get(str)[i] = '\n';
      gt_str_set_length(str, i+1);
      return;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11dfa0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2a67b9
callq 0x197c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x2a67a4
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq 0x18(%rsp), %rcx
movb $0xa, (%rax,%rcx)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
callq 0x11dfd0
jmp 0x2a67b9
jmp 0x2a67a6
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2a6722
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_switch_to_invalid_mode
static void gt_reads2twobit_switch_to_invalid_mode(
    GtReads2TwobitEncodeState *state)
{
  state->invalid_mode = true;
  state->invalid_sequences++;
  state->invalid_total_length += state->seqlen;
  state->invalid_total_length += state->seqlen_mate;
  if (state->varlen_mode && state->backup.seppos_nextfree == 0)
  {
    gt_log_log("switch back to eqlen mode, seqlen = "GT_WU"",
        state->backup.seqlen_first);
    gt_free(state->seppos);
    state->seppos = NULL;
    state->seppos_alloc = 0;
    state->varlen_mode = false;
  }
  GT_READS2TWOBIT_COPY_ENCODE_INFO(state->backup, state->current);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movb $0x1, 0x8f1(%rax)
movq (%rsp), %rax
movq 0x8f8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8f8(%rax)
movq (%rsp), %rax
movq 0x808(%rax), %rcx
movq (%rsp), %rax
addq 0x900(%rax), %rcx
movq %rcx, 0x900(%rax)
movq (%rsp), %rax
movq 0x810(%rax), %rcx
movq (%rsp), %rax
addq 0x900(%rax), %rcx
movq %rcx, 0x900(%rax)
movq (%rsp), %rax
testb $0x1, 0x8f0(%rax)
je 0x2a6899
movq (%rsp), %rax
cmpq $0x0, 0x8d0(%rax)
jne 0x2a6899
movq (%rsp), %rax
movq 0x8e8(%rax), %rsi
leaq 0x2defc0(%rip), %rdi    # 0x58580d
movb $0x0, %al
callq 0xe7740
movq (%rsp), %rax
movq 0x908(%rax), %rdi
leaq 0x2de74a(%rip), %rsi    # 0x584fb0
movl $0x224, %edx            # imm = 0x224
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x908(%rax)
movq (%rsp), %rax
movq $0x0, 0x910(%rax)
movq (%rsp), %rax
movb $0x0, 0x8f0(%rax)
movq (%rsp), %rdi
addq $0x820, %rdi            # imm = 0x820
movq (%rsp), %rsi
addq $0x888, %rsi            # imm = 0x888
movl $0x68, %edx
callq 0x19610
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_process_qualities_line
static inline int gt_reads2twobit_process_qualities_line(
    GtReads2TwobitEncodeState *state, const char *line,
    char *qbuf, GtUword *qbuf_next)
{
  GtUword j = 0;
  char c;
  while ((c = line[j++]) != '\0')
  {
    if (c >= state->phredbase)
    {
      if (*qbuf_next == state->exp_qlen)
        return -1;
      qbuf[*qbuf_next] = c - state->phredbase;
      (*qbuf_next)++;
    }
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rsp)
movb (%rax,%rcx), %al
movb %al, -0x31(%rsp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x2a6970
movsbl -0x31(%rsp), %eax
movq -0x10(%rsp), %rcx
movsbl 0x918(%rcx), %ecx
cmpl %ecx, %eax
jl 0x2a696b
movq -0x28(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x818(%rcx), %rax
jne 0x2a6937
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a6978
movsbl -0x31(%rsp), %eax
movq -0x10(%rsp), %rcx
movsbl 0x918(%rcx), %ecx
subl %ecx, %eax
movb %al, %dl
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2a68dd
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_apply_quality_filter
static void gt_reads2twobit_apply_quality_filter(
    GtReads2TwobitEncodeState *state, const char *qbuf, GtUword nofq)
{
  GtUword i, low = 0;
  for (i = 0; i < nofq; i++)
    if (qbuf[i] <= state->lowqual)
      low++;
  if (low > state->maxlow)
    gt_reads2twobit_switch_to_invalid_mode(state);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x2a69ec
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movsbl 0x930(%rcx), %ecx
cmpl %ecx, %eax
jg 0x2a69da
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2a69dc
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2a69a4
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x958(%rcx), %rax
jbe 0x2a6a08
movq 0x20(%rsp), %rdi
callq 0x2a67c0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_append_seppos
static void gt_reads2twobit_append_seppos(GtReads2TwobitEncodeState *state,
    GtUword pos)
{
  gt_assert(state->seppos != NULL);
  if (state->current.seppos_nextfree == state->seppos_alloc)
  {
    (state->seppos_alloc) += GT_READS2TWOBIT_SEPPOS_INC;
    state->seppos = gt_realloc(state->seppos,
        sizeof (state->seppos) * state->seppos_alloc);
  }
  state->seppos[state->current.seppos_nextfree] = pos;
  state->current.seppos_nextfree++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x908(%rax)
jne 0x2a6a65
movq 0x39556c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26f5d5(%rip), %rsi    # 0x516013
leaq 0x2dee34(%rip), %rdx    # 0x585879
leaq 0x2dee43(%rip), %rcx    # 0x58588f
leaq 0x2de55d(%rip), %r8     # 0x584fb0
movl $0x19b, %r9d            # imm = 0x19B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a6a67
movq 0x10(%rsp), %rax
movq 0x868(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x910(%rcx), %rax
jne 0x2a6ad7
movq 0x10(%rsp), %rax
movq 0x910(%rax), %rcx
addq $0x4000, %rcx           # imm = 0x4000
movq %rcx, 0x910(%rax)
movq 0x10(%rsp), %rax
movq 0x908(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x910(%rax), %rsi
shlq $0x3, %rsi
leaq 0x2de4f2(%rip), %rdx    # 0x584fb0
movl $0x1a0, %ecx            # imm = 0x1A0
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x908(%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x908(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x868(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x868(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x868(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_init_seppos
static void gt_reads2twobit_init_seppos(GtReads2TwobitEncodeState *state,
    GtUword currentpos)
{
  gt_assert(state->seppos == NULL);
  gt_assert(currentpos > 0);
  gt_assert(state->inputfiles_totallength > currentpos);
  state->seppos_alloc = state->inputfiles_totallength / currentpos;
  gt_log_log("rough estimate of nofseqs = "GT_WU"", state->seppos_alloc);
  state->seppos = gt_malloc(sizeof (state->seppos) * state->seppos_alloc);
  state->current.seppos_nextfree = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x908(%rax)
je 0x2a6f25
movq 0x3950ac(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26f115(%rip), %rsi    # 0x516013
leaq 0x2deb0a(%rip), %rdx    # 0x585a0f
leaq 0x2deb19(%rip), %rcx    # 0x585a25
leaq 0x2de09d(%rip), %r8     # 0x584fb0
movl $0x18d, %r9d            # imm = 0x18D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a6f27
jmp 0x2a6f29
cmpq $0x0, 0x8(%rsp)
ja 0x2a6f69
movq 0x395068(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26f0d1(%rip), %rsi    # 0x516013
leaq 0x2deaf8(%rip), %rdx    # 0x585a41
leaq 0x2dead5(%rip), %rcx    # 0x585a25
leaq 0x2de059(%rip), %r8     # 0x584fb0
movl $0x18e, %r9d            # imm = 0x18E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a6f6b
jmp 0x2a6f6d
movq 0x10(%rsp), %rax
movq 0x800(%rax), %rax
cmpq 0x8(%rsp), %rax
ja 0x2a6fb8
movq 0x395019(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26f082(%rip), %rsi    # 0x516013
leaq 0x2deab8(%rip), %rdx    # 0x585a50
leaq 0x2dea86(%rip), %rcx    # 0x585a25
leaq 0x2de00a(%rip), %r8     # 0x584fb0
movl $0x18f, %r9d            # imm = 0x18F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a6fba
movq 0x10(%rsp), %rax
movq 0x800(%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x8(%rsp)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x910(%rax)
movq 0x10(%rsp), %rax
movq 0x910(%rax), %rsi
leaq 0x2dea8a(%rip), %rdi    # 0x585a7b
movb $0x0, %al
callq 0xe7740
movq 0x10(%rsp), %rax
movq 0x910(%rax), %rdi
shlq $0x3, %rdi
leaq 0x2ddfa1(%rip), %rsi    # 0x584fb0
movl $0x192, %edx            # imm = 0x192
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x908(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x868(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_tbe_flush_and_realloc
static void gt_reads2twobit_tbe_flush_and_realloc(GtReads2Twobit *r2t,
    GtReads2TwobitEncodeState *state)
{
  if (state->current.codepos > 0)
  {
    GtUword shift = (GT_UNITSIN2BITENC - state->current.codepos) << 1UL;
    *(state->current.tbe_next++) =
      (GtTwobitencoding)(state->current.kmercode << shift);
  }
  if (state->current.nofseqs > 0)
  {
    gt_log_log("realloc tbe, total_seqlength = "GT_WU", nofseqs = "GT_WU"",
        r2t->total_seqlength, state->current.nofseqs);
    gt_assert(r2t->total_seqlength > 0);
    r2t->twobitencoding = gt_realloc(r2t->twobitencoding,
        sizeof (*r2t->twobitencoding) *
        (GT_DIVBYUNITSIN2BITENC(r2t->total_seqlength) + 2UL));
  }
  else
  {
    gt_free(r2t->twobitencoding);
    r2t->twobitencoding = NULL;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzwl 0x830(%rax), %eax
cmpl $0x0, %eax
jle 0x2a866d
movq 0x8(%rsp), %rax
movzwl 0x830(%rax), %ecx
movl $0x20, %eax
subl %ecx, %eax
shll %eax
cltq
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x828(%rax), %rax
movq (%rsp), %rcx
shlq %cl, %rax
movq %rax, %rcx
movq 0x8(%rsp), %rdx
movq 0x820(%rdx), %rax
movq %rax, %rsi
addq $0x8, %rsi
movq %rsi, 0x820(%rdx)
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x860(%rax)
jbe 0x2a8726
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x860(%rax), %rdx
leaq 0x2dd68e(%rip), %rdi    # 0x585d2a
movb $0x0, %al
callq 0xe7740
movq 0x10(%rsp), %rax
cmpq $0x0, 0x60(%rax)
ja 0x2a86e7
movq 0x3938ea(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26d953(%rip), %rsi    # 0x516013
leaq 0x2dd695(%rip), %rdx    # 0x585d5c
leaq 0x2dd6a7(%rip), %rcx    # 0x585d75
leaq 0x2dc8db(%rip), %r8     # 0x584fb0
movl $0x559, %r9d            # imm = 0x559
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a86e9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rsi
shrq $0x5, %rsi
addq $0x2, %rsi
shlq $0x3, %rsi
leaq 0x2dc8a2(%rip), %rdx    # 0x584fb0
movl $0x55c, %ecx            # imm = 0x55C
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2a874d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2dc87a(%rip), %rsi    # 0x584fb0
movl $0x560, %edx            # imm = 0x560
callq 0xe88c0
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_zeropad_tbe
static void gt_reads2twobit_zeropad_tbe(GtReads2Twobit *r2t)
{
  GtUword pos, codenum, posincode, shift;
  pos = r2t->total_seqlength - 1UL;
  codenum = GT_DIVBYUNITSIN2BITENC(pos);
  posincode = GT_MODBYUNITSIN2BITENC(pos);
  if (posincode < (GtUword)GT_UNITSIN2BITENC - 1UL)
  {
    shift = GT_MULT2(GT_UNITSIN2BITENC - 1UL - posincode);
    r2t->twobitencoding[codenum] =
      (GtTwobitencoding)((r2t->twobitencoding[codenum] >> shift) << shift);
  }
  r2t->twobitencoding[codenum + 1UL] = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x60(%rax), %rax
subq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x5, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
andq $0x1f, %rax
movq %rax, -0x20(%rsp)
cmpq $0x1f, -0x20(%rsp)
jae 0x2a8c01
movl $0x1f, %eax
subq -0x20(%rsp), %rax
shlq %rax
movq %rax, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rsp), %rcx
shrq %cl, %rdx
movq -0x28(%rsp), %rcx
shlq %cl, %rdx
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads2twobit.c
// Function: gt_reads2twobit_less_frequent_char
static inline GtTwobitencoding gt_reads2twobit_less_frequent_char(
    GtReads2Twobit *r2t)
{
  GtTwobitencoding i, code;
  GtUword lowest_value, value;
  lowest_value = r2t->chardistri[0];
  code = 0;
  for (i = (GtTwobitencoding)1;
      i < (GtTwobitencoding)GT_READS2TWOBIT_ALPHASIZE; i++)
  {
    value = r2t->chardistri[i];
    if (value < lowest_value)
    {
      lowest_value = value;
      code = i;
    }
  }
  gt_log_log("less frequent char code: "GT_WU"", (GtUword)code);
  return code;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
cmpq $0x4, 0x18(%rsp)
jae 0x2a8c94
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x2a8c82
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2a8c84
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2a8c49
movq 0x10(%rsp), %rsi
leaq 0x2dd1cc(%rip), %rdi    # 0x585e6c
movb $0x0, %al
callq 0xe7740
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_new
GtReadsLibrariesTable* gt_reads_libraries_table_new(GtUword noflibraries)
{
  GtReadsLibrariesTable *rlt;
  gt_assert(noflibraries > 0);
  rlt = gt_malloc(sizeof (*rlt));
  rlt->library = gt_malloc(sizeof (*rlt->library) * noflibraries);
  rlt->noflibraries = noflibraries;
  rlt->nextfreelibrary = 0;
  rlt->firstunpaired = GT_UNDEF_UWORD;
  return rlt;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x2a8d09
movq 0x3932c8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26d331(%rip), %rsi    # 0x516013
leaq 0x2dd360(%rip), %rdx    # 0x586049
leaq 0x2dd1d1(%rip), %rcx    # 0x585ec1
leaq 0x2dd1e7(%rip), %r8     # 0x585ede
movl $0x28, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a8d0b
movl $0x20, %edi
leaq 0x2dd1c7(%rip), %rsi    # 0x585ede
movl $0x29, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
imulq $0x18, 0x10(%rsp), %rdi
leaq 0x2dd1ab(%rip), %rsi    # 0x585ede
movl $0x2a, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%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 $-0x1, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_get_library
void gt_reads_libraries_table_get_library(GtReadsLibrariesTable *rlt,
    GtUword libnum, GtUword *first_seqnum,
    GtUword *insertlength, GtUword *stdev)
{
  gt_assert(rlt != NULL);
  gt_assert(libnum < rlt->noflibraries);
  if (first_seqnum != NULL)
    *first_seqnum = rlt->library[libnum].first_seqnum;
  if (insertlength != NULL)
    *insertlength = rlt->library[libnum].insertlength;
  if (stdev != NULL)
    *stdev = rlt->library[libnum].stdev;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2a900c
movq 0x392fc5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26d02e(%rip), %rsi    # 0x516013
leaq 0x2dcf14(%rip), %rdx    # 0x585f00
leaq 0x2dcfa6(%rip), %rcx    # 0x585f99
leaq 0x2dcee4(%rip), %r8     # 0x585ede
movl $0x59, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a900e
jmp 0x2a9010
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x2a9057
movq 0x392f7a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26cfe3(%rip), %rsi    # 0x516013
leaq 0x2dcf87(%rip), %rdx    # 0x585fbe
leaq 0x2dcf5b(%rip), %rcx    # 0x585f99
leaq 0x2dce99(%rip), %r8     # 0x585ede
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a9059
cmpq $0x0, 0x10(%rsp)
je 0x2a907e
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x18, 0x18(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0x2a90a4
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x18, 0x18(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rsp)
je 0x2a90c8
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x18, 0x18(%rsp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/reads_libraries_table.c
// Function: gt_reads_libraries_table_save
void gt_reads_libraries_table_save(GtReadsLibrariesTable *rlt, FILE *rlt_fp)
{
  gt_assert(rlt != NULL);
  gt_assert(rlt_fp != NULL);
  gt_xfwrite(&(rlt->noflibraries), sizeof (rlt->noflibraries), (size_t)1,
      rlt_fp);
  gt_xfwrite(&(rlt->firstunpaired), sizeof (rlt->firstunpaired), (size_t)1,
      rlt_fp);
  gt_assert(rlt->noflibraries > 0);
  gt_xfwrite(&(rlt->library), sizeof (*(rlt->library)),
      (size_t)rlt->noflibraries, rlt_fp);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2a91be
movq 0x392e13(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26ce7c(%rip), %rsi    # 0x516013
leaq 0x2dcd62(%rip), %rdx    # 0x585f00
leaq 0x2dce81(%rip), %rcx    # 0x586026
leaq 0x2dcd32(%rip), %r8     # 0x585ede
movl $0x71, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a91c0
jmp 0x2a91c2
cmpq $0x0, 0x8(%rsp)
jne 0x2a9202
movq 0x392dcf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26ce38(%rip), %rsi    # 0x516013
leaq 0x2d735f(%rip), %rdx    # 0x580541
leaq 0x2dce3d(%rip), %rcx    # 0x586026
leaq 0x2dccee(%rip), %r8     # 0x585ede
movl $0x72, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a9204
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x126d30
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
ja 0x2a927d
movq 0x392d54(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26cdbd(%rip), %rsi    # 0x516013
leaq 0x2dcde7(%rip), %rdx    # 0x586044
leaq 0x2dcdc2(%rip), %rcx    # 0x586026
leaq 0x2dcc73(%rip), %r8     # 0x585ede
movl $0x77, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a927f
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rcx
movl $0x18, %esi
callq 0x126d30
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_store_new
GtArrayGtDiagbandseedRectangle *gt_rectangle_store_new(void)
{
  GtArrayGtDiagbandseedRectangle *rectangle_store
    = gt_malloc(sizeof *rectangle_store);
  GT_INITARRAY(rectangle_store,GtDiagbandseedRectangle);
  return rectangle_store;
}

// Assembly:
pushq %rax
movl $0x18, %edi
leaq 0x2dcc32(%rip), %rsi    # 0x5860df
movl $0x2a, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_cmp
static int gt_rectangle_cmp(const GtDiagbandseedRectangle *l,
                            const GtDiagbandseedRectangle *r)
{
  if (l->a_end < r->a_end)
  {
    return -1;
  }
  if (l->a_end > r->a_end)
  {
    return 1;
  }
  if (l->b_end < r->b_end)
  {
    return -1;
  }
  if (l->b_end > r->b_end)
  {
    return 1;
  }
  /*
  fprintf(stderr,"%s: cmp(%u,%u)(%u,%u) vs (%u,%u)(%u,%u)\n",__func__,
                  l->a_start,l->a_end,l->b_start,l->b_end,
                  r->a_start,r->a_end,r->b_start,r->b_end);
  */
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2a97a6
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a9802
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jbe 0x2a97c2
movl $0x1, -0x4(%rsp)
jmp 0x2a9802
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x2a97de
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a9802
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x2a97fa
movl $0x1, -0x4(%rsp)
jmp 0x2a9802
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_previous_equal
const GtDiagbandseedRectangle *gt_rectangle_previous_equal(
                   const GtArrayGtDiagbandseedRectangle *rectangle_store,
                   const GtDiagbandseedRectangle *key)
{
  const GtDiagbandseedRectangle
    *midptr,
    *found = NULL,
    *leftptr = rectangle_store->spaceGtDiagbandseedRectangle,
    *rightptr = leftptr + rectangle_store->nextfreeGtDiagbandseedRectangle - 1;

  while (leftptr <= rightptr)
  {
    midptr = leftptr + (GtUword) (rightptr-leftptr)/2;
    if (gt_rectangle_cmp(key,midptr) < 0)
    {
      rightptr = midptr - 1;
    } else
    {
      /* Now key *midptr <= key. Hence *midptr satisfies the
         requirement, but it may not be the largest element <= key. */
      found = midptr;
      /* if *midptr < key, then there may be a larger element and
         therefore we search for it in the range
         midptr+1 .. rightptr. if *midptr == key, then we have found
         the largest element and we can stop the search. */
      if (gt_rectangle_cmp(key,midptr) > 0)
      {
        leftptr = midptr + 1;
      } else
      {
        break;
      }
    }
  }
  /* if found == NULL, then we have never seen an element <= key and
     so we return NULL. Otherwise found has been set in the else case
     of the loop */
  return found;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0x2a98e2
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
shrq %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2a9780
cmpl $0x0, %eax
jge 0x2a98ab
movq 0x20(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x2a98dd
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2a9780
cmpl $0x0, %eax
jle 0x2a98d9
movq 0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x2a98db
jmp 0x2a98e2
jmp 0x2a98dd
jmp 0x2a9852
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_overlap
bool gt_rectangle_overlap(
                   const GtArrayGtDiagbandseedRectangle *rectangle_store,
                   const GtDiagbandseedRectangle *key)
{
  const GtDiagbandseedRectangle *ptr;
/*
    = gt_rectangle_previous_equal(rectangle_store,key)
*/
   ;

/*
  if (ptr == NULL)
  {
    ptr = rectangle_store->spaceGtDiagbandseedRectangle;
  }
*/
  ptr = rectangle_store->spaceGtDiagbandseedRectangle;
  while (ptr < rectangle_store->spaceGtDiagbandseedRectangle +
               rectangle_store->nextfreeGtDiagbandseedRectangle)
  {
    if (ptr->a_start <= key->a_end && ptr->a_end >= key->a_start &&
        ptr->b_start <= key->b_end && ptr->b_end >= key->b_start)
    {
      return true;
    }
    ptr++;
  }
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq -0x10(%rsp), %rdx
movq 0x10(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x2a9986
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
ja 0x2a9976
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jb 0x2a9976
movq -0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
ja 0x2a9976
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x2a9976
movb $0x1, -0x1(%rsp)
jmp 0x2a998b
movq -0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rsp)
jmp 0x2a9907
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/rectangle-store.c
// Function: gt_rectangle_store_show
void gt_rectangle_store_show(const GtArrayGtDiagbandseedRectangle
                                *rectangle_store)
{
  const GtDiagbandseedRectangle *key;

  printf("# %s\n",__func__);
  for (key = rectangle_store->spaceGtDiagbandseedRectangle;
       key < rectangle_store->spaceGtDiagbandseedRectangle +
             rectangle_store->nextfreeGtDiagbandseedRectangle; key++)
  {
     printf("# %u %u %u %u\n",key->a_start,key->a_end,
                              key->b_start,key->b_end);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x2dc79a(%rip), %rdi    # 0x58614a
leaq 0x2dc799(%rip), %rsi    # 0x586150
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rsp), %rdx
movq 0x10(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x2a9a2b
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edx
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl 0xc(%rax), %r8d
leaq 0x2dc754(%rip), %rdi    # 0x586168
movb $0x0, %al
callq 0x19070
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x2a99cb
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_reverse_complement
void gt_inplace_reverse_complement(GtUchar *seq,GtUword len)
{
  GtUchar tmp, *frontptr, *backptr;

  for (frontptr = seq, backptr = seq + len - 1;
       frontptr <= backptr; frontptr++, backptr--)
  {
    tmp = *frontptr;
    gt_assert((GT_ISSPECIAL(*backptr) || *backptr < 4) &&
              (GT_ISSPECIAL(tmp) || tmp < 4));
    *frontptr = GT_ISSPECIAL(*backptr) ? *backptr : GT_COMPLEMENTBASE(*backptr);
    *backptr = GT_ISSPECIAL(tmp) ? tmp : GT_COMPLEMENTBASE(tmp);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
addq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x2a9b74
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0x27(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jge 0x2a9a92
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x4, %eax
jge 0x2a9aa8
movzbl 0x27(%rsp), %eax
cmpl $0xfe, %eax
jge 0x2a9ae0
movzbl 0x27(%rsp), %eax
cmpl $0x4, %eax
jl 0x2a9ae0
movq 0x3924f1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26c55a(%rip), %rsi    # 0x516013
leaq 0x2dc6b7(%rip), %rdx    # 0x586177
leaq 0x2dc6fb(%rip), %rcx    # 0x5861c2
leaq 0x2dc712(%rip), %r8     # 0x5861e0
movl $0x20, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a9ae2
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jl 0x2a9aff
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x2a9b12
movq 0x10(%rsp), %rax
movzbl (%rax), %ecx
movl $0x3, %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movzbl 0x27(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2a9b36
movzbl 0x27(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x2a9b46
movzbl 0x27(%rsp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2a9a5b
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_reverse
void gt_inplace_reverse(GtUchar *seq,GtUword len)
{
  GtUchar tmp, *frontptr, *backptr;

  for (frontptr = seq, backptr = seq + len - 1;
       frontptr < backptr; frontptr++, backptr--)
  {
    tmp = *frontptr;
    *frontptr = *backptr;
    *backptr = tmp;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
addq -0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x2a9bf5
movq -0x20(%rsp), %rax
movb (%rax), %al
movb %al, -0x11(%rsp)
movq -0x28(%rsp), %rax
movb (%rax), %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movb -0x11(%rsp), %cl
movq -0x28(%rsp), %rax
movb %cl, (%rax)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x2a9ba7
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/revcompl.c
// Function: gt_inplace_complement
void gt_inplace_complement(GtUchar *seq,GtUword len)
{
  GtUchar *ptr;

  for (ptr = seq; ptr < seq + len; ptr++)
  {
    gt_assert(GT_ISSPECIAL(*ptr) || *ptr < 4);
    *ptr = GT_COMPLEMENTBASE(*ptr);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2a9ca7
jmp 0x2a9c2c
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jge 0x2a9c7e
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x4, %eax
jl 0x2a9c7e
movq 0x392353(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26c3bc(%rip), %rsi    # 0x516013
leaq 0x2dc597(%rip), %rdx    # 0x5861f5
leaq 0x2dc5af(%rip), %rcx    # 0x586214
leaq 0x2dc574(%rip), %r8     # 0x5861e0
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2a9c80
movq (%rsp), %rax
movzbl (%rax), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, (%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2a9c17
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/revcompl.c
// Function: gt_copy_reverse_complement
void gt_copy_reverse_complement(GtUchar *dest,const GtUchar *src,
                               GtUword len)
{
  GtUchar *destptr;
  const GtUchar *srcptr;

  for (destptr = dest, srcptr = src + len - 1;
       destptr < dest + len; destptr++, srcptr--)
  {
    *destptr = GT_COMPLEMENTBASE(*srcptr);
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
addq -0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
addq -0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2a9d26
movq -0x28(%rsp), %rax
movzbl (%rax), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x2a9cdc
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_delete
void gt_seedextend_match_iterator_delete(GtSeedextendMatchIterator *semi)
{
  if (semi == NULL)
  {
    return;
  }
  gt_str_delete(semi->ii);
  gt_str_delete(semi->qii);
  gt_encseq_delete(semi->aencseq);
  gt_encseq_delete(semi->bencseq);
  gt_str_delete(semi->line_buffer);
  gt_querymatch_delete(semi->querymatchptr);
  GT_FREEARRAY(&semi->querymatch_table,GtQuerymatch);
  gt_querymatchoutoptions_delete(semi->querymatchoutoptions);
  if (semi->inputfileptr != NULL)
  {
    fclose(semi->inputfileptr);
  }
  gt_querymatch_display_flag_delete(semi->in_display_flag);
  gt_str_delete(semi->saved_options_line);
  gt_free(semi);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2a9d41
jmp 0x2a9e44
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xae070
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xae070
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x267b60
movq (%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x2a9de5
movq (%rsp), %rax
movq 0x88(%rax), %rdi
leaq 0x2dc47c(%rip), %rsi    # 0x58622a
movl $0x3b, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x90(%rax)
movq (%rsp), %rax
movq $0x0, 0x98(%rax)
movq (%rsp), %rax
movq $0x0, 0x88(%rax)
jmp 0x2a9de7
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x263f10
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2a9e0f
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x19780
movq (%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x265d20
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x11f560
movq (%rsp), %rdi
leaq 0x2dc3f0(%rip), %rsi    # 0x58622a
movl $0x43, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/seed-extend-iter.c
// Function: gt_seedextend_match_iterator_trace_delta
GtUword gt_seedextend_match_iterator_trace_delta(
                        const GtSeedextendMatchIterator *semi)
{
  gt_assert(semi != NULL);
  return (gt_querymatch_trace_display(semi->in_display_flag) ||
          gt_querymatch_dtrace_display(semi->in_display_flag))
           ? semi->trace_delta : 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2aac39
movq 0x391398(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x26b401(%rip), %rsi    # 0x516013
leaq 0x2cba1c(%rip), %rdx    # 0x576635
leaq 0x2db8af(%rip), %rcx    # 0x5864cf
leaq 0x2db603(%rip), %r8     # 0x58622a
movl $0x1b1, %r9d            # imm = 0x1B1
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2aac3b
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x265830
testb $0x1, %al
jne 0x2aac67
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x265850
testb $0x1, %al
jne 0x2aac67
jmp 0x2aac7a
movq 0x10(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2aac83
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x2aac83
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)