LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x40432
testb %al, %al
je 0x4e28e
movq %rbx, %rdi
callq 0x40571
movq %rax, %r14
movq %rbx, %rdi
callq 0x40276
leaq 0x9c978(%rip), %rdi     # 0xeab3d
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x35a32
movq %r12, %rdi
movq %r14, %rsi
callq 0x4e38a
movq %rax, %r15
movq %rbx, %rdi
callq 0x40276
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4e406
movq %rax, %rbp
testq %rax, %rax
jne 0x4e25e
movq %r13, %rdi
callq 0x8ad69
movq %rax, %rbp
movq %rbx, %rdi
callq 0x40276
movq %rbp, %rdi
movq %rax, %rsi
callq 0x8b0f1
movq %r13, %rdi
callq 0x40459
movq %r12, %rdi
movq %rbx, %rsi
testb %al, %al
je 0x4e232
xorl %edx, %edx
jmp 0x4e235
movq %r13, %rdx
movq %rbp, %rcx
movq (%rsp), %r8
callq 0x4e587
testl %eax, %eax
js 0x4e27f
movq %rbx, %rdi
callq 0x40276
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0x4e43c
testq %rbp, %rbp
je 0x4e293
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x8adcd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
callq 0x8bcd2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4e270
callq 0x15e3c
callq 0x15e75
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rsi
callq 0x4e38a
movq %rax, %r15
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4e38a
movq %rax, %rbp
movq %rbx, %rdi
callq 0x40276
leaq 0x9c893(%rip), %rdi     # 0xeab6a
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x35a32
movq %r14, (%rbp)
movq %rbx, %rdi
callq 0x40276
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4e406
movq %rax, %rbp
testq %rax, %rax
jne 0x4e355
movq %r14, %rdi
callq 0x8ad69
movq %rax, %rbp
movq %rbx, %rdi
callq 0x40276
movq %rbp, %rdi
movq %rax, %rsi
callq 0x8b0f1
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rbp, %rcx
movq %r12, %r8
callq 0x4e587
testl %eax, %eax
js 0x4e376
movq %rbx, %rdi
callq 0x40276
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbp, %rcx
callq 0x4e43c
testq %rbp, %rbp
je 0x4e385
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x8adcd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
callq 0x8bcd2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4e367
callq 0x15eae
// File: /workspace/github_c_makefile_star2_O1/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 0x4e401
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x77109
movq %rax, %r15
testq %rax, %rax
jne 0x4e3f8
leaq 0x9c42d(%rip), %rdx     # 0xea7df
movl $0x1, %edi
movl $0x18, %esi
movl $0x71, %ecx
callq 0x3601f
movq %rax, %r15
leaq -0x18071(%rip), %rdx    # 0x3635f
movl $0x1, %edi
xorl %esi, %esi
callq 0x76f28
movq %rax, 0x8(%r15)
callq 0x3d23c
movq %rax, 0x10(%r15)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x77144
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x15ee7
// File: /workspace/github_c_makefile_star2_O1/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 0x4e437
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x77109
testq %rax, %rax
je 0x4e433
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x4e433
movq 0x10(%rax), %rax
jmp 0x4e435
xorl %eax, %eax
popq %rbx
retq
callq 0x15f1e
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4e54f
movq %rcx, %r12
testq %rcx, %rcx
je 0x4e554
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x9c376(%rip), %rdx     # 0xea7df
movl $0x1, %edi
movl $0x18, %esi
movl $0x65, %ecx
callq 0x3601f
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, (%rsp)
cmpq $0x0, 0x8(%r15)
jne 0x4e4aa
leaq -0x1813b(%rip), %rdx    # 0x3635f
movl $0x1, %edi
xorl %esi, %esi
callq 0x76f28
movq %rax, 0x8(%r15)
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x77109
movq %rax, %r12
testq %rax, %rax
jne 0x4e515
leaq 0x9c31a(%rip), %rdx     # 0xea7df
movl $0x1, %edi
movl $0x18, %esi
movl $0x94, %ecx
callq 0x3601f
movq %rax, %r12
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x76f28
movq %rax, (%r12)
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x8(%r12)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x77144
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x3d318
movq (%r12), %rdi
movq (%rsp), %rdx
movq %rbx, %rsi
callq 0x77144
cmpq $-0x1, %rbx
je 0x4e531
movb $0x1, 0x10(%r12)
movq 0x8(%r12), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x6ec0e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x15f8c
callq 0x15f55
// File: /workspace/github_c_makefile_star2_O1/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 0x3bfe0
movq %rax, %r14
movq 0x28(%rbp), %rbp
movq %r12, %rdi
callq 0x40276
leaq 0x9c4b7(%rip), %rdx     # 0xeaa73
movq %rbp, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x542cf
cmpl $0x1, %eax
je 0x4e5ed
cmpl $0x2, %eax
jne 0x4e65f
movq %r14, %rdi
callq 0x3d1eb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4e66c
movq %r15, %rdi
callq 0x4e559
movq %rax, %r13
movq %r12, %rdi
callq 0x4e559
movq %rax, %r12
movq %r13, %rax
orq %r12, %rax
je 0x4e654
testq %r15, %r15
je 0x4e642
testq %r13, %r13
je 0x4e621
movq %r15, %rdi
callq 0x40251
testb %al, %al
jne 0x4e628
leaq 0x9f747(%rip), %r13     # 0xedd6f
movq %r14, %rdi
movq %r13, %rsi
callq 0x3c067
leaq 0xa1232(%rip), %rsi     # 0xef86c
movq %r14, %rdi
callq 0x3c067
testq %r12, %r12
je 0x4e65f
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c067
jmp 0x4e65f
movq %r14, %rdi
callq 0x3d1eb
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b0c3
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_O1/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 0x4e78e
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4e78e
movq 0x8(%rax), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x3d94f
movq %rbx, %rax
popq %rbx
retq
callq 0x15fc5
// File: /workspace/github_c_makefile_star2_O1/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 0x4e7f8
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x4e7f8
leaq 0x9c425(%rip), %r14     # 0xeabd4
movl $0x1, %edi
movq %r14, %rdx
movl $0x95, %ecx
callq 0x3601f
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r14, %rdx
movl $0x97, %ecx
callq 0x3601f
movq %rax, 0x8(%r15)
callq 0x3d8a7
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x15ffe
// File: /workspace/github_c_makefile_star2_O1/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 0x4e834
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x4e83c
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d94f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x4e89e
movq 0xd0(%rax), %rax
testq %rax, %rax
je 0x4e855
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d8f7
movq 0x8(%rbx), %rdi
leaq 0x9c35a(%rip), %r14     # 0xeabd4
movq %r14, %rsi
movl $0xab, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0xac, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0x16037
// File: /workspace/github_c_makefile_star2_O1/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 0x4e924
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e924
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e924
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x160e2
// File: /workspace/github_c_makefile_star2_O1/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 0x4e98b
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e98b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e98b
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x1611b
// File: /workspace/github_c_makefile_star2_O1/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 0x4e9f2
movq %rsi, %r14
testq %rsi, %rsi
je 0x4e9f2
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4e9f2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16154
// File: /workspace/github_c_makefile_star2_O1/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 0x4ea59
movq %rsi, %r14
testq %rsi, %rsi
je 0x4ea59
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ea59
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x1618d
// File: /workspace/github_c_makefile_star2_O1/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 0x4eadb
movq %rsi, %r14
testq %rsi, %rsi
je 0x4eadb
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4eadb
leaq 0x50(%rsp), %r15
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x161c6
// File: /workspace/github_c_makefile_star2_O1/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 0x4eb28
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4eb28
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x161ff
// File: /workspace/github_c_makefile_star2_O1/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 0x4eb7f
movq %rsi, %r14
testq %rsi, %rsi
je 0x4eb7f
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4eb7f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x16238
// File: /workspace/github_c_makefile_star2_O1/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 0x4ebe1
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ebe1
leaq 0x40(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x16271
// File: /workspace/github_c_makefile_star2_O1/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 0x4ec47
movq %rsi, %r15
testq %rsi, %rsi
je 0x4ec47
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ec47
movl %ecx, %ebp
movl %edx, %r14d
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x162aa
// File: /workspace/github_c_makefile_star2_O1/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 0x4ec94
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ec94
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x162e3
// File: /workspace/github_c_makefile_star2_O1/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 0x4ece1
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ece1
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x1631c
// File: /workspace/github_c_makefile_star2_O1/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 0x4ed2e
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ed2e
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x16355
// File: /workspace/github_c_makefile_star2_O1/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 0x4ed7b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ed7b
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x1638e
// File: /workspace/github_c_makefile_star2_O1/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 0x4edd1
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4edd1
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x163c7
// File: /workspace/github_c_makefile_star2_O1/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 0x4ee6b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ee6b
leaq 0x60(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16400
// File: /workspace/github_c_makefile_star2_O1/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 0x4eef6
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4eef6
leaq 0x60(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16439
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_vertical_line
void gt_graphics_draw_vertical_line(GtGraphics *g, double x, double y,
                                    GtColor color, double length,
                                    double stroke_width)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_vertical_line(g, x, y, color, length, 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 0x4ef84
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4ef84
leaq 0x60(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 *0x80(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x3d94f
callq 0x16472
// File: /workspace/github_c_makefile_star2_O1/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 0x4f067
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f067
movl %edx, %r14d
movl %esi, %ebp
leaq 0xc0(%rsp), %r15
leaq 0xa0(%rsp), %r12
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x164ab
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_dashes
void gt_graphics_draw_dashes(GtGraphics *g, double x, double y, double width,
                             double height, ArrowStatus arrow_status,
                             double arrow_width, double stroke_width,
                             GtColor stroke_color)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_dashes(g, x, y, width, height, arrow_status, arrow_width,
                          stroke_width, stroke_color);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd %xmm5, 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 0x4f113
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f113
movl %esi, %ebp
leaq 0x70(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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
movl %ebp, %esi
movsd 0x40(%rsp), %xmm4
movsd 0x48(%rsp), %xmm5
callq *0x98(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3d94f
callq 0x164e4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/graphics.c
// Function: gt_graphics_draw_caret
void gt_graphics_draw_caret(GtGraphics *g, double x, double y, double width,
                            double height, ArrowStatus arrow_status,
                            double arrow_width,  double stroke_width,
                            GtColor stroke_color)
{
  gt_assert(g && g->c_class);
  gt_rwlock_wrlock(g->pvt->lock);
  g->c_class->draw_caret(g, x, y, width, height, arrow_status, arrow_width,
                         stroke_width, stroke_color);
  gt_rwlock_unlock(g->pvt->lock);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd %xmm5, 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 0x4f1bf
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f1bf
movl %esi, %ebp
leaq 0x70(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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
movl %ebp, %esi
movsd 0x40(%rsp), %xmm4
movsd 0x48(%rsp), %xmm5
callq *0xa0(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3d94f
callq 0x1651d
// File: /workspace/github_c_makefile_star2_O1/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 0x4f298
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f298
movl %edx, %ebp
movl %esi, %r14d
leaq 0xc0(%rsp), %r15
leaq 0xa0(%rsp), %r12
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16556
// File: /workspace/github_c_makefile_star2_O1/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 0x4f314
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f314
movl %esi, %ebp
leaq 0x50(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x1658f
// File: /workspace/github_c_makefile_star2_O1/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 0x4f3b8
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x4f3b8
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 0x3d934
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 0x3d94f
callq 0x165c8
// File: /workspace/github_c_makefile_star2_O1/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 0x4f3de
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x4f429
testq %rbx, %rbx
je 0x4f424
cmpq $0x0, (%rbx)
je 0x4f424
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1663a
callq 0x16601
// File: /workspace/github_c_makefile_star2_O1/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 0x4f473
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f473
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16673
// File: /workspace/github_c_makefile_star2_O1/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 0x4f4d2
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f4d2
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f4d2
cmpq $0x0, 0x10(%r14)
je 0x4f4d2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x166ac
// File: /workspace/github_c_makefile_star2_O1/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 0x4f531
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f531
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f531
cmpq $0x0, 0x10(%r14)
je 0x4f531
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x166e5
// File: /workspace/github_c_makefile_star2_O1/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 0x4f590
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f590
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f590
cmpq $0x0, 0x10(%r14)
je 0x4f590
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x1671e
// File: /workspace/github_c_makefile_star2_O1/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 0x4f5ef
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f5ef
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f5ef
cmpq $0x0, 0x10(%r14)
je 0x4f5ef
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16757
// File: /workspace/github_c_makefile_star2_O1/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 0x4f664
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f664
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f664
cmpq $0x0, 0x30(%r14)
je 0x4f664
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16790
// File: /workspace/github_c_makefile_star2_O1/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 0x4f6b8
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f6b8
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f6b8
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x167c9
// File: /workspace/github_c_makefile_star2_O1/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 0x4f737
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f737
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f737
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x16802
// File: /workspace/github_c_makefile_star2_O1/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 0x4f7ad
movq %rsi, %r14
testq %rsi, %rsi
je 0x4f7ad
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f7ad
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
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 0x3d94f
callq 0x1683b