LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_guess
GtAlphabet* gt_alphabet_guess(const char *sequence, GtUword seqlen)
{
  GtUword i;
  gt_assert(sequence && seqlen);
  for (i = 0;
       i < seqlen && i < (GtUword) ALPHABET_GUESS_MAX_LENGTH;
        i++) {
    if (strchr(ALPHABET_GUESS_PROTEIN_CHARS, sequence[i]) != NULL)
      return gt_alphabet_new_protein();
  }
  return gt_alphabet_new_dna();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x109c8e
cmpq $0x0, 0x10(%rsp)
jne 0x109cc6
movq 0xaa343(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x543c7(%rip), %rsi     # 0x15e066
leaq 0x79e57(%rip), %rdx     # 0x183afd
leaq 0x79e63(%rip), %rcx     # 0x183b10
leaq 0x79d6e(%rip), %r8      # 0x183a22
movl $0x27b, %r9d            # imm = 0x27B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x109cc8
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x10(%rsp), %rcx
movb %al, 0x7(%rsp)
jae 0x109cf3
cmpq $0x1388, 0x8(%rsp)      # imm = 0x1388
setb %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x109cfd
jmp 0x109d3b
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x79e10(%rip), %rdi     # 0x183b22
callq 0xb1f0
cmpq $0x0, %rax
je 0x109d29
callq 0x109af0
movq %rax, 0x20(%rsp)
jmp 0x109d45
jmp 0x109d2b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x109cd1
callq 0x109990
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_output
void gt_alphabet_output(const GtAlphabet *alphabet, FILE *fpout)
{
  GtStr *buf;
  gt_assert(alphabet && fpout);
  buf = gt_str_new();
  gt_alphabet_to_str(alphabet, buf);
  gt_xfwrite(gt_str_get(buf), sizeof (char), (size_t) gt_str_length(buf),
             fpout);
  gt_str_delete(buf);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x10a1de
cmpq $0x0, 0x18(%rsp)
jne 0x10a216
movq 0xa9df3(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x53e77(%rip), %rsi     # 0x15e066
leaq 0x79a12(%rip), %rdx     # 0x183c08
leaq 0x79a1d(%rip), %rcx     # 0x183c1a
leaq 0x7981e(%rip), %r8      # 0x183a22
movl $0x2e6, %r9d            # imm = 0x2E6
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10a218
callq 0x18f00
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x109f50
movq 0x10(%rsp), %rdi
callq 0x19940
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x19a00
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x1cab0
movq 0x10(%rsp), %rdi
callq 0x1afc0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode_seq_to_fp
void gt_alphabet_decode_seq_to_fp(const GtAlphabet *alphabet, FILE *fpout,
                                  const GtUchar *src, GtUword len)
{
  GtUword i;
  const GtUchar *characters;
  gt_assert(fpout != NULL && (len == 0 || src != NULL));

  if (alphabet == NULL)
  {
    characters = (const GtUchar *) "acgt";
  } else
  {
    characters = alphabet->characters;
  }
  for (i = 0; i < len; i++)
  {
    gt_xfputc((int) characters[(int) src[i]],fpout);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x10a2a0
cmpq $0x0, 0x18(%rsp)
je 0x10a2d8
cmpq $0x0, 0x20(%rsp)
jne 0x10a2d8
movq 0xa9d31(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x53db5(%rip), %rsi     # 0x15e066
leaq 0x79975(%rip), %rdx     # 0x183c2d
leaq 0x79999(%rip), %rcx     # 0x183c58
leaq 0x7975c(%rip), %r8      # 0x183a22
movl $0x2f3, %r9d            # imm = 0x2F3
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10a2da
cmpq $0x0, 0x30(%rsp)
jne 0x10a2f0
leaq 0x7998c(%rip), %rax     # 0x183c75
movq %rax, 0x8(%rsp)
jmp 0x10a301
movq 0x30(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x10a34a
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
movq 0x28(%rsp), %rsi
callq 0x1c8f0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x10a30a
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode_seq_to_cstr
void gt_alphabet_decode_seq_to_cstr(const GtAlphabet *alphabet, char *dest,
                                    const GtUchar *src, GtUword len)
{
  GtUword i;

  for (i = 0; i < len; i++)
  {
    dest[i] = converttoprettysymbol(alphabet, (GtUchar) src[i]);
  }
  dest[len] = '\0';
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x10a3ee
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x10a410
movb %al, %dl
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x10a3b0
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: converttoprettysymbol
static inline char converttoprettysymbol(const GtAlphabet *alphabet,
                                         GtUchar currentchar)
{
  gt_assert(alphabet != NULL && currentchar != (GtUchar) GT_SEPARATOR);
  if (currentchar < (GtUchar) GT_WILDCARD)
  {
    gt_assert((unsigned int) currentchar < alphabet->mapsize-1);
    return (char) alphabet->characters[(int) currentchar];
  } else return (char) alphabet->wildcardshow;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x8(%rsp)
movb %al, 0x7(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10a434
movzbl 0x7(%rsp), %eax
cmpl $0xff, %eax
jne 0x10a46c
movq 0xa9b9d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x53c21(%rip), %rsi     # 0x15e066
leaq 0x79adf(%rip), %rdx     # 0x183f2b
leaq 0x79b12(%rip), %rcx     # 0x183f65
leaq 0x795c8(%rip), %r8      # 0x183a22
movl $0x30b, %r9d            # imm = 0x30B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10a46e
movzbl 0x7(%rsp), %eax
cmpl $0xfe, %eax
jge 0x10a4e7
jmp 0x10a47c
movzbl 0x7(%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jb 0x10a4c8
movq 0xa9b41(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x53bc5(%rip), %rsi     # 0x15e066
leaq 0x79ad3(%rip), %rdx     # 0x183f7b
leaq 0x79ab6(%rip), %rcx     # 0x183f65
leaq 0x7956c(%rip), %r8      # 0x183a22
movl $0x30e, %r9d            # imm = 0x30E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10a4ca
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rax
movzbl 0x7(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, 0x17(%rsp)
jmp 0x10a4f3
movq 0x8(%rsp), %rax
movb 0x14(%rax), %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode_seq_to_str
GtStr* gt_alphabet_decode_seq_to_str(const GtAlphabet *alphabet,
                                     const GtUchar *src,
                                     GtUword len)
{
  char *buffer;
  GtStr *ret;
  gt_assert(alphabet && src);
  buffer = gt_malloc(sizeof (char) * len+1);
  gt_alphabet_decode_seq_to_cstr(alphabet, buffer, src, len);
  ret = gt_str_new_cstr(buffer);
  gt_free(buffer);
  return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x10a523
cmpq $0x0, 0x18(%rsp)
jne 0x10a55b
movq 0xa9aae(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x53b32(%rip), %rsi     # 0x15e066
leaq 0x7973f(%rip), %rdx     # 0x183c7a
leaq 0x79748(%rip), %rcx     # 0x183c8a
leaq 0x794d9(%rip), %r8      # 0x183a22
movl $0x325, %r9d            # imm = 0x325
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10a55d
movq 0x10(%rsp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
leaq 0x794b1(%rip), %rsi     # 0x183a22
movl $0x326, %edx            # imm = 0x326
callq 0xd2e0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x10a390
movq 0x8(%rsp), %rdi
callq 0x18f70
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x7946f(%rip), %rsi     # 0x183a22
movl $0x329, %edx            # imm = 0x329
callq 0xdab0
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_is_protein
bool gt_alphabet_is_protein(const GtAlphabet *alphabet)
{
  GtAlphabet proteinalphabet;
  unsigned int reduceddomainsize1, reduceddomainsize2;
  bool isprot;
  GtUchar domainbuf1[GT_MAXALPHABETCHARACTER+1],
        domainbuf2[GT_MAXALPHABETCHARACTER+1];

  reduceddomainsize1 = removelowercaseproteinchars(&domainbuf1[0],alphabet);
  assign_protein_alphabet(&proteinalphabet);
  reduceddomainsize2 = removelowercaseproteinchars(&domainbuf2[0],
                                                   &proteinalphabet);
  if (reduceddomainsize1 == reduceddomainsize2)
  {
    qsort(&domainbuf1[0],(size_t) reduceddomainsize1,sizeof (char),comparechar);
    qsort(&domainbuf2[0],(size_t) reduceddomainsize2,sizeof (char),comparechar);
    if (memcmp((const void *) domainbuf1,(const void *) domainbuf2,
               reduceddomainsize2 * sizeof (GtUchar)) == 0)
    {
      isprot = true;
    } else
    {
      isprot = false;
    }
  } else
  {
    isprot = false;
  }
  gt_free(proteinalphabet.mapdomain);
  gt_free(proteinalphabet.characters);
  return isprot;
}

// Assembly:
subq $0x358, %rsp            # imm = 0x358
movq %rdi, 0x350(%rsp)
leaq 0x100(%rsp), %rdi
movq 0x350(%rsp), %rsi
callq 0x10a7a0
movl %eax, 0x214(%rsp)
leaq 0x218(%rsp), %rdi
callq 0x109b50
movq %rsp, %rdi
leaq 0x218(%rsp), %rsi
callq 0x10a7a0
movl %eax, 0x210(%rsp)
movl 0x214(%rsp), %eax
cmpl 0x210(%rsp), %eax
jne 0x10a754
leaq 0x100(%rsp), %rdi
movl 0x214(%rsp), %eax
movl %eax, %esi
movl $0x1, %edx
leaq 0x184(%rip), %rcx       # 0x10a880
callq 0xbc40
movq %rsp, %rdi
movl 0x210(%rsp), %eax
movl %eax, %esi
movl $0x1, %edx
leaq 0x167(%rip), %rcx       # 0x10a880
callq 0xbc40
leaq 0x100(%rsp), %rdi
movq %rsp, %rsi
movl 0x210(%rsp), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0xb250
cmpl $0x0, %eax
jne 0x10a74a
movb $0x1, 0x20f(%rsp)
jmp 0x10a752
movb $0x0, 0x20f(%rsp)
jmp 0x10a75c
movb $0x0, 0x20f(%rsp)
movq 0x330(%rsp), %rdi
leaq 0x792b7(%rip), %rsi     # 0x183a22
movl $0x375, %edx            # imm = 0x375
callq 0xdab0
movq 0x338(%rsp), %rdi
leaq 0x7929e(%rip), %rsi     # 0x183a22
movl $0x376, %edx            # imm = 0x376
callq 0xdab0
movb 0x20f(%rsp), %al
andb $0x1, %al
addq $0x358, %rsp            # imm = 0x358
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: removelowercaseproteinchars
static unsigned int removelowercaseproteinchars(GtUchar *domainbuf,
                                                const GtAlphabet *alpha)
{
  unsigned int i, j = 0;

  for (i=0; i< alpha->domainsize - alpha->mappedwildcards; i++)
  {
    if (isalnum((int) alpha->mapdomain[i]) &&
        isupper((int) alpha->mapdomain[i]))
    {
      domainbuf[j++] = alpha->mapdomain[i];
    }
  }
  return j;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, (%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
movq 0x8(%rsp), %rdx
subl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x10a86a
callq 0xb6b0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x118(%rcx), %rcx
movl 0x4(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10a858
callq 0xb6b0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x118(%rcx), %rcx
movl 0x4(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x10a858
movq 0x8(%rsp), %rax
movq 0x118(%rax), %rax
movl 0x4(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movl (%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rsp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x10a85a
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x10a7bd
movl (%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: comparechar
static int comparechar(const void *a,const void *b)
{
  if (UNCAST(a) < UNCAST(b))
  {
    return -1;
  }
  if (UNCAST(a) > UNCAST(b))
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movq -0x18(%rsp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x10a8a8
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x10a8ce
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movq -0x18(%rsp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x10a8c6
movl $0x1, -0x4(%rsp)
jmp 0x10a8ce
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_is_dna
bool gt_alphabet_is_dna(const GtAlphabet *alphabet)
{
  if (gt_alphabet_is_protein(alphabet))
  {
    return false;
  }
  if (alphabet->mapsize == MAPSIZEDNA)
  {
    GtUchar dnasymbolmap[GT_MAXALPHABETCHARACTER+1];

    assign_dna_symbolmap(&dnasymbolmap[0]);
    if (check_symbolmap(alphabet->symbolmap,&dnasymbolmap[0],"acgt"))
    {
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x108(%rsp)
movq 0x108(%rsp), %rdi
callq 0x10a680
testb $0x1, %al
jne 0x10a902
jmp 0x10a90c
movb $0x0, 0x117(%rsp)
jmp 0x10a957
movq 0x108(%rsp), %rax
cmpl $0x5, 0x4(%rax)
jne 0x10a94f
movq %rsp, %rdi
callq 0x10a970
movq 0x108(%rsp), %rdi
addq $0x15, %rdi
movq %rsp, %rsi
leaq 0x7933d(%rip), %rdx     # 0x183c75
callq 0x10aa50
testb $0x1, %al
jne 0x10a943
jmp 0x10a94d
movb $0x1, 0x117(%rsp)
jmp 0x10a957
jmp 0x10a94f
movb $0x0, 0x117(%rsp)
movb 0x117(%rsp), %al
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: assign_dna_symbolmap
static void assign_dna_symbolmap(GtUchar *symbolmap)
{
  unsigned int cnum;

  for (cnum=0; cnum<=(unsigned int) GT_MAXALPHABETCHARACTER; cnum++)
  {
    symbolmap[cnum] = (GtUchar) GT_UNDEFCHAR;
  }
  symbolmap[(unsigned int) 'a'] = (GtUchar) 0;
  symbolmap[(unsigned int) 'A'] = (GtUchar) 0;
  symbolmap[(unsigned int) 'c'] = (GtUchar) 1;
  symbolmap[(unsigned int) 'C'] = (GtUchar) 1;
  symbolmap[(unsigned int) 'g'] = (GtUchar) 2;
  symbolmap[(unsigned int) 'G'] = (GtUchar) 2;
  symbolmap[(unsigned int) 't'] = (GtUchar) 3;
  symbolmap[(unsigned int) 'T'] = (GtUchar) 3;
  symbolmap[(unsigned int) 'u'] = (GtUchar) 3;
  symbolmap[(unsigned int) 'U'] = (GtUchar) 3;
  for (cnum=0; DNAWILDCARDS[cnum] != '\0'; cnum++)
  {
    symbolmap[(unsigned int) DNAWILDCARDS[cnum]] = (GtUchar) GT_WILDCARD;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0xff, -0xc(%rsp)
ja 0x10a9a1
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movb $-0x3, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x10a97d
movq -0x8(%rsp), %rax
movb $0x0, 0x61(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x41(%rax)
movq -0x8(%rsp), %rax
movb $0x1, 0x63(%rax)
movq -0x8(%rsp), %rax
movb $0x1, 0x43(%rax)
movq -0x8(%rsp), %rax
movb $0x2, 0x67(%rax)
movq -0x8(%rsp), %rax
movb $0x2, 0x47(%rax)
movq -0x8(%rsp), %rax
movb $0x3, 0x74(%rax)
movq -0x8(%rsp), %rax
movb $0x3, 0x54(%rax)
movq -0x8(%rsp), %rax
movb $0x3, 0x75(%rax)
movq -0x8(%rsp), %rax
movb $0x3, 0x55(%rax)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x794d2(%rip), %rax     # 0x183ee2
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x10aa42
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %ecx, %edx
leaq 0x794b7(%rip), %rcx     # 0x183ee2
movsbl (%rcx,%rdx), %ecx
movl %ecx, %ecx
movb $-0x2, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x10aa03
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: check_symbolmap
static bool check_symbolmap(const GtUchar *testsymbolmap,
                            const GtUchar *verifiedsymbolmap,
                            const char *testcharacters)
{
  unsigned int i;
  GtUchar cc1, cc2;

  for (i=0; testcharacters[i] != '\0'; i++)
  {
    cc1 = (GtUchar) testcharacters[i];
    if (isupper((int) cc1))
    {
      cc2 = (GtUchar) tolower((int) cc1);
    } else
    {
      gt_assert(islower((int) cc1));
      cc2 = (GtUchar) toupper((int) cc1);
    }
    if (testsymbolmap[cc1] != verifiedsymbolmap[cc1] &&
        testsymbolmap[cc2] != verifiedsymbolmap[cc2])
    {
      return false;
    }
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x10ab80
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movb (%rax,%rcx), %al
movb %al, 0x3(%rsp)
callq 0xb6b0
movq (%rax), %rax
movzbl 0x3(%rsp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x10aabf
movzbl 0x3(%rsp), %edi
callq 0xb8c0
movb %al, 0x2(%rsp)
jmp 0x10ab27
jmp 0x10aac1
callq 0xb6b0
movq (%rax), %rax
movzbl 0x3(%rsp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x10ab17
movq 0xa94f2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x53576(%rip), %rsi     # 0x15e066
leaq 0x794b5(%rip), %rdx     # 0x183fac
leaq 0x794c1(%rip), %rcx     # 0x183fbf
leaq 0x78f1d(%rip), %r8      # 0x183a22
movl $0x389, %r9d            # imm = 0x389
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10ab19
movzbl 0x3(%rsp), %edi
callq 0xbbb0
movb %al, 0x2(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x3(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq 0x10(%rsp), %rcx
movzbl 0x3(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x10ab6e
movq 0x18(%rsp), %rax
movzbl 0x2(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq 0x10(%rsp), %rcx
movzbl 0x2(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x10ab6e
movb $0x0, 0x27(%rsp)
jmp 0x10ab85
jmp 0x10ab70
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x10aa6b
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_decode
char gt_alphabet_decode(const GtAlphabet *alphabet, GtUchar c)
{
  gt_assert(alphabet);
  if (c == (GtUchar) alphabet->mapsize - 1)
    return (char) alphabet->wildcardshow;
  return converttoprettysymbol(alphabet, c);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x8(%rsp)
movb %al, 0x7(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x10ace0
movq 0xa9329(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x533ad(%rip), %rsi     # 0x15e066
leaq 0x6dd88(%rip), %rdx     # 0x178a48
leaq 0x7905e(%rip), %rcx     # 0x183d25
leaq 0x78d54(%rip), %r8      # 0x183a22
movl $0x3b8, %r9d            # imm = 0x3B8
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10ace2
movzbl 0x7(%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
movzbl %cl, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x10ad07
movq 0x8(%rsp), %rax
movb 0x14(%rax), %al
movb %al, 0x17(%rsp)
jmp 0x10ad1a
movq 0x8(%rsp), %rdi
movzbl 0x7(%rsp), %esi
callq 0x10a410
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_encode_seq
void gt_alphabet_encode_seq(const GtAlphabet *alphabet, GtUchar *out,
                            const char *in, GtUword length)
{
  GtUword i;
  gt_assert(alphabet && out && in);
  for (i = 0; i < length; i++) {
    GtUchar cc = alphabet->symbolmap[(int) in[i]];
    gt_assert(cc != (GtUchar) GT_UNDEFCHAR);
    out[i] = cc;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x10ad60
cmpq $0x0, 0x28(%rsp)
je 0x10ad60
cmpq $0x0, 0x20(%rsp)
jne 0x10ad98
movq 0xa9271(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x532f5(%rip), %rsi     # 0x15e066
leaq 0x78fc0(%rip), %rdx     # 0x183d38
leaq 0x78fcf(%rip), %rcx     # 0x183d4e
leaq 0x78c9c(%rip), %r8      # 0x183a22
movl $0x3c2, %r9d            # imm = 0x3C2
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10ad9a
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x10ae3b
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movb 0x15(%rax,%rcx), %al
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfd, %eax
jne 0x10ae15
movq 0xa91f4(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x53278(%rip), %rsi     # 0x15e066
leaq 0x78f70(%rip), %rdx     # 0x183d65
leaq 0x78f52(%rip), %rcx     # 0x183d4e
leaq 0x78c1f(%rip), %r8      # 0x183a22
movl $0x3c5, %r9d            # imm = 0x3C5
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10ae17
movb 0xf(%rsp), %dl
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x10ada3
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_from_file
GtAlphabet *gt_alphabet_new_from_file(const char *filename,
                                      GtError *err)
{
  GtStr *tmpfilename;
  GtAlphabet *a;
  gt_assert(filename);
  tmpfilename = gt_str_new_cstr(filename);
  gt_str_append_cstr(tmpfilename, GT_ALPHABETFILESUFFIX);
  a = gt_alphabet_new_from_file_no_suffix(gt_str_get(tmpfilename), err);
  gt_str_delete(tmpfilename);
  return a;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x10ae8e
movq 0xa917b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x531ff(%rip), %rsi     # 0x15e066
leaq 0x5e35a(%rip), %rdx     # 0x1691c8
leaq 0x78f0d(%rip), %rcx     # 0x183d82
leaq 0x78ba6(%rip), %r8      # 0x183a22
movl $0x3cf, %r9d            # imm = 0x3CF
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10ae90
movq 0x20(%rsp), %rdi
callq 0x18f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x78ef1(%rip), %rsi     # 0x183d9c
callq 0x18fb0
movq 0x10(%rsp), %rdi
callq 0x19940
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x10aee0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1afc0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: read_symbolmap
static int read_symbolmap(GtAlphabet *alpha,const char *mapfile,GtError *err)
{
  bool haserr = false;
  GtStrArray *lines;

  gt_error_check(err);
  lines = gt_str_array_new_file(mapfile);
  gt_assert(lines != NULL);
  if (read_symbolmap_from_lines(alpha,mapfile,lines,err) != 0)
  {
    haserr = true;
  }
  gt_str_array_delete(lines);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x10b988
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x10b950
jmp 0x10b988
movq 0xa8681(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x52705(%rip), %rsi     # 0x15e066
leaq 0x52ce0(%rip), %rdx     # 0x15e648
leaq 0x787b8(%rip), %rcx     # 0x184127
leaq 0x780ac(%rip), %r8      # 0x183a22
movl $0x145, %r9d            # imm = 0x145
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10b98a
movq 0x18(%rsp), %rdi
callq 0x1b0a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x10b9d7
movq 0xa8632(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x526b6(%rip), %rsi     # 0x15e066
leaq 0x7877f(%rip), %rdx     # 0x184136
leaq 0x78769(%rip), %rcx     # 0x184127
leaq 0x7805d(%rip), %r8      # 0x183a22
movl $0x147, %r9d            # imm = 0x147
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10b9d9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x10b350
cmpl $0x0, %eax
je 0x10b9fb
movb $0x1, 0xf(%rsp)
movq (%rsp), %rdi
callq 0x1b780
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_to_file
int gt_alphabet_to_file(const GtAlphabet *alphabet, const char *indexname,
                        GtError *err)
{
  FILE *al1fp;
  bool haserr = false;

  gt_error_check(err);
  al1fp = gt_fa_fopen_with_suffix(indexname,GT_ALPHABETFILESUFFIX,"wb",err);
  if (al1fp == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    GtStr *buf = gt_str_new();
    gt_alphabet_to_str(alphabet, buf);
    gt_xfwrite(gt_str_get(buf), sizeof (char), (size_t) gt_str_length(buf),
               al1fp);
    gt_fa_xfclose(al1fp);
    gt_str_delete(buf);
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x17(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x10ba88
movq 0x20(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x10ba50
jmp 0x10ba88
movq 0xa8581(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x52605(%rip), %rsi     # 0x15e066
leaq 0x52be0(%rip), %rdx     # 0x15e648
leaq 0x7839f(%rip), %rcx     # 0x183e0e
leaq 0x77fac(%rip), %r8      # 0x183a22
movl $0x428, %r9d            # imm = 0x428
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10ba8a
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %r9
leaq 0x78301(%rip), %rsi     # 0x183d9c
leaq 0x78380(%rip), %rdx     # 0x183e22
leaq 0x77f79(%rip), %rcx     # 0x183a22
movl $0x429, %r8d            # imm = 0x429
callq 0x7faa0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x10bac6
movb $0x1, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x10bb28
callq 0x18f00
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x109f50
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x19a00
movq (%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x1cab0
movq 0x18(%rsp), %rdi
callq 0x7fd50
movq 0x8(%rsp), %rdi
callq 0x1afc0
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: assignproteinsymbolmap
static void assignproteinsymbolmap(GtUchar *symbolmap)
{
  unsigned int cnum;

  for (cnum=0; cnum<=(unsigned int) GT_MAXALPHABETCHARACTER; cnum++)
  {
    symbolmap[cnum] = (GtUchar) GT_UNDEFCHAR;
  }
  for (cnum=0; PROTEINUPPERAMINOACIDS[cnum] != '\0'; cnum++)
  {
    symbolmap[(unsigned int) PROTEINUPPERAMINOACIDS[cnum]] = (GtUchar) cnum;
  }
  for (cnum=0; PROTEINWILDCARDS[cnum] != '\0'; cnum++)
  {
    symbolmap[(unsigned int) PROTEINWILDCARDS[cnum]] = (GtUchar) GT_WILDCARD;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0xff, -0xc(%rsp)
ja 0x10bdd1
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movb $-0x3, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x10bdad
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x78130(%rip), %rax     # 0x183f16
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x10be1d
movl -0xc(%rsp), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %ecx, %esi
leaq 0x7810f(%rip), %rcx     # 0x183f16
movsbl (%rcx,%rsi), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x10bdd9
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x780db(%rip), %rax     # 0x183f0d
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x10be64
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %ecx, %edx
leaq 0x780c0(%rip), %rcx     # 0x183f0d
movsbl (%rcx,%rdx), %ecx
movl %ecx, %ecx
movb $-0x2, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x10be25
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_new
GtBioseq* gt_bioseq_new(const char *sequence_file, GtError *err)
{
  GtBioseq *bs;
  GtStr *seqfile;
  gt_error_check(err);
  seqfile = gt_str_new_cstr(sequence_file);
  bs = bioseq_new_with_recreate_and_type(seqfile, false, err);
  gt_str_delete(seqfile);
  return bs;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x10bece
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x10be96
jmp 0x10bece
movq 0xa813b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x521bf(%rip), %rsi     # 0x15e066
leaq 0x5279a(%rip), %rdx     # 0x15e648
leaq 0x7828f(%rip), %rcx     # 0x184144
leaq 0x78296(%rip), %r8      # 0x184152
movl $0xfd, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10bed0
movq 0x20(%rsp), %rdi
callq 0x18f70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
xorl %esi, %esi
callq 0x10bf10
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_new_recreate
GtBioseq* gt_bioseq_new_recreate(const char *sequence_file, GtError *err)
{
  GtBioseq *bs;
  GtStr *seqfile;
  gt_error_check(err);
  seqfile = gt_str_new_cstr(sequence_file);
  bs = bioseq_new_with_recreate_and_type(seqfile, true, err);
  gt_str_delete(seqfile);
  return bs;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x10c15e
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x10c126
jmp 0x10c15e
movq 0xa7eab(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x51f2f(%rip), %rsi     # 0x15e066
leaq 0x5250a(%rip), %rdx     # 0x15e648
leaq 0x7801f(%rip), %rcx     # 0x184164
leaq 0x78006(%rip), %r8      # 0x184152
movl $0x108, %r9d            # imm = 0x108
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c160
movq 0x20(%rsp), %rdi
callq 0x18f70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0x1, %esi
callq 0x10bf10
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_delete
void gt_bioseq_delete(GtBioseq *bs)
{
  GtUword i;
  if (!bs) return;
  gt_str_delete(bs->sequence_file);
  gt_md5_tab_delete(bs->md5_tab);
  if (bs->descriptions) {
    for (i = 0; i < gt_encseq_num_of_sequences(bs->encseq); i++) {
      gt_free(bs->descriptions[i]);
    }
    gt_free(bs->descriptions);
  }
  gt_encseq_delete(bs->encseq);
  if (bs->use_stdin)
    remove_bioseq_files(bs);
  gt_free(bs);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x10c1e6
jmp 0x10c2bf
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x149660
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10c287
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x10c26d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x77eff(%rip), %rsi     # 0x184152
movl $0x11c, %edx            # imm = 0x11C
callq 0xdab0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x10c217
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x77ed5(%rip), %rsi     # 0x184152
movl $0x11e, %edx            # imm = 0x11E
callq 0xdab0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x118250
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x10c2a9
movq 0x10(%rsp), %rdi
callq 0x10c2d0
movq 0x10(%rsp), %rdi
leaq 0x77e9d(%rip), %rsi     # 0x184152
movl $0x123, %edx            # imm = 0x123
callq 0xdab0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: remove_bioseq_files
static void remove_bioseq_files(GtBioseq *bs)
{
  GtStr *base = gt_str_new_cstr("stdin.");
  gt_str_append_uword(base, (GtUword) bs);
  remove_indexfile(GT_ENCSEQFILESUFFIX, gt_str_get(base));
  remove_indexfile(GT_DESTABFILESUFFIX, gt_str_get(base));
  remove_indexfile(GT_SSPTABFILESUFFIX, gt_str_get(base));
  remove_indexfile(GT_SDSTABFILESUFFIX, gt_str_get(base));
  remove_indexfile(GT_MD5TABFILESUFFIX, gt_str_get(base));
  remove_indexfile(GT_OISTABFILESUFFIX, gt_str_get(base));
  gt_str_delete(base);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x7839d(%rip), %rdi     # 0x18467d
callq 0x18f70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x19390
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rsi
leaq 0x78377(%rip), %rdi     # 0x184684
callq 0x10e190
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rsi
leaq 0x78372(%rip), %rdi     # 0x184698
callq 0x10e190
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rsi
leaq 0x7839a(%rip), %rdi     # 0x1846d9
callq 0x10e190
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rsi
leaq 0x78336(%rip), %rdi     # 0x18468e
callq 0x10e190
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rsi
leaq 0x78322(%rip), %rdi     # 0x184693
callq 0x10e190
movq 0x8(%rsp), %rdi
callq 0x19940
movq %rax, %rsi
leaq 0x782ff(%rip), %rdi     # 0x184689
callq 0x10e190
movq 0x8(%rsp), %rdi
callq 0x1afc0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_seq
GtSeq* gt_bioseq_get_seq(GtBioseq *bs, GtUword idx)
{
  GtSeq *seq;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  seq = gt_seq_new_own(gt_bioseq_get_sequence(bs, idx),
                       gt_bioseq_get_sequence_length(bs, idx),
                       gt_encseq_alphabet(bs->encseq));
  gt_seq_set_description(seq, gt_bioseq_get_description(bs, idx));
  return seq;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x10c44e
movq 0xa7bbb(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x51c3f(%rip), %rsi     # 0x15e066
leaq 0x6f181(%rip), %rdx     # 0x17b5af
leaq 0x77d5d(%rip), %rcx     # 0x184192
leaq 0x77d16(%rip), %r8      # 0x184152
movl $0x12f, %r9d            # imm = 0x12F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c450
jmp 0x10c452
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jb 0x10c4af
movq 0xa7b5a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x51bde(%rip), %rsi     # 0x15e066
leaq 0x77d15(%rip), %rdx     # 0x1841a4
leaq 0x77cfc(%rip), %rcx     # 0x184192
leaq 0x77cb5(%rip), %r8      # 0x184152
movl $0x130, %r9d            # imm = 0x130
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c4b1
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10c530
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10c6a0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11b0e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x149cf0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10c710
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x149d30
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_sequence
char* gt_bioseq_get_sequence(const GtBioseq *bs, GtUword idx)
{
  char *out;
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  out = gt_calloc(gt_encseq_seqlength(bs->encseq, idx) + 1, sizeof (char));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_decoded(bs->encseq, out, startpos,
                            startpos
                              + gt_encseq_seqlength(bs->encseq, idx) - 1);
  return out;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x10c57e
movq 0xa7a8b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x51b0f(%rip), %rsi     # 0x15e066
leaq 0x6f051(%rip), %rdx     # 0x17b5af
leaq 0x77d28(%rip), %rcx     # 0x18428d
leaq 0x77be6(%rip), %r8      # 0x184152
movl $0x174, %r9d            # imm = 0x174
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c580
jmp 0x10c582
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jb 0x10c5df
movq 0xa7a2a(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x51aae(%rip), %rsi     # 0x15e066
leaq 0x77be5(%rip), %rdx     # 0x1841a4
leaq 0x77cc7(%rip), %rcx     # 0x18428d
leaq 0x77b85(%rip), %r8      # 0x184152
movl $0x175, %r9d            # imm = 0x175
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c5e1
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x11abd0
movq %rax, %rdi
addq $0x1, %rdi
movl $0x1, %esi
leaq 0x77b4b(%rip), %rdx     # 0x184152
movl $0x176, %ecx            # imm = 0x176
callq 0xd5b0
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x11a710
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x11abd0
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rax, %rcx
subq $0x1, %rcx
callq 0x116750
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_description
const char* gt_bioseq_get_description(GtBioseq *bs, GtUword idx)
{
  const char *desc;
  char *mydesc;
  GtUword desclen;
  gt_assert(bs && bs->encseq);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  if (!(mydesc = bs->descriptions[idx])) {
    desc = gt_encseq_description(bs->encseq, &desclen, idx);
    mydesc = gt_calloc(desclen + 1, sizeof (char));
    strncpy(mydesc, desc, desclen);
    bs->descriptions[idx] = mydesc;
  }
  return (const char*) mydesc;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x10c732
movq 0x30(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x10c76a
movq 0xa789f(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x51923(%rip), %rsi     # 0x15e066
leaq 0x77ad6(%rip), %rdx     # 0x184220
leaq 0x77ae0(%rip), %rcx     # 0x184231
leaq 0x779fa(%rip), %r8      # 0x184152
movl $0x14c, %r9d            # imm = 0x14C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c76c
jmp 0x10c76e
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x10c7cb
movq 0xa783e(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x518c2(%rip), %rsi     # 0x15e066
leaq 0x779f9(%rip), %rdx     # 0x1841a4
leaq 0x77a7f(%rip), %rcx     # 0x184231
leaq 0x77999(%rip), %r8      # 0x184152
movl $0x14d, %r9d            # imm = 0x14D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c7cd
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0x10c856
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x11bd20
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
leaq 0x77936(%rip), %rdx     # 0x184152
movl $0x150, %ecx            # imm = 0x150
callq 0xd5b0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xb2b0
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_seq_range
GtSeq* gt_bioseq_get_seq_range(GtBioseq *bs, GtUword idx,
                               GtUword start, GtUword end)
{
  GtSeq *seq;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq));
  gt_assert(end >= start);
  gt_assert(end - start + 1 > gt_encseq_seqlength(bs->encseq, idx));
  seq = gt_seq_new_own(gt_bioseq_get_sequence_range(bs, idx, start, end),
                       end - start + 1,
                       gt_encseq_alphabet(bs->encseq));
  gt_seq_set_description(seq, gt_bioseq_get_description(bs, idx));
  return seq;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x10c8b8
movq 0xa7751(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x517d5(%rip), %rsi     # 0x15e066
leaq 0x6ed17(%rip), %rdx     # 0x17b5af
leaq 0x77932(%rip), %rcx     # 0x1841d1
leaq 0x778ac(%rip), %r8      # 0x184152
movl $0x13c, %r9d            # imm = 0x13C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c8ba
jmp 0x10c8bc
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jb 0x10c919
movq 0xa76f0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x51774(%rip), %rsi     # 0x15e066
leaq 0x778ab(%rip), %rdx     # 0x1841a4
leaq 0x778d1(%rip), %rcx     # 0x1841d1
leaq 0x7784b(%rip), %r8      # 0x184152
movl $0x13d, %r9d            # imm = 0x13D
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c91b
jmp 0x10c91d
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x10c961
movq 0xa76a8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x5172c(%rip), %rsi     # 0x15e066
leaq 0x779b0(%rip), %rdx     # 0x1842f1
leaq 0x77889(%rip), %rcx     # 0x1841d1
leaq 0x77803(%rip), %r8      # 0x184152
movl $0x13e, %r9d            # imm = 0x13E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c963
jmp 0x10c965
movq 0x38(%rsp), %rax
subq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x11abd0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
ja 0x10c9d0
movq 0xa7639(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x516bd(%rip), %rsi     # 0x15e066
leaq 0x77839(%rip), %rdx     # 0x1841e9
leaq 0x7781a(%rip), %rcx     # 0x1841d1
leaq 0x77794(%rip), %r8      # 0x184152
movl $0x13f, %r9d            # imm = 0x13F
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10c9d2
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x10ca60
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
subq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11b0e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x149cf0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x10c710
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x149d30
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_sequence_range
char* gt_bioseq_get_sequence_range(const GtBioseq *bs, GtUword idx,
                                   GtUword start, GtUword end)
{
  char *out;
  GtUword startpos;
  gt_assert(bs);
  gt_assert(idx < gt_encseq_num_of_sequences(bs->encseq) && end >= start);
  out = gt_calloc((end - start + 1) + 1, sizeof (char));
  startpos = gt_encseq_seqstartpos(bs->encseq, idx);
  gt_encseq_extract_decoded(bs->encseq, out, startpos + start, startpos + end);
  return out;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x10cab8
movq 0xa7551(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x515d5(%rip), %rsi     # 0x15e066
leaq 0x6eb17(%rip), %rdx     # 0x17b5af
leaq 0x77805(%rip), %rcx     # 0x1842a4
leaq 0x776ac(%rip), %r8      # 0x184152
movl $0x183, %r9d            # imm = 0x183
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10caba
jmp 0x10cabc
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x10caeb
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x10cb23
movq 0xa74e6(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x5156a(%rip), %rsi     # 0x15e066
leaq 0x777be(%rip), %rdx     # 0x1842c1
leaq 0x7779a(%rip), %rcx     # 0x1842a4
leaq 0x77641(%rip), %r8      # 0x184152
movl $0x184, %r9d            # imm = 0x184
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10cb25
movq 0x18(%rsp), %rdi
subq 0x20(%rsp), %rdi
addq $0x1, %rdi
addq $0x1, %rdi
movl $0x1, %esi
leaq 0x7760f(%rip), %rdx     # 0x184152
movl $0x185, %ecx            # imm = 0x185
callq 0xd5b0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x11a710
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
addq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
addq 0x18(%rsp), %rcx
callq 0x116750
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bioseq.c
// Function: gt_bioseq_get_char
char gt_bioseq_get_char(const GtBioseq *bs, GtUword index,
                        GtUword position)
{
  GtUword startpos;
  gt_assert(bs);
  gt_assert(index < gt_encseq_num_of_sequences(bs->encseq));
  startpos = gt_encseq_seqstartpos(bs->encseq, index);
  return gt_encseq_get_decoded_char(bs->encseq, startpos + position,
                                    GT_READMODE_FORWARD);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x10cbf3
movq 0xa7416(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x5149a(%rip), %rsi     # 0x15e066
leaq 0x6e9dc(%rip), %rdx     # 0x17b5af
leaq 0x77671(%rip), %rcx     # 0x18424b
leaq 0x77571(%rip), %r8      # 0x184152
movl $0x15b, %r9d            # imm = 0x15B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10cbf5
jmp 0x10cbf7
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x113f30
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x10cc52
movq 0xa73b7(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x5143b(%rip), %rsi     # 0x15e066
leaq 0x7762c(%rip), %rdx     # 0x18425e
leaq 0x77612(%rip), %rcx     # 0x18424b
leaq 0x77512(%rip), %r8      # 0x184152
movl $0x15c, %r9d            # imm = 0x15C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x10cc54
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x11a710
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
addq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x114690
addq $0x28, %rsp
retq
nopl (%rax,%rax)