LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x144227
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1440c9
movb %bpl, 0x51(%rbx)
leaq 0x1fdbde(%rip), %r15    # 0x341d35
movq %r14, %rdi
callq 0x2f520
cmpl $-0x1, %eax
je 0x144215
movl %eax, %ebp
cmpl $0xa, %eax
je 0x144207
movsbl 0x51(%rbx), %eax
cmpl %eax, %ebp
jne 0x144197
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x14422c
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
jae 0x1441c1
movq 0x18(%rbx), %rax
jmp 0x1441e9
cmpb $0x1, 0x50(%rbx)
jne 0x1441b3
callq 0x2f1b0
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x1441b3
movb $0x0, 0x50(%rbx)
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x14422c
jmp 0x144157
leaq 0x400(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq 0x18(%rbx), %rdi
leaq 0x2000(,%rax,8), %rsi
movq %r15, %rdx
movl $0x74, %ecx
callq 0x2d900
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x144222
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%rbx)
movq %rcx, (%rax,%rdx,8)
jmp 0x144157
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14422c
movb $0x1, %al
jmp 0x144217
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3875c
callq 0x38793
// File: /workspace/github_c_makefile_star2_O3/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 0x144244
movq (%rbx), %rax
jmp 0x144266
addq $0x400, %rsi            # imm = 0x400
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x1fdadc(%rip), %rdx    # 0x341d35
movl $0x37, %ecx
callq 0x2d900
movq %rax, (%rbx)
testq %rax, %rax
je 0x1442e9
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 0x1442dd
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x40(%rbx)
jae 0x14429c
movq 0x30(%rbx), %rax
jmp 0x1442c0
addq $0x100, %rsi            # imm = 0x100
movq %rsi, 0x38(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x1fda83(%rip), %rdx    # 0x341d35
movl $0x3a, %ecx
callq 0x2d900
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x1442ee
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
callq 0x38801
callq 0x387ca
// File: /workspace/github_c_makefile_star2_O3/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 0x144352
cmpb $0x1, 0x50(%rdi)
je 0x144352
testq %rsi, %rsi
je 0x144332
leaq -0x1(%rsi), %rax
movq 0x28(%rdi), %rcx
cmpq %rcx, %rax
jae 0x144357
movq 0x18(%rdi), %r8
movq -0x8(%r8,%rsi,8), %rdx
movq (%rdi), %rax
addq %rdx, %rax
notq %rdx
cmpq %rsi, %rcx
jne 0x144349
addq $0x10, %rdi
jmp 0x14434d
cmpq $0x1, 0x10(%rdi)
jbe 0x14435c
movq (%rdi), %rax
movq 0x18(%rdi), %rdi
movq $-0x1, %rdx
jmp 0x14434d
leaq (%r8,%rsi,8), %rdi
addq (%rdi), %rdx
popq %rcx
retq
callq 0x388aa
callq 0x38838
callq 0x38871
// File: /workspace/github_c_makefile_star2_O3/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 0x14439a
movq (%rbx), %rcx
xorl %edx, %edx
movsbq (%rcx,%rdx), %rsi
incq (%rsp,%rsi,8)
incq %rdx
cmpq %rdx, %rax
jne 0x144389
movq 0x48(%rbx), %rax
xorl %ecx, %ecx
movq (%rsp,%rcx,8), %r8
movq (%rax,%rcx,8), %r9
cmpq %r9, %r8
jne 0x1443c2
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x1443a0
addq $0x800, %rsp            # imm = 0x800
popq %rbx
retq
movq 0x341bf7(%rip), %rax    # 0x485fc0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x1fdafe(%rip), %rsi    # 0x341ed4
xorl %eax, %eax
callq 0x31920
movl $0x2, %edi
callq 0x2dd40
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x0, 0x50(%rdi)
jne 0x1444e7
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %r12
leaq 0x1(%r12), %rax
cmpq %rsi, %rax
jbe 0x1444e7
movq 0x48(%rbx), %rax
movsbq 0x51(%rbx), %rcx
cmpq %r12, (%rax,%rcx,8)
jne 0x1444e7
movq $0x0, (%rax,%rcx,8)
cmpq $0x1, (%rax)
jne 0x1444ec
movq $0x0, (%rax)
xorl %r15d, %r15d
cmpq %r14, %r15
je 0x144489
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1442f7
testq %rdx, %rdx
je 0x144489
movq 0x48(%rbx), %rcx
xorl %esi, %esi
movsbq (%rax,%rsi), %rdi
movq (%rcx,%rdi,8), %r8
testq %r8, %r8
je 0x1444e2
decq %r8
movq %r8, (%rcx,%rdi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x14446c
leaq 0x1(%r15), %rax
cmpq %r12, %r15
movq %rax, %r15
jne 0x144451
movq 0x40(%rbx), %rcx
testq %rcx, %rcx
je 0x1444d0
xorl %edx, %edx
xorl %eax, %eax
movq 0x30(%rbx), %rsi
movq 0x48(%rbx), %r8
movsbq (%rsi,%rdx), %rdi
cmpq $0x0, (%r8,%rdi,8)
je 0x1444c6
cmpq %rdx, %rax
jae 0x1444c3
movb %dil, (%rsi,%rax)
movq 0x40(%rbx), %rcx
incq %rax
incq %rdx
cmpq %rcx, %rdx
jb 0x1444a2
jmp 0x1444d2
xorl %eax, %eax
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3891c
callq 0x38955
callq 0x388e3
// File: /workspace/github_c_makefile_star2_O3/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 0x14452d
xorl %eax, %eax
movsbq (%r15,%rax), %rcx
incq (%rsp,%rcx,8)
incq %rax
cmpq %rax, %r14
jne 0x14451c
movq 0x48(%rbx), %rax
xorl %esi, %esi
xorl %edi, %edi
movq (%rsp,%rsi,8), %rdx
cmpq (%rax,%rsi,8), %rdx
jne 0x144590
movq %rdi, %rcx
cmpq $0x1, %rdx
sbbq $-0x1, %rdi
incq %rsi
cmpq $0x100, %rsi            # imm = 0x100
jne 0x144535
cmpq 0x40(%rbx), %rdi
jne 0x14459a
testq %rdi, %rdi
je 0x144583
movq 0x30(%rbx), %rsi
cmpq $0x1, %rdx
sbbq $-0x1, %rcx
xorl %edx, %edx
movsbq (%rsi,%rdx), %rdi
cmpq $0x0, (%rax,%rdi,8)
je 0x144595
incq %rdx
cmpq %rdx, %rcx
jne 0x14456f
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq
callq 0x3898e
callq 0x38a00
callq 0x389c7
// File: /workspace/github_c_makefile_star2_O3/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 0x1445f5
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1fdb01(%rip), %r14    # 0x3420b6
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 0x1445e5
movsbl 0x51(%rbx), %edi
callq 0x2df70
cmpq 0x40(%rbx), %r15
jb 0x1445b8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x144623
movq 0x30(%rdx), %rax
xorl %ecx, %ecx
movsbq (%rax,%rcx), %r8
cmpq %rsi, %r8
ja 0x144625
movq 0x48(%rdx), %r9
movq (%r9,%r8,8), %r9
addq %r9, (%rdi,%r8,8)
incq %rcx
cmpq 0x40(%rdx), %rcx
jb 0x144604
popq %rax
retq
callq 0x38a39
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x15d900
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x15d902
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x15d8eb
movq %rbx, %rdi
callq *%rax
leaq 0x1ebe33(%rip), %rsi    # 0x349725
movq %rbx, %rdi
movl $0x2b, %edx
popq %rbx
jmp 0x2feb0
popq %rbx
retq
callq 0x411ec
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x322ec6(%rip), %r14    # 0x4824e0
movq %r14, %rdi
callq 0x15f07c
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x15f159
movq %rax, %r14
movq %r15, %rdi
callq 0x2f2c0
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0x15f661
movq %r15, %rdi
callq 0x31b20
leaq 0x1dffe8(%rip), %rsi    # 0x33f63b
movq %rax, %rdi
callq 0x2e3b0
movq %rax, 0x10(%r14)
jmp 0x15f671
leaq 0x25556f(%rip), %rdi    # 0x3b4bd7
callq 0x2f0d0
movq %rax, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x322a69(%rip), %rdi    # 0x482510
callq 0x15f159
movq %rax, 0x18(%rsp)
testq %rbx, %rbx
je 0x15fac6
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x15fba6
movq %r13, %rax
orq %r12, %rax
orq %r15, %rax
je 0x15fba1
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 0x15fb87
js 0x15fb8b
testq %r13, %r13
je 0x15fb28
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 0x15fb2a
xorl %ebp, %ebp
testq %r12, %r12
sete %al
testl %ebp, %ebp
setne %cl
orb %al, %cl
jne 0x15fb4e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *%r12
movl %eax, %ebp
testq %r15, %r15
je 0x15fb67
testl %ebp, %ebp
jne 0x15fb67
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x1ea5e3(%rip), %rsi    # 0x34a156
movl $0x44, %edx
callq 0x2feb0
testl %ebp, %ebp
je 0x15fad5
jmp 0x15fb90
xorl %ebp, %ebp
jmp 0x15fb90
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 0x427e6
callq 0x427af
// File: /workspace/github_c_makefile_star2_O3/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 0x15fc3e
movq %rdi, %r14
leaq 0x322928(%rip), %r15    # 0x482510
movq %r15, %rdi
callq 0x15f07c
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x15f159
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 0x4281d
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x16d025
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x16cf69
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x16d02a
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x2ff50
testl %eax, %eax
je 0x16cf82
leaq 0x1e0989(%rip), %rsi    # 0x34d909
jmp 0x16cfa9
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 0x16cfc7
leaq 0x1e0973(%rip), %rsi    # 0x34d91c
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 0x318ff2(%rip), %r15    # 0x485fc0
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2fba0
leaq 0x1e094f(%rip), %rdi    # 0x34d92f
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x30ca0
cmpl $0x1, %eax
jne 0x16d02f
leaq 0x4(%rsp), %rdx
movl %ebp, 0xc(%rdx)
xorl %edi, %edi
movl $0x2, %esi
callq 0x2d190
testl %eax, %eax
jne 0x16cfa2
movq (%r15), %rsi
movl $0xa, %edi
callq 0x2ecc0
leaq 0x40(%rsp), %rdi
callq 0x2f0d0
movq %rax, %r14
jmp 0x16cfb6
callq 0x46957
callq 0x468e9
callq 0x46920
// File: /workspace/github_c_makefile_star2_O3/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 0x17d89b
movq %rsi, %r14
testq %rsi, %rsi
je 0x17d89b
movq %rdx, %rbx
testq %rdx, %rdx
je 0x17d89b
movq %rdi, %r15
leaq 0x1d41d9(%rip), %r12    # 0x351a2d
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 0x4a76f
// File: /workspace/github_c_makefile_star2_O3/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 0x17d8f9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x17d8cb
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x31fe0
incq %r14
cmpq 0x18(%rbx), %r14
jb 0x17d8b6
movq (%rbx), %rdi
leaq 0x1d4158(%rip), %r14    # 0x351a2d
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_O3/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 0x17d945
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x17d945
movq (%r14), %rax
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
jne 0x17d939
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 0x17d94a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2f2c0
callq 0x4a7dd
callq 0x4a7a6
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x17f73f
movq %rdx, %r15
testq %rdx, %rdx
je 0x17f73f
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 0x17f733
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 0x4b9d0
jmp 0x17f70a
callq 0x4b999
// File: /workspace/github_c_makefile_star2_O3/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 0x17f7f8
movq %rcx, %r14
testq %rcx, %rcx
je 0x17f7f8
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 0x17f79f
movq %r12, %rdi
callq 0x17f041
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 0x17f7ec
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 0x4ba85
jmp 0x17f7c5
callq 0x4ba4e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x141717
cmpq $0x0, 0x301f16(%rip)    # 0x48d948
jne 0x18ba53
leaq 0x26(%rip), %rsi        # 0x18ba61
leaq 0x6e(%rip), %rdx        # 0x18bab0
movl $0x28, %edi
callq 0x2e6f0
movq %rax, 0x301ef5(%rip)    # 0x48d948
callq 0x14172d
movq 0x301ee9(%rip), %rax    # 0x48d948
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18ba9d
movq 0x18(%rbx), %rdi
callq 0x301c0
movq %rax, %rdi
callq 0x32038
movq 0x18(%rbx), %rdi
jmp 0x18ba7c
movq 0x18(%rbx), %rdi
callq 0x2d080
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x31d10
// File: /workspace/github_c_makefile_star2_O3/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 0x18bacf
movq %r14, %rdi
callq 0x310f0
testb %al, %al
jne 0x18bb49
callq 0x2fd20
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ef70
movq %rax, %r15
cmpb $0x1, 0x20(%rax)
jne 0x18bb1f
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2f490
movl %eax, %r14d
testl %eax, %eax
jne 0x18bb40
movq (%rbx), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x18bb40
movq 0x18(%r15), %rbx
callq 0x2eea0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x31bb0
jmp 0x18bb40
movq 0x18(%r15), %rdi
callq 0x30850
xorl %r14d, %r14d
testq %rax, %rax
je 0x18bb3b
movq 0x18(%r15), %rdi
callq 0x301c0
jmp 0x18bb3d
xorl %eax, %eax
movq %rax, (%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x4ffd3
// File: /workspace/github_c_makefile_star2_O3/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 0x18bba3
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 0x5000a
// File: /workspace/github_c_makefile_star2_O3/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 0x19d3f6
movq %rdi, %rbx
callq 0x19d52d
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x30ff0
callq 0x54e63
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1d023a
testq %rsi, %rsi
je 0x1d023a
testq %rdx, %rdx
je 0x1d023a
decq %rdx
leaq -0x1(%rsi), %rcx
movl $0x1, %eax
xorl %r9d, %r9d
xorl %r8d, %r8d
movsbq (%rdi,%r8), %r10
cmpq %r10, %rdx
ja 0x1d0232
movb $0x0, (%rdi,%r8)
cmpq %r8, %rcx
cmovel %r9d, %eax
incq %r8
cmpq %r8, %rsi
jne 0x1d0213
retq
incb %r10b
movb %r10b, (%rdi,%r8)
retq
pushq %rax
callq 0x65867
// File: /workspace/github_c_makefile_star2_O3/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 0x141717
cmpq $0x0, 0x2afa26(%rip)    # 0x48db28
jne 0x1de123
leaq 0x26(%rip), %rsi        # 0x1de131
leaq 0x47(%rip), %rdx        # 0x1de159
movl $0x20, %edi
callq 0x2e6f0
movq %rax, 0x2afa05(%rip)    # 0x48db28
callq 0x14172d
movq 0x2af9f9(%rip), %rax    # 0x48db28
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1de158
pushq %rbx
movq %rdi, %rbx
callq 0x1de0f4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2ef70
movq 0x18(%rax), %rax
testq %rax, %rax
popq %rbx
je 0x1de158
xorl %edi, %edi
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1de178
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1de199
callq 0x1de0f4
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 0x6abda
// File: /workspace/github_c_makefile_star2_O3/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 0x1de1e1
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1de0f4
movq %rax, %rdi
xorl %esi, %esi
callq 0x30240
movq %rax, %r15
callq 0x1de0f4
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 0x6ac11
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x141717
cmpq $0x0, 0x2af93a(%rip)    # 0x48db30
jne 0x1de246
leaq 0x1cb(%rip), %rax       # 0x1de3ca
movq %rax, (%rsp)
leaq 0x4a(%rip), %rsi        # 0x1de254
leaq 0x71(%rip), %rdx        # 0x1de282
leaq 0xbc(%rip), %rcx        # 0x1de2d4
leaq 0x107(%rip), %r8        # 0x1de326
leaq 0x152(%rip), %r9        # 0x1de378
movl $0x48, %edi
callq 0x2db70
movq %rax, 0x2af8f9(%rip)    # 0x48db30
leaq 0x1de(%rip), %rsi       # 0x1de41c
movq %rax, %rdi
callq 0x2d590
callq 0x14172d
movq 0x2af8de(%rip), %rax    # 0x48db30
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1de27d
movq %rdi, %rbx
callq 0x1de1e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2e4d0
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x1de27b
xorl %edi, %edi
popq %rbx
jmpq *%rax
popq %rbx
retq
callq 0x6ac48
// File: /workspace/github_c_makefile_star2_O3/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 0x1de2a1
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1de2cf
callq 0x1de1e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1de2c7
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 0x6ac7f
// File: /workspace/github_c_makefile_star2_O3/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 0x1de2f3
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1de321
callq 0x1de1e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x1de319
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 0x6acb6
// File: /workspace/github_c_makefile_star2_O3/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 0x1de345
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1de373
callq 0x1de1e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1de36b
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 0x6aced
// File: /workspace/github_c_makefile_star2_O3/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 0x1de397
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1de3c5
callq 0x1de1e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1de3bd
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 0x6ad24
// File: /workspace/github_c_makefile_star2_O3/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 0x1de3e9
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1de417
callq 0x1de1e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x1de40f
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 0x6ad5b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/script_wrapper_visitor.c
// Function: script_wrapper_visitor_meta_node
static int script_wrapper_visitor_meta_node(GtNodeVisitor *nv,
                                            GtMetaNode *rn,
                                            GtError *err)
{
  GtScriptWrapperVisitor *swv;
  int had_err = 0;
  gt_error_check(err);
  swv = gt_script_wrapper_visitor_cast(nv);
  if (swv->meta_node_func)
    had_err = swv->meta_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 0x1de43b
movq %rbx, %rdi
callq 0x310f0
testb %al, %al
jne 0x1de469
callq 0x1de1e8
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e4d0
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x1de461
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 0x6ad92
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_new
GtUnionFind* gt_union_find_new(GtUword num_of_elems)
{
  GtUnionFind *uf;
  GtUword i;
  gt_assert(num_of_elems);
  uf = gt_malloc(sizeof *uf);
  uf->elems = gt_calloc(sizeof (GtUnionFindElement), num_of_elems);
  uf->allocated = num_of_elems;
  for (i = 0; i < num_of_elems; i++)
    uf->elems[i].parent = i;
  uf->num_of_elems = num_of_elems;
  return uf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f1525
movq %rdi, %rbx
leaq 0x18ed4e(%rip), %r15    # 0x3801a2
movl $0x18, %edi
movq %r15, %rsi
movl $0x28, %edx
callq 0x2d5f0
movq %rax, %r14
movl $0x8, %edi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x29, %ecx
callq 0x2fef0
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
leaq 0x1(%rbx), %rcx
andq $-0x2, %rcx
leaq -0x1(%rbx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x1452ed(%rip), %xmm1   # 0x336790
xorl %edx, %edx
movdqa 0x1452f3(%rip), %xmm2   # 0x3367a0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x145323(%rip), %xmm4   # 0x3367e0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x1f14f3
movq %rdx, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1f150b
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x1f14bd
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x71262
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/union_find.c
// Function: gt_union_find_reset
void gt_union_find_reset(GtUnionFind *uf, GtUword num_of_elems)
{
  GtUword i;
  gt_assert(num_of_elems);
  if (num_of_elems > uf->allocated)
  {
    uf->elems = gt_realloc(uf->elems, sizeof (GtUnionFindElement) *
        num_of_elems);
    uf->allocated = num_of_elems;
  }
  for (i = 0; i < num_of_elems; i++)
    uf->elems[i].parent = i;
  uf->num_of_elems = num_of_elems;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1f1608
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rsi, 0x10(%rdi)
jae 0x1f1569
leaq (,%rbx,8), %rsi
leaq 0x18ec4d(%rip), %rdx    # 0x3801a2
movq %rax, %rdi
movl $0x38, %ecx
callq 0x2d900
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
leaq 0x1(%rbx), %rcx
andq $-0x2, %rcx
leaq -0x1(%rbx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x145209(%rip), %xmm1   # 0x336790
xorl %edx, %edx
movdqa 0x14520f(%rip), %xmm2   # 0x3367a0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x14523f(%rip), %xmm4   # 0x3367e0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x1f15d7
movq %rdx, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1f15ef
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x1f15a1
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x71299