LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_new_generic
static GtDiagram* gt_diagram_new_generic(GtArray *features,
                                         const GtRange *range,
                                         GtStyle *style,
                                         bool ref_features)
{
  GtDiagram *diagram;
  diagram = gt_calloc(1, sizeof (GtDiagram));
  diagram->nodeinfo = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
  diagram->style = style;
  diagram->lock = gt_rwlock_new();
  diagram->range = *range;
  if (ref_features)
    diagram->features = gt_array_ref(features);
  else
    diagram->features = features;
  diagram->select_func = default_track_selector;
  diagram->custom_tracks = gt_array_new(sizeof (GtCustomTrack*));
  /* init caches */
  diagram->collapsingtypes = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
  diagram->groupedtypes = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
  diagram->caption_display_status = gt_hashmap_new(GT_HASH_DIRECT, NULL,
                                                   gt_free_func);
  return diagram;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xa8f44(%rip), %rdx     # 0xd377f
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
movl $0x330, %ecx            # imm = 0x330
callq 0xce9a
movq %rax, %rbx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, 0x8(%rbx)
movq %r15, 0x28(%rbx)
callq 0x15d09
movq %rax, 0x60(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0x40(%rbx)
testl %ebp, %ebp
je 0x2a882
movq %r14, %rdi
callq 0x4b482
movq %rax, %r14
movq %r14, 0x30(%rbx)
leaq 0x1f2(%rip), %rax       # 0x2aa7f
movq %rax, 0x58(%rbx)
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x38(%rbx)
leaq -0x1d515(%rip), %r14    # 0xd38f
pushq $0x1
popq %rbp
movl %ebp, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x55da4
movq %rax, 0x10(%rbx)
movl %ebp, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x55da4
movq %rax, 0x20(%rbx)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x55da4
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_get_range
GtRange gt_diagram_get_range(const GtDiagram *diagram)
{
  GtRange rng;
  gt_assert(diagram);
  gt_rwlock_rdlock(diagram->lock);
  rng = diagram->range;
  gt_rwlock_unlock(diagram->lock);
  return rng;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2a966
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15e28
movq 0x40(%rbx), %r14
movq 0x48(%rbx), %r15
movq 0x60(%rbx), %rdi
callq 0x15f0a
movq %r14, %rax
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
retq
movq 0x10364b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f6ef(%rip), %rsi     # 0xca066
leaq 0xbbf41(%rip), %rdx     # 0xe68bf
leaq 0xa8e79(%rip), %rcx     # 0xd37fe
leaq 0xa8df3(%rip), %r8      # 0xd377f
movl $0x366, %r9d            # imm = 0x366
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_set_track_selector_func
void gt_diagram_set_track_selector_func(GtDiagram *diagram,
                                        GtTrackSelectorFunc bsfunc,
                                        void *ptr)
{
  gt_assert(diagram);
  gt_rwlock_wrlock(diagram->lock);
  /* register selector function and attached pointer */
  diagram->select_func = bsfunc;
  diagram->ptr = ptr;
  /* this could change track assignment -> discard current blocks and requeue */
  gt_hashmap_delete(diagram->blocks);
  diagram->blocks = NULL;
  gt_rwlock_unlock(diagram->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2a9dc
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15e99
movq %r15, 0x58(%rbx)
movq %r14, 0x50(%rbx)
movq (%rbx), %rdi
callq 0x563a7
andq $0x0, (%rbx)
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x15f0a
movq 0x1035d5(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f679(%rip), %rsi     # 0xca066
leaq 0xbbecb(%rip), %rdx     # 0xe68bf
leaq 0xa8e18(%rip), %rcx     # 0xd3813
leaq 0xa8d7d(%rip), %r8      # 0xd377f
movl $0x371, %r9d            # imm = 0x371
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_reset_track_selector_func
void gt_diagram_reset_track_selector_func(GtDiagram *diagram)
{
  gt_assert(diagram);
  gt_rwlock_wrlock(diagram->lock);
  diagram->select_func = default_track_selector;
  gt_hashmap_delete(diagram->blocks);
  diagram->blocks = NULL;
  gt_rwlock_unlock(diagram->lock);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2aa47
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15e99
leaq 0x52(%rip), %rax        # 0x2aa7f
movq %rax, 0x58(%rbx)
movq (%rbx), %rdi
callq 0x563a7
andq $0x0, (%rbx)
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x15f0a
movq 0x10356a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f60e(%rip), %rsi     # 0xca066
leaq 0xbbe60(%rip), %rdx     # 0xe68bf
leaq 0xa8dd0(%rip), %rcx     # 0xd3836
leaq 0xa8d12(%rip), %r8      # 0xd377f
movl $0x37e, %r9d            # imm = 0x37E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: default_track_selector
static void default_track_selector(GtBlock *block, GtStr *result,
                                   GT_UNUSED void *data)
{
  GtGenomeNode *top;
  char *basename;
  gt_assert(block && result);
  gt_str_reset(result);
  top = (GtGenomeNode*) gt_block_get_top_level_feature(block);
  /* we take the basename of the filename to have nicer output in the
     generated graphic. this might lead to ``collapsed'' tracks, if two files
     with different paths have the same basename. */
  basename = gt_basename(gt_genome_node_get_filename(top));
  gt_str_append_cstr(result, basename);
  gt_free(basename);
  gt_str_append_char(result, GT_FILENAME_TYPE_SEPARATOR);
  gt_str_append_cstr(result, gt_block_get_type(block));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2aaf9
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2aaf9
movq %rdi, %r14
movq %rbx, %rdi
callq 0x1452f
movq %r14, %rdi
callq 0x6b84b
movq %rax, %rdi
callq 0x1c285
movq %rax, %rdi
callq 0x4d1c0
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13dd3
leaq 0xa8cb6(%rip), %rsi     # 0xd377f
movq %r15, %rdi
movl $0x29b, %edx            # imm = 0x29B
callq 0xd249
pushq $0x7c
popq %rsi
movq %rbx, %rdi
callq 0x140b1
movq %r14, %rdi
callq 0x6bb96
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13dd3
movq 0x1034b8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f55c(%rip), %rsi     # 0xca066
leaq 0xa8dd2(%rip), %rdx     # 0xd38e3
leaq 0xa8ddb(%rip), %rcx     # 0xd38f3
leaq 0xa8c60(%rip), %r8      # 0xd377f
movl $0x293, %r9d            # imm = 0x293
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_get_blocks
GtHashmap* gt_diagram_get_blocks(GtDiagram *diagram, GtError *err)
{
  GtHashmap *ret;
  int had_err = 0;
  gt_assert(diagram);
  gt_rwlock_wrlock(diagram->lock);
  had_err = gt_diagram_build((GtDiagram*) diagram, err);
  if (had_err)
    ret = NULL;
  else
    ret = diagram->blocks;
  gt_rwlock_unlock(diagram->lock);
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x2ac5d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15e99
movq %rbx, 0x18(%rsp)
movq %r14, 0x10(%rsp)
movq 0x10(%rbx), %rdi
callq 0x56030
movq 0x20(%rbx), %rdi
callq 0x56030
movq 0x18(%rbx), %rdi
callq 0x56030
movq (%rbx), %r14
testq %r14, %r14
jne 0x2ac43
movq 0x8(%rbx), %rdi
callq 0x56030
xorl %r14d, %r14d
leaq 0xe05(%rip), %r15       # 0x2b99f
leaq 0x8(%rsp), %r12
movq 0x30(%rbx), %rdi
callq 0x4b988
cmpq %rax, %r14
jae 0x2ac06
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %r13
movq %r13, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2b2f0
testl %eax, %eax
jne 0x2ac01
movq %r13, %rdi
callq 0x194d0
testb %al, %al
je 0x2abfc
movq 0x10(%rsp), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1ae00
testl %eax, %eax
jne 0x2ac01
incq %r14
jmp 0x2ab9f
xorl %r14d, %r14d
jmp 0x2ac43
leaq -0x1d87e(%rip), %rsi    # 0xd38f
leaq 0x3ee(%rip), %rdx       # 0x2b002
pushq $0x1
popq %rdi
callq 0x55da4
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
leaq 0x41c(%rip), %rsi       # 0x2b046
leaq -0xec78(%rip), %rcx     # 0x1bfb9
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x55f80
testl %eax, %eax
jne 0x2ac95
movq (%rbx), %r14
movq 0x60(%rbx), %rdi
callq 0x15f0a
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x103354(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f3f8(%rip), %rsi     # 0xca066
leaq 0xbbc4a(%rip), %rdx     # 0xe68bf
leaq 0xa8bdf(%rip), %rcx     # 0xd385b
leaq 0xa8afc(%rip), %r8      # 0xd377f
movl $0x38a, %r9d            # imm = 0x38A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x10331c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f3c0(%rip), %rsi     # 0xca066
leaq 0x9f966(%rip), %rdx     # 0xca613
leaq 0xa8c56(%rip), %rcx     # 0xd390a
leaq 0xa8ac4(%rip), %r8      # 0xd377f
movl $0x324, %r9d            # imm = 0x324
jmp 0x2ac89
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_get_custom_tracks
GtArray* gt_diagram_get_custom_tracks(const GtDiagram *diagram)
{
  GtArray *ret;
  gt_assert(diagram);
  gt_rwlock_rdlock(diagram->lock);
  ret = diagram->custom_tracks;
  gt_rwlock_unlock(diagram->lock);
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2acf0
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15e28
movq 0x38(%rbx), %r14
movq 0x60(%rbx), %rdi
callq 0x15f0a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1032c1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f365(%rip), %rsi     # 0xca066
leaq 0xbbbb7(%rip), %rdx     # 0xe68bf
leaq 0xa8b62(%rip), %rcx     # 0xd3871
leaq 0xa8a69(%rip), %r8      # 0xd377f
movl $0x398, %r9d            # imm = 0x398
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_add_custom_track
void gt_diagram_add_custom_track(GtDiagram *diagram, GtCustomTrack* ctrack)
{
  gt_assert(diagram && ctrack);
  gt_rwlock_wrlock(diagram->lock);
  gt_array_add(diagram->custom_tracks, ctrack);
  gt_rwlock_unlock(diagram->lock);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x2ad68
testq %rsi, %rsi
je 0x2ad68
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15e99
movq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4b801
movq 0x60(%rbx), %rdi
callq 0x15f0a
addq $0x10, %rsp
popq %rbx
retq
movq 0x103249(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f2ed(%rip), %rsi     # 0xca066
leaq 0xa8b0e(%rip), %rdx     # 0xd388e
leaq 0xa8b19(%rip), %rcx     # 0xd38a0
leaq 0xa89f1(%rip), %r8      # 0xd377f
movl $0x3a1, %r9d            # imm = 0x3A1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_unit_test_sketch_func
void* gt_diagram_unit_test_sketch_func(void *data)
{
  int had_err = 0;
  GtLayout *l = NULL;
  GtUword height;
  GtCanvas *c = NULL;
  GtDiagramTestShared *sh = (GtDiagramTestShared*) data;

  l = gt_layout_new(sh->d, 1000, sh->sty, sh->err);
  if (!l)
    had_err = -1;
  if (!had_err)
    had_err = gt_layout_get_height(l, &height, sh->err);
  if (!had_err) {
    c = gt_canvas_cairo_file_new(sh->sty, GT_GRAPHICS_PNG, 1000,
                                 height, NULL, sh->err);
    if (!c)
      had_err = -1;
  }
  if (!had_err) {
    had_err = gt_layout_sketch(l, c, sh->err);
  }
  if (had_err)
    sh->errstatus = 1;
  gt_layout_delete(l);
  gt_canvas_delete(c);
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x311f4
movq %rax, %r14
testq %rax, %rax
je 0x2addc
movq 0x8(%rbx), %rdx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x31a49
testl %eax, %eax
je 0x2ae04
xorl %r15d, %r15d
movl $0x1, 0x20(%rbx)
movq %r14, %rdi
callq 0x3155b
movq %r15, %rdi
callq 0x29ef3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rbx), %r9
movq 0x18(%rbx), %rdi
movq (%rsp), %rcx
xorl %r15d, %r15d
pushq $0x1
popq %rsi
movl $0x3e8, %edx            # imm = 0x3E8
xorl %r8d, %r8d
callq 0x2a575
testq %rax, %rax
je 0x2addf
movq %rax, %r12
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x315c9
movq %r12, %r15
testl %eax, %eax
jne 0x2addf
jmp 0x2ade6
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_unit_test
int gt_diagram_unit_test(GtError *err)
{
  int had_err = 0;
  GtGenomeNode *gn;
  GtDiagramTestShared sh;
  GtRange testrng = {100, 10000};
  gt_error_check(err);

  gn = gt_feature_node_new_standard_gene();
  sh.fi = gt_feature_index_memory_new();
  sh.sty = gt_style_new(err);
  sh.err = err;
  sh.errstatus = 0;
  gt_feature_index_add_feature_node(sh.fi, gt_feature_node_cast(gn), err);
  gt_genome_node_delete(gn);
  sh.d = gt_diagram_new(sh.fi, "ctg123", &testrng, sh.sty, err);

  /* removed the multithreading test for now until it is fixed */
  gt_diagram_unit_test_sketch_func(&sh);
  gt_ensure(sh.errstatus == 0);

  gt_style_delete(sh.sty);
  gt_diagram_delete(sh.d);
  gt_feature_index_delete(sh.fi);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movups 0xa8cee(%rip), %xmm0    # 0xd3b48
movaps %xmm0, (%rsp)
testq %rdi, %rdi
je 0x2ae73
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x2af4d
callq 0x18fd1
movq %rax, %r15
callq 0x18544
movq %rax, %r12
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x32840
movq %rax, %r13
movq %rax, 0x18(%r14)
movq %rbx, 0x8(%r14)
andl $0x0, 0x20(%r14)
movq %r15, %rdi
callq 0x18df7
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x16acd
movq %r15, %rdi
callq 0x1d1e3
leaq 0xa2d4b(%rip), %rsi     # 0xcdc13
movq %rsp, %rdx
movq %r12, %rdi
movq %r13, %rcx
movq %rbx, %r8
callq 0x2a748
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x2ada0
cmpl $0x0, 0x20(%r14)
je 0x2af1d
leaq 0xa1266(%rip), %rsi     # 0xcc159
leaq 0xa89d7(%rip), %rdx     # 0xd38d1
leaq 0xa89bb(%rip), %rcx     # 0xd38bc
leaq 0xa8877(%rip), %r8      # 0xd377f
movq %rbx, %rdi
movl $0x3df, %r9d            # imm = 0x3DF
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rbx
jmp 0x2af1f
xorl %ebx, %ebx
movq 0x30(%rsp), %rdi
callq 0x34915
movq 0x28(%rsp), %rdi
callq 0x2af85
movq 0x18(%rsp), %rdi
callq 0x16967
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x103064(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f108(%rip), %rsi     # 0xca066
leaq 0x9f6f4(%rip), %rdx     # 0xca659
leaq 0xa8950(%rip), %rcx     # 0xd38bc
leaq 0xa880c(%rip), %r8      # 0xd377f
movl $0x3d2, %r9d            # imm = 0x3D2
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: gt_diagram_delete
void gt_diagram_delete(GtDiagram *diagram)
{
  if (!diagram) return;
  gt_rwlock_wrlock(diagram->lock);
  gt_array_delete(diagram->features);
  if (diagram->blocks)
    gt_hashmap_delete(diagram->blocks);
  gt_hashmap_delete(diagram->nodeinfo);
  gt_hashmap_delete(diagram->collapsingtypes);
  gt_hashmap_delete(diagram->groupedtypes);
  gt_hashmap_delete(diagram->caption_display_status);
  gt_array_delete(diagram->custom_tracks);
  gt_rwlock_unlock(diagram->lock);
  gt_rwlock_delete(diagram->lock);
  gt_free(diagram);
}

// Assembly:
testq %rdi, %rdi
je 0x2b001
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x15e99
movq 0x30(%rbx), %rdi
callq 0x4c19d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2afad
callq 0x563a7
movq 0x8(%rbx), %rdi
callq 0x563a7
movq 0x10(%rbx), %rdi
callq 0x563a7
movq 0x20(%rbx), %rdi
callq 0x563a7
movq 0x18(%rbx), %rdi
callq 0x563a7
movq 0x38(%rbx), %rdi
callq 0x4c19d
movq 0x60(%rbx), %rdi
callq 0x15f0a
movq 0x60(%rbx), %rdi
callq 0x15dd5
leaq 0xa878c(%rip), %rsi     # 0xd377f
movq %rbx, %rdi
movl $0x3f6, %edx            # imm = 0x3F6
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: blocklist_delete
static void blocklist_delete(void *value)
{
  GtUword i;
  GtArray *a;
  if (!value) return;
  a = (GtArray*) value;
  for (i = 0; i < gt_array_size(a); i++)
    gt_block_delete(*(GtBlock**) gt_array_get(a, i));
  gt_array_delete(a);
}

// Assembly:
testq %rdi, %rdi
je 0x2b045
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x4b988
cmpq %rax, %r14
jae 0x2b036
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x6c7e1
incq %r14
jmp 0x2b011
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4c19d
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/diagram.c
// Function: visit_child
static int visit_child(GtFeatureNode* fn, void *nti, GtError *err)
{
  NodeTraverseInfo* gt_genome_node_info;
  int had_err = 0;
  gt_genome_node_info = (NodeTraverseInfo*) nti;
  gt_error_check(err);

  if (gt_feature_node_has_children(fn))
  {
    GtFeatureNode *oldparent = gt_genome_node_info->parent;
    had_err = process_node(gt_genome_node_info->diagram, fn,
                           gt_genome_node_info->parent, err);
    if (!had_err) {
      gt_genome_node_info->parent = fn;
      had_err = gt_feature_node_traverse_direct_children(fn,
                                                         gt_genome_node_info,
                                                         visit_child, err);
    }
    if (!had_err) {
      gt_genome_node_info->parent = oldparent;
    }
  }
  else
  {
    had_err = process_node(gt_genome_node_info->diagram, fn,
                           gt_genome_node_info->parent, err);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x2b9c1
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x2ba35
movq %r15, %rdi
callq 0x194d0
testb %al, %al
je 0x2b9eb
movq (%rbx), %r12
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2b2f0
testl %eax, %eax
je 0x2ba08
pushq $-0x1
popq %rax
jmp 0x2ba29
movq (%rbx), %rdx
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b2f0
movq %r15, (%rbx)
leaq -0x73(%rip), %rdx       # 0x2b99f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x1ae00
testl %eax, %eax
jne 0x2ba29
movq %r12, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10257c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9e620(%rip), %rsi     # 0xca066
leaq 0x9ec0c(%rip), %rdx     # 0xca659
leaq 0xa80cd(%rip), %rcx     # 0xd3b21
leaq 0xa7d24(%rip), %r8      # 0xd377f
movl $0x275, %r9d            # imm = 0x275
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2bfad
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x55ef6
movq %rax, %r15
testq %rax, %rax
jne 0x2bfa4
leaq 0xa7819(%rip), %rdx     # 0xd377f
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x71
popq %rcx
callq 0xce9a
movq %rax, %r15
leaq -0x1ebef(%rip), %rdx    # 0xd38f
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x55da4
movq %rax, 0x8(%r15)
callq 0x1532c
movq %rax, 0x10(%r15)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x55f31
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x102004(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9e0a8(%rip), %rsi     # 0xca066
leaq 0xa7956(%rip), %rdx     # 0xd391b
leaq 0xa79f2(%rip), %rcx     # 0xd39be
leaq 0xa77ac(%rip), %r8      # 0xd377f
pushq $0x6f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c014
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x55ef6
testq %rax, %rax
je 0x2c010
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x2c010
movq 0x10(%rax), %rax
jmp 0x2c012
xorl %eax, %eax
popq %rbx
retq
movq 0x101f9d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9e041(%rip), %rsi     # 0xca066
leaq 0xa2855(%rip), %rdx     # 0xce881
leaq 0xa7998(%rip), %rcx     # 0xd39cb
leaq 0xa7745(%rip), %r8      # 0xd377f
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c157
movq %rcx, %r13
testq %rcx, %rcx
je 0x2c185
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa7703(%rip), %rdx     # 0xd377f
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x65
popq %rcx
callq 0xce9a
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 0x2c0be
leaq -0x1ed1e(%rip), %rdx    # 0xd38f
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x55da4
movq %rax, %rdi
movq %rax, 0x8(%r15)
movq %r14, %rsi
callq 0x55ef6
movq %rax, %r13
testq %rax, %rax
jne 0x2c11e
leaq 0xa76aa(%rip), %rdx     # 0xd377f
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
movl $0x94, %ecx
callq 0xce9a
movq %rax, %r13
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, (%r13)
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x8(%r13)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x55f31
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x15407
movq (%r13), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x55f31
cmpq $-0x1, %rbx
je 0x2c138
movb $0x1, 0x10(%r13)
movq 0x8(%r13), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4b801
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x101e5a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9defe(%rip), %rsi     # 0xca066
leaq 0xa2712(%rip), %rdx     # 0xce881
leaq 0xa7869(%rip), %rcx     # 0xd39df
leaq 0xa7602(%rip), %r8      # 0xd377f
movl $0x8c, %r9d
jmp 0x2c1af
movq 0x101e2c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9ded0(%rip), %rsi     # 0xca066
leaq 0xb3e9f(%rip), %rdx     # 0xe003c
leaq 0xa784e(%rip), %rcx     # 0xd39f2
leaq 0xa75d4(%rip), %r8      # 0xd377f
pushq $0x64
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x13d5c
movq %rax, %r14
movq 0x28(%rbp), %rbp
movq %r12, %rdi
callq 0x19528
leaq 0xa77f5(%rip), %rdx     # 0xd3a13
movq %rbp, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x33b98
cmpl $0x1, %eax
je 0x2c249
cmpl $0x2, %eax
jne 0x2c2bb
movq %r14, %rdi
callq 0x152db
pushq $-0x1
popq %rax
jmp 0x2c2c8
movq %r15, %rdi
callq 0x2c1bb
movq %rax, %r13
movq %r12, %rdi
callq 0x2c1bb
movq %rax, %r12
movq %r13, %rax
orq %r12, %rax
je 0x2c2b0
testq %r15, %r15
je 0x2c29e
testq %r13, %r13
je 0x2c27d
movq %r15, %rdi
callq 0x194d0
testb %al, %al
jne 0x2c284
leaq 0xaaa4b(%rip), %r13     # 0xd6ccf
movq %r14, %rdi
movq %r13, %rsi
callq 0x13dd3
leaq 0xac533(%rip), %rsi     # 0xd87c9
movq %r14, %rdi
callq 0x13dd3
testq %r12, %r12
je 0x2c2bb
movq %r14, %rdi
movq %r12, %rsi
callq 0x13dd3
jmp 0x2c2bb
movq %r14, %rdi
callq 0x152db
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6ba8c
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_O2/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 0x2c3ea
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2c3ea
movq 0x8(%rax), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x15f0a
movq %rbx, %rax
popq %rbx
retq
movq 0x101bc7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9dc6b(%rip), %rsi     # 0xca066
leaq 0xa7756(%rip), %rdx     # 0xd3b58
leaq 0xa775b(%rip), %rcx     # 0xd3b64
leaq 0xa7764(%rip), %r8      # 0xd3b74
movl $0x8a, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2c490
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x2c490
leaq 0xa7733(%rip), %r14     # 0xd3b74
pushq $0x1
popq %r15
movq %r15, %rdi
movq %r14, %rdx
movl $0x95, %ecx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x10
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movl $0x97, %ecx
callq 0xce9a
movq %rax, 0x8(%r12)
callq 0x15d09
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x101b21(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9dbc5(%rip), %rsi     # 0xca066
leaq 0xa76ec(%rip), %rdx     # 0xd3b94
leaq 0xa76f4(%rip), %rcx     # 0xd3ba3
leaq 0xa76be(%rip), %r8      # 0xd3b74
movl $0x94, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c4ff
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x2c507
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15f0a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x2c569
movq 0xd0(%rcx), %rcx
testq %rcx, %rcx
je 0x2c524
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15dd5
movq 0x8(%rbx), %rdi
leaq 0xa762f(%rip), %r14     # 0xd3b74
movq %r14, %rsi
movl $0xab, %edx
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0xac, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0x101a48(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9daec(%rip), %rsi     # 0xca066
leaq 0xa772d(%rip), %rdx     # 0xd3cae
leaq 0xa762e(%rip), %rcx     # 0xd3bb6
leaq 0xa75e5(%rip), %r8      # 0xd3b74
movl $0xa6, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c67e
movq %rsi, %r14
testq %rsi, %rsi
je 0x2c67e
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c67e
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x101933(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d9d7(%rip), %rsi     # 0xca066
leaq 0xa755d(%rip), %rdx     # 0xd3bf3
leaq 0xa756d(%rip), %rcx     # 0xd3c0a
leaq 0xa74d0(%rip), %r8      # 0xd3b74
movl $0xb9, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c718
movq %rsi, %r14
testq %rsi, %rsi
je 0x2c718
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c718
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x101899(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d93d(%rip), %rsi     # 0xca066
leaq 0xa74c3(%rip), %rdx     # 0xd3bf3
leaq 0xa74e9(%rip), %rcx     # 0xd3c20
leaq 0xa7436(%rip), %r8      # 0xd3b74
movl $0xc2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c7b2
movq %rsi, %r14
testq %rsi, %rsi
je 0x2c7b2
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c7b2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x1017ff(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d8a3(%rip), %rsi     # 0xca066
leaq 0xa7471(%rip), %rdx     # 0xd3c3b
leaq 0xa747f(%rip), %rcx     # 0xd3c50
leaq 0xa739c(%rip), %r8      # 0xd3b74
movl $0xcb, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c84c
movq %rsi, %r14
testq %rsi, %rsi
je 0x2c84c
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c84c
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x101765(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d809(%rip), %rsi     # 0xca066
leaq 0xa738f(%rip), %rdx     # 0xd3bf3
leaq 0xa7404(%rip), %rcx     # 0xd3c6f
leaq 0xa7302(%rip), %r8      # 0xd3b74
movl $0xd4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c901
movq %rsi, %r14
testq %rsi, %rsi
je 0x2c901
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c901
leaq 0x50(%rsp), %r15
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x1016b0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d754(%rip), %rsi     # 0xca066
leaq 0xa72da(%rip), %rdx     # 0xd3bf3
leaq 0xa736b(%rip), %rcx     # 0xd3c8b
leaq 0xa724d(%rip), %r8      # 0xd3b74
movl $0xdd, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2c981
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c981
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x101630(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d6d4(%rip), %rsi     # 0xca066
leaq 0xa7310(%rip), %rdx     # 0xd3ca9
leaq 0xa7319(%rip), %rcx     # 0xd3cb9
leaq 0xa71cd(%rip), %r8      # 0xd3b74
movl $0xe6, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2ca0b
movq %rsi, %r14
testq %rsi, %rsi
je 0x2ca0b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2ca0b
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1015a6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d64a(%rip), %rsi     # 0xca066
leaq 0xa72b2(%rip), %rdx     # 0xd3cd5
leaq 0xa72c3(%rip), %rcx     # 0xd3ced
leaq 0xa7143(%rip), %r8      # 0xd3b74
movl $0xf0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2caa0
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2caa0
leaq 0x40(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x101511(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d5b5(%rip), %rsi     # 0xca066
leaq 0xa71f1(%rip), %rdx     # 0xd3ca9
leaq 0xa7249(%rip), %rcx     # 0xd3d08
leaq 0xa70ae(%rip), %r8      # 0xd3b74
movl $0xfa, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2cb39
movq %rsi, %r15
testq %rsi, %rsi
je 0x2cb39
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2cb39
movl %ecx, %ebp
movl %edx, %r14d
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x101478(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d51c(%rip), %rsi     # 0xca066
leaq 0xa71d8(%rip), %rdx     # 0xd3d29
leaq 0xa71eb(%rip), %rcx     # 0xd3d43
leaq 0xa7015(%rip), %r8      # 0xd3b74
movl $0x104, %r9d            # imm = 0x104
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2cbb9
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2cbb9
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x1013f8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d49c(%rip), %rsi     # 0xca066
leaq 0xa70d8(%rip), %rdx     # 0xd3ca9
leaq 0xa7180(%rip), %rcx     # 0xd3d58
leaq 0xa6f95(%rip), %r8      # 0xd3b74
movl $0x10d, %r9d            # imm = 0x10D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2cc39
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2cc39
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x101378(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d41c(%rip), %rsi     # 0xca066
leaq 0xa7058(%rip), %rdx     # 0xd3ca9
leaq 0xa711d(%rip), %rcx     # 0xd3d75
leaq 0xa6f15(%rip), %r8      # 0xd3b74
movl $0x117, %r9d            # imm = 0x117
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2ccb9
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2ccb9
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x1012f8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d39c(%rip), %rsi     # 0xca066
leaq 0xa6fd8(%rip), %rdx     # 0xd3ca9
leaq 0xa70b9(%rip), %rcx     # 0xd3d91
leaq 0xa6e95(%rip), %r8      # 0xd3b74
movl $0x121, %r9d            # imm = 0x121
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2cd39
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2cd39
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x101278(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d31c(%rip), %rsi     # 0xca066
leaq 0xa6f58(%rip), %rdx     # 0xd3ca9
leaq 0xa7052(%rip), %rcx     # 0xd3daa
leaq 0xa6e15(%rip), %r8      # 0xd3b74
movl $0x12b, %r9d            # imm = 0x12B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2cdc2
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2cdc2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x1011ef(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d293(%rip), %rsi     # 0xca066
leaq 0xa6ecf(%rip), %rdx     # 0xd3ca9
leaq 0xa6fe2(%rip), %rcx     # 0xd3dc3
leaq 0xa6d8c(%rip), %r8      # 0xd3b74
movl $0x134, %r9d            # imm = 0x134
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2ce8f
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2ce8f
leaq 0x60(%rsp), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
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 0x15f0a
movq 0x101122(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0x9d1c6(%rip), %rsi     # 0xca066
leaq 0xa6e02(%rip), %rdx     # 0xd3ca9
leaq 0xa6f2d(%rip), %rcx     # 0xd3ddb
leaq 0xa6cbf(%rip), %r8      # 0xd3b74
movl $0x13e, %r9d            # imm = 0x13E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300