LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: add_recursive
static void add_recursive(GtDiagram *d, GtFeatureNode *node,
                          GtFeatureNode* parent,
                          GtFeatureNode *original_node)
{
  NodeInfoElement *ni;
  GtFeatureNode *rep = GT_UNDEF_REPR;
  gt_assert(d && node && original_node);
  if (!parent) return;
  ni = nodeinfo_get(d, node);
  if (gt_feature_node_is_multi(original_node)) {
    rep = gt_feature_node_get_multi_representative(original_node);
  }
    /* end of recursion, insert into target block */
  if (parent == node) {
    GtBlock *block ;
    block = nodeinfo_find_block(ni,
                                gt_feature_node_get_type(node),
                                rep);
    if (!block) {
      block = gt_block_new_from_node(node);
      nodeinfo_add_block(ni,
                         gt_feature_node_get_type(node),
                         rep,
                         block);
    }
    gt_block_insert_element(block, original_node);
    gt_log_log("add %s to target %s", gt_feature_node_get_type(original_node),
                                      gt_block_get_type(block));
  }
  else
  {
    /* not at target type block yet, set up reverse entry and follow */
    NodeInfoElement *parent_ni;
    /* set up reverse entry */
    ni->parent = parent;
    parent_ni = gt_hashmap_get(d->nodeinfo, parent);
    if (parent_ni) {
      gt_log_log("recursion: %s -> %s", gt_feature_node_get_type(node),
                                        gt_feature_node_get_type(parent));
      add_recursive(d, parent, parent_ni->parent, original_node);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4d157
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x4d6d3
movq %rax, %rbp
movq %rbx, %rdi
callq 0x3facd
movq $-0x1, %r12
testb %al, %al
je 0x4d107
movq %rbx, %rdi
callq 0x3fc0c
movq %rax, %r12
cmpq %r14, %r13
je 0x4d166
movq %r13, (%rbp)
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0x775ed
testq %rax, %rax
je 0x4d157
movq %rax, %r12
movq %r14, %rdi
callq 0x3f914
movq %rax, %r14
movq %r13, %rdi
callq 0x3f914
leaq 0x9d87c(%rip), %rdi     # 0xea9ba
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x353ae
movq (%r12), %rdx
movq %r13, %r14
testq %rdx, %rdx
jne 0x4d0d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x3f914
movq %rbp, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x4d74f
movq %rax, %r15
testq %rax, %rax
jne 0x4d1a8
movq %r14, %rdi
callq 0x8a84d
movq %rax, %r15
movq %r14, %rdi
callq 0x3f914
movq %rbp, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4d785
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8a8b1
movq %rbx, %rdi
callq 0x3f914
movq %rax, %rbx
movq %r15, %rdi
callq 0x8abe5
leaq 0x9d7d9(%rip), %rdi     # 0xea9a6
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x353ae
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: add_to_rep
static int add_to_rep(GtDiagram *d, GtFeatureNode *node, GtFeatureNode* parent,
                      GtError *err)
{
  GtBlock *block = NULL;
  GtFeatureNode *rep = GT_UNDEF_REPR;
  NodeInfoElement *ni;
  gt_assert(d && node && gt_feature_node_is_multi(node));

  rep = gt_feature_node_get_multi_representative(node);
  gt_log_log("adding %s to representative %p", gt_feature_node_get_type(node),
                                               rep);
  ni = nodeinfo_get(d, rep);

  block = nodeinfo_find_block(ni,
                              gt_feature_node_get_type(node),
                              rep);
  if (!block) {
    block = gt_block_new_from_node(parent);
    gt_block_set_type(block, gt_feature_node_get_type(node));
    /* if parent is a pseudonode, then we have a multiline feature without
       a parent. we must not access the parent in this case! */
    if (gt_feature_node_is_pseudo(parent)) {
      if (assign_block_caption(d, node, NULL, block, err) < 0) {
        gt_block_delete(block);
        return -1;
      }
    } else {
      if (assign_block_caption(d, node, parent, block, err) < 0) {
        gt_block_delete(block);
        return -1;
      }
    }
    nodeinfo_add_block(ni, gt_feature_node_get_type(node),
                       rep, block);
  }
  gt_assert(block);
  gt_block_insert_element(block, node);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x3facd
testb %al, %al
je 0x4d5d3
movq %rbx, %rdi
callq 0x3fc0c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f914
leaq 0x9d5e3(%rip), %rdi     # 0xeaaed
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x353ae
movq %r12, %rdi
movq %r14, %rsi
callq 0x4d6d3
movq %rax, %rbp
movq %rbx, %rdi
callq 0x3f914
movq %rbp, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4d74f
movq %rax, %r15
testq %rax, %rax
jne 0x4d5a8
movq %r13, %rdi
callq 0x8a84d
movq %rax, %r15
movq %rbx, %rdi
callq 0x3f914
movq %r15, %rdi
movq %rax, %rsi
callq 0x8abd5
movq %r13, %rdi
callq 0x3faf4
movq %r12, %rdi
movq %rbx, %rsi
testb %al, %al
je 0x4d577
xorl %edx, %edx
jmp 0x4d57a
movq %r13, %rdx
movq %r15, %rcx
movq (%rsp), %r8
callq 0x4d8da
testl %eax, %eax
js 0x4d5c4
movq %rbx, %rdi
callq 0x3f914
movq %rbp, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x4d785
testq %r15, %r15
je 0x4d5d8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8a8b1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x8b7c2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4d5b5
callq 0x15cea
callq 0x15d23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: add_to_parent
static int add_to_parent(GtDiagram *d, GtFeatureNode *node,
                         GtFeatureNode *parent, GtError *err)
{
  GtBlock *block = NULL;
  NodeInfoElement *par_ni, *ni;
  gt_assert(d && node);
  if (!parent)
    return 0;
  par_ni = nodeinfo_get(d, parent);
  ni = nodeinfo_get(d, node);
  gt_log_log("adding %s to parent %p", gt_feature_node_get_type(node), parent);
  ni->parent = parent;
  block = nodeinfo_find_block(par_ni,
                              gt_feature_node_get_type(node),
                              parent);
  if (!block) {
    block = gt_block_new_from_node(parent);
    gt_block_set_type(block, gt_feature_node_get_type(node));
    if (assign_block_caption(d, node, parent, block, err) < 0) {
      gt_block_delete(block);
      return -1;
    }
    nodeinfo_add_block(par_ni,
                     gt_feature_node_get_type((GtFeatureNode*) node),
                     parent,
                     block);
  }
  gt_assert(block);
  gt_block_insert_element(block, node);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rsi
callq 0x4d6d3
movq %rax, %r15
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4d6d3
movq %rax, %r12
movq %rbx, %rdi
callq 0x3f914
leaq 0x9d4fd(%rip), %rdi     # 0xeab1a
xorl %ebp, %ebp
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x353ae
movq %r14, (%r12)
movq %rbx, %rdi
callq 0x3f914
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4d74f
movq %rax, %r12
testq %rax, %rax
jne 0x4d6a3
movq %r14, %rdi
callq 0x8a84d
movq %rax, %r12
movq %rbx, %rdi
callq 0x3f914
movq %r12, %rdi
movq %rax, %rsi
callq 0x8abd5
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq (%rsp), %r8
callq 0x4d8da
testl %eax, %eax
js 0x4d6bf
movq %rbx, %rdi
callq 0x3f914
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x4d785
testq %r12, %r12
je 0x4d6ce
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8a8b1
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x8b7c2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x4d6ae
callq 0x15d5c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: nodeinfo_get
static NodeInfoElement* nodeinfo_get(GtDiagram *d, GtFeatureNode *node)
{
  NodeInfoElement *ni;
  gt_assert(d && node);
  if (!(ni = gt_hashmap_get(d->nodeinfo, node))) {
    ni = gt_calloc(1, sizeof (NodeInfoElement));
    ni->type_index  = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
    ni->types       = gt_str_array_new();
    gt_hashmap_add(d->nodeinfo, node, ni);
  }
  return ni;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4d74a
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x775ed
movq %rax, %r15
testq %rax, %rax
jne 0x4d741
leaq 0x9d094(%rip), %rdx     # 0xea78f
movl $0x1, %edi
movl $0x18, %esi
movl $0x71, %ecx
callq 0x359a6
movq %rax, %r15
leaq -0x17a33(%rip), %rdx    # 0x35ce6
movl $0x1, %edi
xorl %esi, %esi
callq 0x7740c
movq %rax, 0x8(%r15)
callq 0x3c8cc
movq %rax, 0x10(%r15)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x77628
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x15d95
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: nodeinfo_find_block
static GtBlock* nodeinfo_find_block(NodeInfoElement* ni, const char *gft,
                                    GtFeatureNode *fn)
{
  PerTypeInfo *type_struc = NULL;
  GtBlockTuple *bt = NULL;
  gt_assert(ni);
  if (!(type_struc = gt_hashmap_get(ni->type_index, gft)))
    return NULL;
  if (!(bt = gt_hashmap_get(type_struc->rep_index, fn)))
    return NULL;
  gt_assert(bt);
  return bt->block;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x4d780
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x775ed
testq %rax, %rax
je 0x4d77c
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x4d77c
movq 0x10(%rax), %rax
jmp 0x4d77e
xorl %eax, %eax
popq %rbx
retq
callq 0x15dcc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: nodeinfo_add_block
static void nodeinfo_add_block(NodeInfoElement *ni, const char *gft,
                               GtFeatureNode *rep, GtBlock *block)
{
  GtBlockTuple *bt;
  PerTypeInfo *type_struc = NULL;
  gt_assert(ni);
  bt = blocktuple_new(gft, rep, block);
  if (!(ni->type_index))
  {
    ni->type_index = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
  }
  if (!(type_struc = gt_hashmap_get(ni->type_index, gft)))
  {
    type_struc = gt_calloc(1, sizeof (PerTypeInfo));
    type_struc->rep_index = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
    type_struc->blocktuples = gt_array_new(sizeof (GtBlockTuple*));
    gt_hashmap_add(ni->type_index, (char*) gft, type_struc);
    gt_str_array_add_cstr(ni->types, gft);
  }
  gt_hashmap_add(type_struc->rep_index, rep, bt);
  if (rep != GT_UNDEF_REPR)
    type_struc->must_merge = true;
  gt_array_add(type_struc->blocktuples, bt);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4d8a2
movq %rcx, %r13
testq %rcx, %rcx
je 0x4d8a7
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x9cfd8(%rip), %rdx     # 0xea78f
movl $0x1, %edi
movl $0x18, %esi
movl $0x65, %ecx
callq 0x359a6
movq %rax, %r12
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0x4d801
leaq -0x17b08(%rip), %rdx    # 0x35ce6
movl $0x1, %edi
xorl %esi, %esi
callq 0x7740c
movq %rax, %rdi
movq %rax, 0x8(%r15)
movq %r14, %rsi
callq 0x775ed
movq %rax, %r13
testq %rax, %rax
jne 0x4d867
leaq 0x9cf77(%rip), %rdx     # 0xea78f
movl $0x1, %edi
movl $0x18, %esi
movl $0x94, %ecx
callq 0x359a6
movq %rax, %r13
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7740c
movq %rax, (%r13)
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x8(%r13)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x77628
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x3c9a5
movq (%r13), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x77628
cmpq $-0x1, %rbx
je 0x4d881
movb $0x1, 0x10(%r13)
movq 0x8(%r13), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6f240
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x15e3a
callq 0x15e03
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: assign_block_caption
static int assign_block_caption(GtDiagram *d,
                                GtFeatureNode *node,
                                GtFeatureNode *parent,
                                GtBlock *block,
                                GtError *err)
{
  const char *nnid_p = NULL, *nnid_n = NULL;
  GtStr *caption = NULL;
  bool status = true;
  int rval;

  caption = gt_str_new();
  rval = gt_style_get_str(d->style,
                          gt_feature_node_get_type(node), "block_caption",
                          caption, node, err);
  if (rval == GT_STYLE_QUERY_ERROR) {
    gt_str_delete(caption);
    return -1;
  } else if (rval == GT_STYLE_QUERY_NOT_SET) {
    nnid_p = get_node_name_or_id(parent);
    nnid_n = get_node_name_or_id(node);
    if ((nnid_p || nnid_n) && status)
    {
      if (parent) {
        if (nnid_p && gt_feature_node_has_children(parent))
          gt_str_append_cstr(caption, nnid_p);
        else
          gt_str_append_cstr(caption, "-");
        gt_str_append_cstr(caption, "/");
      }
      if (nnid_n)
        gt_str_append_cstr(caption, nnid_n);
    } else {
      gt_str_delete(caption);
      caption = NULL;
    }
  }
  gt_block_set_caption(block, caption);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
callq 0x3b728
movq %rax, %r14
movq 0x28(%rbp), %rbp
movq %r12, %rdi
callq 0x3f914
leaq 0x9d114(%rip), %rdx     # 0xeaa23
movq %rbp, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x5363b
cmpl $0x1, %eax
je 0x4d940
cmpl $0x2, %eax
jne 0x4d9b2
movq %r14, %rdi
callq 0x3c87b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4d9bf
movq %r15, %rdi
callq 0x4d8ac
movq %rax, %r13
movq %r12, %rdi
callq 0x4d8ac
movq %rax, %r12
movq %r13, %rax
orq %r12, %rax
je 0x4d9a7
testq %r15, %r15
je 0x4d995
testq %r13, %r13
je 0x4d974
movq %r15, %rdi
callq 0x3f8ef
testb %al, %al
jne 0x4d97b
leaq 0xa03ac(%rip), %r13     # 0xedd27
movq %r14, %rdi
movq %r13, %rsi
callq 0x3b7af
leaq 0xa1e94(%rip), %rsi     # 0xef821
movq %r14, %rdi
callq 0x3b7af
testq %r12, %r12
je 0x4d9b2
movq %r14, %rdi
movq %r12, %rsi
callq 0x3b7af
jmp 0x4d9b2
movq %r14, %rdi
callq 0x3c87b
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8aba7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_ref
GtGraphics* gt_graphics_ref(GtGraphics *g)
{
  gt_assert(g && g->pvt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->pvt->reference_count++;
  gt_rwlock_unlock(g->pvt->lock);
  return g;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x4dae2
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4dae2
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq %rbx, %rax
popq %rbx
retq
callq 0x15e73
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_create
GtGraphics* gt_graphics_create(const GtGraphicsClass *gc)
{
  GtGraphics *g;
  gt_assert(gc && gc->size);
  g = gt_calloc(1, gc->size);
  g->c_class = gc;
  g->pvt = gt_calloc(1, sizeof (GtGraphicsMembers));
  g->pvt->lock = gt_rwlock_new();
  return g;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4db4c
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x4db4c
leaq 0x9d081(%rip), %r14     # 0xeab84
movl $0x1, %edi
movq %r14, %rdx
movl $0x95, %ecx
callq 0x359a6
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r14, %rdx
movl $0x97, %ecx
callq 0x359a6
movq %rax, 0x8(%r15)
callq 0x3cf33
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x15eac
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_delete
void gt_graphics_delete(GtGraphics *g)
{
  if (!g) return;
  gt_rwlock_wrlock(g->pvt->lock);
  if (g->pvt->reference_count)
  {
    g->pvt->reference_count--;
    gt_rwlock_unlock(g->pvt->lock);
    return;
  }
  gt_assert(g->c_class);
  if (g->c_class->free)
    g->c_class->free(g);
  gt_rwlock_unlock(g->pvt->lock);
  gt_rwlock_delete(g->pvt->lock);
  gt_free(g->pvt);
  gt_free(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4db88
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x4db90
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x4dbf2
movq 0xd0(%rcx), %rcx
testq %rcx, %rcx
je 0x4dbad
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cf83
movq 0x8(%rbx), %rdi
leaq 0x9cfb6(%rip), %r14     # 0xeab84
movq %r14, %rsi
movl $0xab, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0xac, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0x15ee5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text
void gt_graphics_draw_text(GtGraphics *g, double x, double y, const char* txt)
{
  gt_assert(g && g->c_class && txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text(g, x, y, txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
testq %rdi, %rdi
je 0x4dc78
movq %rsi, %r14
testq %rsi, %rsi
je 0x4dc78
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4dc78
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rsi
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x15f90
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text_clip
void gt_graphics_draw_text_clip(GtGraphics *g, double x, double y,
                                const char* txt)
{
  gt_assert(g && g->c_class && txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text_clip(g, x, y, txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
testq %rdi, %rdi
je 0x4dcdf
movq %rsi, %r14
testq %rsi, %rsi
je 0x4dcdf
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4dcdf
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rsi
callq *0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x15fc9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text_centered
void gt_graphics_draw_text_centered(GtGraphics *g, double x, double y,
                                    const char *t)
{
  gt_assert(g && g->c_class && t);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text_centered(g, x, y, t);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
testq %rdi, %rdi
je 0x4dd46
movq %rsi, %r14
testq %rsi, %rsi
je 0x4dd46
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4dd46
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rsi
callq *0x18(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x16002
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text_right
void gt_graphics_draw_text_right(GtGraphics *g, double x, double y,
                                 const char *txt)
{
  gt_assert(g && g->c_class && txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text_right(g, x, y, txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
testq %rdi, %rdi
je 0x4ddad
movq %rsi, %r14
testq %rsi, %rsi
je 0x4ddad
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ddad
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rsi
callq *0x20(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x1603b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_colored_text
void gt_graphics_draw_colored_text(GtGraphics *g, double x, double y,
                                   GtColor col, const char *txt)
{
  gt_assert(g && g->c_class && txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_colored_text(g, x, y, col, txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
testq %rdi, %rdi
je 0x4de2f
movq %rsi, %r14
testq %rsi, %rsi
je 0x4de2f
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4de2f
leaq 0x50(%rsp), %r15
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3cfdb
callq 0x16074
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_get_text_height
double gt_graphics_get_text_height(GtGraphics *g)
{
  double ret;
  gt_assert(g && g->c_class);
  gt_rwlock_rdlock(g->pvt->lock);
  ret = g->c_class->get_text_height(g);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4de7c
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4de7c
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x160ad
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_get_text_width
double gt_graphics_get_text_width(GtGraphics *g, const char *text)
{
  double ret;
  gt_assert(g && g->c_class && text);
  gt_rwlock_rdlock(g->pvt->lock);
  ret = g->c_class->get_text_width(g, text);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4ded3
movq %rsi, %r14
testq %rsi, %rsi
je 0x4ded3
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ded3
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x160e6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_set_background_color
int gt_graphics_set_background_color(GtGraphics *g, GtColor color)
{
  int ret;
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  ret = g->c_class->set_background_color(g, color);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x4df35
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4df35
leaq 0x40(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq *0x40(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1611f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_set_font
void gt_graphics_set_font(GtGraphics *g, const char *family,
                       FontSlant slant, FontWeight weight, double size)
{
  gt_assert(g && g->c_class && family);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->set_font(g, family, slant, weight, size);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
testq %rdi, %rdi
je 0x4df9b
movq %rsi, %r15
testq %rsi, %rsi
je 0x4df9b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4df9b
movl %ecx, %ebp
movl %edx, %r14d
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movsd (%rsp), %xmm0
callq *0x48(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x16158
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_get_image_height
double gt_graphics_get_image_height(GtGraphics *g)
{
  double ret;
  gt_assert(g && g->c_class);
  gt_rwlock_rdlock(g->pvt->lock);
  ret = g->c_class->get_image_height(g);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4dfe8
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4dfe8
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x16191
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_get_image_width
double gt_graphics_get_image_width(GtGraphics *g)
{
  double ret;
  gt_assert(g && g->c_class);
  gt_rwlock_rdlock(g->pvt->lock);
  ret = g->c_class->get_image_width(g);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4e035
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e035
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x161ca
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_get_xmargins
double gt_graphics_get_xmargins(GtGraphics *g)
{
  double ret;
  gt_assert(g && g->c_class);
  gt_rwlock_rdlock(g->pvt->lock);
  ret = g->c_class->get_xmargins(g);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4e082
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e082
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x16203
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_get_ymargins
double gt_graphics_get_ymargins(GtGraphics *g)
{
  double ret;
  gt_assert(g && g->c_class);
  gt_rwlock_rdlock(g->pvt->lock);
  ret = g->c_class->get_ymargins(g);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4e0cf
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e0cf
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x1623c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_set_margins
void gt_graphics_set_margins(GtGraphics *g, double margin_x, double margin_y)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->set_margins(g, margin_x, margin_y);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
testq %rdi, %rdi
je 0x4e125
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e125
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq *0x70(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3cfdb
callq 0x16275
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_line
void gt_graphics_draw_line(GtGraphics *g, double x, double y,
                           double xto, double yto, GtColor color,
                           double stroke_width)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_line(g, x, y, xto, yto, color, stroke_width);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm4, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
testq %rdi, %rdi
je 0x4e1bf
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e1bf
leaq 0x60(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movsd 0x40(%rsp), %xmm4
callq *0x88(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x162ae
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_horizontal_line
void gt_graphics_draw_horizontal_line(GtGraphics *g, double x, double y,
                                      GtColor color, double width,
                                      double stroke_width)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_horizontal_line(g, x, y, color, width, stroke_width);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm3, 0x40(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
testq %rdi, %rdi
je 0x4e24a
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e24a
leaq 0x60(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
movsd 0x40(%rsp), %xmm3
callq *0x78(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x162e7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_box
void gt_graphics_draw_box(GtGraphics *g, double x, double y, double width,
                          double height, GtColor fill_color,
                          ArrowStatus arrow_status, double arrow_width,
                          double stroke_width, GtColor stroke_color,
                          bool dashed)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_box(g, x, y, width, height, fill_color, arrow_status,
                       arrow_width, stroke_width, stroke_color, dashed);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movsd %xmm5, 0x68(%rsp)
movsd %xmm4, 0x60(%rsp)
movsd %xmm3, 0x58(%rsp)
movsd %xmm2, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
testq %rdi, %rdi
je 0x4e3bb
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e3bb
movl %edx, %r14d
movl %esi, %ebp
leaq 0xc0(%rsp), %r15
leaq 0xa0(%rsp), %r12
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movzbl %r14b, %edx
movq %rbx, %rdi
movsd 0x40(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
movsd 0x58(%rsp), %xmm3
movl %ebp, %esi
movsd 0x60(%rsp), %xmm4
movsd 0x68(%rsp), %xmm5
callq *0x90(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x16359
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_rectangle
void gt_graphics_draw_rectangle(GtGraphics *g, double x, double y,
                                bool filled, GtColor fill_color, bool stroked,
                                GtColor stroke_color, double stroke_width,
                                double width, double height)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_rectangle(g, x, y, filled, fill_color, stroked,
                             stroke_color, stroke_width, width, height);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movsd %xmm4, 0x68(%rsp)
movsd %xmm3, 0x60(%rsp)
movsd %xmm2, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
testq %rdi, %rdi
je 0x4e5ec
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e5ec
movl %edx, %ebp
movl %esi, %r14d
leaq 0xc0(%rsp), %r15
leaq 0xa0(%rsp), %r12
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movzbl %r14b, %esi
movzbl %bpl, %edx
movq %rbx, %rdi
movsd 0x48(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
movsd 0x58(%rsp), %xmm2
movsd 0x60(%rsp), %xmm3
movsd 0x68(%rsp), %xmm4
callq *0xa8(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x16404
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_arrowhead
void gt_graphics_draw_arrowhead(GtGraphics *g, double x, double y,
                                GtColor col, ArrowStatus arrow_status)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_arrowhead(g, x, y, col, arrow_status);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
testq %rdi, %rdi
je 0x4e668
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e668
movl %esi, %ebp
leaq 0x50(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movl %ebp, %esi
callq *0xb0(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3cfdb
callq 0x1643d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_curve_data
void gt_graphics_draw_curve_data(GtGraphics *g, double x, double y,
                                 GtColor color,
                                 double data[], GtUword ndata,
                                 GtRange valrange, GtUword height)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_curve(g, x, y, color, data, ndata, valrange, height);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
testq %rdi, %rdi
je 0x4e70c
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x4e70c
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
leaq 0x70(%rsp), %rbx
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%r15), %rax
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
movq 0x30(%rsp), %r9
callq *0xb8(%rax)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x16476
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_save_to_file
int gt_graphics_save_to_file(const GtGraphics *g, const char *filename,
                             GtError *err)
{
  int ret;
  gt_error_check(err);
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  ret = g->c_class->save_to_file(g, filename, err);
  gt_rwlock_unlock(g->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x4e732
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x4e77d
testq %rbx, %rbx
je 0x4e778
cmpq $0x0, (%rbx)
je 0x4e778
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0xc0(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x164e8
callq 0x164af
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_save_to_stream
void gt_graphics_save_to_stream(const GtGraphics *g, GtStr *stream)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->save_to_stream(g, stream);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4e7c7
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e7c7
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0xc8(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x16521
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text_p
void gt_graphics_draw_text_p(GtGraphics *g, GraphicsDrawTextFuncParams *params)
{
  gt_assert(g && g->c_class && params && params->txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text(g, params->x, params->y, params->txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4e826
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e826
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e826
cmpq $0x0, 0x10(%r14)
je 0x4e826
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x1655a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text_clip_p
void gt_graphics_draw_text_clip_p(GtGraphics *g,
                                  GraphicsDrawTextFuncParams *params)
{
  gt_assert(g && g->c_class && params && params->txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text_clip(g, params->x, params->y, params->txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4e885
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e885
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e885
cmpq $0x0, 0x10(%r14)
je 0x4e885
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x16593
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text_centered_p
void gt_graphics_draw_text_centered_p(GtGraphics *g,
                                      GraphicsDrawTextFuncParams *params)
{
  gt_assert(g && g->c_class && params && params->txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text_centered(g, params->x, params->y, params->txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4e8e4
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e8e4
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e8e4
cmpq $0x0, 0x10(%r14)
je 0x4e8e4
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x165cc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_text_right_p
void gt_graphics_draw_text_right_p(GtGraphics *g,
                                   GraphicsDrawTextFuncParams *params)
{
  gt_assert(g && g->c_class && params && params->txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_text_right(g, params->x, params->y, params->txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4e943
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e943
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e943
cmpq $0x0, 0x10(%r14)
je 0x4e943
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x16605
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_colored_text_p
void gt_graphics_draw_colored_text_p(GtGraphics *g,
                                     GraphicsDrawColoredTextFuncParams *params)
{
  gt_assert(g && g->c_class && params && params->txt);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_colored_text(g, params->x, params->y, params->col,
                                params->txt);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x4e9b8
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e9b8
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e9b8
cmpq $0x0, 0x30(%r14)
je 0x4e9b8
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movq 0x30(%r14), %rsi
movups 0x10(%r14), %xmm2
movups 0x20(%r14), %xmm3
movups %xmm3, 0x10(%rsp)
movups %xmm2, (%rsp)
movq %rbx, %rdi
callq *0x28(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x1663e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_set_margins_p
void gt_graphics_set_margins_p(GtGraphics *g,
                               GraphicsSetMarginsFuncParams *params)
{
  gt_assert(g && g->c_class && params);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->set_margins(g, params->margin_x, params->margin_y);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4ea0c
movq %rsi, %r14
testq %rsi, %rsi
je 0x4ea0c
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ea0c
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x16677
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_line_p
void gt_graphics_draw_line_p(GtGraphics *g,
                             GraphicsDrawLineToFuncParams *params)
{
  gt_assert(g && g->c_class && params);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_line(g, params->x, params->y, params->xto, params->yto,
                        params->color, params->stroke_width);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x4ea8b
movq %rsi, %r14
testq %rsi, %rsi
je 0x4ea8b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ea8b
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x10(%r14), %xmm2
movsd 0x18(%r14), %xmm3
movsd 0x40(%r14), %xmm4
movups 0x20(%r14), %xmm5
movups 0x30(%r14), %xmm6
movups %xmm6, 0x10(%rsp)
movups %xmm5, (%rsp)
movq %rbx, %rdi
callq *0x88(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x166b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_horizontal_line_p
void gt_graphics_draw_horizontal_line_p(GtGraphics *g,
                                        GraphicsDrawLineFuncParams *params)
{
  gt_assert(g && g->c_class && params);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_horizontal_line(g, params->x, params->y, params->color,
                                   params->len, params->stroke_width);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x4eb01
movq %rsi, %r14
testq %rsi, %rsi
je 0x4eb01
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4eb01
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x30(%r14), %xmm2
movsd 0x38(%r14), %xmm3
movups 0x10(%r14), %xmm4
movups 0x20(%r14), %xmm5
movups %xmm5, 0x10(%rsp)
movups %xmm4, (%rsp)
movq %rbx, %rdi
callq *0x78(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x166e9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_vertical_line_p
void gt_graphics_draw_vertical_line_p(GtGraphics *g,
                                      GraphicsDrawLineFuncParams *params)
{
  gt_assert(g && g->c_class && params);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_vertical_line(g, params->x, params->y, params->color,
                                 params->len, params->stroke_width);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x4eb7a
movq %rsi, %r14
testq %rsi, %rsi
je 0x4eb7a
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4eb7a
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x30(%r14), %xmm2
movsd 0x38(%r14), %xmm3
movups 0x10(%r14), %xmm4
movups 0x20(%r14), %xmm5
movups %xmm5, 0x10(%rsp)
movups %xmm4, (%rsp)
movq %rbx, %rdi
callq *0x80(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
callq 0x16722