LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_remove
void gt_tag_value_map_remove(GtTagValueMap *map, const char *tag)
{
  size_t tag_len, value_len, map_len;
  char *value;
  gt_assert(map && tag && get_map_nof_items(*map) > 1);
  tag_len = strlen(tag);
  gt_assert(tag_len);
  /* determine value for given tag */
  value = get_value(*map, tag, NULL);
  gt_assert(value);
  map_len = get_map_len(*map);
  value_len = strlen(value);
  /* move memory from end position of value to start position of tag */
  memmove(value - tag_len - 1, value + value_len + 1,
          map_len - ((size_t) value - (size_t) *map + value_len));
  *map = gt_realloc(*map, map_len - (tag_len + 1 + value_len + 1) + 1);
  gt_assert((*map)[map_len - (tag_len + 1 + value_len + 1)] == '\0');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2730e
movq %rsi, %r15
testq %rsi, %rsi
je 0x2730e
movq %rdi, %r13
movq (%rdi), %r12
movq %r12, %rdi
callq 0x273d3
cmpq $0x1, %rax
jbe 0x2730e
movq %r15, %rdi
callq 0xb260
testq %rax, %rax
je 0x2733f
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x271b8
testq %rax, %rax
je 0x2736d
movq %rax, %r15
movq %r14, %rbx
negq %rbx
movq (%r13), %r12
movq %r12, %rdi
callq 0x273f1
movq %r13, (%rsp)
movq %rax, %r13
movq %r15, %rdi
callq 0xb260
movq %rax, %rbp
leaq (%r15,%rbx), %rdi
decq %rdi
leaq (%r15,%rax), %rsi
incq %rsi
addq %rax, %r15
addq %r13, %r12
subq %r15, %r12
movq %r12, %rdx
callq 0xba50
movq (%rsp), %r15
movq (%r15), %rdi
addq %rbp, %r14
movq %r13, %rbx
subq %r14, %rbx
negq %r14
leaq (%r14,%r13), %rsi
decq %rsi
leaq 0xab197(%rip), %rdx     # 0xd247e
movl $0x99, %ecx
callq 0xcfc2
movq %rax, (%r15)
cmpb $0x0, -0x2(%rax,%rbx)
jne 0x2739b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x106ca3(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2d47(%rip), %rsi     # 0xca066
leaq 0xab1cd(%rip), %rdx     # 0xd24f3
leaq 0xab1f0(%rip), %rcx     # 0xd251d
leaq 0xab14a(%rip), %r8      # 0xd247e
movl $0x8e, %r9d
jmp 0x273c7
movq 0x106c72(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2d16(%rip), %rsi     # 0xca066
leaq 0xab1de(%rip), %rdx     # 0xd2535
leaq 0xab1bf(%rip), %rcx     # 0xd251d
leaq 0xab119(%rip), %r8      # 0xd247e
movl $0x90, %r9d
jmp 0x273c7
movq 0x106c44(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2ce8(%rip), %rsi     # 0xca066
leaq 0xabed7(%rip), %rdx     # 0xd325c
leaq 0xab191(%rip), %rcx     # 0xd251d
leaq 0xab0eb(%rip), %r8      # 0xd247e
movl $0x93, %r9d
jmp 0x273c7
movq 0x106c16(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2cba(%rip), %rsi     # 0xca066
leaq 0xab18a(%rip), %rdx     # 0xd253d
leaq 0xab163(%rip), %rcx     # 0xd251d
leaq 0xab0bd(%rip), %r8      # 0xd247e
movl $0x9a, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_foreach
void gt_tag_value_map_foreach(const GtTagValueMap map,
                              GtTagValueMapIteratorFunc func,
                              void *data)
{
  const char *map_ptr, *tag;
  gt_assert(map && func);
  map_ptr = map;
  do { /* the map has at least one tag/value pair */
    tag = map_ptr;
    while (*map_ptr++ != '\0'); /* skip tag and \0 */
    func(tag, map_ptr /* value */, data);
    while (*map_ptr++ != '\0'); /* skip value and \0 */
  } while (*map_ptr != '\0');
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x277b9
movq %rsi, %r14
testq %rsi, %rsi
je 0x277b9
movq %rdx, %rbx
movq %rdi, %r15
cmpb $0x0, (%r15)
leaq 0x1(%r15), %r15
jne 0x2778f
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
movq %r15, %rdi
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x277a5
cmpb $0x0, (%rdi)
jne 0x2778c
popq %rbx
popq %r14
popq %r15
retq
movq 0x1067f8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa289c(%rip), %rsi     # 0xca066
leaq 0xaae64(%rip), %rdx     # 0xd2635
leaq 0xaae69(%rip), %rcx     # 0xd2641
leaq 0xaac9f(%rip), %r8      # 0xd247e
movl $0xd3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_show
void gt_tag_value_map_show(const GtTagValueMap map)
{
  bool null_terminator_read = false;
  const char *map_ptr;
  gt_assert(map);
  map_ptr = map;
  for (;;) {
    if (*map_ptr == '\0') {
      printf("\\0");
      if (null_terminator_read)
        break;
      else
        null_terminator_read = true;
    }
    else {
      gt_xputchar(*map_ptr);
      null_terminator_read = false;
    }
    map_ptr++;
  }
  gt_xputchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x27845
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0xaae67(%rip), %r14     # 0xd2670
movsbl (%rbx), %edi
testl %edi, %edi
sete %r15b
je 0x2781b
callq 0x165a7
jmp 0x2782b
movq %r14, %rdi
xorl %eax, %eax
callq 0xb070
testb $0x1, %bpl
jne 0x27833
incq %rbx
movl %r15d, %ebp
jmp 0x27809
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x165a7
movq 0x10676c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2810(%rip), %rsi     # 0xca066
leaq 0xcb422(%rip), %rdx     # 0xf2c7f
leaq 0xaadf6(%rip), %rcx     # 0xd265a
leaq 0xaac13(%rip), %r8      # 0xd247e
movl $0xe1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_example
int gt_tag_value_map_example(GT_UNUSED GtError *err)
{
  GtTagValueMap map;

  gt_error_check(err);

  map = gt_tag_value_map_new("tag 1", "value 1");
  gt_tag_value_map_add(&map, "tag 2", "value 2");
  gt_tag_value_map_add(&map, "tag 3", "value 3");

  gt_assert(!gt_tag_value_map_get(map, "unused tag"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 1"), "value 1"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 2"), "value 2"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 3"), "value 3"));

  gt_tag_value_map_delete(map);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x27894
callq 0xc103
testb %al, %al
jne 0x27a3b
leaq 0xaadf1(%rip), %rdi     # 0xd268c
leaq 0xaadf0(%rip), %rsi     # 0xd2692
callq 0x26f28
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0xaade4(%rip), %rsi     # 0xd269a
leaq 0xaade3(%rip), %rdx     # 0xd26a0
movq %rbx, %rdi
callq 0x27035
leaq 0xaaddc(%rip), %rsi     # 0xd26a8
leaq 0xaaddb(%rip), %rdx     # 0xd26ae
movq %rbx, %rdi
callq 0x27035
movq (%rbx), %rdi
leaq 0xaadd1(%rip), %rsi     # 0xd26b6
callq 0x276e6
testq %rax, %rax
jne 0x2797d
movq 0x8(%rsp), %rdi
leaq 0xaad8d(%rip), %rsi     # 0xd268c
callq 0x276e6
leaq 0xaad87(%rip), %rsi     # 0xd2692
movq %rax, %rdi
callq 0xb880
testl %eax, %eax
jne 0x279ae
movq 0x8(%rsp), %rdi
leaq 0xaad73(%rip), %rsi     # 0xd269a
callq 0x276e6
leaq 0xaad6d(%rip), %rsi     # 0xd26a0
movq %rax, %rdi
callq 0xb880
testl %eax, %eax
jne 0x279df
movq 0x8(%rsp), %rdi
leaq 0xaad59(%rip), %rsi     # 0xd26a8
callq 0x276e6
leaq 0xaad53(%rip), %rsi     # 0xd26ae
movq %rax, %rdi
callq 0xb880
testl %eax, %eax
jne 0x27a0d
movq 0x8(%rsp), %rdi
callq 0x27a73
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movq 0x106634(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa26d8(%rip), %rsi     # 0xca066
leaq 0xaad2c(%rip), %rdx     # 0xd26c1
leaq 0xaacd7(%rip), %rcx     # 0xd2673
leaq 0xaaadb(%rip), %r8      # 0xd247e
movl $0xfe, %r9d
jmp 0x27a67
movq 0x106603(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa26a7(%rip), %rsi     # 0xca066
leaq 0xaad24(%rip), %rdx     # 0xd26ea
leaq 0xaaca6(%rip), %rcx     # 0xd2673
leaq 0xaaaaa(%rip), %r8      # 0xd247e
movl $0xff, %r9d
jmp 0x27a67
movq 0x1065d2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2676(%rip), %rsi     # 0xca066
leaq 0xaad2a(%rip), %rdx     # 0xd2721
leaq 0xaac75(%rip), %rcx     # 0xd2673
leaq 0xaaa79(%rip), %r8      # 0xd247e
movl $0x100, %r9d            # imm = 0x100
jmp 0x27a67
movq 0x1065a4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2648(%rip), %rsi     # 0xca066
leaq 0xaad33(%rip), %rdx     # 0xd2758
leaq 0xaac47(%rip), %rcx     # 0xd2673
leaq 0xaaa4b(%rip), %r8      # 0xd247e
movl $0x101, %r9d            # imm = 0x101
jmp 0x27a67
movq 0x106576(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa261a(%rip), %rsi     # 0xca066
leaq 0xa2c06(%rip), %rdx     # 0xca659
leaq 0xaac19(%rip), %rcx     # 0xd2673
leaq 0xaaa1d(%rip), %r8      # 0xd247e
movl $0xf8, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_stream.c
// Function: gt_tidy_region_node_stream_class
const GtNodeStreamClass* gt_tidy_region_node_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtTidyRegionNodeStream),
                                   tidy_region_node_stream_free,
                                   tidy_region_node_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x106ff6(%rip)    # 0x12fb68
jne 0x28b91
leaq 0x24(%rip), %rsi        # 0x28b9f
leaq 0x47(%rip), %rdx        # 0x28bc9
pushq $0x28
popq %rdi
callq 0x25a78
movq %rax, 0x106fd7(%rip)    # 0x12fb68
callq 0x4f266
movq 0x106fcb(%rip), %rax    # 0x12fb68
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_stream.c
// Function: tidy_region_node_stream_next
static int tidy_region_node_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                               GtError *err)
{
  GtTidyRegionNodeStream *ais;
  int had_err = 0;
  gt_error_check(err);
  ais = gt_tidy_region_node_stream_cast(ns);

  if (!ais->queued) {
    /* no nodes in the buffer -> get new nodes */
    while (!(had_err = gt_node_stream_next(ais->in_stream, gn, err)) && *gn) {
      gt_assert(*gn && !had_err);
      had_err = gt_genome_node_accept(*gn, ais->tidy_region_node_visitor, err);
      if (had_err) {
        /* we own the node -> delete it */
        gt_genome_node_delete(*gn);
        *gn = NULL;
        break;
      }
    }
    if (!had_err) {
      ais->queued = true;
    }
  }
  if (!had_err) {
    if (gt_tidy_region_node_visitor_node_buffer_size(
                                               ais->tidy_region_node_visitor)) {
      *gn = gt_tidy_region_node_visitor_get_node(ais->tidy_region_node_visitor);
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x28bee
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x28c76
callq 0x28b64
movq %rax, %rdi
movq %r15, %rsi
callq 0x25ec1
movq %rax, %r15
cmpb $0x0, 0x20(%rax)
jne 0x28c49
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x25c62
testl %eax, %eax
jne 0x28c40
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28c44
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x1c56c
testl %eax, %eax
je 0x28c07
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x1d1e3
xorl %eax, %eax
jmp 0x28c62
movl %eax, %ebp
jmp 0x28c69
movb $0x1, 0x20(%r15)
movq 0x18(%r15), %rdi
callq 0x2928a
testq %rax, %rax
je 0x28c67
movq 0x18(%r15), %rdi
callq 0x292a8
xorl %ebp, %ebp
movq %rax, (%rbx)
jmp 0x28c69
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10533b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa13df(%rip), %rsi     # 0xca066
leaq 0xa19cb(%rip), %rdx     # 0xca659
leaq 0xaa14f(%rip), %rcx     # 0xd2de4
leaq 0xaa121(%rip), %r8      # 0xd2dbd
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_stream.c
// Function: gt_tidy_region_node_stream_new
GtNodeStream* gt_tidy_region_node_stream_new(GtNodeStream *in_stream)
{
  GtTidyRegionNodeStream *tidy_region_node_stream;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_tidy_region_node_stream_class(), false);
  tidy_region_node_stream = gt_tidy_region_node_stream_cast(ns);
  tidy_region_node_stream->in_stream = gt_node_stream_ref(in_stream);
  tidy_region_node_stream->tidy_region_node_visitor =
                                              gt_tidy_region_node_visitor_new();
  tidy_region_node_stream->queued = false;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x28d01
movq %rdi, %rbx
callq 0x28b64
movq %rax, %rdi
xorl %esi, %esi
callq 0x25adf
movq %rax, %r14
callq 0x28b64
movq %rax, %rdi
movq %r14, %rsi
callq 0x25ec1
movq %rax, %r15
movq %rbx, %rdi
callq 0x25b74
movq %rax, 0x10(%r15)
callq 0x29235
movq %rax, 0x18(%r15)
movb $0x0, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x1052b0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa1354(%rip), %rsi     # 0xca066
leaq 0xaa07b(%rip), %rdx     # 0xd2d94
leaq 0xaa07e(%rip), %rcx     # 0xd2d9e
leaq 0xaa096(%rip), %r8      # 0xd2dbd
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: gt_tidy_region_node_visitor_class
const GtNodeVisitorClass* gt_tidy_region_node_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtTidyRegionNodeVisitor),
                                    tidy_region_node_visitor_free,
                                    tidy_region_node_visitor_comment_node,
                                    tidy_region_node_visitor_feature_node,
                                    tidy_region_node_visitor_region_node,
                                    tidy_region_node_visitor_sequence_node,
                                    tidy_region_node_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc,
                                            tidy_region_node_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x106e2a(%rip)    # 0x12fb70
jne 0x28d94
leaq 0x3f4(%rip), %rax       # 0x29143
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x28da2
leaq 0x6b(%rip), %rdx        # 0x28dcc
leaq 0xdd(%rip), %rcx        # 0x28e45
leaq 0x225(%rip), %r8        # 0x28f94
leaq 0x356(%rip), %r9        # 0x290cc
pushq $0x20
popq %rdi
callq 0x25f10
movq %rax, 0x106deb(%rip)    # 0x12fb70
leaq 0x430(%rip), %rsi       # 0x291bc
movq %rax, %rdi
callq 0x25f9f
callq 0x4f266
movq 0x106dd0(%rip), %rax    # 0x12fb70
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: tidy_region_node_visitor_comment_node
static int tidy_region_node_visitor_comment_node(GtNodeVisitor *nv,
                                                 GtCommentNode *cn,
                                                 GT_UNUSED GtError *err)
{
  GtTidyRegionNodeVisitor *trnv;
  gt_error_check(err);
  trnv = tidy_region_node_visitor_cast(nv);
  gt_queue_add(trnv->node_buffer, cn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x28de7
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x28e0d
callq 0x28d38
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x5b055
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1051a4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa1248(%rip), %rsi     # 0xca066
leaq 0xa1834(%rip), %rdx     # 0xca659
leaq 0xa9fd5(%rip), %rcx     # 0xd2e01
leaq 0xa9ff4(%rip), %r8      # 0xd2e27
movl $0x87, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: tidy_region_node_visitor_region_node
static int tidy_region_node_visitor_region_node(GtNodeVisitor *nv,
                                                GtRegionNode *rn,
                                                GT_UNUSED GtError *err)
{
  GtTidyRegionNodeVisitor *trnv;
  const char *seqid;
  gt_error_check(err);
  trnv = tidy_region_node_visitor_cast(nv);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn));
  gt_assert(seqid);
  if (!gt_hashmap_get(trnv->region_nodes, seqid)) {
    gt_hashmap_add(trnv->region_nodes, gt_cstr_dup(seqid),
                   gt_genome_node_ref((GtGenomeNode*) rn));
    gt_assert(gt_hashmap_get(trnv->region_nodes, seqid));
  }
  gt_queue_add(trnv->node_buffer, rn);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x28fb8
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x2906c
callq 0x28d38
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c31a
movq %rax, %rdi
callq 0x143d2
testq %rax, %rax
je 0x29042
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x55ef6
testq %rax, %rax
jne 0x2902a
movq 0x18(%r14), %r12
movq %r15, %rdi
callq 0x4f8ae
movq %rax, %r13
movq %rbx, %rdi
callq 0x1bec8
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x55f31
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x29096
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x5b055
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x104f6f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa1013(%rip), %rsi     # 0xca066
leaq 0xc1f16(%rip), %rdx     # 0xeaf70
leaq 0xa9e2a(%rip), %rcx     # 0xd2e8b
leaq 0xa9dbf(%rip), %r8      # 0xd2e27
pushq $0x6d
jmp 0x290be
movq 0x104f45(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0fe9(%rip), %rsi     # 0xca066
leaq 0xa15d5(%rip), %rdx     # 0xca659
leaq 0xa9e00(%rip), %rcx     # 0xd2e8b
leaq 0xa9d95(%rip), %r8      # 0xd2e27
pushq $0x6a
jmp 0x290be
movq 0x104f1b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0fbf(%rip), %rsi     # 0xca066
leaq 0xa9e02(%rip), %rdx     # 0xd2eb0
leaq 0xa9dd6(%rip), %rcx     # 0xd2e8b
leaq 0xa9d6b(%rip), %r8      # 0xd2e27
pushq $0x71
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: tidy_region_node_visitor_sequence_node
static int tidy_region_node_visitor_sequence_node(GtNodeVisitor *nv,
                                                  GtSequenceNode *sn,
                                                  GT_UNUSED GtError *err)
{
  GtTidyRegionNodeVisitor *trnv;
  gt_error_check(err);
  trnv = tidy_region_node_visitor_cast(nv);
  gt_queue_add(trnv->node_buffer, sn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x290e7
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x2910d
callq 0x28d38
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x5b055
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x104ea4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0f48(%rip), %rsi     # 0xca066
leaq 0xa1534(%rip), %rdx     # 0xca659
leaq 0xa9dae(%rip), %rcx     # 0xd2eda
leaq 0xa9cf4(%rip), %r8      # 0xd2e27
pushq $0x7c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: tidy_region_node_visitor_eof_node
static int tidy_region_node_visitor_eof_node(GtNodeVisitor *nv,
                                             GtEOFNode *en,
                                             GT_UNUSED GtError *err)
{
  GtTidyRegionNodeVisitor *trnv;
  gt_error_check(err);
  trnv = tidy_region_node_visitor_cast(nv);
  gt_queue_add(trnv->node_buffer, en);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x2915e
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x29184
callq 0x28d38
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x5b055
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x104e2d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0ed1(%rip), %rsi     # 0xca066
leaq 0xa14bd(%rip), %rdx     # 0xca659
leaq 0xa9d5e(%rip), %rcx     # 0xd2f01
leaq 0xa9c7d(%rip), %r8      # 0xd2e27
movl $0x9d, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: tidy_region_node_visitor_meta_node
static int tidy_region_node_visitor_meta_node(GtNodeVisitor *nv,
                                              GtMetaNode *mn,
                                              GT_UNUSED GtError *err)
{
  GtTidyRegionNodeVisitor *trnv;
  gt_error_check(err);
  trnv = tidy_region_node_visitor_cast(nv);
  gt_queue_add(trnv->node_buffer, mn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x291d7
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x291fd
callq 0x28d38
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x5b055
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x104db4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0e58(%rip), %rsi     # 0xca066
leaq 0xa1444(%rip), %rdx     # 0xca659
leaq 0xa9d07(%rip), %rcx     # 0xd2f23
leaq 0xa9c04(%rip), %r8      # 0xd2e27
movl $0x92, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: gt_tidy_region_node_visitor_new
GtNodeVisitor* gt_tidy_region_node_visitor_new(void)
{
  GtNodeVisitor *nv;
  GtTidyRegionNodeVisitor *tidy_region_node_visitor;
  nv = gt_node_visitor_create(gt_tidy_region_node_visitor_class());
  tidy_region_node_visitor = tidy_region_node_visitor_cast(nv);
  tidy_region_node_visitor->node_buffer = gt_queue_new();
  tidy_region_node_visitor->region_nodes = gt_hashmap_new(GT_HASH_STRING,
                                                gt_free_func,
                                                (GtFree) gt_genome_node_delete);
  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x28d38
movq %rax, %rdi
callq 0x25fe0
movq %rax, %rbx
callq 0x28d38
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
movq %rax, %r14
callq 0x5b040
movq %rax, 0x10(%r14)
leaq -0x1bedd(%rip), %rsi    # 0xd38f
leaq -0xc090(%rip), %rdx     # 0x1d1e3
pushq $0x1
popq %rdi
callq 0x55da4
movq %rax, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/type_checker.c
// Function: gt_type_checker_create
GtTypeChecker* gt_type_checker_create(const GtTypeCheckerClass
                                       *type_checker_class)
{
  GtTypeChecker *type_checker;
  gt_assert(type_checker_class && type_checker_class->size);
  type_checker = gt_calloc(1, type_checker_class->size);
  type_checker->c_class = type_checker_class;
  return type_checker;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x292f0
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x292f0
leaq 0xa9cac(%rip), %rdx     # 0xd2f8c
pushq $0x1
popq %rdi
pushq $0x1c
popq %rcx
callq 0xce9a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x104cc1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0d65(%rip), %rsi     # 0xca066
leaq 0xa9c3e(%rip), %rdx     # 0xd2f46
leaq 0xa9c66(%rip), %rcx     # 0xd2f75
leaq 0xa9c76(%rip), %r8      # 0xd2f8c
pushq $0x1b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/type_checker.c
// Function: gt_type_checker_delete
void gt_type_checker_delete(GtTypeChecker *type_checker)
{
  if (!type_checker) return;
  if (type_checker->reference_count) {
    type_checker->reference_count--;
    return;
  }
  gt_assert(type_checker->c_class);
  if (type_checker->c_class->free)
    type_checker->c_class->free(type_checker);
  gt_free(type_checker);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x29513
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x29515
decl %eax
movl %eax, 0x8(%rbx)
popq %rbx
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x2953e
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2952b
movq %rbx, %rdi
callq *%rax
leaq 0xa9a5a(%rip), %rsi     # 0xd2f8c
pushq $0x5a
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
movq 0x104a73(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0b17(%rip), %rsi     # 0xca066
leaq 0xa9c09(%rip), %rdx     # 0xd315f
leaq 0xa9c18(%rip), %rcx     # 0xd3175
leaq 0xa9a28(%rip), %r8      # 0xd2f8c
pushq $0x57
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/visitor_stream.c
// Function: gt_visitor_stream_class
const GtNodeStreamClass* gt_visitor_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtVisitorStream),
                                   visitor_stream_free,
                                   visitor_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x1065aa(%rip)    # 0x12fb78
jne 0x295ed
leaq 0x24(%rip), %rsi        # 0x295fb
leaq 0x47(%rip), %rdx        # 0x29625
pushq $0x20
popq %rdi
callq 0x25a78
movq %rax, 0x10658b(%rip)    # 0x12fb78
callq 0x4f266
movq 0x10657f(%rip), %rax    # 0x12fb78
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/visitor_stream.c
// Function: visitor_stream_next
static int visitor_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                               GtError *err)
{
  GtVisitorStream *visitor_stream;
  int had_err;
  gt_error_check(err);
  visitor_stream = visitor_stream_cast(ns);
  had_err = gt_node_stream_next(visitor_stream->in_stream, gn, err);
  if (!had_err && *gn)
    had_err = gt_genome_node_accept(*gn, visitor_stream->visitor, err);
  if (had_err) {
    /* we own the node -> delete it */
    gt_genome_node_delete(*gn);
    *gn = NULL;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x29646
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x296a3
callq 0x295c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x25ec1
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x25c62
testl %eax, %eax
je 0x29687
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x1d1e3
andq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x2967a
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x1c56c
testl %eax, %eax
jne 0x2966c
jmp 0x2967a
movq 0x10490e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa09b2(%rip), %rsi     # 0xca066
leaq 0xa0f9e(%rip), %rdx     # 0xca659
leaq 0xa9b7f(%rip), %rcx     # 0xd3241
leaq 0xa9b5a(%rip), %r8      # 0xd3223
pushq $0x24
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/visitor_stream.c
// Function: gt_visitor_stream_new
GtNodeStream* gt_visitor_stream_new(GtNodeStream *in_stream,
                                    GtNodeVisitor *visitor)
{
  GtVisitorStream *visitor_stream;
  GtNodeStream *ns;
  ns = gt_node_stream_create(gt_visitor_stream_class(),
                             gt_node_stream_is_sorted(in_stream));
  visitor_stream = visitor_stream_cast(ns);
  visitor_stream->in_stream = gt_node_stream_ref(in_stream);
  visitor_stream->visitor = visitor;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x295c0
movq %rax, %r15
movq %r14, %rdi
callq 0x25e7d
movzbl %al, %esi
movq %r15, %rdi
callq 0x25adf
movq %rax, %r15
callq 0x295c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x25ec1
movq %rax, %r12
movq %r14, %rdi
callq 0x25b74
movq %rax, 0x10(%r12)
movq %rbx, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/xrf_checker.c
// Function: gt_xrf_checker_new
GtXRFChecker* gt_xrf_checker_new(const char *file_path, GtError *err)
{
  GtXRFChecker *xrc;
  GtUword i;
  gt_error_check(err);
  gt_assert(file_path);

  xrc = gt_calloc(1UL, sizeof (GtXRFChecker));
  xrc->xpt = gt_xrf_abbr_parse_tree_new(file_path, err);
  if (!xrc->xpt) {
    gt_xrf_checker_delete(xrc);
    return NULL;
  }
  xrc->abbrvs = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
  for (i = 0; i < gt_xrf_abbr_parse_tree_num_of_entries(xrc->xpt); i++) {
    const GtXRFAbbrEntry *e = gt_xrf_abbr_parse_tree_get_entry(xrc->xpt, i);
    const char *synonym;
    gt_hashmap_add(xrc->abbrvs,
                   (void*) gt_xrf_abbr_entry_get_value(e, "abbreviation"),
                   (void*) e);
    if ((synonym = gt_xrf_abbr_entry_get_value(e, "synonym"))) {
      gt_hashmap_add(xrc->abbrvs, (void*) synonym, (void*) e);
    }
  }
  xrc->splitter = gt_splitter_new();
  return xrc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x29a4b
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x29b51
testq %r15, %r15
je 0x29b27
leaq 0xa981f(%rip), %rdx     # 0xd327a
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x70
popq %rcx
callq 0xce9a
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x66710
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x29b0b
xorl %r14d, %r14d
pushq $0x1
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, (%rbx)
leaq 0xa98f8(%rip), %r15     # 0xd3395
leaq 0xa98fe(%rip), %r12     # 0xd33a2
movq 0x8(%rbx), %rdi
callq 0x6717f
cmpq %rax, %r14
jae 0x29b00
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x67134
movq %rax, %r13
movq (%rbx), %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0x66632
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x55f31
movq %r13, %rdi
movq %r12, %rsi
callq 0x66632
testq %rax, %rax
je 0x29afb
movq (%rbx), %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x55f31
incq %r14
jmp 0x29aa4
callq 0x124cc
movq %rax, 0x10(%rbx)
jmp 0x29b15
movq %rbx, %rdi
callq 0x29b87
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10448a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa052e(%rip), %rsi     # 0xca066
leaq 0xb47ac(%rip), %rdx     # 0xde2eb
leaq 0xa983c(%rip), %rcx     # 0xd3382
leaq 0xa972d(%rip), %r8      # 0xd327a
pushq $0x6e
jmp 0x29b79
movq 0x104460(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0504(%rip), %rsi     # 0xca066
leaq 0xa0af0(%rip), %rdx     # 0xca659
leaq 0xa9812(%rip), %rcx     # 0xd3382
leaq 0xa9703(%rip), %r8      # 0xd327a
pushq $0x6d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/xrf_checker.c
// Function: gt_xrf_checker_delete
void gt_xrf_checker_delete(GtXRFChecker *xrc)
{
  if (!xrc) return;
  if (xrc->reference_count) {
    xrc->reference_count--;
    return;
  }
  gt_xrf_abbr_parse_tree_delete(xrc->xpt);
  gt_hashmap_delete(xrc->abbrvs);
  gt_splitter_delete(xrc->splitter);
  gt_free(xrc);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x29ba0
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x29ba2
decq %rax
movq %rax, 0x18(%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rdi
callq 0x6708a
movq (%rbx), %rdi
callq 0x563a7
movq 0x10(%rbx), %rdi
callq 0x1283e
leaq 0xa96b7(%rip), %rsi     # 0xd327a
movq %rbx, %rdi
movl $0x8f, %edx
popq %rbx
jmp 0xd249
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_create
GtCanvas* gt_canvas_create(const GtCanvasClass *cc)
{
  GtCanvas *c;
  gt_assert(cc && cc->size);
  c = gt_calloc(1, cc->size);
  c->c_class = cc;
  c->pvt = gt_calloc(1, sizeof (GtCanvasMembers));
  return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29ebb
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x29ebb
leaq 0xa9564(%rip), %r14     # 0xd33de
pushq $0x1
popq %r15
movq %r15, %rdi
movq %r14, %rdx
movl $0xa5, %ecx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x68
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movl $0xa7, %ecx
callq 0xce9a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1040f6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa019a(%rip), %rsi     # 0xca066
leaq 0xa955a(%rip), %rdx     # 0xd342d
leaq 0xa9562(%rip), %rcx     # 0xd343c
leaq 0xa94fd(%rip), %r8      # 0xd33de
movl $0xa4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_delete
void gt_canvas_delete(GtCanvas *canvas)
{
  if (!canvas) return;
  gt_assert(canvas->c_class);
  if (canvas->c_class->free)
    canvas->c_class->free(canvas);
  if (canvas->pvt->g)
    gt_graphics_delete(canvas->pvt->g);
  if (canvas->pvt->bt)
    gt_bittab_delete(canvas->pvt->bt);
  gt_free(canvas->pvt);
  gt_free(canvas);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29f6e
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x29f76
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x29f15
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x29f2e
movq %rax, %rdi
callq 0x2c4c8
movq 0x8(%rbx), %rdi
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x29f43
movq %rax, %rdi
callq 0x4e2ea
movq 0x8(%rbx), %rdi
leaq 0xa9494(%rip), %r14     # 0xd33de
movq %r14, %rsi
movl $0xb5, %edx
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10403b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa00df(%rip), %rsi     # 0xca066
leaq 0xa94bf(%rip), %rdx     # 0xd344d
leaq 0xa94c8(%rip), %rcx     # 0xd345d
leaq 0xa9442(%rip), %r8      # 0xd33de
movl $0xae, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_layout_pre
int gt_canvas_visit_layout_pre(GtCanvas *canvas, GtLayout* layout, GtError *err)
{
  gt_assert(canvas && layout);
  if (canvas->c_class->visit_layout_pre)
    return canvas->c_class->visit_layout_pre(canvas, layout, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a0a9
testq %rsi, %rsi
je 0x2a0a9
movq (%rdi), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2a0a6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103f07(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9ffab(%rip), %rsi     # 0xca066
leaq 0xa9407(%rip), %rdx     # 0xd34c9
leaq 0xa9411(%rip), %rcx     # 0xd34da
leaq 0xa930e(%rip), %r8      # 0xd33de
movl $0xcf, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_layout_post
int gt_canvas_visit_layout_post(GtCanvas *canvas, GtLayout* layout,
                                GtError *err)
{
  gt_assert(canvas && layout);
  if (canvas->c_class->visit_layout_post)
    return canvas->c_class->visit_layout_post(canvas, layout, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a0fd
testq %rsi, %rsi
je 0x2a0fd
movq (%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2a0fa
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103eb3(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9ff57(%rip), %rsi     # 0xca066
leaq 0xa93b3(%rip), %rdx     # 0xd34c9
leaq 0xa93d8(%rip), %rcx     # 0xd34f5
leaq 0xa92ba(%rip), %r8      # 0xd33de
movl $0xd9, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_track_pre
int gt_canvas_visit_track_pre(GtCanvas *canvas, GtTrack *track, GtError *err)
{
  gt_assert(canvas && track);
  canvas->pvt->current_track = track;
  if (canvas->c_class->visit_track_pre)
    return canvas->c_class->visit_track_pre(canvas, track, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a159
testq %rsi, %rsi
je 0x2a159
movq 0x8(%rdi), %rax
movq %rsi, 0x40(%rax)
movq (%rdi), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x2a156
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103e57(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fefb(%rip), %rsi     # 0xca066
leaq 0xa939f(%rip), %rdx     # 0xd3511
leaq 0xa93a8(%rip), %rcx     # 0xd3521
leaq 0xa925e(%rip), %r8      # 0xd33de
movl $0xe2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_track_post
int gt_canvas_visit_track_post(GtCanvas *canvas, GtTrack *track, GtError *err)
{
  gt_assert(canvas && track);
  if (canvas->c_class->visit_track_post)
    return canvas->c_class->visit_track_post(canvas, track, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a1ad
testq %rsi, %rsi
je 0x2a1ad
movq (%rdi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2a1aa
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103e03(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fea7(%rip), %rsi     # 0xca066
leaq 0xa934b(%rip), %rdx     # 0xd3511
leaq 0xa936e(%rip), %rcx     # 0xd353b
leaq 0xa920a(%rip), %r8      # 0xd33de
movl $0xec, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_line_pre
int gt_canvas_visit_line_pre(GtCanvas *canvas, GtLine *line, GtError *err)
{
  gt_assert(canvas && line);
  if (canvas->c_class->visit_line_pre)
    return canvas->c_class->visit_line_pre(canvas, line, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a201
testq %rsi, %rsi
je 0x2a201
movq (%rdi), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x2a1fe
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103daf(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fe53(%rip), %rsi     # 0xca066
leaq 0xa933c(%rip), %rdx     # 0xd3556
leaq 0xa9344(%rip), %rcx     # 0xd3565
leaq 0xa91b6(%rip), %r8      # 0xd33de
movl $0xf5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_line_post
int gt_canvas_visit_line_post(GtCanvas *canvas, GtLine *line, GtError *err)
{
  gt_assert(canvas && line);
  if (canvas->c_class->visit_line_post)
    return canvas->c_class->visit_line_post(canvas, line, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a255
testq %rsi, %rsi
je 0x2a255
movq (%rdi), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x2a252
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103d5b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fdff(%rip), %rsi     # 0xca066
leaq 0xa92e8(%rip), %rdx     # 0xd3556
leaq 0xa9309(%rip), %rcx     # 0xd357e
leaq 0xa9162(%rip), %r8      # 0xd33de
movl $0xfe, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_block
int gt_canvas_visit_block(GtCanvas *canvas, GtBlock *block, GtError *err)
{
  gt_assert(canvas && block);
  if (canvas->c_class->visit_block)
    return canvas->c_class->visit_block(canvas, block, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a2a9
testq %rsi, %rsi
je 0x2a2a9
movq (%rdi), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x2a2a6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103d07(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fdab(%rip), %rsi     # 0xca066
leaq 0xa92d6(%rip), %rdx     # 0xd3598
leaq 0xa92df(%rip), %rcx     # 0xd35a8
leaq 0xa910e(%rip), %r8      # 0xd33de
movl $0x107, %r9d            # imm = 0x107
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_element
int gt_canvas_visit_element(GtCanvas *canvas, GtElement *element, GtError *err)
{
  gt_assert(canvas && element);
  if (canvas->c_class->visit_element)
    return canvas->c_class->visit_element(canvas, element, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a2fd
testq %rsi, %rsi
je 0x2a2fd
movq (%rdi), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x2a2fa
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103cb3(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fd57(%rip), %rsi     # 0xca066
leaq 0xa92a8(%rip), %rdx     # 0xd35be
leaq 0xa92b3(%rip), %rcx     # 0xd35d0
leaq 0xa90ba(%rip), %r8      # 0xd33de
movl $0x110, %r9d            # imm = 0x110
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas.c
// Function: gt_canvas_visit_custom_track
int gt_canvas_visit_custom_track(GtCanvas *canvas, GtCustomTrack *ct,
                                 GtError *err)
{
  gt_assert(canvas && ct);
  if (canvas->c_class->visit_ct)
    return canvas->c_class->visit_ct(canvas, ct, err);
  else
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2a351
testq %rsi, %rsi
je 0x2a351
movq (%rdi), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x2a34e
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x103c5f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fd03(%rip), %rsi     # 0xca066
leaq 0xa927e(%rip), %rdx     # 0xd35e8
leaq 0xa9284(%rip), %rcx     # 0xd35f5
leaq 0xa9066(%rip), %r8      # 0xd33de
movl $0x11a, %r9d            # imm = 0x11A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas_cairo_file.c
// Function: gt_canvas_cairo_file_to_file
int gt_canvas_cairo_file_to_file(GtCanvasCairoFile *canvas,
                                 const char *filename, GtError *err)
{
  int had_err = 0;
  GtCanvas *c = (GtCanvas*) canvas;
  gt_error_check(err);
  gt_assert(canvas && filename);
  /* write out result file */
  if (c->pvt->g)
    had_err = gt_graphics_save_to_file(c->pvt->g, filename, err);
  else
  {
    /* XXX: shouldn't this be an assertion? */
    gt_error_set(err, "No graphics has been created yet!");
    had_err = -1;
  }

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x2a3f3
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x2a45e
testq %r15, %r15
je 0x2a434
testq %r14, %r14
je 0x2a434
movq 0x8(%r15), %rax
movq 0x58(%rax), %rdi
testq %rdi, %rdi
je 0x2a41a
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2d5ac
leaq 0xa9280(%rip), %rsi     # 0xd36a1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x103b7d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fc21(%rip), %rsi     # 0xca066
leaq 0xa9242(%rip), %rdx     # 0xd368e
leaq 0xa91f5(%rip), %rcx     # 0xd3648
leaq 0xa920b(%rip), %r8      # 0xd3665
pushq $0x30
jmp 0x2a486
movq 0x103b53(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fbf7(%rip), %rsi     # 0xca066
leaq 0xa01e3(%rip), %rdx     # 0xca659
leaq 0xa91cb(%rip), %rcx     # 0xd3648
leaq 0xa91e1(%rip), %r8      # 0xd3665
pushq $0x2f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas_cairo_file.c
// Function: gt_canvas_cairo_file_to_stream
int gt_canvas_cairo_file_to_stream(GtCanvasCairoFile *canvas, GtStr *stream)
{
  int had_err = 0;
  GtCanvas *c = (GtCanvas*) canvas;
  gt_assert(canvas && stream);

  /* write out result file */
  if (c->pvt->g)
    gt_graphics_save_to_stream(c->pvt->g, stream);

  return had_err;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2a4b5
testq %rsi, %rsi
je 0x2a4b5
movq 0x8(%rdi), %rax
movq 0x58(%rax), %rdi
testq %rdi, %rdi
je 0x2a4b1
callq 0x2d679
xorl %eax, %eax
popq %rcx
retq
movq 0x103afc(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9fba0(%rip), %rsi     # 0xca066
leaq 0xa91f6(%rip), %rdx     # 0xd36c3
leaq 0xa9200(%rip), %rcx     # 0xd36d4
leaq 0xa918a(%rip), %r8      # 0xd3665
pushq $0x42
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas_cairo_file.c
// Function: gt_canvas_cairo_file_class
const GtCanvasClass* gt_canvas_cairo_file_class(void)
{
  static const GtCanvasClass *canvas_class = NULL;
  gt_class_alloc_lock_enter();
  if (!canvas_class) {
    canvas_class = gt_canvas_class_new(sizeof (GtCanvasCairoFile),
                                       gt_canvas_cairo_visit_layout_pre,
                                       gt_canvas_cairo_visit_layout_post,
                                       gt_canvas_cairo_visit_track_pre,
                                       gt_canvas_cairo_visit_track_post,
                                       gt_canvas_cairo_visit_line_pre,
                                       gt_canvas_cairo_visit_line_post,
                                       gt_canvas_cairo_visit_block,
                                       gt_canvas_cairo_visit_element,
                                       gt_canvas_cairo_visit_custom_track,
                                       gt_canvas_cairo_draw_ruler,
                                       NULL);
  }
  gt_class_alloc_lock_leave();
  return canvas_class;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x105684(%rip)    # 0x12fb80
jne 0x2a561
leaq 0x440f6(%rip), %rax     # 0x6e5fb
leaq 0x43e08(%rip), %r10     # 0x6e314
leaq 0x432cd(%rip), %r11     # 0x6d7e0
leaq 0x42ab0(%rip), %rbx     # 0x6cfca
leaq 0x429b1(%rip), %r14     # 0x6ced2
leaq 0x42344(%rip), %rsi     # 0x6c86c
leaq 0x423db(%rip), %rdx     # 0x6c90a
leaq 0x423d7(%rip), %rcx     # 0x6c90d
leaq 0x4270c(%rip), %r8      # 0x6cc49
leaq 0x427ac(%rip), %r9      # 0x6ccf0
pushq $0x18
popq %rdi
pushq $0x0
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
callq 0x29bd4
addq $0x30, %rsp
movq %rax, 0x10561f(%rip)    # 0x12fb80
callq 0x4f266
movq 0x105613(%rip), %rax    # 0x12fb80
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_new
GtDiagram* gt_diagram_new(GtFeatureIndex *feature_index, const char *seqid,
                          const GtRange *range, GtStyle *style,
                          GtError *err)
{
  GtDiagram *diagram;
  int had_err = 0;
  GtArray *features = NULL;
  gt_assert(seqid && range && style);
  if (range->start == range->end)
  {
    gt_error_set(err, "range start must not be equal to range end");
    return NULL;
  }
  features = gt_array_new(sizeof (GtGenomeNode*));
  had_err = gt_feature_index_get_features_for_range(feature_index, features,
                                                    seqid, range, err);
  if (had_err)
  {
    gt_array_delete(features);
    return NULL;
  }
  diagram = gt_diagram_new_generic(features, range, style, false);
  return diagram;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2a7e9
movq %rdx, %r14
testq %rdx, %rdx
je 0x2a7e9
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2a7e9
movq %r8, %r15
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jne 0x2a78f
leaq 0xa901b(%rip), %rsi     # 0xd379e
movq %r15, %rdi
xorl %eax, %eax
callq 0xc007
jmp 0x2a7c0
movq %rsi, %r12
movq %rdi, %r13
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %rbp
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x16e42
movq %rbp, %rdi
testl %eax, %eax
je 0x2a7d1
callq 0x4c19d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a821
movq 0x1037c8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f86c(%rip), %rsi     # 0xca066
leaq 0xa8f57(%rip), %rdx     # 0xd3758
leaq 0xa8f68(%rip), %rcx     # 0xd3770
leaq 0xa8f70(%rip), %r8      # 0xd377f
movl $0x34a, %r9d            # imm = 0x34A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300