LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x202d75(%rip), %rsi    # 0x34ace5
movl $0x58, %edi
movl $0x29, %edx
callq 0x2d5f0
testq %rax, %rax
je 0x147fcb
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x40(%rax)
movw $0x1, 0x50(%rax)
leaq 0x202d37(%rip), %rdx    # 0x34ace5
movl $0x100, %edi            # imm = 0x100
movl $0x8, %esi
movl $0x31, %ecx
callq 0x2fef0
movq %rax, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x38784
// File: /workspace/github_c_makefile_star2_O1/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 0x148090
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x14800d
leaq 0x18(%rbx), %r14
leaq 0x202cf1(%rip), %rsi    # 0x34ace5
movl $0x43, %edx
callq 0x2feb0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x148034
leaq 0x202cc9(%rip), %rsi    # 0x34ace5
movl $0x44, %edx
callq 0x2feb0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x148061
leaq 0x30(%rbx), %r14
leaq 0x202c9d(%rip), %rsi    # 0x34ace5
movl $0x45, %edx
callq 0x2feb0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x48(%rbx), %rdi
leaq 0x202c79(%rip), %r14    # 0x34ace5
movq %r14, %rsi
movl $0x46, %edx
callq 0x2feb0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x47, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2feb0
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x40(%rdi)
je 0x1480c1
movq 0x30(%rdi), %rax
movq 0x48(%rdi), %rcx
xorl %edx, %edx
movsbq (%rax,%rdx), %rsi
movq $0x0, (%rcx,%rsi,8)
incq %rdx
cmpq 0x40(%rdi), %rdx
jb 0x1480ab
movq $0x0, 0x40(%rdi)
movq 0x48(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1480f0
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x1480cf
movq $0x0, 0x28(%rdi)
movb $0x1, 0x50(%rdi)
popq %rax
retq
callq 0x387bb
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x148204
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x148091
movb %bpl, 0x51(%r14)
leaq 0x202bc8(%rip), %r15    # 0x34ace5
movq %rbx, %rdi
callq 0x2f520
cmpl $-0x1, %eax
je 0x148145
movl %eax, %ebp
cmpl $0xa, %eax
jne 0x14814f
movq %r14, %rdi
xorl %esi, %esi
callq 0x148209
movl $0x1, %eax
jmp 0x1481e1
movl $0x5, %eax
jmp 0x1481e1
movsbl 0x51(%r14), %eax
cmpl %eax, %ebp
jne 0x1481b5
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x148209
movq 0x20(%r14), %rax
cmpq %rax, 0x28(%r14)
jb 0x148196
leaq 0x400(%rax), %rcx
movq %rcx, 0x20(%r14)
movq 0x18(%r14), %rdi
leaq 0x2000(,%rax,8), %rsi
movq %r15, %rdx
movl $0x74, %ecx
callq 0x2d900
movq %rax, 0x18(%r14)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x1481ff
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movq %rcx, (%rax,%rdx,8)
jmp 0x1481df
cmpb $0x1, 0x50(%r14)
jne 0x1481d3
callq 0x2f1b0
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x1481d3
movb $0x0, 0x50(%r14)
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x148209
xorl %eax, %eax
testl %eax, %eax
je 0x14811d
cmpl $0x1, %eax
jne 0x1481f2
movb $0x1, %al
jmp 0x1481f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x387f2
callq 0x38829
// File: /workspace/github_c_makefile_star2_O1/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)
jb 0x14823e
addq $0x400, %rsi            # imm = 0x400
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x202ab4(%rip), %rdx    # 0x34ace5
movl $0x37, %ecx
callq 0x2d900
movq %rax, (%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1482b9
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %bpl, (%rax,%rcx)
movq 0x48(%rbx), %rax
movsbq %bpl, %r14
cmpq $0x0, (%rax,%r14,8)
jne 0x1482ac
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x40(%rbx)
jb 0x148293
addq $0x100, %rsi            # imm = 0x100
movq %rsi, 0x38(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x202a60(%rip), %rdx    # 0x34ace5
movl $0x3a, %ecx
callq 0x2d900
movq %rax, 0x30(%rbx)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x1482be
movq 0x40(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x40(%rbx)
movb %bpl, (%rax,%rcx)
movq 0x48(%rbx), %rax
incq (%rax,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x38897
callq 0x38860
// File: /workspace/github_c_makefile_star2_O1/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 0x148335
cmpb $0x1, 0x50(%rdi)
je 0x148335
testq %rsi, %rsi
je 0x1482f0
leaq -0x1(%rsi), %rax
cmpq 0x28(%rdi), %rax
jae 0x14833a
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
addq -0x8(%rcx,%rsi,8), %rax
jmp 0x1482fa
cmpq $0x1, 0x10(%rdi)
jbe 0x14833f
movq (%rdi), %rax
testq %rsi, %rsi
je 0x148317
cmpq %rsi, 0x28(%rdi)
jne 0x148323
movq 0x18(%rdi), %rcx
movq -0x8(%rcx,%rsi,8), %rdx
notq %rdx
addq 0x10(%rdi), %rdx
jmp 0x148333
movq 0x18(%rdi), %rcx
movq (%rcx), %rdx
decq %rdx
jmp 0x148333
movq 0x18(%rdi), %rcx
movq -0x8(%rcx,%rsi,8), %rdx
notq %rdx
addq (%rcx,%rsi,8), %rdx
popq %rcx
retq
callq 0x38940
callq 0x388ce
callq 0x38907
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x2d4b0
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x14837d
movq (%rbx), %rcx
xorl %edx, %edx
movsbq (%rcx,%rdx), %rsi
incq (%rsp,%rsi,8)
incq %rdx
cmpq %rdx, %rax
jne 0x14836c
movq 0x48(%rbx), %rax
xorl %ecx, %ecx
movq (%rsp,%rcx,8), %r8
movq (%rax,%rcx,8), %r9
cmpq %r9, %r8
jne 0x1483a5
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x148383
addq $0x800, %rsp            # imm = 0x800
popq %rbx
retq
movq 0x347c14(%rip), %rax    # 0x48ffc0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x202acb(%rip), %rsi    # 0x34ae84
xorl %eax, %eax
callq 0x31920
movl $0x2, %edi
callq 0x2dd40
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/csvline_reader.c
// Function: gt_csvline_reader_dist_only_for_column
void gt_csvline_reader_dist_only_for_column(GtCsvlineReader *csvline_reader,
                                            GtUword colnum)
{
  GtUword idx, write_idx,
          numofcols = gt_csvline_reader_column_number(csvline_reader);

  gt_assert(numofcols > 0 && colnum < numofcols &&
            csvline_reader->dist.charcount[(int) csvline_reader->separator]
            == numofcols - 1);
  csvline_reader->dist.charcount[(int) csvline_reader->separator] = 0;
  gt_assert(csvline_reader->dist.charcount[(int) '\0'] == 1);
  csvline_reader->dist.charcount[(int) '\0'] = 0;
  for (idx = 0; idx < numofcols; idx++)
  {
    if (idx != colnum)
    {
      GtCsvcolumn col = gt_csvline_reader_column(csvline_reader,idx);
      GtUword j;

      for (j = 0; j < col.width; j++)
      {
        char currentcc = col.content[j];
        gt_assert(csvline_reader->dist.charcount[(int) currentcc] > 0);
        csvline_reader->dist.charcount[(int) currentcc]--;
      }
    }
  }
  for (idx = 0, write_idx = 0;
       idx < csvline_reader->dist.alphabet.nextfreechar; idx++)
  {
    char currentcc = csvline_reader->dist.alphabet.spacechar[idx];
    if (csvline_reader->dist.charcount[(int) currentcc] > 0)
    {
      if (write_idx < idx)
      {
        csvline_reader->dist.alphabet.spacechar[write_idx] = currentcc;
      }
      write_idx++;
    }
  }
  csvline_reader->dist.alphabet.nextfreechar = write_idx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x50(%rdi)
je 0x1483f4
xorl %r12d, %r12d
jmp 0x1483fb
movq 0x28(%rbx), %r12
incq %r12
cmpq %r14, %r12
jbe 0x1484c5
movq 0x48(%rbx), %rax
movsbq 0x51(%rbx), %rcx
leaq -0x1(%r12), %rdx
cmpq %rdx, (%rax,%rcx,8)
jne 0x1484c5
movq $0x0, (%rax,%rcx,8)
cmpq $0x1, (%rax)
jne 0x1484ca
movq $0x0, (%rax)
xorl %r15d, %r15d
cmpq %r14, %r15
je 0x148470
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1482c7
testq %rdx, %rdx
je 0x148470
movq 0x48(%rbx), %rcx
xorl %esi, %esi
movsbq (%rax,%rsi), %rdi
movq (%rcx,%rdi,8), %r8
testq %r8, %r8
je 0x1484c0
decq %r8
movq %r8, (%rcx,%rdi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x148453
incq %r15
cmpq %r12, %r15
jne 0x148438
cmpq $0x0, 0x40(%rbx)
je 0x1484ae
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x30(%rbx), %rdx
movq 0x48(%rbx), %rdi
movsbq (%rdx,%rcx), %rsi
cmpq $0x0, (%rdi,%rsi,8)
je 0x1484a3
cmpq %rcx, %rax
jae 0x1484a0
movb %sil, (%rdx,%rax)
incq %rax
incq %rcx
cmpq 0x40(%rbx), %rcx
jb 0x148483
jmp 0x1484b0
xorl %eax, %eax
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x389eb
callq 0x38979
callq 0x389b2
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x2d4b0
testq %r14, %r14
je 0x14850b
xorl %eax, %eax
movsbq (%r15,%rax), %rcx
incq (%rsp,%rcx,8)
incq %rax
cmpq %rax, %r14
jne 0x1484fa
movq 0x48(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
movq (%rdx,%rsi,8), %rcx
cmpq %rcx, (%rsp,%rsi,8)
jne 0x148572
movq %rdi, %rax
cmpq $0x1, %rcx
sbbq $-0x1, %rdi
incq %rsi
cmpq $0x100, %rsi            # imm = 0x100
jne 0x148513
cmpq 0x40(%rbx), %rdi
jne 0x14857c
testq %rdi, %rdi
je 0x148565
movq 0x30(%rbx), %rdx
movq 0x48(%rbx), %rsi
cmpq $0x1, %rcx
sbbq $-0x1, %rax
xorl %ecx, %ecx
movsbq (%rdx,%rcx), %rdi
cmpq $0x0, (%rsi,%rdi,8)
je 0x148577
incq %rcx
cmpq %rcx, %rax
jne 0x148551
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq
callq 0x38a24
callq 0x38a96
callq 0x38a5d
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x40(%rdi)
je 0x1485d7
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x202acf(%rip), %r14    # 0x34b066
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq 0x48(%rbx), %rcx
movsbq (%rax,%r15), %rsi
movq (%rcx,%rsi,8), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2d300
incq %r15
movl $0xa, %edi
cmpq 0x40(%rbx), %r15
jae 0x1485c7
movsbl 0x51(%rbx), %edi
callq 0x2df70
cmpq 0x40(%rbx), %r15
jb 0x14859a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x40(%rdx)
je 0x148605
movq 0x30(%rdx), %rax
xorl %ecx, %ecx
movsbq (%rax,%rcx), %r8
cmpq %rsi, %r8
ja 0x148607
movq 0x48(%rdx), %r9
movq (%r9,%r8,8), %r9
addq %r9, (%rdi,%r8,8)
incq %rcx
cmpq 0x40(%rdx), %rcx
jb 0x1485e6
popq %rax
retq
callq 0x38acf
// File: /workspace/github_c_makefile_star2_O1/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 0x1622e0
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1622e2
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1622cb
movq %rbx, %rdi
callq *%rax
leaq 0x1f054b(%rip), %rsi    # 0x35281d
movq %rbx, %rdi
movl $0x2b, %edx
popq %rbx
jmp 0x2feb0
popq %rbx
retq
callq 0x41684
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x32847d(%rip), %r14    # 0x48c4e0
movq %r14, %rdi
callq 0x163ab4
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x163b91
movq %rax, %r14
movq %r15, %rdi
callq 0x2f2c0
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0x1640aa
movq %r15, %rdi
callq 0x31b20
leaq 0x1e454f(%rip), %rsi    # 0x3485eb
movq %rax, %rdi
callq 0x2e3b0
movq %rax, 0x10(%r14)
jmp 0x1640ba
leaq 0x25a28e(%rip), %rdi    # 0x3be33f
callq 0x2f0d0
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/fasta_reader_seqit.c
// Function: gt_fasta_reader_seqit_run
static int gt_fasta_reader_seqit_run(GtFastaReader *fasta_reader,
                                     GtFastaReaderProcDescription
                                     proc_description,
                                     GtFastaReaderProcSequencePart
                                     proc_sequence_part,
                                     GtFastaReaderProcSequenceLength
                                     proc_sequence_length,
                                     void *data, GtError *err)
{
  GtFastaReaderSeqIt *gt_fasta_reader_seqit =
    gt_fasta_reader_seqit_cast(fasta_reader);
  const GtUchar *sequence;
  GtUword len;
  char *desc;
  int rval, had_err = 0;
  gt_error_check(err);

  /* at least one function has to be defined */
  gt_assert(proc_description || proc_sequence_part || proc_sequence_length);

  while ((rval = gt_seq_iterator_next(gt_fasta_reader_seqit->seqit, &sequence,
                                     &len, &desc, err))) {
    if (rval < 0) {
      had_err = -1;
      break;
    }

    if (proc_description)
      had_err = proc_description(desc, strlen(desc), data, err);
    if (!had_err && proc_sequence_part)
      had_err = proc_sequence_part((char*) sequence, len, data, err);
    if (!had_err && proc_sequence_length)
      had_err = proc_sequence_length(len, data, err);

    gt_free(desc);
    if (had_err)
      break;
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rsi
leaq 0x328009(%rip), %rdi    # 0x48c510
callq 0x163b91
movq %rax, 0x18(%rsp)
testq %rbx, %rbx
je 0x164526
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x164606
movq %r13, %rax
orq %r12, %rax
orq %r15, %rax
je 0x164601
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %r8
callq 0x31c20
testl %eax, %eax
je 0x1645e7
js 0x1645eb
testq %r13, %r13
je 0x164588
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x2ee50
movq %rbp, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *%r13
movl %eax, %ebp
jmp 0x16458a
xorl %ebp, %ebp
testq %r12, %r12
sete %al
testl %ebp, %ebp
setne %cl
orb %al, %cl
jne 0x1645ae
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *%r12
movl %eax, %ebp
testq %r15, %r15
je 0x1645c7
testl %ebp, %ebp
jne 0x1645c7
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x1eec83(%rip), %rsi    # 0x353256
movl $0x44, %edx
callq 0x2feb0
testl %ebp, %ebp
je 0x164535
jmp 0x1645f0
xorl %ebp, %ebp
jmp 0x1645f0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x42c7e
callq 0x42c47
// File: /workspace/github_c_makefile_star2_O1/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 0x16469e
movq %rdi, %r14
leaq 0x327ec8(%rip), %r15    # 0x48c510
movq %r15, %rdi
callq 0x163ab4
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x163b91
movq %rax, %r15
callq 0x30540
movq %rax, %r12
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x31b20
movq %r12, %rdi
movq %rax, %rsi
callq 0x2d570
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq 0x31f20
movq %rax, 0x10(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x42cb5
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x171dd1
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x171d15
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x171dd6
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x2ff50
testl %eax, %eax
je 0x171d2e
leaq 0x1e4d00(%rip), %rsi    # 0x356a2c
jmp 0x171d55
leaq 0x4(%rsp), %rdx
movl 0xc(%rdx), %ebp
movl %ebp, %eax
andl $-0x9, %eax
movl %eax, 0xc(%rdx)
xorl %edi, %edi
movl $0x2, %esi
callq 0x2d190
testl %eax, %eax
je 0x171d73
leaq 0x1e4cea(%rip), %rsi    # 0x356a3f
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2f9e0
movq %r14, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x31e246(%rip), %r15    # 0x48ffc0
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2fba0
leaq 0x1e4cc6(%rip), %rdi    # 0x356a52
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x30ca0
cmpl $0x1, %eax
jne 0x171ddb
leaq 0x4(%rsp), %rdx
movl %ebp, 0xc(%rdx)
xorl %edi, %edi
movl $0x2, %esi
callq 0x2d190
testl %eax, %eax
jne 0x171d4e
movq (%r15), %rsi
movl $0xa, %edi
callq 0x2ecc0
leaq 0x40(%rsp), %rdi
callq 0x2f0d0
movq %rax, %r14
jmp 0x171d62
callq 0x46e02
callq 0x46d94
callq 0x46dcb
// File: /workspace/github_c_makefile_star2_O1/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 0x18314b
movq %rsi, %r14
testq %rsi, %rsi
je 0x18314b
movq %rdx, %rbx
testq %rdx, %rdx
je 0x18314b
movq %rdi, %r15
leaq 0x1d7a59(%rip), %r12    # 0x35ab5d
movl $0x20, %edi
movq %r12, %rsi
movl $0x21, %edx
callq 0x2d5f0
movq %rax, %r13
movl $0x8, %esi
movq %rbx, %rdi
movq %r12, %rdx
movl $0x22, %ecx
callq 0x2fef0
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
callq 0x4ac51
// File: /workspace/github_c_makefile_star2_O1/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 0x1831a9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x18317b
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x31fe0
incq %r14
cmpq 0x18(%rbx), %r14
jb 0x183166
movq (%rbx), %rdi
leaq 0x1d79d8(%rip), %r14    # 0x35ab5d
movq %r14, %rsi
movl $0x2f, %edx
callq 0x2feb0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x30, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2feb0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1831f3
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x1831f3
movq (%r14), %rax
cmpq $0x0, (%rax,%rbx,8)
jne 0x1831db
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 0x1831f8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2f2c0
callq 0x4acbf
callq 0x4ac88
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x184fb7
movq %rdx, %r15
testq %rdx, %rdx
je 0x184fb7
movl %esi, %ebp
movq %rdi, %r14
callq 0x2f550
callq 0x2e120
movq %rax, %rbx
movq (%r15), %rsi
movq %rax, %rdi
callq 0x31a10
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
movl %eax, %ebp
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x184fab
movq %rbx, %rdi
callq 0x31f80
callq 0x30b90
xorl %ecx, %ecx
testl %ebp, %ebp
setne %cl
testl %eax, %eax
movl $0x2, %eax
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4beb2
jmp 0x184f82
callq 0x4be7b
// File: /workspace/github_c_makefile_star2_O1/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 0x185070
movq %rcx, %r14
testq %rcx, %rcx
je 0x185070
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
callq 0x2f550
callq 0x2e120
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
callq 0x31a10
callq *%r12
movq %rax, %r12
testq %r15, %r15
je 0x185017
movq %r12, %rdi
callq 0x1848c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31780
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30bf0
movl %eax, %ebp
movq %r12, %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x185064
movq %rbx, %rdi
callq 0x31f80
callq 0x30b90
xorl %ecx, %ecx
testl %ebp, %ebp
setne %cl
testl %eax, %eax
movl $0x2, %eax
cmovel %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4bf67
jmp 0x18503d
callq 0x4bf30
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x1456d7
cmpq $0x0, 0x3064be(%rip)    # 0x497948
jne 0x1914ab
leaq 0x26(%rip), %rsi        # 0x1914b9
leaq 0x6e(%rip), %rdx        # 0x191508
movl $0x28, %edi
callq 0x2e6f0
movq %rax, 0x30649d(%rip)    # 0x497948
callq 0x1456ed
movq 0x306491(%rip), %rax    # 0x497948
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2fd20
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2ef70
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x30850
testq %rax, %rax
je 0x1914f5
movq 0x18(%rbx), %rdi
callq 0x301c0
movq %rax, %rdi
callq 0x32038
movq 0x18(%rbx), %rdi
jmp 0x1914d4
movq 0x18(%rbx), %rdi
callq 0x2d080
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x31d10
// File: /workspace/github_c_makefile_star2_O1/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 0x191527
movq %r14, %rdi
callq 0x310f0
testb %al, %al
jne 0x19159e
callq 0x2fd20
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ef70
movq %rax, %r15
cmpb $0x1, 0x20(%rax)
jne 0x191574
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2f490
movl %eax, %r14d
testl %eax, %eax
jne 0x191595
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x191595
movq 0x18(%r15), %rbx
callq 0x2eea0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x31bb0
jmp 0x191595
movq 0x18(%r15), %rdi
callq 0x30850
xorl %r14d, %r14d
testq %rax, %rax
je 0x191590
movq 0x18(%r15), %rdi
callq 0x301c0
jmp 0x191592
xorl %eax, %eax
movq %rax, (%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5055e
// File: /workspace/github_c_makefile_star2_O1/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 0x1915f8
movq %rdi, %rbx
callq 0x2fd20
movq %rax, %rdi
xorl %esi, %esi
callq 0x30240
movq %rax, %r14
callq 0x2fd20
movq %rax, %rdi
movq %r14, %rsi
callq 0x2ef70
movq %rax, %r15
movq %rbx, %rdi
callq 0x2d9c0
movq %rax, 0x10(%r15)
callq 0x2d930
movq %rax, 0x18(%r15)
movb $0x1, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x50595
// File: /workspace/github_c_makefile_star2_O1/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 0x1a369e
movq %rdi, %rbx
callq 0x1a37d9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x30ff0
callq 0x55504
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1d7e5a
testq %rsi, %rsi
je 0x1d7e5a
testq %rdx, %rdx
je 0x1d7e5a
decq %rdx
leaq -0x1(%rsi), %rcx
movl $0x1, %eax
xorl %r9d, %r9d
xorl %r8d, %r8d
movsbq (%rdi,%r8), %r10
cmpq %r10, %rdx
ja 0x1d7e52
movb $0x0, (%rdi,%r8)
cmpq %r8, %rcx
cmovel %r9d, %eax
incq %r8
cmpq %r8, %rsi
jne 0x1d7e33
retq
incb %r10b
movb %r10b, (%rdi,%r8)
retq
pushq %rax
callq 0x66314
// File: /workspace/github_c_makefile_star2_O1/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 0x1456d7
cmpq $0x0, 0x2b18de(%rip)    # 0x497b28
jne 0x1e626b
leaq 0x26(%rip), %rsi        # 0x1e6279
leaq 0x47(%rip), %rdx        # 0x1e62a1
movl $0x20, %edi
callq 0x2e6f0
movq %rax, 0x2b18bd(%rip)    # 0x497b28
callq 0x1456ed
movq 0x2b18b1(%rip), %rax    # 0x497b28
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e62a0
pushq %rbx
movq %rdi, %rbx
callq 0x1e623c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2ef70
movq 0x18(%rax), %rax
testq %rax, %rax
popq %rbx
je 0x1e62a0
xorl %edi, %edi
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e62c0
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1e62e1
callq 0x1e623c
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ef70
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
callq 0x6b6f9
// File: /workspace/github_c_makefile_star2_O1/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 0x1e6329
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e623c
movq %rax, %rdi
xorl %esi, %esi
callq 0x30240
movq %rax, %r15
callq 0x1e623c
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ef70
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6b730
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1456d7
cmpq $0x0, 0x2b17f2(%rip)    # 0x497b30
jne 0x1e638e
leaq 0x1cb(%rip), %rax       # 0x1e6512
movq %rax, (%rsp)
leaq 0x4a(%rip), %rsi        # 0x1e639c
leaq 0x71(%rip), %rdx        # 0x1e63ca
leaq 0xbc(%rip), %rcx        # 0x1e641c
leaq 0x107(%rip), %r8        # 0x1e646e
leaq 0x152(%rip), %r9        # 0x1e64c0
movl $0x48, %edi
callq 0x2db70
movq %rax, 0x2b17b1(%rip)    # 0x497b30
leaq 0x1de(%rip), %rsi       # 0x1e6564
movq %rax, %rdi
callq 0x2d590
callq 0x1456ed
movq 0x2b1796(%rip), %rax    # 0x497b30
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e63c5
movq %rdi, %rbx
callq 0x1e6330
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2e4d0
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x1e63c3
xorl %edi, %edi
popq %rbx
jmpq *%rax
popq %rbx
retq
callq 0x6b767
// File: /workspace/github_c_makefile_star2_O1/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 0x1e63e9
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1e6417
callq 0x1e6330
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1e640f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6b79e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_feature_node
static int script_wrapper_visitor_feature_node(GtNodeVisitor *nv,
                                               GtFeatureNode *fn,
                                               GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->feature_node_func)
    had_err = swv->feature_node_func(fn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1e643b
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1e6469
callq 0x1e6330
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x1e6461
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6b7d5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_region_node
static int script_wrapper_visitor_region_node(GtNodeVisitor *nv,
                                              GtRegionNode *rn,
                                              GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->region_node_func)
    had_err = swv->region_node_func(rn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1e648d
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1e64bb
callq 0x1e6330
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1e64b3
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6b80c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_sequence_node
static int script_wrapper_visitor_sequence_node(GtNodeVisitor *nv,
                                                GtSequenceNode *sn,
                                                GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->sequence_node_func)
    had_err = swv->sequence_node_func(sn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1e64df
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1e650d
callq 0x1e6330
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1e6505
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6b843
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_eof_node
static int script_wrapper_visitor_eof_node(GtNodeVisitor *nv,
                                           GtEOFNode *rn,
                                           GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->eof_node_func)
    had_err = swv->eof_node_func(rn, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1e6531
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1e655f
callq 0x1e6330
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x1e6557
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6b87a