LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_has_only_one_fullsize_element
bool gt_block_has_only_one_fullsize_element(const GtBlock *block)
{
  bool ret = false;
  GtUword bsize;
  gt_assert(block);
  bsize = gt_array_size(block->elements);
  if (bsize == 1) {
    GtRange elem_range, block_range;
    gt_assert(*(GtElement**) gt_array_get(block->elements, 0) ==
              *(GtElement**) gt_array_get(block->elements, bsize-1));
    elem_range = gt_element_get_range(*(GtElement**)
                                             gt_array_get(block->elements, 0));
    block_range = gt_block_get_range(block);
    ret = (gt_range_compare(&block_range, &elem_range) == 0);
  }
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x6b997
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4b988
cmpq $0x1, %rax
jne 0x6b98d
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x4b48e
movq (%rax), %r14
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x4b48e
cmpq (%rax), %r14
jne 0x6b9c5
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x4b48e
movq (%rax), %rdi
callq 0x6f551
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movups 0x8(%rbx), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
callq 0x5cec8
testl %eax, %eax
sete %al
jmp 0x6b98f
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0xc261a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5e6be(%rip), %rsi     # 0xca066
leaq 0x7468d(%rip), %rdx     # 0xe003c
leaq 0x73867(%rip), %rcx     # 0xdf21d
leaq 0x736e4(%rip), %r8      # 0xdf0a1
movl $0xf7, %r9d
jmp 0x6b9f1
movq 0xc25ec(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5e690(%rip), %rsi     # 0xca066
leaq 0x73867(%rip), %rdx     # 0xdf244
leaq 0x73839(%rip), %rcx     # 0xdf21d
leaq 0x736b6(%rip), %r8      # 0xdf0a1
movl $0xfc, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_sketch
int gt_block_sketch(GtBlock *block, GtCanvas *canvas, GtError *err)
{
  int had_err = 0;
  GtUword i;
  gt_assert(block && canvas && err);
  /* if resulting block was too short,
     do not traverse this feature tree further */
  had_err = gt_canvas_visit_block(canvas, block, err);
  if (had_err)
  {
    if (had_err == 1)  /* 'magic' value */
      return 0;
    else
      return had_err;
  } /* we have in any case returned if had_err was set */
  if (!block->sorted)
  {
    GtStyle *sty = gt_canvas_get_style(canvas);
    /* sort elements if they have changed since last sketch operation */
    gt_array_sort_with_data(block->elements, elemcmp, sty);
    block->sorted = true;
  }
  /* delegate sketch request to elements */
  for (i=0;i<gt_array_size(block->elements);i++) {
     GtElement *elem = *(GtElement**) gt_array_get(block->elements, i);
     had_err = gt_element_sketch(elem, canvas, err);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6be47
movq %rsi, %r14
testq %rsi, %rsi
je 0x6be47
movq %rdx, %rbx
testq %rdx, %rdx
je 0x6be47
movq %rdi, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2a28e
testl %eax, %eax
je 0x6bdef
xorl %ebp, %ebp
cmpl $0x1, %eax
je 0x6bde4
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x29(%r15)
jne 0x6be15
movq %r14, %rdi
callq 0x2a38a
movq (%r15), %rdi
leaq 0x77(%rip), %rsi        # 0x6be7f
movq %rax, %rdx
callq 0x4bb46
movb $0x1, 0x29(%r15)
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r15), %rdi
callq 0x4b988
cmpq %rax, %r12
jae 0x6bde4
movq (%r15), %rdi
movq %r12, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6f656
movl %eax, %ebp
incq %r12
jmp 0x6be1a
movq 0xc216a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5e20e(%rip), %rsi     # 0xca066
leaq 0x73550(%rip), %rdx     # 0xdf3af
leaq 0x73560(%rip), %rcx     # 0xdf3c6
leaq 0x73234(%rip), %r8      # 0xdf0a1
movl $0x165, %r9d            # imm = 0x165
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: elemcmp
static int elemcmp(const void *a, const void *b, void *data)
{
  const char *type_a, *type_b;
  double zindex_a = GT_UNDEF_DOUBLE, zindex_b= GT_UNDEF_DOUBLE;
  GtStyle *sty = (GtStyle*) data;
  GtElement *elem_a = *(GtElement**) a;
  GtElement *elem_b = *(GtElement**) b;

  type_a = gt_element_get_type(elem_a);
  type_b = gt_element_get_type(elem_b);

  /* same types are equal, no further action needed */
  if (type_a == type_b)
    return 0;
  /* if not, then get z-index from style */
  if (sty)
  {
    (void) gt_style_get_num(sty, type_a, "z_index", &zindex_a, NULL, NULL);
    (void) gt_style_get_num(sty, type_b, "z_index", &zindex_b, NULL, NULL);
  }
  /* only one is set -> put types with set z-indices always on top of others*/
  if (zindex_a == GT_UNDEF_DOUBLE && zindex_b != GT_UNDEF_DOUBLE)
    return -1;
  if (zindex_b == GT_UNDEF_DOUBLE && zindex_a != GT_UNDEF_DOUBLE)
    return 1;
  /* none is set, fall back to default alphabetic ordering */
  if (zindex_a == GT_UNDEF_DOUBLE && zindex_b == GT_UNDEF_DOUBLE)
  {
    if (strcmp(type_a, type_b) < 0)
      return 1;
    return -1;
  }
  /* both z-indices are set */
  if (gt_double_equals_double(zindex_a, zindex_b))
    return 0;
  if (gt_double_smaller_double(zindex_a, zindex_b))
    return -1;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq (%rdi), %rdi
movq (%rsi), %rbx
callq 0x6f596
movq %rax, %r14
movq %rbx, %rdi
callq 0x6f596
xorl %ebx, %ebx
cmpq %rax, %r14
je 0x6bfb3
movq %rax, %r15
testq %r12, %r12
je 0x6bf37
leaq 0x736c6(%rip), %r13     # 0xdf59a
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x33ff8
leaq 0x10(%rsp), %rbp
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x33ff8
leaq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movsd (%rbp), %xmm1
movsd 0x5e9c9(%rip), %xmm2    # 0xca8e8
ucomisd %xmm2, %xmm0
jne 0x6bf49
jp 0x6bf49
ucomisd 0x5e9b9(%rip), %xmm1    # 0xca8e8
jne 0x6bf33
jnp 0x6bf49
pushq $-0x1
jmp 0x6bf67
movsd 0x5e9a9(%rip), %xmm1    # 0xca8e8
movb $0x1, %al
movapd %xmm1, %xmm0
movb $0x1, %cl
jmp 0x6bf77
ucomisd %xmm2, %xmm1
setnp %cl
sete %al
andb %cl, %al
ucomisd %xmm2, %xmm0
setp %cl
setne %dl
orb %cl, %dl
testb %al, %dl
je 0x6bf6a
pushq $0x1
popq %rbx
jmp 0x6bfb3
cmpeqsd %xmm0, %xmm2
movq %xmm2, %rcx
andl $0x1, %ecx
andb %cl, %al
cmpb $0x1, %al
jne 0x6bf91
movq %r14, %rdi
movq %r15, %rsi
callq 0xb880
movl %eax, %ebx
notl %ebx
sarl $0x1f, %ebx
jmp 0x6bfb0
callq 0x58d7d
testb %al, %al
jne 0x6bfb3
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x58dba
movzbl %al, %ebx
negl %ebx
orl $0x1, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_delete
void gt_block_delete(GtBlock *block)
{
  GtUword i;
  if (!block) return;
  if (block->reference_count) {
    block->reference_count--;
    return;
  }
  for (i=0;i<gt_array_size(block->elements);i++) {
    GtElement *elem = *(GtElement**) gt_array_get(block->elements, i);
    gt_element_delete(elem);
  }
  if (block->caption)
    gt_str_delete(block->caption);
  gt_array_delete(block->elements);
  if (block->top_level_feature)
    gt_genome_node_delete((GtGenomeNode*) block->top_level_feature);
  gt_free(block);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6c7fd
movq %rdi, %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x6c805
decq %rax
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x4b988
cmpq %rax, %r14
jae 0x6c82d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x6fad9
incq %r14
jmp 0x6c808
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x6c83b
callq 0x152db
movq (%rbx), %rdi
callq 0x4c19d
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6c851
callq 0x1d1e3
leaq 0x72849(%rip), %rsi     # 0xdf0a1
movq %rbx, %rdi
movl $0x1ec, %edx            # imm = 0x1EC
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_layout_pre
int gt_canvas_cairo_visit_layout_pre(GtCanvas *canvas,
                                     GtLayout *layout,
                                     GtError *err)
{
  double head_track_space = HEAD_TRACK_SPACE_DEFAULT;
  /* get displayed range for internal use */
  canvas->pvt->viewrange = gt_layout_get_range(layout);
  if (gt_canvas_draw_ruler(canvas, canvas->pvt->viewrange, err)) {
    return -1;
  }
  if (gt_style_get_num(canvas->pvt->sty, "format", "ruler_space",
                       &head_track_space, NULL,err) == GT_STYLE_QUERY_ERROR) {
    return -1;
  }
  canvas->pvt->y += HEADER_SPACE + head_track_space;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movabsq $0x402e000000000000, %rax # imm = 0x402E000000000000
movq %rax, (%rsp)
movq 0x8(%rdi), %r15
movq %rsi, %rdi
callq 0x319bf
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x29e14
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0x6c8fd
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
leaq 0x5d8d0(%rip), %rsi     # 0xca196
leaq 0x681f4(%rip), %rdx     # 0xd4ac1
movq %rsp, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x33ff8
cmpl $0x2, %eax
je 0x6c8fd
movsd (%rsp), %xmm0
addsd 0x67fe3(%rip), %xmm0    # 0xd48d0
movq 0x8(%rbx), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_track_post
int gt_canvas_cairo_visit_track_post(GtCanvas *canvas, GT_UNUSED GtTrack *track,
                                     GtError *err)
{
  double vspace = TRACK_VSPACE_DEFAULT;
  gt_assert(canvas && track);
  /* put track spacer after track */
  if (gt_style_get_num(canvas->pvt->sty, "format", "track_vspace", &vspace,
                       NULL, err) == GT_STYLE_QUERY_ERROR) {
    return -1;
  }
  canvas->pvt->y += vspace;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x402e000000000000, %rax # imm = 0x402E000000000000
movq %rax, (%rsp)
testq %rdi, %rdi
je 0x6ccb8
testq %rsi, %rsi
je 0x6ccb8
movq %rdx, %r9
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rdi
leaq 0x5d51c(%rip), %rsi     # 0xca196
leaq 0x67e33(%rip), %rdx     # 0xd4ab4
xorl %r14d, %r14d
movq %rsp, %rcx
xorl %r8d, %r8d
callq 0x33ff8
cmpl $0x2, %eax
jne 0x6cc9a
pushq $-0x1
popq %r14
jmp 0x6ccad
movsd (%rsp), %xmm0
movq 0x8(%rbx), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xc12f9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5d39d(%rip), %rsi     # 0xca066
leaq 0x66841(%rip), %rdx     # 0xd3511
leaq 0x72a6e(%rip), %rcx     # 0xdf745
leaq 0x729a2(%rip), %r8      # 0xdf680
movl $0xa1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_line_post
int gt_canvas_cairo_visit_line_post(GtCanvas *canvas, GtLine *line,
                                    GtError *err)
{
  int had_err = 0;
  double lheight,
         bar_vspace = BAR_VSPACE_DEFAULT;
  gt_assert(canvas && line);
  had_err = gt_line_get_height(line, &lheight, canvas->pvt->sty, err);
  if (!had_err) {
    if (gt_style_get_num(canvas->pvt->sty,
                         "format", "bar_vspace",
                         &bar_vspace, NULL, err) == GT_STYLE_QUERY_ERROR) {
      return -1;
    }
    canvas->pvt->y += bar_vspace + lheight/2;
    if (canvas->pvt->bt)
      gt_bittab_delete(canvas->pvt->bt);
    canvas->pvt->bt = NULL;
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movabsq $0x4024000000000000, %rax # imm = 0x4024000000000000
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x6cf92
testq %rsi, %rsi
je 0x6cf92
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rdx
leaq 0x10(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x6fcf5
testl %eax, %eax
jne 0x6cf8a
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
leaq 0x5d268(%rip), %rsi     # 0xca196
leaq 0x68ea6(%rip), %rdx     # 0xd5ddb
leaq 0x8(%rsp), %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x33ff8
cmpl $0x2, %eax
jne 0x6cf4f
pushq $-0x1
popq %rax
jmp 0x6cf8a
movsd 0x10(%rsp), %xmm0
mulsd 0x666e3(%rip), %xmm0    # 0xd3640
addsd 0x8(%rsp), %xmm0
movq 0x8(%rbx), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x6cf83
callq 0x4e2ea
movq 0x8(%rbx), %rax
andq $0x0, 0x50(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0xc101f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5d0c3(%rip), %rsi     # 0xca066
leaq 0x665ac(%rip), %rdx     # 0xd3556
leaq 0x727d4(%rip), %rcx     # 0xdf785
leaq 0x726c8(%rip), %r8      # 0xdf680
movl $0xd9, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/color.c
// Function: gt_color_new
GtColor* gt_color_new(double red, double green, double blue, double alpha)
{
  GtColor *color = gt_malloc(sizeof *color);
  color->red = red;
  color->green = green;
  color->blue = blue;
  color->alpha = alpha;
  return color;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x70c00(%rip), %rsi     # 0xdf97b
pushq $0x20
popq %rdi
pushq $0x18
popq %rdx
callq 0xccb0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/color.c
// Function: gt_color_set
void gt_color_set(GtColor *color, double red, double green, double blue,
                  double alpha)
{
  gt_assert(color);
  color->red = red;
  color->green = green;
  color->blue = blue;
  color->alpha = alpha;
}

// Assembly:
testq %rdi, %rdi
je 0x6edcf
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
movsd %xmm3, 0x18(%rdi)
retq
pushq %rax
movq 0xbf1e1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5b285(%rip), %rsi     # 0xca066
leaq 0x6627b(%rip), %rdx     # 0xd5063
leaq 0x70ba9(%rip), %rcx     # 0xdf998
leaq 0x70b85(%rip), %r8      # 0xdf97b
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/coords.c
// Function: gt_coords_calc_generic_range
GtDrawingRange gt_coords_calc_generic_range(GtRange node_range,
                                            GtRange viewrange)
{
  GtDrawingRange converted_range;
  converted_range.clip = CLIPPED_NONE;
  node_range.end++;
  /* scale coordinates to target image width */
  if (node_range.start < viewrange.start )
    converted_range.clip = CLIPPED_LEFT;
  converted_range.start = gt_coords_convert_point(viewrange, node_range.start);

  if (node_range.end > viewrange.end+1)
    converted_range.clip = (converted_range.clip == CLIPPED_LEFT ?
                                                      CLIPPED_BOTH :
                                                      CLIPPED_RIGHT);
  converted_range.end = gt_coords_convert_point(viewrange, node_range.end);

  return converted_range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
incq %r15
cmpq %rcx, %rsi
pushq $0x2
popq %rax
sbbl $0x0, %eax
movl %eax, 0x10(%rdi)
movq %rcx, %rdi
movq %r8, %rsi
movq %r13, %rdx
callq 0x6ee9c
movsd %xmm0, (%rbx)
leaq 0x1(%r14), %rax
cmpq %rax, %r15
jbe 0x6ef40
xorl %eax, %eax
cmpq %r12, %r13
setb %al
leal (%rax,%rax,2), %eax
movl %eax, 0x10(%rbx)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6ee9c
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_class_new
const GtCustomTrackClass* gt_custom_track_class_new(size_t size,
                                          GtCustomTrackRenderFunc render,
                                          GtCustomTrackGetHeightFunc get_height,
                                          GtCustomTrackGetTitleFunc get_title,
                                          GtCustomTrackFreeFunc free)
{
  GtCustomTrackClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->render = render;
  c_class->get_height = get_height;
  c_class->get_title = get_title;
  c_class->free = free;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0x28
popq %rdi
callq 0x4f148
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_create
GtCustomTrack* gt_custom_track_create(const GtCustomTrackClass *ctc)
{
  GtCustomTrack *ct;
  gt_assert(ctc && ctc->size);
  ct = gt_calloc(1, ctc->size);
  ct->c_class = ctc;
  ct->pvt = gt_calloc(1, sizeof (GtCustomTrackMembers));
  return ct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6eff9
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x6eff9
leaq 0x70a2a(%rip), %r14     # 0xdf9e6
pushq $0x1
popq %r15
pushq $0x38
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x4
popq %rsi
pushq $0x3a
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xbefb8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5b05c(%rip), %rsi     # 0xca066
leaq 0x709ad(%rip), %rdx     # 0xdf9be
leaq 0x709b7(%rip), %rcx     # 0xdf9cf
leaq 0x709c7(%rip), %r8      # 0xdf9e6
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_delete
void gt_custom_track_delete(GtCustomTrack *ctrack)
{
  if (!ctrack) return;
  if (ctrack->pvt->reference_count) {
    ctrack->pvt->reference_count--;
    return;
  }
  gt_assert(ctrack->c_class);
  if (ctrack->c_class->free)
    ctrack->c_class->free(ctrack);
  gt_free(ctrack->pvt);
  gt_free(ctrack);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f08f
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
testl %eax, %eax
je 0x6f097
decl %eax
movl %eax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x6f0d8
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x6f0b1
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x7092e(%rip), %r14     # 0xdf9e6
pushq $0x4f
popq %rdx
movq %r14, %rsi
callq 0xd249
pushq $0x50
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0xbeed9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5af7d(%rip), %rsi     # 0xca066
leaq 0x709bd(%rip), %rdx     # 0xdfaad
leaq 0x70927(%rip), %rcx     # 0xdfa1e
leaq 0x708e8(%rip), %r8      # 0xdf9e6
pushq $0x4c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/drawing_range.c
// Function: gt_drawing_range_compare
int gt_drawing_range_compare(GtDrawingRange range_a, GtDrawingRange range_b)
{
  gt_assert(range_a.start <= range_a.end && range_b.start <= range_b.end);

  if (gt_double_equals_double(range_a.start, range_b.start) &&
      gt_double_equals_double(range_a.end, range_b.end))
    return 0; /* range_a == range_b */

  if (gt_double_smaller_double(range_a.start, range_b.start) ||
      (gt_double_equals_double(range_a.start, range_b.start)
       && gt_double_smaller_double(range_a.end, range_b.end)))
    return -1; /* range_a < range_b */

  return 1; /* range_a > range_b */
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jb 0x6f33d
leaq 0x48(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm2
movsd %xmm2, (%rsp)
ucomisd %xmm1, %xmm2
jb 0x6f33d
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x58d7d
testb %al, %al
je 0x6f2f1
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x58d7d
xorl %ebx, %ebx
testb %al, %al
jne 0x6f335
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x58dba
pushq $-0x1
popq %rbx
testb %al, %al
jne 0x6f335
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x58d7d
testb %al, %al
je 0x6f332
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x58dba
testb %al, %al
jne 0x6f335
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq 0xbec74(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ad18(%rip), %rsi     # 0xca066
leaq 0x707d2(%rip), %rdx     # 0xdfb27
leaq 0x70808(%rip), %rcx     # 0xdfb64
leaq 0x7081a(%rip), %r8      # 0xdfb7d
pushq $0x18
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_new
GtElement* gt_element_new(GtFeatureNode *node)
{
  GtElement *element;
  gt_assert(node);
  element = gt_element_new_empty();
  gt_element_set_type(element, gt_feature_node_get_type(node));
  gt_element_set_range(element, gt_genome_node_get_range((GtGenomeNode*) node));
  element->strand = gt_feature_node_get_strand(node);
  element->mark = gt_feature_node_is_marked(node);
  element->gn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) node);
  return element;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6f43d
movq %rdi, %rbx
callq 0x6f473
movq %rax, %r14
movq %rbx, %rdi
callq 0x19528
movq %r14, %rdi
movq %rax, %rsi
callq 0x6f488
movq %rbx, %rdi
callq 0x1c3c4
movq %r14, %rdi
movq %rax, %rsi
callq 0x6f4c8
movq %rbx, %rdi
callq 0x18f89
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x1b273
movb %al, 0x48(%r14)
movq %rbx, %rdi
callq 0x1bec8
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xbeb74(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ac18(%rip), %rsi     # 0xca066
leaq 0x644cb(%rip), %rdx     # 0xd3920
leaq 0x70746(%rip), %rcx     # 0xdfba2
leaq 0x7074e(%rip), %r8      # 0xdfbb1
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/element.c
// Function: elements_are_equal
static bool elements_are_equal(const GtElement *e1, const GtElement *e2)
{
  gt_assert(e1 && e2);
  if (e1->type == e2->type && !gt_range_compare(&e1->range, &e2->range))
    return true;
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x6faa3
testq %rsi, %rsi
je 0x6faa3
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x6fa9b
addq $0x20, %rdi
addq $0x20, %rsi
callq 0x5cec8
testl %eax, %eax
je 0x6fa9f
xorl %eax, %eax
popq %rcx
retq
movb $0x1, %al
jmp 0x6fa9d
movq 0xbe50e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5a5b2(%rip), %rsi     # 0xca066
leaq 0x702c7(%rip), %rdx     # 0xdfd82
leaq 0x702c9(%rip), %rcx     # 0xdfd8b
leaq 0x700e8(%rip), %r8      # 0xdfbb1
pushq $0x64
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_delete
void gt_element_delete(GtElement *element)
{
  if (!element) return;
  if (element->refcount) {
    element->refcount--;
    return;
  }
  gt_genome_node_delete((GtGenomeNode*) element->gn);
  gt_free(element);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x6faf2
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x6faf4
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x1d1e3
leaq 0x700ad(%rip), %rsi     # 0xdfbb1
movq %rbx, %rdi
movl $0xb4, %edx
popq %rbx
jmp 0xd249
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_new
GtLine* gt_line_new(void)
{
  GtLine *line;
  line = gt_calloc(1, sizeof (GtLine));
  line->blocks = gt_array_new(sizeof (GtBlock*));
  line->has_captions = false;
  return line;
}

// Assembly:
pushq %rbx
leaq 0x70282(%rip), %rdx     # 0xdfd9e
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
pushq $0x26
popq %rcx
callq 0xce9a
movq %rax, %rbx
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x8(%rbx)
movb $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_insert_block
void gt_line_insert_block(GtLine *line, GtBlock *block)
{
  gt_assert(line && block);
  if (!line->has_captions && gt_block_get_caption(block) != NULL)
    line->has_captions = true;
  gt_array_add(line->blocks, block);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x6fb84
testq %rsi, %rsi
je 0x6fb84
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x6fb6d
movq %rsi, %rdi
callq 0x6b29b
testq %rax, %rax
je 0x6fb6d
movb $0x1, (%rbx)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4b801
addq $0x10, %rsp
popq %rbx
retq
movq 0xbe42d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5a4d1(%rip), %rsi     # 0xca066
leaq 0x70498(%rip), %rdx     # 0xe0034
leaq 0x70217(%rip), %rcx     # 0xdfdba
leaq 0x701f4(%rip), %r8      # 0xdfd9e
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_sketch
int gt_line_sketch(GtLine *line, GtCanvas *canvas, GtError *err)
{
  int i = 0, had_err = 0;
  gt_assert(line && canvas);
  had_err = gt_canvas_visit_line_pre(canvas, line, err);
  if (!had_err)
  {
    for (i = 0; !had_err && i < gt_array_size(line->blocks); i++) {
      GtBlock *block;
      block = *(GtBlock**) gt_array_get(line->blocks, i);
      had_err = gt_block_sketch(block, canvas, err);
    }
  }
  if (!had_err)
    had_err = gt_canvas_visit_line_post(canvas, line, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6fcbf
movq %rsi, %r15
testq %rsi, %rsi
je 0x6fcbf
movq %rdx, %rbx
movq %rdi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a1e6
testl %eax, %eax
je 0x6fc70
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
xorl %eax, %eax
testl %eax, %eax
jne 0x6fc64
movq 0x8(%r14), %rdi
callq 0x4b988
cmpq %r12, %rax
jbe 0x6fca6
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6bd9d
incq %r12
jmp 0x6fc75
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a23a
movq 0xbe2f2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5a396(%rip), %rsi     # 0xca066
leaq 0x70120(%rip), %rdx     # 0xdfdf7
leaq 0x70128(%rip), %rcx     # 0xdfe06
leaq 0x700b9(%rip), %r8      # 0xdfd9e
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_get_height
int gt_line_get_height(GtLine *line, double *height, const GtStyle *sty,
                       GtError *err)
{
  double line_height = 0;
  GtUword i;
  gt_assert(line && sty);
  for (i = 0; i < gt_array_size(line->blocks); i++) {
    GtBlock *block;
    double myheight = BAR_HEIGHT_DEFAULT;
    block = *(GtBlock**) gt_array_get(line->blocks, i);
    /* check again for caption presence, may have changed in the meantime */
    if (!line->has_captions && gt_block_get_caption(block) != NULL) {
      line->has_captions = true;
    }
    if (gt_block_get_max_height(block, &myheight, sty, err) < 0) {
      return -1;
    }
    if (gt_double_smaller_double(line_height, myheight)) {
      line_height = myheight;
    }
  }
  *height = line_height;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
je 0x6fdd7
movq %rdx, %r15
testq %rdx, %rdx
je 0x6fdd7
movq %rcx, %rbx
movq %rdi, %r12
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
leaq 0x8(%rsp), %rbp
movq 0x8(%r12), %rdi
callq 0x4b988
cmpq %rax, %r13
jae 0x6fdb3
movabsq $0x4030000000000000, %rax # imm = 0x4030000000000000
movq %rax, 0x8(%rsp)
movq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0x4b48e
movq (%rax), %r14
cmpb $0x0, (%r12)
jne 0x6fd7a
movq %r14, %rdi
callq 0x6b29b
testq %rax, %rax
je 0x6fd7a
movb $0x1, (%r12)
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x6bbd9
testl %eax, %eax
js 0x6fdc5
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
callq 0x58dba
testb %al, %al
je 0x6fdae
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
incq %r13
jmp 0x6fd33
movq 0x10(%rsp), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
xorl %eax, %eax
jmp 0x6fdc8
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbe1da(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5a27e(%rip), %rsi     # 0xca066
leaq 0x70026(%rip), %rdx     # 0xdfe15
leaq 0x7002b(%rip), %rcx     # 0xdfe21
leaq 0x6ffa1(%rip), %r8      # 0xdfd9e
pushq $0x57
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_delete
void gt_line_delete(GtLine *line)
{
  GtUword i;
  if (!line) return;
  for (i = 0; i < gt_array_size(line->blocks); i++)
    gt_block_delete(*(GtBlock**) gt_array_get(line->blocks, i));
  gt_array_delete(line->blocks);
  gt_free(line);
}

// Assembly:
testq %rdi, %rdi
je 0x7069d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
callq 0x4b988
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jae 0x7067d
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x6c7e1
incq %r14
jmp 0x70656
callq 0x4c19d
leaq 0x6f715(%rip), %rsi     # 0xdfd9e
movq %rbx, %rdi
movl $0xd6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_class_new
const GtLineBreakerClass* gt_line_breaker_class_new(size_t size,
                                  GtLineBreakerIsOccupiedFunc is_occupied,
                                  GtLineBreakerRegisterBlockFunc register_block,
                                  GtLineBreakerFreeFunc free)
{
  GtLineBreakerClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->is_occupied = is_occupied;
  c_class->register_block = register_block;
  c_class->free = free;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x4f148
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_create
GtLineBreaker* gt_line_breaker_create(const GtLineBreakerClass *lbc)
{
  GtLineBreaker *lb;
  gt_assert(lbc && lbc->size);
  lb = gt_calloc(1, lbc->size);
  lb->c_class = lbc;
  lb->pvt = gt_calloc(1, sizeof (GtLineBreakerMembers));
  return lb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x70733
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x70733
leaq 0x6f880(%rip), %r14     # 0xdff76
pushq $0x1
popq %r15
pushq $0x34
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x4
popq %rsi
pushq $0x36
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xbd87e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x59922(%rip), %rsi     # 0xca066
leaq 0x6f803(%rip), %rdx     # 0xdff4e
leaq 0x6f80d(%rip), %rcx     # 0xdff5f
leaq 0x6f81d(%rip), %r8      # 0xdff76
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_delete
void gt_line_breaker_delete(GtLineBreaker *lb)
{
  if (!lb) return;
  if (lb->pvt->reference_count) {
    lb->pvt->reference_count--;
    return;
  }
  gt_assert(lb->c_class);
  if (lb->c_class->free)
    lb->c_class->free(lb);
  gt_free(lb->pvt);
  gt_free(lb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x707c9
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
testl %eax, %eax
je 0x707d1
decl %eax
movl %eax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x70812
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x707eb
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x6f784(%rip), %r14     # 0xdff76
pushq $0x4b
popq %rdx
movq %r14, %rsi
callq 0xd249
pushq $0x4c
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0xbd79f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x59843(%rip), %rsi     # 0xca066
leaq 0x6f784(%rip), %rdx     # 0xdffae
leaq 0x6f789(%rip), %rcx     # 0xdffba
leaq 0x6f73e(%rip), %r8      # 0xdff76
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_is_line_occupied
int gt_line_breaker_bases_is_line_occupied(GtLineBreaker* lb, bool *result,
                                           GtLine *line, GtBlock *block,
                                           GT_UNUSED GtError *err)
{
  GtLineBreakerBases *lbb;
  GtRange r;
  GtIntervalTree *t;
  gt_assert(lb && block && line);
  r = gt_block_get_range(block);
  lbb = gt_line_breaker_bases_cast(lb);
  if (!(t = gt_hashmap_get(lbb->itrees, line)))
    *result = false;
  else
    *result = (gt_interval_tree_find_first_overlapping(t, r.start, r.end));
  return 0; /* gt_line_breaker_bases_is_line_occupied() is sane */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x709e2
movq %rdi, %r13
testq %rdi, %rdi
je 0x709e2
testq %rcx, %rcx
je 0x709e2
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
callq 0x6b254
movq %rax, %r15
movq %rdx, %r12
callq 0x70a18
movq %rax, %rdi
movq %r13, %rsi
callq 0x70921
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x709d2
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x57cd6
testq %rax, %rax
setne %al
jmp 0x709d4
xorl %eax, %eax
movb %al, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xbd5cf(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x59673(%rip), %rsi     # 0xca066
leaq 0x6425d(%rip), %rdx     # 0xd4c57
leaq 0x6f695(%rip), %rcx     # 0xe0096
leaq 0x6f6b5(%rip), %r8      # 0xe00bd
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_class
const GtLineBreakerClass* gt_line_breaker_bases_class(void)
{
  static const GtLineBreakerClass *lbc = NULL;
  gt_class_alloc_lock_enter();
  if (!lbc)
  {
    lbc = gt_line_breaker_class_new(sizeof (GtLineBreakerBases),
                                    gt_line_breaker_bases_is_line_occupied,
                                    gt_line_breaker_bases_register_block,
                                    gt_line_breaker_bases_delete);
  }
  gt_class_alloc_lock_leave();
  return lbc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0xbf21a(%rip)     # 0x12fc40
jne 0x70a4c
leaq -0xc3(%rip), %rsi       # 0x7096c
leaq 0x24(%rip), %rdx        # 0x70a5a
leaq 0xea(%rip), %rcx        # 0x70b27
pushq $0x18
popq %rdi
callq 0x706a0
movq %rax, 0xbf1f4(%rip)     # 0x12fc40
callq 0x4f266
movq 0xbf1e8(%rip), %rax     # 0x12fc40
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_register_block
int gt_line_breaker_bases_register_block(GtLineBreaker *lb,
                                         GtLine *line,
                                         GtBlock *block,
                                         GT_UNUSED GtError *err)
{
  GtLineBreakerBases *lbb;
  GtIntervalTree *t;
  GtIntervalTreeNode *new_node;
  GtRange *rng;
  gt_assert(lb && block && line);
  lbb = gt_line_breaker_bases_cast(lb);
  rng = gt_block_get_range_ptr(block);
  new_node = gt_interval_tree_node_new(rng, rng->start, rng->end);
  if (!(t = gt_hashmap_get(lbb->itrees, line)))
  {
    t = gt_interval_tree_new(NULL);
    gt_hashmap_add(lbb->itrees, line, t);
  }
  gt_interval_tree_insert(t, new_node);
  return 0; /* gt_line_breaker_bases_register_block() is sane */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x70af1
movq %rdi, %r14
testq %rdi, %rdi
je 0x70af1
movq %rdx, %r15
testq %rdx, %rdx
je 0x70af1
movq %rsi, %rbx
callq 0x70a18
movq %rax, %rdi
movq %r14, %rsi
callq 0x70921
movq %rax, %r14
movq %r15, %rdi
callq 0x6b88e
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rax, %rdi
callq 0x57bc0
movq %rax, %r15
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x55ef6
movq %rax, %r12
testq %rax, %rax
jne 0x70ad8
xorl %edi, %edi
callq 0x57bf5
movq %rax, %r12
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x55f31
movq %r12, %rdi
movq %r15, %rsi
callq 0x57f19
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xbd4c0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x59564(%rip), %rsi     # 0xca066
leaq 0x6414e(%rip), %rdx     # 0xd4c57
leaq 0x6f5d7(%rip), %rcx     # 0xe00e7
leaq 0x6f5a6(%rip), %r8      # 0xe00bd
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_new
GtLineBreaker* gt_line_breaker_bases_new()
{
  GtLineBreakerBases *lbb;
  GtLineBreaker *lb;
  lb = gt_line_breaker_create(gt_line_breaker_bases_class());
  lbb = gt_line_breaker_bases_cast(lb);
  lbb->itrees = gt_hashmap_new(GT_HASH_DIRECT, NULL,
                               (GtFree) gt_interval_tree_delete);
  return lb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x70a18
movq %rax, %rdi
callq 0x706d7
movq %rax, %rbx
callq 0x70a18
movq %rax, %rdi
movq %rbx, %rsi
callq 0x70921
movq %rax, %r14
leaq -0x18aa7(%rip), %rdx    # 0x580d2
xorl %edi, %edi
xorl %esi, %esi
callq 0x55da4
movq %rax, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/regerror.c
// Function: tre_regerror
size_t
tre_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
{
  const char *err;
  size_t err_len;

  /*LINTED*/(void)&preg;
  if (errcode >= 0
      && errcode < (int)(sizeof(tre_error_messages)
			 / sizeof(*tre_error_messages)))
    err = gettext(tre_error_messages[errcode]);
  else
    err = gettext("Unknown error");

  err_len = strlen(err) + 1;
  if (errbuf_size > 0 && errbuf != NULL)
    {
      if (err_len > errbuf_size)
	{
	  strncpy(errbuf, err, errbuf_size - 1);
	  errbuf[errbuf_size - 1] = '\0';
	}
      else
	{
	  strcpy(errbuf, err);
	}
    }
  return err_len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
cmpl $0xd, %edi
ja 0x70bf9
movl %edi, %eax
leaq 0x6f51c(%rip), %rcx     # 0xe010c
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
jmp 0x70c00
leaq 0x6f544(%rip), %r15     # 0xe0144
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
incq %r12
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x70c45
cmpq %r14, %r12
jbe 0x70c3a
leaq -0x1(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2d0
movb $0x0, -0x1(%rbx,%r14)
jmp 0x70c45
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb600
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_ast_to_tnfa
static reg_errcode_t
tre_ast_to_tnfa(tre_ast_node_t *node, tre_tnfa_transition_t *transitions,
		int *counts, int *offs)
{
  tre_union_t *uni;
  tre_catenation_t *cat;
  tre_iteration_t *iter;
  reg_errcode_t errcode = REG_OK;

  /* XXX - recurse using a stack!. */
  switch (node->type)
    {
    case LITERAL:
      break;
    case UNION:
      uni = (tre_union_t *)node->obj;
      errcode = tre_ast_to_tnfa(uni->left, transitions, counts, offs);
      if (errcode != REG_OK)
	return errcode;
      errcode = tre_ast_to_tnfa(uni->right, transitions, counts, offs);
      break;

    case CATENATION:
      cat = (tre_catenation_t *)node->obj;
      /* Add a transition from each position in cat->left->lastpos
	 to each position in cat->right->firstpos. */
      errcode = tre_make_trans(cat->left->lastpos, cat->right->firstpos,
			       transitions, counts, offs);
      if (errcode != REG_OK)
	return errcode;
      errcode = tre_ast_to_tnfa(cat->left, transitions, counts, offs);
      if (errcode != REG_OK)
	return errcode;
      errcode = tre_ast_to_tnfa(cat->right, transitions, counts, offs);
      break;

    case ITERATION:
      iter = (tre_iteration_t *)node->obj;
      assert(iter->max == -1 || iter->max == 1);

      if (iter->max == -1)
	{
	  assert(iter->min == 0 || iter->min == 1);
	  /* Add a transition from each last position in the iterated
	     expression to each first position. */
	  errcode = tre_make_trans(iter->arg->lastpos, iter->arg->firstpos,
				   transitions, counts, offs);
	  if (errcode != REG_OK)
	    return errcode;
	}
      errcode = tre_ast_to_tnfa(iter->arg, transitions, counts, offs);
      break;
    }
  return errcode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x72cd9
cmpl $0x2, %eax
je 0x72cc1
cmpl $0x3, %eax
jne 0x72d4b
movq 0x8(%rdi), %r12
jmp 0x72d00
movq 0x8(%rdi), %r12
movl 0xc(%r12), %eax
cmpl $-0x1, %eax
je 0x72d1c
cmpl $0x1, %eax
je 0x72d42
jmp 0x72d59
movq 0x8(%rdi), %r12
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq 0x28(%rax), %rdi
movq 0x20(%rcx), %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x739a9
testl %eax, %eax
jne 0x72d4d
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x72c95
testl %eax, %eax
jne 0x72d4d
addq $0x8, %r12
jmp 0x72d42
cmpl $0x2, 0x8(%r12)
jae 0x72d78
movq (%r12), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x739a9
testl %eax, %eax
jne 0x72d4d
movq (%r12), %rdi
jmp 0x72ca6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6d8dc(%rip), %rdi     # 0xe063c
leaq 0x6d66c(%rip), %rsi     # 0xe03d3
leaq 0x6d8f0(%rip), %rcx     # 0xe065e
movl $0x721, %edx            # imm = 0x721
callq 0xb400
leaq 0x6d936(%rip), %rdi     # 0xe06b5
leaq 0x6d64d(%rip), %rsi     # 0xe03d3
leaq 0x6d8d1(%rip), %rcx     # 0xe065e
movl $0x725, %edx            # imm = 0x725
callq 0xb400
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_free
void
tre_free(regex_t *preg)
{
  tre_tnfa_t *tnfa;
  unsigned int i;
  tre_tnfa_transition_t *trans;

  tnfa = (void *)preg->TRE_REGEX_T_FIELD;
  if (!tnfa)
    return;

  for (i = 0; i < tnfa->num_transitions; i++)
    if (tnfa->transitions[i].state)
      {
	if (tnfa->transitions[i].tags)
	  xfree(tnfa->transitions[i].tags);
	if (tnfa->transitions[i].neg_classes)
	  xfree(tnfa->transitions[i].neg_classes);
	if (tnfa->transitions[i].params)
	  xfree(tnfa->transitions[i].params);
      }
  if (tnfa->transitions)
    xfree(tnfa->transitions);

  if (tnfa->initial)
    {
      for (trans = tnfa->initial; trans->state; trans++)
	{
	  if (trans->tags)
	    xfree(trans->tags);
	  if (trans->params)
	    xfree(trans->params);
	}
      xfree(tnfa->initial);
    }

  if (tnfa->submatch_data)
    {
      for (i = 0; i < tnfa->num_submatches; i++)
	if (tnfa->submatch_data[i].parents)
	  xfree(tnfa->submatch_data[i].parents);
      xfree(tnfa->submatch_data);
    }

  if (tnfa->tag_directions)
    xfree(tnfa->tag_directions);
  if (tnfa->firstpos_chars)
    xfree(tnfa->firstpos_chars);
  if (tnfa->minimal_tags)
    xfree(tnfa->minimal_tags);
  xfree(tnfa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x72e81
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0x8(%rbx), %eax
movq (%rbx), %rdi
cmpq %rax, %r15
jae 0x72def
cmpq $0x0, 0x8(%rdi,%r14)
je 0x72de6
movq 0x18(%rdi,%r14), %rdi
callq 0xb790
movq (%rbx), %rax
movq 0x38(%rax,%r14), %rdi
callq 0xb790
movq (%rbx), %rax
movq 0x20(%rax,%r14), %rdi
callq 0xb790
incq %r15
addq $0x40, %r14
jmp 0x72daf
callq 0xb790
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x72e28
addq $0x20, %r14
cmpq $0x0, -0x18(%r14)
je 0x72e1f
movq -0x8(%r14), %rdi
callq 0xb790
movq (%r14), %rdi
callq 0xb790
addq $0x40, %r14
jmp 0x72e01
movq 0x10(%rbx), %rdi
callq 0xb790
cmpq $0x0, 0x20(%rbx)
je 0x72e59
pushq $0x8
popq %r14
xorl %r15d, %r15d
movl 0x34(%rbx), %eax
movq 0x20(%rbx), %rdi
cmpq %rax, %r15
jae 0x72e54
movq (%rdi,%r14), %rdi
callq 0xb790
incq %r15
addq $0x10, %r14
jmp 0x72e36
callq 0xb790
movq 0x38(%rbx), %rdi
callq 0xb790
movq 0x28(%rbx), %rdi
callq 0xb790
movq 0x40(%rbx), %rdi
callq 0xb790
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb790
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_add_tag_left
static reg_errcode_t
tre_add_tag_left(tre_mem_t mem, tre_ast_node_t *node, int tag_id)
{
  tre_catenation_t *c;

  DPRINT(("add_tag_left: tag %d\n", tag_id));

  c = tre_mem_alloc(mem, sizeof(*c));
  if (c == NULL)
    return REG_ESPACE;
  c->left = tre_ast_new_literal(mem, TAG, tag_id, -1);
  if (c->left == NULL)
    return REG_ESPACE;
  c->right = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
  if (c->right == NULL)
    return REG_ESPACE;

  c->right->obj = node->obj;
  c->right->type = node->type;
  c->right->nullable = -1;
  c->right->submatch_id = -1;
  c->right->firstpos = NULL;
  c->right->lastpos = NULL;
  c->right->num_tags = 0;
  node->obj = c;
  node->type = CATENATION;
  return REG_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x10
popq %r8
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x75ecf
pushq $0xc
popq %rbp
testq %rax, %rax
je 0x72f7a
movq %rax, %r14
pushq $-0x3
popq %rsi
pushq $-0x1
popq %rcx
movq %r15, %rdi
movl %r12d, %edx
callq 0x95a69
movq %rax, (%r14)
testq %rax, %rax
je 0x72f7a
pushq $0x30
popq %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x75ecf
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x72f7a
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movl (%rbx), %ecx
movl %ecx, (%rax)
orq $-0x1, 0x10(%rax)
xorps %xmm0, %xmm0
andl $0x0, 0x2c(%rax)
movups %xmm0, 0x1c(%rax)
movq %r14, 0x8(%rbx)
movl $0x1, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq