LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-embedimage.c
// Function: main
int main(int argc, char **argv) {
  int32_t size = 0;
  int32_t i;
  int32_t n;

  if (argc == 2)
      size = ngaLoadImage(argv[1]);
  else
      size = ngaLoadImage("ngaImage");

  output_header(size);

  i = 0;
  n = 0;
  while (i < size) {
    n++;
    if (n == 20) {
      printf("\n                       ");
      n = 0;
    }
    if (i+1 < size)
      printf("%lld,", (long long)memory[i]);
    else
      printf("%lld };\n", (long long)memory[i]);
    i++;
  }
  exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x1308
movq 0x8(%rsi), %rdi
jmp 0x130f
leaq 0xd29(%rip), %rdi       # 0x2038
callq 0x11bc
movl %eax, %ebx
movl %eax, %edi
callq 0x1237
testl %ebx, %ebx
movl $0x0, %r15d
cmovgl %ebx, %r15d
shlq $0x2, %r15
pushq $0x1
popq %rbp
leaq 0xd29(%rip), %r14       # 0x2060
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r12, %r15
je 0x1386
incl %r13d
cmpl $0x14, %r13d
jne 0x135c
xorl %r13d, %r13d
leaq 0xcec(%rip), %rdi       # 0x2041
xorl %eax, %eax
callq 0x1060
cmpl %ebp, %ebx
leaq 0x2d1b(%rip), %rax      # 0x4080
movslq (%r12,%rax), %rsi
movq %r14, %rdi
leaq 0xce7(%rip), %rax       # 0x205a
cmovgq %rax, %rdi
xorl %eax, %eax
callq 0x1060
addq $0x4, %r12
incl %ebp
jmp 0x133d
xorl %edi, %edi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_new
GtCsvlineReader *gt_csvline_reader_new(void)
{
  GtCsvlineReader *csvline_reader = gt_malloc(sizeof *csvline_reader);
  gt_assert(csvline_reader != NULL);
  GT_INITARRAY(&csvline_reader->line,char);
  GT_INITARRAY(&csvline_reader->dist.alphabet,char);
  GT_INITARRAY(&csvline_reader->columnoffset,GtUword);
  csvline_reader->empty = true;
  csvline_reader->separator = 0;
  csvline_reader->dist.charcount
    = gt_calloc(UCHAR_MAX+1,sizeof *csvline_reader->dist.charcount);
  return csvline_reader;
}

// Assembly:
pushq %rbx
leaq 0x2269a9(%rip), %rsi    # 0x2e4c05
pushq $0x58
popq %rdi
pushq $0x29
popq %rdx
callq 0x2e5f0
testq %rax, %rax
je 0xbe2ac
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
andq $0x0, 0x40(%rax)
movw $0x1, 0x50(%rax)
leaq 0x226972(%rip), %rdx    # 0x2e4c05
pushq $0x8
popq %rsi
pushq $0x31
popq %rcx
movl $0x100, %edi            # imm = 0x100
callq 0x30f40
movq %rax, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x34ccfd(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x220533(%rip), %rsi    # 0x2de7f0
leaq 0x22695b(%rip), %rdx    # 0x2e4c1f
leaq 0x22696b(%rip), %rcx    # 0x2e4c36
leaq 0x226933(%rip), %r8     # 0x2e4c05
pushq $0x2a
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_delete
void gt_csvline_reader_delete(GtCsvlineReader *csvline_reader)
{
  if (csvline_reader != NULL)
  {
    GT_FREEARRAY(&csvline_reader->columnoffset,GtUword);
    GT_FREEARRAY(&csvline_reader->line,char);
    GT_FREEARRAY(&csvline_reader->dist.alphabet,char);
    gt_free(csvline_reader->dist.charcount);
    gt_free(csvline_reader);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xbe38f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xbe31a
leaq 0x18(%rbx), %r14
leaq 0x2268ff(%rip), %rsi    # 0x2e4c05
pushq $0x43
popq %rdx
callq 0x30f00
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbe33c
leaq 0x2268dc(%rip), %rsi    # 0x2e4c05
pushq $0x44
popq %rdx
callq 0x30f00
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xbe364
leaq 0x30(%rbx), %r14
leaq 0x2268b5(%rip), %rsi    # 0x2e4c05
pushq $0x45
popq %rdx
callq 0x30f00
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x48(%rbx), %rdi
leaq 0x226896(%rip), %r14    # 0x2e4c05
pushq $0x46
popq %rdx
movq %r14, %rsi
callq 0x30f00
pushq $0x47
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30f00
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_clear
void gt_csvline_reader_clear(GtCsvlineReader *csvline_reader)
{
  GtUword idx;

  csvline_reader->line.nextfreechar = 0;
  for (idx = 0; idx < csvline_reader->dist.alphabet.nextfreechar; idx++)
  {
    char cc = csvline_reader->dist.alphabet.spacechar[idx];
    csvline_reader->dist.charcount[(int) cc] = 0;
  }
  csvline_reader->dist.alphabet.nextfreechar = 0;
  for (idx = 0; idx <= UCHAR_MAX; idx++)
  {
    gt_assert(csvline_reader->dist.charcount[idx] == 0);
  }
  csvline_reader->columnoffset.nextfreeGtUword = 0;
  csvline_reader->empty = true;
}

// Assembly:
pushq %rax
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
cmpq 0x40(%rdi), %rax
jae 0xbe3b5
movq 0x30(%rdi), %rcx
movq 0x48(%rdi), %rdx
movsbq (%rcx,%rax), %rcx
andq $0x0, (%rdx,%rcx,8)
incq %rax
jmp 0xbe398
andq $0x0, 0x40(%rdi)
movq 0x48(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0xbe40a
cmpq $0x0, (%rax,%rcx,8)
leaq 0x1(%rcx), %rcx
je 0xbe3c0
movq 0x34cbd5(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x22040b(%rip), %rsi    # 0x2de7f0
leaq 0x226860(%rip), %rdx    # 0x2e4c4c
leaq 0x226882(%rip), %rcx    # 0x2e4c75
leaq 0x22680b(%rip), %r8     # 0x2e4c05
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
andq $0x0, 0x28(%rdi)
movb $0x1, 0x50(%rdi)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_next
bool gt_csvline_reader_next(GtCsvlineReader *csvline_reader,
                            FILE *inputfp,char separator)
{
  gt_assert(csvline_reader != NULL);
  gt_csvline_reader_clear(csvline_reader);
  csvline_reader->separator = separator;
  while (true)
  {
    int cc = fgetc(inputfp);

    if (cc == EOF)
    {
      break;
    }
    if (cc == '\n')
    {
      csvline_reader_append_char(csvline_reader,'\0');
      return true;
    }
    if (cc == csvline_reader->separator)
    {
      csvline_reader_append_char(csvline_reader,cc);
      GT_CHECKARRAYSPACE(&csvline_reader->columnoffset,GtUword,1024);
      csvline_reader->columnoffset.spaceGtUword[csvline_reader->
                                                columnoffset.nextfreeGtUword++]
        = csvline_reader->line.nextfreechar;
    } else
    {
      if (csvline_reader->empty && !isspace(cc))
      {
        csvline_reader->empty = false;
      }
      csvline_reader_append_char(csvline_reader,cc);
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbe53f
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xbe390
movb %bpl, 0x51(%rbx)
leaq 0x2267c7(%rip), %r15    # 0x2e4c05
pushq $0x74
popq %rbp
movq %r14, %rdi
callq 0x30550
cmpl $-0x1, %eax
je 0xbe4fe
movl %eax, %r12d
cmpl $0xa, %eax
je 0xbe4f0
movsbl 0x51(%rbx), %eax
cmpl %eax, %r12d
jne 0xbe483
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0xbe569
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
jae 0xbe4ad
movq 0x18(%rbx), %rax
jmp 0xbe4d2
cmpb $0x1, 0x50(%rbx)
jne 0xbe49f
callq 0x301c0
movq (%rax), %rax
movslq %r12d, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xbe49f
movb $0x0, 0x50(%rbx)
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0xbe569
jmp 0xbe441
leaq 0x400(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq 0x18(%rbx), %rdi
leaq 0x2000(,%rax,8), %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x2e900
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0xbe509
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%rbx)
movq %rcx, (%rax,%rdx,8)
jmp 0xbe441
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbe569
movb $0x1, %al
jmp 0xbe500
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x34caa0(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x2202d6(%rip), %rsi    # 0x2de7f0
leaq 0x226783(%rip), %rdx    # 0x2e4ca4
leaq 0x226765(%rip), %rcx    # 0x2e4c8d
leaq 0x2266d6(%rip), %r8     # 0x2e4c05
pushq $0x74
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
movq 0x34ca6a(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x2202a0(%rip), %rsi    # 0x2de7f0
leaq 0x2266c8(%rip), %rdx    # 0x2e4c1f
leaq 0x22672f(%rip), %rcx    # 0x2e4c8d
leaq 0x2266a0(%rip), %r8     # 0x2e4c05
pushq $0x61
jmp 0xbe531
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: csvline_reader_append_char
static void csvline_reader_append_char(GtCsvlineReader *csvline_reader,char cc)
{
  GT_STOREINARRAY(&csvline_reader->line,char,1024UL,cc);
  if (csvline_reader->dist.charcount[(int) cc] == 0)
  {
    GT_STOREINARRAY(&csvline_reader->dist.alphabet,char,256UL,cc);
  }
  csvline_reader->dist.charcount[(int) cc]++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
jae 0xbe581
movq (%rbx), %rax
jmp 0xbe5a1
addq $0x400, %rsi            # imm = 0x400
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x22666f(%rip), %rdx    # 0x2e4c05
pushq $0x37
popq %rcx
callq 0x2e900
movq %rax, (%rbx)
testq %rax, %rax
je 0xbe622
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %bpl, (%rax,%rcx)
movq 0x48(%rbx), %rax
movsbq %bpl, %r14
movq (%rax,%r14,8), %rcx
testq %rcx, %rcx
jne 0xbe616
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x40(%rbx)
jae 0xbe5d7
movq 0x30(%rbx), %rax
jmp 0xbe5f9
addq $0x100, %rsi            # imm = 0x100
movq %rsi, 0x38(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x226618(%rip), %rdx    # 0x2e4c05
pushq $0x3a
popq %rcx
callq 0x2e900
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0xbe64c
movq 0x40(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x40(%rbx)
movb %r14b, (%rax,%rcx)
movq 0x48(%rbx), %rax
movq (%rax,%r14,8), %rcx
incq %rcx
movq %rcx, (%rax,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x34c987(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x2201bd(%rip), %rsi    # 0x2de7f0
leaq 0x2269a4(%rip), %rdx    # 0x2e4fde
leaq 0x226982(%rip), %rcx    # 0x2e4fc3
leaq 0x2265bd(%rip), %r8     # 0x2e4c05
pushq $0x37
jmp 0xbe674
movq 0x34c95d(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x220193(%rip), %rsi    # 0x2de7f0
leaq 0x2269a5(%rip), %rdx    # 0x2e5009
leaq 0x226958(%rip), %rcx    # 0x2e4fc3
leaq 0x226593(%rip), %r8     # 0x2e4c05
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_column
GtCsvcolumn gt_csvline_reader_column(const GtCsvlineReader *csvline_reader,
                                     GtUword colnum)
{
  GtCsvcolumn col;

  gt_assert(csvline_reader != NULL &&
            !gt_csvline_reader_white_space_line(csvline_reader));
  if (colnum == 0)
  {
    gt_assert(csvline_reader->line.nextfreechar >= 2UL);
    col.content = csvline_reader->line.spacechar;
  } else
  {
    gt_assert(colnum - 1 < csvline_reader->columnoffset.nextfreeGtUword);
    col.content = csvline_reader->line.spacechar +
                  csvline_reader->columnoffset.spaceGtUword[colnum-1];
  }
  if (colnum == 0)
  {
    col.width = csvline_reader->columnoffset.spaceGtUword[colnum] - 1;
  } else
  {
    if (colnum == csvline_reader->columnoffset.nextfreeGtUword)
    {
      col.width = csvline_reader->line.nextfreechar -
                  csvline_reader->columnoffset.spaceGtUword[colnum-1] - 1;
    } else
    {
      col.width = csvline_reader->columnoffset.spaceGtUword[colnum] -
                  csvline_reader->columnoffset.spaceGtUword[colnum-1] - 1;
    }
  }
  return col;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbe6dd
cmpb $0x1, 0x50(%rdi)
je 0xbe6dd
testq %rsi, %rsi
je 0xbe6c1
leaq -0x1(%rsi), %rax
movq 0x28(%rdi), %rcx
cmpq %rcx, %rax
jae 0xbe70b
movq 0x18(%rdi), %r8
movq -0x8(%r8,%rsi,8), %rdx
movq (%rdi), %rax
addq %rdx, %rax
notq %rdx
cmpq %rsi, %rcx
jne 0xbe6d4
addq $0x10, %rdi
jmp 0xbe6d8
cmpq $0x1, 0x10(%rdi)
jbe 0xbe739
movq (%rdi), %rax
movq 0x18(%rdi), %rdi
pushq $-0x1
popq %rdx
jmp 0xbe6d8
leaq (%r8,%rsi,8), %rdi
addq (%rdi), %rdx
popq %rcx
retq
movq 0x34c8cc(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x220102(%rip), %rsi    # 0x2de7f0
leaq 0x2265e5(%rip), %rdx    # 0x2e4cda
leaq 0x22662c(%rip), %rcx    # 0x2e4d28
leaq 0x226502(%rip), %r8     # 0x2e4c05
movl $0x8f, %r9d
jmp 0xbe765
movq 0x34c89e(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x2200d4(%rip), %rsi    # 0x2de7f0
leaq 0x226647(%rip), %rdx    # 0x2e4d6a
leaq 0x2265fe(%rip), %rcx    # 0x2e4d28
leaq 0x2264d4(%rip), %r8     # 0x2e4c05
movl $0x96, %r9d
jmp 0xbe765
movq 0x34c870(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x2200a6(%rip), %rsi    # 0x2de7f0
leaq 0x2265f0(%rip), %rdx    # 0x2e4d41
leaq 0x2265d0(%rip), %rcx    # 0x2e4d28
leaq 0x2264a6(%rip), %r8     # 0x2e4c05
movl $0x92, %r9d
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_check
void gt_csvline_reader_check(const GtCsvlineReader *csvline_reader)
{
  GtUword idx, bfdist[UCHAR_MAX+1] = {0};

  for (idx = 0; idx < csvline_reader->line.nextfreechar; idx++)
  {
    bfdist[(int) csvline_reader->line.spacechar[idx]]++;
  }
  for (idx = 0; idx <= UCHAR_MAX; idx++)
  {
    if (bfdist[idx] != csvline_reader->dist.charcount[idx])
    {
      fprintf(stderr,"%s\nidx=" GT_WU ",bfdist=" GT_WU " != "
                                                 GT_WU " = chardist\n",
                csvline_reader->line.spacechar,idx,bfdist[idx],
                csvline_reader->dist.charcount[idx]);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
movq %rsp, %rdi
xorl %r14d, %r14d
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x2e4b0
movq 0x10(%rbx), %rax
cmpq %r14, %rax
je 0xbe7aa
movq (%rbx), %rcx
movsbq (%rcx,%r14), %rcx
incq (%rsp,%rcx,8)
incq %r14
jmp 0xbe794
movq 0x48(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0xbe7cb
movq (%rsp,%rcx,8), %r8
movq (%rax,%rcx,8), %r9
cmpq %r9, %r8
jne 0xbe7d6
incq %rcx
jmp 0xbe7b0
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
movq 0x34c7d3(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x2265ba(%rip), %rsi    # 0x2e4da4
xorl %eax, %eax
callq 0x32960
pushq $0x2
popq %rdi
callq 0x2ed60
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_dist_check
void gt_csvline_reader_dist_check(const GtCsvlineReader *csvline_reader,
                                  const char *string,GtUword len)
{
  GtUword idx, numchars = 0, dist_tab[UCHAR_MAX+1] = {0};

  for (idx = 0; idx < len; idx++)
  {
    dist_tab[(int) string[idx]]++;
  }
  for (idx = 0; idx <= UCHAR_MAX; idx++)
  {
    gt_assert(dist_tab[idx] == csvline_reader->dist.charcount[idx]);
    if (csvline_reader->dist.charcount[idx] > 0)
    {
      numchars++;
    }
  }
  gt_assert(numchars == csvline_reader->dist.alphabet.nextfreechar);
  for (idx = 0; idx < numchars; idx++)
  {
    char cc = csvline_reader->dist.alphabet.spacechar[idx];
    gt_assert(csvline_reader->dist.charcount[(int) cc] > 0);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
xorl %r12d, %r12d
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x2e4b0
cmpq %r12, %r14
je 0xbe9aa
movsbq (%r15,%r12), %rax
incq (%rsp,%rax,8)
incq %r12
jmp 0xbe997
movq 0x48(%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq $0x100, %rdx            # imm = 0x100
je 0xbe9d2
movq (%rsp,%rdx,8), %rsi
cmpq (%rax,%rdx,8), %rsi
jne 0xbea33
cmpq $0x1, %rsi
sbbq $-0x1, %rcx
incq %rdx
jmp 0xbe9b2
cmpq 0x40(%rbx), %rcx
jne 0xbea6b
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xbea24
movq 0x30(%rbx), %rsi
movsbq (%rsi,%rdx), %rsi
incq %rdx
cmpq $0x0, (%rax,%rsi,8)
jne 0xbe9de
movq 0x34c5b3(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x21fde9(%rip), %rsi    # 0x2de7f0
leaq 0x22654b(%rip), %rdx    # 0x2e4f59
leaq 0x2264f0(%rip), %rcx    # 0x2e4f05
leaq 0x2261e9(%rip), %r8     # 0x2e4c05
movl $0x10b, %r9d            # imm = 0x10B
jmp 0xbea5f
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x34c576(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x21fdac(%rip), %rsi    # 0x2de7f0
leaq 0x226485(%rip), %rdx    # 0x2e4ed0
leaq 0x2264b3(%rip), %rcx    # 0x2e4f05
leaq 0x2261ac(%rip), %r8     # 0x2e4c05
movl $0x101, %r9d            # imm = 0x101
xorl %eax, %eax
callq 0x32960
callq 0x2e820
movq 0x34c53e(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x21fd74(%rip), %rsi    # 0x2de7f0
leaq 0x22649f(%rip), %rdx    # 0x2e4f22
leaq 0x22647b(%rip), %rcx    # 0x2e4f05
leaq 0x226174(%rip), %r8     # 0x2e4c05
movl $0x107, %r9d            # imm = 0x107
jmp 0xbea5f
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_dist_show
void gt_csvline_reader_dist_show(const GtCsvlineReader *csvline_reader)
{
  GtUword idx;

  for (idx = 0; idx < csvline_reader->dist.alphabet.nextfreechar; idx++)
  {
    char cc = csvline_reader->dist.alphabet.spacechar[idx];
    printf("%c/" GT_WU,cc,csvline_reader->dist.charcount[(int) cc]);
    if (idx + 1 < csvline_reader->dist.alphabet.nextfreechar)
    {
      printf("%c",csvline_reader->separator);
    } else
    {
      printf("\n");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2264dc(%rip), %r14    # 0x2e4f86
pushq $0xa
popq %rbp
xorl %r15d, %r15d
cmpq 0x40(%rbx), %r15
jae 0xbeae7
movq 0x30(%rbx), %rax
movq 0x48(%rbx), %rcx
movsbq (%rax,%r15), %rsi
movq (%rcx,%rsi,8), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e300
incq %r15
movl %ebp, %edi
cmpq 0x40(%rbx), %r15
jae 0xbeae0
movsbl 0x51(%rbx), %edi
callq 0x2ef90
jmp 0xbeab0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_dist_accumulate
void gt_csvline_reader_dist_accumulate(GtUword *charcount,
                                       GT_UNUSED GtUword max_character,
                                       const GtCsvlineReader *csvline_reader)
{
  GtUword idx;

  for (idx = 0; idx < csvline_reader->dist.alphabet.nextfreechar; idx++)
  {
    char cc = csvline_reader->dist.alphabet.spacechar[idx];
    gt_assert(cc <= max_character);
    charcount[(int) cc] += csvline_reader->dist.charcount[(int) cc];
  }
}

// Assembly:
pushq %rax
xorl %eax, %eax
cmpq 0x40(%rdx), %rax
jae 0xbeb1a
movq 0x30(%rdx), %rcx
movsbq (%rcx,%rax), %rcx
cmpq %rsi, %rcx
ja 0xbeb1c
movq 0x48(%rdx), %r8
movq (%r8,%rcx,8), %r8
addq %r8, (%rdi,%rcx,8)
incq %rax
jmp 0xbeaf5
popq %rax
retq
movq 0x34c48d(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x21fcc3(%rip), %rsi    # 0x2de7f0
leaq 0x226459(%rip), %rdx    # 0x2e4f8d
leaq 0x226466(%rip), %rcx    # 0x2e4fa1
leaq 0x2260c3(%rip), %r8     # 0x2e4c05
movl $0x12b, %r9d            # imm = 0x12B
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/example.c
// Function: gt_example_delete
void gt_example_delete(GtExample *e)
{
  if (!e) return;
  gt_assert(e && e->c_class);
  if (e->c_class->delete != NULL) {
    e->c_class->delete(e);                 /* delete implementation-specific
                                              members */
  }
  gt_free(e);                              /* delete interface */
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xdd58b
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xdd58d
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xdd578
movq %rbx, %rdi
callq *%rax
leaq 0x20f0a6(%rip), %rsi    # 0x2ec625
pushq $0x2b
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x30f00
popq %rbx
retq
movq 0x32da1c(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x201252(%rip), %rsi    # 0x2de7f0
leaq 0x20f0c5(%rip), %rdx    # 0x2ec66a
leaq 0x20f0ce(%rip), %rcx    # 0x2ec67a
leaq 0x20f072(%rip), %r8     # 0x2ec625
pushq $0x26
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fasta_reader_fsm.c
// Function: gt_fasta_reader_fsm_new
GtFastaReader* gt_fasta_reader_fsm_new(GtStr *sequence_filename)
{
  GtFastaReader *fr = gt_fasta_reader_create(gt_fasta_reader_fsm_class());
  GtFastaReaderFSM *gt_fasta_reader_fsm = gt_fasta_reader_fsm_cast(fr);
  gt_fasta_reader_fsm->sequence_filename = gt_str_ref(sequence_filename);
  if (sequence_filename) {
    gt_fasta_reader_fsm->sequence_file =
      gt_file_xopen(gt_str_get(sequence_filename), "r");
  }
  else
    gt_fasta_reader_fsm->sequence_filename = gt_str_new_cstr("stdin");
  return fr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x32723d(%rip), %r14    # 0x4074b0
movq %r14, %rdi
callq 0xdfadc
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0xdfc6b
movq %rax, %r14
movq %r15, %rdi
callq 0x302f0
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0xe02ba
movq %r15, %rdi
callq 0x32b70
leaq 0x20229f(%rip), %rsi    # 0x2e254b
movq %rax, %rdi
callq 0x2f3c0
movq %rax, 0x10(%r14)
jmp 0xe02ca
leaq 0x277d66(%rip), %rdi    # 0x358027
callq 0x300e0
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/fasta_reader_seqit.c
// Function: gt_fasta_reader_seqit_new
GtFastaReader* gt_fasta_reader_seqit_new(GtStr *sequence_filename)
{
  GtFastaReader *fr;
  GtFastaReaderSeqIt *gt_fasta_reader_seqit;
  gt_assert(sequence_filename);
  fr = gt_fasta_reader_create(gt_fasta_reader_seqit_class());
  gt_fasta_reader_seqit = gt_fasta_reader_seqit_cast(fr);
  gt_fasta_reader_seqit->filenametab = gt_str_array_new();
  gt_str_array_add_cstr(gt_fasta_reader_seqit->filenametab,
                       gt_str_get(sequence_filename));
  gt_fasta_reader_seqit->seqit = gt_seq_iterator_sequence_buffer_new(
                                             gt_fasta_reader_seqit->filenametab,
                                             NULL);
  return fr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe09f4
movq %rdi, %r14
leaq 0x326b42(%rip), %r15    # 0x4074e0
movq %r15, %rdi
callq 0xdfadc
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0xdfc6b
movq %rax, %r15
callq 0x315a0
movq %rax, %r12
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x32b70
movq %r12, %rdi
movq %rax, %rsi
callq 0x2e570
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq 0x32f60
movq %rax, 0x10(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x32a5b5(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1fddeb(%rip), %rsi    # 0x2de7f0
leaq 0x20c61e(%rip), %rdx    # 0x2ed02a
leaq 0x20c629(%rip), %rcx    # 0x2ed03c
leaq 0x20c63c(%rip), %r8     # 0x2ed056
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/password_entry.c
// Function: gt_get_password
GtStr* gt_get_password(GT_UNUSED const char *prompt, GT_UNUSED GtError *err)
{
#ifndef _WIN32
  int flags,
      GT_UNUSED retval;
  char buf[255];
  struct termios term_attr;
  gt_assert(prompt);
  gt_error_check(err);

  if (tcgetattr(STDIN_FILENO, &term_attr)) {
    gt_error_set(err, "tcgetattr() failed");
    return NULL;
  }
  flags = term_attr.c_lflag;
  term_attr.c_lflag &= ~ECHO;
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &term_attr)) {
    gt_error_set(err, "tcsetattr() failed");
    return NULL;
  }
  fprintf(stderr, "%s", prompt);
  retval = scanf("%254s", buf);
  gt_assert(retval == 1);
  term_attr.c_lflag = flags;
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &term_attr)) {
    gt_error_set(err, "tcsetattr() failed");
    return NULL;
  }
  fprintf(stderr, "\n");
  return gt_str_new_cstr(buf);
#else
  /* XXX */
  fprintf(stderr, "gt_get_password() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
testq %rdi, %rdi
je 0xf086b
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xf07b1
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0xf0895
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x30fa0
testl %eax, %eax
je 0xf07ca
leaq 0x200409(%rip), %rsi    # 0x2f0bd1
jmp 0xf07ef
leaq 0x4(%rsp), %rdx
movl 0xc(%rdx), %ebp
movl %ebp, %eax
andl $-0x9, %eax
movl %eax, 0xc(%rdx)
pushq $0x2
popq %rsi
xorl %edi, %edi
callq 0x2e190
testl %eax, %eax
je 0xf080d
leaq 0x2003f5(%rip), %rsi    # 0x2f0be4
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30a30
movq %r14, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x31a79c(%rip), %r15    # 0x40afb0
movq (%r15), %rsi
movq %r14, %rdi
callq 0x30bf0
leaq 0x2003d1(%rip), %rdi    # 0x2f0bf7
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x31d00
cmpl $0x1, %eax
jne 0xf08cb
leaq 0x4(%rsp), %rdx
movl %ebp, 0xc(%rdx)
pushq $0x2
popq %rsi
xorl %edi, %edi
callq 0x2e190
testl %eax, %eax
jne 0xf07e8
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x2fcd0
leaq 0x40(%rsp), %rdi
callq 0x300e0
movq %rax, %r14
jmp 0xf07fc
movq 0x31a73e(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1edf74(%rip), %rsi    # 0x2de7f0
leaq 0x20031d(%rip), %rdx    # 0x2f0ba0
leaq 0x20031d(%rip), %rcx    # 0x2f0ba7
leaq 0x200326(%rip), %r8     # 0x2f0bb7
pushq $0x22
jmp 0xf08bd
movq 0x31a714(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1edf4a(%rip), %rsi    # 0x2de7f0
leaq 0x1ee116(%rip), %rdx    # 0x2de9c3
leaq 0x2002f3(%rip), %rcx    # 0x2f0ba7
leaq 0x2002fc(%rip), %r8     # 0x2f0bb7
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
movq (%r15), %rdi
leaq 0x1edf1b(%rip), %rsi    # 0x2de7f0
leaq 0x200321(%rip), %rdx    # 0x2f0bfd
leaq 0x2002c4(%rip), %rcx    # 0x2f0ba7
leaq 0x2002cd(%rip), %r8     # 0x2f0bb7
pushq $0x31
jmp 0xf08bd
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/str_cache.c
// Function: gt_str_cache_new
GtStrCache* gt_str_cache_new(void *str_source,
                             GtStrConstructorFunc str_constructor,
                             GtUword num_of_strings)
{
  GtStrCache *str_cache;
  gt_assert(str_source && str_constructor && num_of_strings);
  str_cache = gt_malloc(sizeof *str_cache);
  str_cache->cache = gt_calloc(num_of_strings, sizeof (GtStr*));
  str_cache->source = str_source;
  str_cache->constructor = str_constructor;
  str_cache->num_of_strings = num_of_strings;
  return str_cache;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x102937
movq %rsi, %r14
testq %rsi, %rsi
je 0x102937
movq %rdx, %rbx
testq %rdx, %rdx
je 0x102937
movq %rdi, %r15
leaq 0x1f240d(%rip), %r12    # 0x2f4d05
pushq $0x20
popq %rdi
pushq $0x21
popq %rdx
movq %r12, %rsi
callq 0x2e5f0
movq %rax, %r13
pushq $0x8
popq %rsi
pushq $0x22
popq %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x30f40
movq %rax, (%r13)
movq %r15, 0x8(%r13)
movq %r14, 0x10(%r13)
movq %rbx, 0x18(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x308672(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1dbea8(%rip), %rsi    # 0x2de7f0
leaq 0x1f2375(%rip), %rdx    # 0x2f4cc4
leaq 0x1f239e(%rip), %rcx    # 0x2f4cf4
leaq 0x1f23a8(%rip), %r8     # 0x2f4d05
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/str_cache.c
// Function: gt_str_cache_delete
void gt_str_cache_delete(GtStrCache *str_cache)
{
  GtUword i;
  if (!str_cache) return;
  for (i = 0; i < str_cache->num_of_strings; i++)
    gt_str_delete(str_cache->cache[i]);
  gt_free(str_cache->cache);
  gt_free(str_cache);
}

// Assembly:
testq %rdi, %rdi
je 0x1029ba
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x18(%rbx), %r14
jae 0x102993
movq (%rdi,%r14,8), %rdi
callq 0x33020
incq %r14
jmp 0x10297c
leaq 0x1f236b(%rip), %r14    # 0x2f4d05
pushq $0x2f
popq %rdx
movq %r14, %rsi
callq 0x30f00
pushq $0x30
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30f00
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/str_cache.c
// Function: gt_str_cache_get
GtStr* gt_str_cache_get(GtStrCache *str_cache, GtUword index)
{
  gt_assert(str_cache && index < str_cache->num_of_strings);
  if (!str_cache->cache[index])
    str_cache->cache[index] = str_cache->constructor(str_cache->source, index);
  gt_assert(str_cache->cache[index]);
  return gt_str_ref(str_cache->cache[index]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x102a06
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x102a06
movq (%r14), %rax
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
jne 0x1029fa
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *0x10(%r14)
movq (%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq (%r14), %rax
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
je 0x102a3c
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x302f0
movq 0x3085a3(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1dbdd9(%rip), %rsi    # 0x2de7f0
leaq 0x1f22fc(%rip), %rdx    # 0x2f4d1a
leaq 0x1f2324(%rip), %rcx    # 0x2f4d49
leaq 0x1f22d9(%rip), %r8     # 0x2f4d05
pushq $0x35
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
movq 0x30856d(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1dbda3(%rip), %rsi    # 0x2de7f0
leaq 0x1f2306(%rip), %rdx    # 0x2f4d5a
leaq 0x1f22ee(%rip), %rcx    # 0x2f4d49
leaq 0x1f22a3(%rip), %r8     # 0x2f4d05
pushq $0x38
jmp 0x102a2e
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/tooldriver.c
// Function: gt_tooldriver
int gt_tooldriver(GtToolFunc tool, int argc, char *argv[])
{
  gt_assert(tool && argv);
  GtError *err;
  int had_err;
  gt_lib_init();
  gt_assert(tool && argv);
  err = gt_error_new();
  gt_error_set_progname(err, argv[0]);
  had_err = tool(argc, (const char**) argv, err);
  if (gt_error_is_set(err)) {
    fprintf(stderr, "%s: error: %s\n", gt_error_get_progname(err),
            gt_error_get(err));
    gt_assert(had_err);
  }
  gt_error_delete(err);
  if (gt_lib_clean())
    return GT_EXIT_PROGRAMMING_ERROR; /* programmer error */
  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x10562d
movq %rdx, %r15
testq %rdx, %rdx
je 0x10562d
movl %esi, %ebp
movq %rdi, %r14
callq 0x30580
callq 0x2f140
movq %rax, %rbx
movq (%r15), %rsi
movq %rax, %rdi
callq 0x32a50
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
movl %eax, %ebp
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x1055d0
movq %rbx, %rdi
callq 0x32fc0
callq 0x31bf0
xorl %ecx, %ecx
testl %ebp, %ebp
setne %cl
testl %eax, %eax
pushq $0x2
popq %rax
cmovel %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3059d9(%rip), %r12    # 0x40afb0
movq (%r12), %r14
movq %rbx, %rdi
callq 0x317b0
movq %rax, %r15
movq %rbx, %rdi
callq 0x31a60
leaq 0x1f012e(%rip), %rsi    # 0x2f5723
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x32960
testl %ebp, %ebp
jne 0x1055ab
movq (%r12), %rdi
leaq 0x1d91dc(%rip), %rsi    # 0x2de7f0
leaq 0x1df4ee(%rip), %rdx    # 0x2e4b09
leaq 0x1f00dd(%rip), %rcx    # 0x2f56ff
leaq 0x1f00e4(%rip), %r8     # 0x2f570d
pushq $0x24
jmp 0x105655
movq 0x30597c(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1d91b2(%rip), %rsi    # 0x2de7f0
leaq 0x1f00ad(%rip), %rdx    # 0x2f56f2
leaq 0x1f00b3(%rip), %rcx    # 0x2f56ff
leaq 0x1f00ba(%rip), %r8     # 0x2f570d
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/tooldriver.c
// Function: gt_toolobjdriver
int gt_toolobjdriver(GtToolConstructor tool_constructor,
                     GtShowVersionFunc version_func, int argc, char *argv[])
{
  gt_assert(tool_constructor && argv);
  GtTool *tool;
  GtError *err;
  int had_err;
  gt_lib_init();
  gt_assert(tool_constructor && argv);
  err = gt_error_new();
  gt_error_set_progname(err, argv[0]);
  tool = tool_constructor();
  if (version_func) {
    GtOptionParser *op = gt_tool_get_option_parser(tool);
    gt_option_parser_set_version_func(op, version_func);
  }
  had_err = gt_tool_run(tool, argc, (const char**) argv, err);
  gt_tool_delete(tool);
  if (gt_error_is_set(err)) {
    fprintf(stderr, "%s: error: %s\n", gt_error_get_progname(err),
            gt_error_get(err));
    gt_assert(had_err);
  }
  gt_error_delete(err);
  if (gt_lib_clean())
    return GT_EXIT_PROGRAMMING_ERROR; /* programmer error */
  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x105766
movq %rcx, %r14
testq %rcx, %rcx
je 0x105766
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
callq 0x30580
callq 0x2f140
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
callq 0x32a50
callq *%r12
movq %rax, %r12
testq %r15, %r15
je 0x1056be
movq %r12, %rdi
callq 0x104b7f
movq %rax, %rdi
movq %r15, %rsi
callq 0x327c0
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x31c50
movl %eax, %ebp
movq %r12, %rdi
callq 0x2f170
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x105709
movq %rbx, %rdi
callq 0x32fc0
callq 0x31bf0
xorl %ecx, %ecx
testl %ebp, %ebp
setne %cl
testl %eax, %eax
pushq $0x2
popq %rax
cmovel %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3058a0(%rip), %r12    # 0x40afb0
movq (%r12), %r14
movq %rbx, %rdi
callq 0x317b0
movq %rax, %r15
movq %rbx, %rdi
callq 0x31a60
leaq 0x1efff5(%rip), %rsi    # 0x2f5723
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x32960
testl %ebp, %ebp
jne 0x1056e4
movq (%r12), %rdi
leaq 0x1d90a3(%rip), %rsi    # 0x2de7f0
leaq 0x1df3b5(%rip), %rdx    # 0x2e4b09
leaq 0x1efff0(%rip), %rcx    # 0x2f574b
leaq 0x1effab(%rip), %r8     # 0x2f570d
pushq $0x43
jmp 0x10578e
movq 0x305843(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1d9079(%rip), %rsi    # 0x2de7f0
leaq 0x1effb4(%rip), %rdx    # 0x2f5732
leaq 0x1effc6(%rip), %rcx    # 0x2f574b
leaq 0x1eff81(%rip), %r8     # 0x2f570d
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/buffer_stream.c
// Function: gt_buffer_stream_class
const GtNodeStreamClass* gt_buffer_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtBufferStream),
                                   buffer_stream_free,
                                   buffer_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xbafdf
cmpq $0x0, 0x2fdd8e(%rip)    # 0x412968
jne 0x114bf9
leaq 0x24(%rip), %rsi        # 0x114c07
leaq 0x64(%rip), %rdx        # 0x114c4e
pushq $0x28
popq %rdi
callq 0x2f6f0
movq %rax, 0x2fdd6f(%rip)    # 0x412968
callq 0xbb026
movq 0x2fdd63(%rip), %rax    # 0x412968
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/buffer_stream.c
// Function: buffer_stream_free
static void buffer_stream_free(GtNodeStream *ns)
{
  GtBufferStream *bs = buffer_stream_cast(ns);
  while (gt_queue_size(bs->node_buffer))
    gt_genome_node_delete(gt_queue_get(bs->node_buffer));
  gt_queue_delete(bs->node_buffer);
  gt_node_stream_delete(bs->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30d70
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2ff80
movq %rax, %rbx
movq 0x18(%rbx), %rdi
callq 0x318a0
movq 0x18(%rbx), %rdi
testq %rax, %rax
je 0x114c3f
callq 0x31220
movq %rax, %rdi
callq 0x33078
jmp 0x114c1e
callq 0x2e080
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x32d70
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/buffer_stream.c
// Function: buffer_stream_next
static int buffer_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err)
{
  GtBufferStream *bs;
  gt_error_check(err);
  bs = buffer_stream_cast(ns);
  if (bs->buffering) {
    int had_err = gt_node_stream_next(bs->in_stream, gn, err);
    if (!had_err && *gn)
      gt_queue_add(bs->node_buffer, gt_genome_node_ref(*gn));
    return had_err;
  }
  else {
    *gn = gt_queue_size(bs->node_buffer) ? gt_queue_get(bs->node_buffer) : NULL;
    return 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x114c6d
movq %r14, %rdi
callq 0x32150
testb %al, %al
jne 0x114ce7
callq 0x30d70
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ff80
movq %rax, %r15
cmpb $0x1, 0x20(%rax)
jne 0x114cbd
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x304c0
movl %eax, %r14d
testl %eax, %eax
jne 0x114cde
movq (%rbx), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x114cde
movq 0x18(%r15), %rbx
callq 0x2feb0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x32c00
jmp 0x114cde
movq 0x18(%r15), %rdi
callq 0x318a0
xorl %r14d, %r14d
testq %rax, %rax
je 0x114cd9
movq 0x18(%r15), %rdi
callq 0x31220
jmp 0x114cdb
xorl %eax, %eax
movq %rax, (%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2f62c2(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1c9af8(%rip), %rsi    # 0x2de7f0
leaq 0x1c9cc4(%rip), %rdx    # 0x2de9c3
leaq 0x1e6d4b(%rip), %rcx    # 0x2fba51
leaq 0x1e6d0e(%rip), %r8     # 0x2fba1b
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/buffer_stream.c
// Function: gt_buffer_stream_new
GtNodeStream* gt_buffer_stream_new(GtNodeStream *in_stream)
{
  GtBufferStream *bs;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_buffer_stream_class(), false);
  bs = buffer_stream_cast(ns);
  bs->in_stream = gt_node_stream_ref(in_stream);
  bs->node_buffer = gt_queue_new();
  bs->buffering = true;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x114d72
movq %rdi, %rbx
callq 0x30d70
movq %rax, %rdi
xorl %esi, %esi
callq 0x312a0
movq %rax, %r14
callq 0x30d70
movq %rax, %rdi
movq %r14, %rsi
callq 0x2ff80
movq %rax, %r15
movq %rbx, %rdi
callq 0x2e9c0
movq %rax, 0x10(%r15)
callq 0x2e930
movq %rax, 0x18(%r15)
movb $0x1, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2f6237(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1c9a6d(%rip), %rsi    # 0x2de7f0
leaq 0x1e2902(%rip), %rdx    # 0x2f768c
leaq 0x1e6c75(%rip), %rcx    # 0x2fba06
leaq 0x1e6c83(%rip), %r8     # 0x2fba1b
pushq $0x4b
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/dot_out_stream.c
// Function: gt_dot_out_stream_new
GtNodeStream* gt_dot_out_stream_new(GtNodeStream *in_stream)
{
  GtNodeVisitor *nv;
  gt_assert(in_stream);
  nv = gt_dot_visitor_new();
  return gt_visitor_stream_new(in_stream, nv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x128662
movq %rdi, %rbx
callq 0x128849
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x32060
movq 0x2e2947(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x1b617d(%rip), %rsi    # 0x2de7f0
leaq 0x1cf012(%rip), %rdx    # 0x2f768c
leaq 0x1d77f9(%rip), %rcx    # 0x2ffe7a
leaq 0x1d7808(%rip), %r8     # 0x2ffe90
pushq $0x1a
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/permute_words.c
// Function: gt_permute_word_next
unsigned int gt_permute_word_next(char *w, GtUword l,
                               GtUword alphabet_size)
{
  GtUword i;
  unsigned int next = 1;

  gt_assert(w && l && alphabet_size);

  for (i = 0; i < l; i++) {
    if (w[i] < alphabet_size - 1) {
      w[i]++;
      break;
    }
    else {
      w[i] = 0;
      if (i == l - 1)
        next = 0;
    }
  }

  return next;
}

// Assembly:
testq %rdi, %rdi
je 0x165373
testq %rsi, %rsi
je 0x165373
testq %rdx, %rdx
je 0x165373
decq %rdx
leaq -0x1(%rsi), %r8
pushq $0x1
popq %rax
xorl %r9d, %r9d
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x165372
movsbq (%rdi,%rcx), %r10
cmpq %r10, %rdx
ja 0x16536b
movb $0x0, (%rdi,%rcx)
cmpq %rcx, %r8
cmovel %r9d, %eax
incq %rcx
jmp 0x16534c
incb %r10b
movb %r10b, (%rdi,%rcx)
retq
pushq %rax
movq 0x2a5c35(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x17946b(%rip), %rsi    # 0x2de7f0
leaq 0x1aed9b(%rip), %rdx    # 0x314127
leaq 0x1aedac(%rip), %rcx    # 0x31413f
leaq 0x1aedba(%rip), %r8     # 0x314154
pushq $0x21
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_stream.c
// Function: gt_script_wrapper_stream_class
const GtNodeStreamClass* gt_script_wrapper_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtScriptWrapperStream),
                                   script_wrapper_stream_free,
                                   script_wrapper_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xbafdf
cmpq $0x0, 0x29c3a6(%rip)    # 0x412b48
jne 0x1767c1
leaq 0x24(%rip), %rsi        # 0x1767cf
leaq 0x45(%rip), %rdx        # 0x1767f7
pushq $0x20
popq %rdi
callq 0x2f6f0
movq %rax, 0x29c387(%rip)    # 0x412b48
callq 0xbb026
movq 0x29c37b(%rip), %rax    # 0x412b48
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_stream.c
// Function: script_wrapper_stream_free
static void script_wrapper_stream_free(GtNodeStream *ns)
{
  GtScriptWrapperStream *script_wrapper_stream;
  if (!ns) return;
  script_wrapper_stream = script_wrapper_stream_cast(ns);
  if (script_wrapper_stream->free_func)
    script_wrapper_stream->free_func(NULL);
}

// Assembly:
testq %rdi, %rdi
je 0x1767f6
pushq %rbx
movq %rdi, %rbx
callq 0x176794
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2ff80
movq 0x18(%rax), %rax
testq %rax, %rax
popq %rbx
je 0x1767f6
xorl %edi, %edi
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_stream.c
// Function: script_wrapper_stream_next
static int script_wrapper_stream_next(GtNodeStream *ns,
                                      GtGenomeNode **gn,
                                      GtError *err)
{
  GtScriptWrapperStream *script_wrapper_stream;
  int had_err = 0;
  gt_error_check(err);
  script_wrapper_stream = script_wrapper_stream_cast(ns);
  had_err = script_wrapper_stream->next_func(gn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x176816
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x176837
callq 0x176794
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ff80
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq 0x294772(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167fa8(%rip), %rsi    # 0x2de7f0
leaq 0x168174(%rip), %rdx    # 0x2de9c3
leaq 0x1a22c6(%rip), %rcx    # 0x318b1c
leaq 0x1a229a(%rip), %r8     # 0x318af7
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_stream.c
// Function: gt_script_wrapper_stream_new
GtNodeStream* gt_script_wrapper_stream_new(GtScriptWrapperStreamNextFunc next,
                                           GtScriptWrapperStreamFreeFunc free)
{
  GtNodeStream *ns;
  GtScriptWrapperStream *script_wrapper_stream;
  gt_assert(next);
  ns = gt_node_stream_create(gt_script_wrapper_stream_class(), false);
  script_wrapper_stream = script_wrapper_stream_cast(ns);
  script_wrapper_stream->next_func = next;
  script_wrapper_stream->free_func = free;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1768b0
movq %rsi, %rbx
movq %rdi, %r14
callq 0x176794
movq %rax, %rdi
xorl %esi, %esi
callq 0x312a0
movq %rax, %r15
callq 0x176794
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ff80
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2946f9(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167f2f(%rip), %rsi    # 0x2de7f0
leaq 0x19ce96(%rip), %rdx    # 0x31375e
leaq 0x1a220b(%rip), %rcx    # 0x318ada
leaq 0x1a2221(%rip), %r8     # 0x318af7
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: gt_script_wrapper_visitor_class
const GtNodeVisitorClass* gt_script_wrapper_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtScriptWrapperVisitor),
                                    script_wrapper_visitor_free,
                                    script_wrapper_visitor_comment_node,
                                    script_wrapper_visitor_feature_node,
                                    script_wrapper_visitor_region_node,
                                    script_wrapper_visitor_sequence_node,
                                    script_wrapper_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc,
                                             script_wrapper_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xbafdf
cmpq $0x0, 0x29c25a(%rip)    # 0x412b50
jne 0x176944
leaq 0x2be(%rip), %rax       # 0x176bbd
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x176952
leaq 0xa0(%rip), %rdx        # 0x1769b1
leaq 0x11c(%rip), %rcx       # 0x176a34
leaq 0x198(%rip), %r8        # 0x176ab7
leaq 0x214(%rip), %r9        # 0x176b3a
pushq $0x48
popq %rdi
callq 0x2eb80
movq %rax, 0x29c21b(%rip)    # 0x412b50
leaq 0x304(%rip), %rsi       # 0x176c40
movq %rax, %rdi
callq 0x2e590
callq 0xbb026
movq 0x29c200(%rip), %rax    # 0x412b50
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_free
static void script_wrapper_visitor_free(GtNodeVisitor *nv)
{
  GtScriptWrapperVisitor *swv;
  gt_assert(nv);
  swv  = gt_script_wrapper_visitor_cast(nv);
  if (swv->free_func)
    swv->free_func(NULL);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x17697b
movq %rdi, %rbx
callq 0x1768e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2f4e0
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x176979
xorl %edi, %edi
popq %rbx
jmpq *%rax
popq %rbx
retq
movq 0x29462e(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167e64(%rip), %rsi    # 0x2de7f0
leaq 0x1af056(%rip), %rdx    # 0x3259e9
leaq 0x1a219d(%rip), %rcx    # 0x318b37
leaq 0x1a21b2(%rip), %r8     # 0x318b53
pushq $0x2a
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_comment_node
static int script_wrapper_visitor_comment_node(GtNodeVisitor *nv,
                                               GtCommentNode *cn,
                                               GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->comment_node_func)
    had_err = swv->comment_node_func(cn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1769d0
movq %rbx, %rdi
callq 0x32150
testb %al, %al
jne 0x1769fe
callq 0x1768e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2f4e0
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1769f6
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2945ab(%rip), %rax    # 0x40afb0
movq (%rax), %rdi
leaq 0x167de1(%rip), %rsi    # 0x2de7f0
leaq 0x167fad(%rip), %rdx    # 0x2de9c3
leaq 0x1a215c(%rip), %rcx    # 0x318b79
leaq 0x1a212f(%rip), %r8     # 0x318b53
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x32960
callq 0x2e820