LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/multieoplist.c
// Function: gt_multieoplist_unit_test_2
int gt_multieoplist_unit_test_2(GtError *err)
{
  /* char *u = "attttgatatcgtctctctatgctgtcac", */
       /* *v = "atttngatatcgtctctctatgctgtcac"; */
  GtMultieoplist *meop = gt_multieoplist_new();
  unsigned int i;
  int had_err = 0;

  for (i = 0; i < 4; ++i) {
    gt_multieoplist_add_match(meop);
  }
  gt_multieoplist_add_mismatch(meop);
  for (i = 0; i < 24; ++i) {
    gt_multieoplist_add_match(meop);
  }
  gt_ensure(gt_multieoplist_get_length(meop) == 29);
  gt_log_log("length: " GT_WU, gt_multieoplist_get_length(meop));

  gt_multieoplist_delete(meop);
  return had_err;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x1af960
movq %rax, 0x8(%rsp)
movl $0x0, (%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jae 0x1b0b90
movq 0x8(%rsp), %rdi
callq 0x1b0030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1b0b72
movq 0x8(%rsp), %rdi
callq 0x1b0010
movl $0x0, 0x4(%rsp)
cmpl $0x18, 0x4(%rsp)
jae 0x1b0bc0
movq 0x8(%rsp), %rdi
callq 0x1b0030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1b0ba2
jmp 0x1b0bc2
cmpl $0x0, (%rsp)
jne 0x1b0c0f
movq 0x8(%rsp), %rdi
callq 0x1b02d0
cmpq $0x1d, %rax
je 0x1b0c0d
movq 0x10(%rsp), %rdi
leaq 0x37ea16(%rip), %rsi    # 0x52f5fa
leaq 0x3ae9f9(%rip), %rdx    # 0x55f5e4
leaq 0x3aea19(%rip), %rcx    # 0x55f60b
leaq 0x3ae7cf(%rip), %r8     # 0x55f3c8
movl $0x1ab, %r9d            # imm = 0x1AB
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
jmp 0x1b0c0f
jmp 0x1b0c11
movq 0x8(%rsp), %rdi
callq 0x1b02d0
movq %rax, %rsi
leaq 0x3d2610(%rip), %rdi    # 0x583235
movb $0x0, %al
callq 0xe7740
movq 0x8(%rsp), %rdi
callq 0x1afba0
movl (%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/mutate.c
// Function: gt_mutate_seq
GtSeq* gt_mutate_seq(const char *description, const char *orig_seq,
                     GtUword len, GtAlphabet *alphabet, unsigned int rate)
{
  char *mutated_description, *mutated_seq;
  GtSeq *seq;
  gt_assert(description && orig_seq && alphabet);
  gt_assert(rate <= 100);
  mutated_description = mutate_description(description, rate);
  mutated_seq = mutate_seq(orig_seq, len, alphabet, rate);
  seq = gt_seq_new_own(mutated_seq, strlen(mutated_seq), alphabet);
  gt_seq_set_description_own(seq, mutated_description);
  return seq;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x1b1515
cmpq $0x0, 0x38(%rsp)
je 0x1b1515
cmpq $0x0, 0x28(%rsp)
jne 0x1b154d
movq 0x48aa84(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x364aed(%rip), %rsi    # 0x516013
leaq 0x3ae63b(%rip), %rdx    # 0x55fb68
leaq 0x3ae658(%rip), %rcx    # 0x55fb8c
leaq 0x3ae65f(%rip), %r8     # 0x55fb9a
movl $0x70, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b154f
jmp 0x1b1551
cmpl $0x64, 0x24(%rsp)
jbe 0x1b1590
movq 0x48aa41(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x364aaa(%rip), %rsi    # 0x516013
leaq 0x3ae640(%rip), %rdx    # 0x55fbb0
leaq 0x3ae615(%rip), %rcx    # 0x55fb8c
leaq 0x3ae61c(%rip), %r8     # 0x55fb9a
movl $0x71, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b1592
movq 0x40(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1b1610
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x1b1760
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x192b0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
callq 0x1104d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x110580
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/mutate.c
// Function: mutate_description
static char* mutate_description(const char *description, unsigned int rate)
{
  GtUword mutated_description_len;
  char *mutated_description;
  GT_UNUSED int rval;
  gt_assert(description);
  gt_assert(rate <= 100);
  mutated_description_len = strlen(description) + strlen(MUTATED_DESC_PRIMER)
                            + 3  /* for the rate */
                            + 1  /* terminal ']' */
                            + 1; /* terminal '\n' */
  mutated_description = gt_malloc(sizeof (char) * mutated_description_len);
  rval = snprintf(mutated_description, mutated_description_len, "%s%s%u]",
                  description, MUTATED_DESC_PRIMER, rate);
  gt_assert(rval < mutated_description_len);
  return mutated_description;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1b165d
movq 0x48a974(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3649dd(%rip), %rsi    # 0x516013
leaq 0x3b16c8(%rip), %rdx    # 0x562d05
leaq 0x3ae578(%rip), %rcx    # 0x55fbbc
leaq 0x3ae54f(%rip), %r8     # 0x55fb9a
movl $0x22, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b165f
jmp 0x1b1661
cmpl $0x64, 0x1c(%rsp)
jbe 0x1b16a0
movq 0x48a931(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36499a(%rip), %rsi    # 0x516013
leaq 0x3ae530(%rip), %rdx    # 0x55fbb0
leaq 0x3ae535(%rip), %rcx    # 0x55fbbc
leaq 0x3ae50c(%rip), %r8     # 0x55fb9a
movl $0x23, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b16a2
movq 0x20(%rsp), %rdi
callq 0x192b0
addq $0x14, %rax
addq $0x3, %rax
addq $0x1, %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
shlq $0x0, %rdi
leaq 0x3ae4c9(%rip), %rsi    # 0x55fb9a
movl $0x28, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r9d
leaq 0x3ae4d4(%rip), %rdx    # 0x55fbcf
leaq 0x3ae4d5(%rip), %r8     # 0x55fbd7
movb $0x0, %al
callq 0x19b90
movl %eax, 0x4(%rsp)
movslq 0x4(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x1b1751
movq 0x48a880(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3648e9(%rip), %rsi    # 0x516013
leaq 0x3ae4bb(%rip), %rdx    # 0x55fbec
leaq 0x3ae484(%rip), %rcx    # 0x55fbbc
leaq 0x3ae45b(%rip), %r8     # 0x55fb9a
movl $0x2b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b1753
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/mutate.c
// Function: random_character
static char random_character(GtAlphabet *alphabet, bool upper_case)
{
  /* we do not want to get wildcard characters */
  char random_char = gt_alphabet_decode(alphabet,
                           gt_rand_max(gt_alphabet_num_of_chars(alphabet) - 1));
  if (upper_case)
    return toupper(random_char);
  return tolower(random_char);
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7e8c0
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0xec350
movq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x7f7b0
movb %al, 0x16(%rsp)
testb $0x1, 0x17(%rsp)
je 0x1b1aba
movsbl 0x16(%rsp), %edi
callq 0x19dd0
movb %al, 0x27(%rsp)
jmp 0x1b1ac8
movsbl 0x16(%rsp), %edi
callq 0x19a20
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_class
const GtNodeStreamClass* gt_orf_finder_stream_class(void)
{
  static const GtNodeStreamClass *gsc;
  gt_class_alloc_lock_enter();
  if (!gsc) {
    gsc = gt_node_stream_class_new(sizeof (GtORFFinderStream),
                                   gt_orf_finder_stream_free,
                                   gt_orf_finder_stream_next);
  }
  gt_class_alloc_lock_leave();
  return gsc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x4903ea(%rip)    # 0x642e58
jne 0x1b2a8f
movl $0x20, %edi
leaq 0x24(%rip), %rsi        # 0x1b2aa0
leaq 0x6d(%rip), %rdx        # 0x1b2af0
callq 0x1b1ae0
movq %rax, 0x4903c9(%rip)    # 0x642e58
callq 0x9f280
movq 0x4903bd(%rip), %rax    # 0x642e58
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_next
static int gt_orf_finder_stream_next(GtNodeStream *gs, GtGenomeNode **gn,
                                    GtError *err)
{
  GtORFFinderStream *ls;
  int had_err;

  gt_error_check(err);
  ls = gt_orf_finder_stream_cast(gs);

  had_err = gt_node_stream_next(ls->in_stream, gn, err);
  if (!had_err && *gn) {
    had_err = gt_genome_node_accept(*gn, (GtNodeVisitor*) ls->lv, err);
  }
  if (had_err) {
    gt_genome_node_delete(*gn);
    *gn = NULL;
  }
  return had_err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1b2b53
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x1b2b1b
jmp 0x1b2b53
movq 0x48947e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3634e7(%rip), %rsi    # 0x516013
leaq 0x36368c(%rip), %rdx    # 0x5161bf
leaq 0x3ad4fe(%rip), %rcx    # 0x560038
leaq 0x3ad511(%rip), %r8     # 0x560052
movl $0x31, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b2b55
callq 0x1b2a60
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x1b20f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1b1d90
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1b2bb9
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1b2bb9
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x171f90
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x1b2bd9
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x173180
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_new
GtNodeStream* gt_orf_finder_stream_new(GtNodeStream *in_stream,
                                       GtRegionMapping *rmap,
                                       GtHashmap *types,
                                       unsigned int min,
                                       unsigned int max,
                                       bool all,
                                       GtError *err)
{
  GtNodeStream *gs;
  GtORFFinderStream *ls;
  gs = gt_node_stream_create(gt_orf_finder_stream_class(), false);
  ls = gt_orf_finder_stream_cast(gs);
  ls->in_stream = gt_node_stream_ref(in_stream);
  ls->lv = (GtORFFinderVisitor*) gt_orf_finder_visitor_new(rmap,types,
                                                           min, max, all, err);
  return gs;
}

// Assembly:
subq $0x38, %rsp
movb %r9b, %al
movq 0x40(%rsp), %r9
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
callq 0x1b2a60
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b1b80
movq %rax, 0x8(%rsp)
callq 0x1b2a60
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b20f0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x1b1c50
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movb 0x17(%rsp), %al
movq 0x40(%rsp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x1b2fc0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: gt_orf_finder_visitor_class
const GtNodeVisitorClass* gt_orf_finder_visitor_class(void)
{
  static const GtNodeVisitorClass *gvc = NULL;
  gt_class_alloc_lock_enter();
  if (!gvc) {
    gvc = gt_node_visitor_class_new(sizeof (GtORFFinderVisitor),
                                    NULL,
                                    NULL,
                                    gt_orf_finder_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return gvc;
}

// Assembly:
pushq %rax
callq 0x9f220
cmpq $0x0, 0x4901b2(%rip)    # 0x642e60
jne 0x1b2cde
movl $0x30, %edi
xorl %eax, %eax
movl %eax, %r9d
leaq 0x2f(%rip), %rcx        # 0x1b2cf0
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %r8
movq $0x0, (%rsp)
callq 0x1b2170
movq %rax, 0x490182(%rip)    # 0x642e60
callq 0x9f280
movq 0x490176(%rip), %rax    # 0x642e60
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: gt_orf_finder_visitor_new
GtNodeVisitor* gt_orf_finder_visitor_new(GtRegionMapping *rmap,
                                         GtHashmap *types,
                                         unsigned int min,
                                         unsigned int max,
                                         bool all,
                                         GT_UNUSED GtError *err)
{
  GtNodeVisitor *gv;
  GtORFFinderVisitor *lv;
  gv = gt_node_visitor_create(gt_orf_finder_visitor_class());
  lv = gt_orf_finder_visitor_cast(gv);
  gt_assert(lv);
  lv->rmap = rmap;
  lv->types=types;
  lv->min = min;
  lv->max = max;
  lv->all = all;
  return gv;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %r9, 0x10(%rsp)
callq 0x1b2ca0
movq %rax, %rdi
callq 0x1b22c0
movq %rax, 0x8(%rsp)
callq 0x1b2ca0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1b2350
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1b304b
movq 0x488f86(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x362fef(%rip), %rsi    # 0x516013
leaq 0x3e0057(%rip), %rdx    # 0x593082
leaq 0x3ad041(%rip), %rcx    # 0x560073
leaq 0x3ad054(%rip), %r8     # 0x56008d
movl $0x15c, %r9d            # imm = 0x15C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b304d
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x24(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0x20(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x24(%rax)
movb 0x1f(%rsp), %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: process_orf
static void process_orf(GtRange orf_rng, unsigned int orf_frame,
                        GtStrand strand, GtFeatureNode *gf,
                        GtUword offset, unsigned int min,
                        unsigned int max, GT_UNUSED GtError *err)
{

  gt_assert(gf);
  GtUword tmp;

  if ((gt_range_length(&orf_rng) >= min) &&
      (gt_range_length(&orf_rng) <= max)) {
    switch (strand) {
      case GT_STRAND_FORWARD:
        orf_rng.start = orf_rng.start + offset;
        orf_rng.end = orf_rng.end + offset;
        break;
      case GT_STRAND_REVERSE:
        tmp = orf_rng.start;
        orf_rng.start = offset - orf_rng.end;
        orf_rng.end = offset - tmp;
        break;
      default:
        exit(GT_EXIT_PROGRAMMING_ERROR);
        break;
    }
    orf_attach_results_to_gff3(gf, orf_rng, orf_frame, strand, err);
  }
}

// Assembly:
subq $0x38, %rsp
movq 0x50(%rsp), %rax
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %eax
movq %rdi, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1b3a5d
movq 0x488574(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3625dd(%rip), %rsi    # 0x516013
leaq 0x393ae9(%rip), %rdx    # 0x547526
leaq 0x3ac6af(%rip), %rcx    # 0x5600f3
leaq 0x3ac642(%rip), %r8     # 0x56008d
movl $0x72, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b3a5f
leaq 0x28(%rsp), %rdi
callq 0x107320
movl 0x40(%rsp), %ecx
cmpq %rcx, %rax
jb 0x1b3b1c
leaq 0x28(%rsp), %rdi
callq 0x107320
movl 0x48(%rsp), %ecx
cmpq %rcx, %rax
ja 0x1b3b1c
movl 0x20(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x1b3aa6
jmp 0x1b3a9b
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x1b3ac6
jmp 0x1b3af0
movq 0x28(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1b3afa
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
subq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1b3afa
movl $0x2, %edi
callq 0x19890
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
movq 0x50(%rsp), %r9
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x1b3b30
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_iterator.c
// Function: gt_orf_iterator_new
GtORFIterator* gt_orf_iterator_new(GtCodonIterator *ci,
                                   GtTranslator *translator)
{
  gt_assert(ci && translator);
  GtORFIterator *orfi = gt_malloc(sizeof (GtORFIterator));
  int i;

  orfi->ci = ci;
  orfi->translator = translator;

  for (i = 0; i < 3; i++) {
    orfi->orf_start[i] = GT_UNDEF_UWORD;
    orfi->found_start[i] = false;
  }
  return orfi;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1b3cee
cmpq $0x0, 0x18(%rsp)
jne 0x1b3d26
movq 0x4882ab(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x362314(%rip), %rsi    # 0x516013
leaq 0x3ac405(%rip), %rdx    # 0x56010b
leaq 0x3ac40f(%rip), %rcx    # 0x56011c
leaq 0x3ac41c(%rip), %r8     # 0x560130
movl $0x26, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b3d28
movl $0x30, %edi
leaq 0x3ac3fc(%rip), %rsi    # 0x560130
movl $0x27, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x1b3d9c
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq $-0x1, 0x10(%rax,%rcx,8)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, 0x28(%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b3d66
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/orf_iterator.c
// Function: gt_orf_iterator_next
GtORFIteratorStatus gt_orf_iterator_next(
                        GtORFIterator *orfi, GtRange *orf_rng,
                        unsigned int *orf_frame, GtError *err)
{
  gt_assert(orfi);
  unsigned int frame;
  char translated;
  GtTranslatorStatus state;

  while ((state = gt_translator_next(orfi->translator,
                            &translated, &frame, err)) != GT_TRANSLATOR_END) {
    if (state == GT_TRANSLATOR_ERROR)
      return GT_ORF_ITERATOR_ERROR;
    if (translated == GT_START_AMINO && !orfi->found_start[frame]) {
      orfi->orf_start[frame] = gt_codon_iterator_current_position(orfi->ci) - 1;
      orfi->found_start[frame] = true;
    }
    else if ((translated == GT_STOP_AMINO) &&
             (orfi->found_start[frame] == true)) {
      orf_rng->start = orfi->orf_start[frame];
      /* ORF ends before GT_STOP_AMINO */
      orf_rng->end = gt_codon_iterator_current_position(orfi->ci) - 2;
      *orf_frame = frame;
      orfi->found_start[frame] = false;
      return GT_ORF_ITERATOR_OK;
    }
  }
  return GT_ORF_ITERATOR_END;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x1b3e08
movq 0x4881c9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x362232(%rip), %rsi    # 0x516013
leaq 0x3ac306(%rip), %rdx    # 0x5600ee
leaq 0x3ac35d(%rip), %rcx    # 0x56014c
leaq 0x3ac33a(%rip), %r8     # 0x560130
movl $0x38, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b3e0a
jmp 0x1b3e0c
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rcx
leaq 0xb(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x125540
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0x1b3f14
cmpl $-0x2, 0x4(%rsp)
jne 0x1b3e4a
movl $0xfffffffe, 0x34(%rsp) # imm = 0xFFFFFFFE
jmp 0x1b3f1c
movsbl 0xb(%rsp), %eax
cmpl $0x4d, %eax
jne 0x1b3e96
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
testb $0x1, 0x28(%rax,%rcx)
jne 0x1b3e96
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x9f580
movq %rax, %rdx
subq $0x1, %rdx
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movb $0x1, 0x28(%rax,%rcx)
jmp 0x1b3f0f
movsbl 0xb(%rsp), %eax
cmpl $0x2a, %eax
jne 0x1b3f0d
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movb 0x28(%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1b3f0d
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0x10(%rax,%rcx,8), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x9f580
movq %rax, %rcx
subq $0x2, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movb $0x0, 0x28(%rax,%rcx)
movl $0x0, 0x34(%rsp)
jmp 0x1b3f1c
jmp 0x1b3f0f
jmp 0x1b3e0c
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_new
GtPopcountTab *gt_popcount_tab_new(unsigned int blocksize)
{
  GtPopcountTab *popcount_tab;
  GT_UNUSED GtUword idx_check;
  gt_assert(blocksize <= (unsigned) GT_INTWORDSIZE);

  popcount_tab = gt_malloc(sizeof (GtPopcountTab));
  popcount_tab->rev_blocks = NULL;
  popcount_tab->bit_sizes = NULL;
  popcount_tab->num_of_blocks = 1UL << blocksize;
  popcount_tab->blocksize = blocksize;

  popcount_tab->blocks = gt_compact_ulong_store_new(popcount_tab->num_of_blocks,
                                                    blocksize);
  popcount_tab->offsets =
    gt_compact_ulong_store_new((GtUword) blocksize + 1, blocksize);
  gt_popcount_tab_init_offset_tab(popcount_tab);
  idx_check = gt_popcount_tab_init_blocks_tab(popcount_tab->blocks, blocksize);
  gt_assert(idx_check == popcount_tab->num_of_blocks);
  return popcount_tab;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jbe 0x1b44b7
movq 0x487b1a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x361b83(%rip), %rsi    # 0x516013
leaq 0x3abdd6(%rip), %rdx    # 0x56026d
leaq 0x3abdf6(%rip), %rcx    # 0x560294
leaq 0x3abe03(%rip), %r8     # 0x5602a8
movl $0x81, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b44b9
movl $0x30, %edi
leaq 0x3abde3(%rip), %rsi    # 0x5602a8
movl $0x83, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movl 0x14(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0xa1e30
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x14(%rsp), %eax
movl %eax, %edi
addq $0x1, %rdi
movl 0x14(%rsp), %esi
callq 0xa1e30
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
callq 0x1b45d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x1b4710
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0x1b45b7
movq 0x487a1a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x361a83(%rip), %rsi    # 0x516013
leaq 0x3abd2d(%rip), %rdx    # 0x5602c4
leaq 0x3abcf6(%rip), %rcx    # 0x560294
leaq 0x3abd03(%rip), %r8     # 0x5602a8
movl $0x8f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b45b9
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_init_offset_tab
static void gt_popcount_tab_init_offset_tab(GtPopcountTab *popcount_tab)
{
  GtUword idx, class_size,
                blocksize = (GtUword) popcount_tab->blocksize,
                num_of_blocks = popcount_tab->num_of_blocks;
  GtCompactUlongStore *offsets = popcount_tab->offsets;

  gt_compact_ulong_store_update(offsets, 0, 0);
  gt_compact_ulong_store_update(offsets, 1UL, 1UL);
  gt_compact_ulong_store_update(offsets, 2UL, blocksize + 1UL);
  for (idx = 3UL; idx < blocksize - 1; idx++) {
    class_size = gt_combinatorics_binomial_ln(blocksize, idx - 1);
    gt_compact_ulong_store_update(offsets, idx,
                                  class_size + gt_compact_ulong_store_get(
                                                                      offsets,
                                                                      idx - 1));

  }
  gt_compact_ulong_store_update(offsets, blocksize - 1,
                                num_of_blocks - blocksize - 1);
  gt_compact_ulong_store_update(offsets, blocksize, num_of_blocks - 1);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl 0x28(%rax), %eax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xa21f0
movq 0x18(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0xa21f0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq $0x1, %rdx
movl $0x2, %esi
callq 0xa21f0
movq $0x3, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1b46ca
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
subq $0x1, %rsi
callq 0xa1a20
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
subq $0x1, %rsi
callq 0xa20c0
movq (%rsp), %rdx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq %rax, %rdx
callq 0xa21f0
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x1b4646
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
subq $0x1, %rsi
movq 0x20(%rsp), %rdx
subq 0x28(%rsp), %rdx
subq $0x1, %rdx
callq 0xa21f0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
subq $0x1, %rdx
callq 0xa21f0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_init_blocks_tab
static GtUword
gt_popcount_tab_init_blocks_tab(GtCompactUlongStore *blocks,
                                unsigned int blocksize)
{
  GtUword idx = 1UL,
                blockmask;
  unsigned int popcount_c = 1U;
  blockmask = gt_popcount_tab_perm_start(blocksize);
  gt_compact_ulong_store_update(blocks, 0, 0);
  while (popcount_c < blocksize) {
    idx = gt_popcount_tab_gen_blocks(popcount_c++, idx, blockmask, blocks);
  }
  gt_compact_ulong_store_update(blocks, idx++, blockmask);
  return idx;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq $0x1, 0x10(%rsp)
movl $0x1, 0x4(%rsp)
movl 0x1c(%rsp), %edi
callq 0x1b5e70
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xa21f0
movl 0x4(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1b477f
movl 0x4(%rsp), %edi
movl %edi, %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x1b5f10
movq %rax, 0x10(%rsp)
jmp 0x1b474d
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
callq 0xa21f0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_delete
void gt_popcount_tab_delete(GtPopcountTab *popcount_tab)
{
  if (popcount_tab != NULL) {
    gt_compact_ulong_store_delete(popcount_tab->blocks);
    gt_compact_ulong_store_delete(popcount_tab->offsets);
    gt_compact_ulong_store_delete(popcount_tab->rev_blocks);
    gt_free(popcount_tab->bit_sizes);
    gt_free(popcount_tab);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x1b4810
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xa2080
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa2080
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xa2080
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x3abab7(%rip), %rsi    # 0x5602a8
movl $0x99, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x3abaa2(%rip), %rsi    # 0x5602a8
movl $0x9a, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_calculate_size
size_t gt_popcount_tab_calculate_size(unsigned int blocksize)
{
  GtUword num_of_blocks = 1UL << blocksize;
  size_t size = gt_compact_ulong_store_size(num_of_blocks, blocksize);
  size += sizeof (GtPopcountTab);
  size += sizeof (GtUword) * blocksize;
  return size;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xa1fc0
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x30, %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq (%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_popcount
static inline unsigned int gt_popcount_tab_popcount(GtUword val)
{
#ifdef __SSE4_2__
  return __builtin_popcountl(val);
#else
  uint64_t x = (uint64_t) val;
#ifdef POPCOUNT_TL
  return (GtUword)
         gt_byte_popcount[x         & 0xFFULL] +
         gt_byte_popcount[(x >>  8) & 0xFFULL] +
         gt_byte_popcount[(x >> 16) & 0xFFULL] +
         gt_byte_popcount[(x >> 24) & 0xFFULL] +
         gt_byte_popcount[(x >> 32) & 0xFFULL] +
         gt_byte_popcount[(x >> 40) & 0xFFULL] +
         gt_byte_popcount[(x >> 48) & 0xFFULL] +
         gt_byte_popcount[(x >> 56) & 0xFFULL];
#else
  /* see page 11, Knuth TAOCP Vol 4 F1A */
  x = x - ((x >> 1) & (uint64_t) 0x5555555555555555ULL);
  x = (x & (uint64_t) 0x3333333333333333ULL) +
      ((x >> 2) & (uint64_t) 0x3333333333333333ULL);
  x = (x + (x >> 4)) & (uint64_t) 0x0f0f0f0f0f0f0f0fULL;
  return (unsigned) ((uint64_t) 0x0101010101010101ULL * x >> 56);
#endif
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x10(%rsp), %rcx
shrq %rcx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x10(%rsp)
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
andq -0x10(%rsp), %rax
movq -0x10(%rsp), %rcx
shrq $0x2, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x10(%rsp), %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movq %rax, -0x10(%rsp)
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
imulq -0x10(%rsp), %rax
shrq $0x38, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_offset_bits
unsigned int gt_popcount_tab_offset_bits(GtPopcountTab *popcount_tab,
                                         unsigned int class)
{
  gt_assert(popcount_tab != NULL);
  gt_assert(class <= popcount_tab->blocksize);
  if (popcount_tab->bit_sizes == NULL) {
    popcount_tab->bit_sizes = gt_calloc((size_t) popcount_tab->blocksize + 1,
                                        sizeof (*(popcount_tab->bit_sizes)));
    gt_popcount_tab_init_bit_sizes(popcount_tab->bit_sizes,
                                   popcount_tab->blocksize);
  }
  return popcount_tab->bit_sizes[class];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1b4c0d
movq 0x4873c4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x36142d(%rip), %rsi    # 0x516013
leaq 0x3ab7d4(%rip), %rdx    # 0x5603c1
leaq 0x3ab81e(%rip), %rcx    # 0x560412
leaq 0x3ab6ad(%rip), %r8     # 0x5602a8
movl $0xf5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b4c0f
jmp 0x1b4c11
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jbe 0x1b4c57
movq 0x48737a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3613e3(%rip), %rsi    # 0x516013
leaq 0x3ab7f7(%rip), %rdx    # 0x56042e
leaq 0x3ab7d4(%rip), %rcx    # 0x560412
leaq 0x3ab663(%rip), %r8     # 0x5602a8
movl $0xf6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b4c59
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1b4ca8
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, %edi
addq $0x1, %rdi
movl $0x4, %esi
leaq 0x3ab62a(%rip), %rdx    # 0x5602a8
movl $0xf9, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x1b4cc0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
movl (%rax,%rcx,4), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_init_bit_sizes
static void gt_popcount_tab_init_bit_sizes(unsigned int *bit_sizes,
                                           unsigned int blocksize)
{
  unsigned int class;
  for (class = 0; class <= blocksize; ++class) {
#ifdef __SSE4_2__
    bit_sizes[class] = (unsigned int) (sizeof (GtUword) * CHAR_BIT -
       __builtin_clzl(gt_combinatorics_binomial_dp((GtUword) blocksize,
                                                   (GtUword) class)));
#else
    bit_sizes[class] = gt_determinebitspervalue(
        gt_combinatorics_binomial_dp((GtUword) blocksize,
                                     (GtUword) class));
#endif
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
ja 0x1b4d13
movl 0xc(%rsp), %eax
movl %eax, %edi
movl 0x8(%rsp), %eax
movl %eax, %esi
callq 0xa19f0
movq %rax, %rdi
callq 0xec660
movl %eax, %edx
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1b4cd5
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_block_to_str
void gt_popcount_tab_block_to_str(GtPopcountTab *popcount_tab,
                                  GtUword block,
                                  char *buffer)
{
  unsigned int idx;
  buffer[popcount_tab->blocksize] = 0;
  for (idx = 0; idx < popcount_tab->blocksize; ++idx) {
    buffer[idx] =
      ((block >> (GtUword) (popcount_tab->blocksize - idx - 1)) &
       (GtUword) 1) ==
      (GtUword) 1 ?
      '1' : '0';
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x28(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x1b5021
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rax
movl 0x28(%rax), %eax
subl -0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
shrq %cl, %rdx
andq $0x1, %rdx
movl $0x30, %eax
movl $0x31, %ecx
cmpq $0x1, %rdx
cmovel %ecx, %eax
movb %al, %dl
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1b4fc8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_get_offset_for_block
GtUword gt_popcount_tab_get_offset_for_block(GtPopcountTab *popcount_tab,
                                                   GtUword block)
{
  gt_assert(popcount_tab != NULL);
  if (popcount_tab->rev_blocks == NULL)
    gt_popcount_tab_init_rev_offset(popcount_tab);
  return gt_compact_ulong_store_get(popcount_tab->rev_blocks, block);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1b507e
movq 0x486f53(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x360fbc(%rip), %rsi    # 0x516013
leaq 0x3ab363(%rip), %rdx    # 0x5603c1
leaq 0x3ab41f(%rip), %rcx    # 0x560484
leaq 0x3ab23c(%rip), %r8     # 0x5602a8
movl $0x153, %r9d            # imm = 0x153
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b5080
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1b5096
movq 0x10(%rsp), %rdi
callq 0x1b50b0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa20c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_init_rev_offset
static inline void gt_popcount_tab_init_rev_offset(GtPopcountTab *popcount_tab)
{
  GtUword idx, current_offset = 0, current_block;
  unsigned int max_bits =
    gt_popcount_tab_offset_bits(popcount_tab, GT_DIV2(popcount_tab->blocksize)),
               current_class = 0;
  popcount_tab->rev_blocks =
    gt_compact_ulong_store_new(popcount_tab->num_of_blocks, max_bits);
  for (idx = 0; idx < popcount_tab->num_of_blocks; idx++) {
    current_block = gt_compact_ulong_store_get(popcount_tab->blocks, idx);
    if (current_class < popcount_tab->blocksize &&
        idx ==
          gt_compact_ulong_store_get(popcount_tab->offsets,
                                     (GtUword) current_class + 1))
      current_class++;
    if (current_class != 0)
      current_offset =
        idx - gt_compact_ulong_store_get(popcount_tab->offsets,
                                         (GtUword) current_class);
    gt_compact_ulong_store_update(popcount_tab->rev_blocks,
                                  current_block,
                                  current_offset);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x28(%rax), %esi
shrl %esi
callq 0x1b4bc0
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0xa1e30
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x1b51db
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xa20c0
movq %rax, 0x18(%rsp)
movl 0x10(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x1b517d
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
addq $0x1, %rsi
callq 0xa20c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0x1b517d
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x1b51b0
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0xa20c0
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xa21f0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x1b5109
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_next_perm
static GtUword gt_popcount_tab_next_perm(GtUword v)
{
  GtUword head, tail;

  head = (v | (v - 1)) + 1;
  tail = v & (((head & -head) >> 1) -1);
  if (tail != 0) {
#ifdef __SSE__
    int zero_trail = __builtin_ctzl(tail);
    tail >>= zero_trail;
#else
    while (( tail & 1 ) == 0)
      tail = tail >> 1;
#endif
  }
  return head | tail;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
subq $0x1, %rcx
orq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
xorl %edx, %edx
subq -0x10(%rsp), %rdx
andq %rdx, %rcx
shrq %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x1b5efb
movq -0x18(%rsp), %rax
tzcntq %rax, %rax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
orq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_gen_blocks
static GtUword gt_popcount_tab_gen_blocks(unsigned int popcount_c,
                                                GtUword idx,
                                                GtUword blockmask,
                                                GtCompactUlongStore *blocks)
{
  GtUword v, init;

  v = init = gt_popcount_tab_perm_start(popcount_c);
  while (v >= init) {
    gt_compact_ulong_store_update(blocks, idx++, v);
    if (popcount_c == 1U)
      v = (v << 1) & blockmask;
    else
      v = gt_popcount_tab_next_perm(v) & blockmask;
  }
  return idx;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl 0x34(%rsp), %edi
callq 0x1b5e70
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x1b5f97
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdx
callq 0xa21f0
cmpl $0x1, 0x34(%rsp)
jne 0x1b5f81
movq 0x10(%rsp), %rax
shlq %rax
andq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1b5f95
movq 0x10(%rsp), %rdi
callq 0x1b5e90
andq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1b5f3a
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_new
GtPriorityQueue *gt_priority_queue_new(GtCompare cmpfun,
                                       GtUword maxnumofelements)
{
  GtPriorityQueue *pq = gt_malloc(sizeof *pq);
  pq->elements = gt_calloc((maxnumofelements + 1), sizeof (*pq->elements));
  pq->minelement = NULL;
  pq->cmpfun = cmpfun;
  pq->capacity = maxnumofelements;
  pq->numofelements = 0;
  return pq;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x28, %edi
leaq 0x3aa9aa(%rip), %rsi    # 0x560974
movl $0x2b, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
movl $0x8, %esi
leaq 0x3aa987(%rip), %rdx    # 0x560974
movl $0x2c, %ecx
callq 0xe83c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_find_min
const void *gt_priority_queue_find_min(const GtPriorityQueue *pq)
{
  gt_assert(pq != NULL && !gt_priority_queue_is_empty(pq));
  return *(pq->elements +
         (pq->capacity < (GtUword) GT_MINPQSIZE ? pq->numofelements-1
                                                      : 1UL));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1b6631
movq 0x10(%rsp), %rdi
callq 0x1b6040
testb $0x1, %al
jne 0x1b6631
jmp 0x1b6669
movq 0x485968(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x35f9d1(%rip), %rsi    # 0x516013
leaq 0x3aa3cc(%rip), %rdx    # 0x560a15
leaq 0x3aa431(%rip), %rcx    # 0x560a81
leaq 0x3aa31d(%rip), %r8     # 0x560974
movl $0x93, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b666b
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x10, 0x8(%rax)
jae 0x1b6698
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1b66a3
movl $0x1, %eax
movq %rax, (%rsp)
jmp 0x1b66a3
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_cmpulong
static int gt_priority_queue_cmpulong(const void *aptr,const void *bptr)
{
  GtUword a, b;

  gt_assert(aptr != NULL && bptr != NULL);
  a = *((const GtUword *) aptr);
  b = *((const GtUword *) bptr);
  return a < b ? -1 : (a > b ? 1 : 0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1b6cfe
cmpq $0x0, 0x18(%rsp)
jne 0x1b6d36
movq 0x48529b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x35f304(%rip), %rsi    # 0x516013
leaq 0x3a9de6(%rip), %rdx    # 0x560afc
leaq 0x3a9dfc(%rip), %rcx    # 0x560b19
leaq 0x3a9c50(%rip), %r8     # 0x560974
movl $0xa6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b6d38
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x1b6d69
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rsp)
jmp 0x1b6d84
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmoval %ecx, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_sort
static void gt_priority_sort(GtUword *numbers,GtUword len)
{
  GtUword j, previousvalue = ULONG_MAX;
  GtPriorityQueue *pq = gt_priority_queue_new(gt_priority_queue_cmpulong, len);

  for (j = 0; j < len; j++)
  {
    gt_priority_queue_add(pq, numbers + j);
  }
  gt_assert(gt_priority_queue_is_full(pq));
  for (j = 0; j < len; j++)
  {
    void *elem = gt_priority_queue_extract_min(pq);

    if (previousvalue != ULONG_MAX)
    {
      gt_assert(previousvalue <= *((GtUword *) elem));
    }
    previousvalue = *((GtUword *) elem);
  }
  gt_assert(gt_priority_queue_is_empty(pq));
  gt_priority_queue_delete(pq);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $-0x1, 0x18(%rsp)
movq 0x28(%rsp), %rsi
leaq -0xd3(%rip), %rdi       # 0x1b6ce0
callq 0x1b5fb0
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x1b6dfd
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1b6120
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1b6dc6
jmp 0x1b6dff
movq 0x10(%rsp), %rdi
callq 0x1b60b0
testb $0x1, %al
jne 0x1b6e45
movq 0x48518c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x35f1f5(%rip), %rsi    # 0x516013
leaq 0x3a9bbc(%rip), %rdx    # 0x5609e1
leaq 0x3a9d08(%rip), %rcx    # 0x560b34
leaq 0x3a9b41(%rip), %r8     # 0x560974
movl $0xb5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b6e47
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x1b6ee4
movq 0x10(%rsp), %rdi
callq 0x1b6360
movq %rax, 0x8(%rsp)
cmpq $-0x1, 0x18(%rsp)
je 0x1b6ec4
jmp 0x1b6e79
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x1b6ec0
movq 0x485111(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x35f17a(%rip), %rsi    # 0x516013
leaq 0x3a9ca5(%rip), %rdx    # 0x560b45
leaq 0x3a9c8d(%rip), %rcx    # 0x560b34
leaq 0x3a9ac6(%rip), %r8     # 0x560974
movl $0xbc, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b6ec2
jmp 0x1b6ec4
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1b6e50
jmp 0x1b6ee6
movq 0x10(%rsp), %rdi
callq 0x1b6040
testb $0x1, %al
jne 0x1b6f2c
movq 0x4850a5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x35f10e(%rip), %rsi    # 0x516013
leaq 0x3a9b18(%rip), %rdx    # 0x560a24
leaq 0x3a9c21(%rip), %rcx    # 0x560b34
leaq 0x3a9a5a(%rip), %r8     # 0x560974
movl $0xc0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1b6f2e
movq 0x10(%rsp), %rdi
callq 0x1b66c0
addq $0x38, %rsp
retq
nopl (%rax)