LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/layout.c
// Function: gt_layout_sketch
int gt_layout_sketch(GtLayout *layout, GtCanvas *target_canvas, GtError *err)
{
  int had_err = 0;
  GtUword i;
  GtRenderTraverseInfo rti;
  gt_assert(layout && target_canvas);

  had_err = layout_all_tracks(layout, err);
  if (!had_err) {
    rti.layout = layout;
    rti.canvas = target_canvas;
    had_err = gt_canvas_visit_layout_pre(target_canvas, layout, err);
    if (had_err) return had_err;

    if (layout->track_ordering_func == NULL) {
      had_err = gt_hashmap_foreach_in_key_order(layout->tracks, render_tracks,
                                                &rti, err);
    } else {
      had_err = gt_hashmap_foreach_ordered(layout->tracks, render_tracks,
                                           &rti, (GtCompare) track_cmp_wrapper,
                                           err);
    }
    if (had_err) return had_err;
    had_err = gt_canvas_visit_layout_post(target_canvas, layout, err);
    if (had_err) return had_err;
    for (i=0;i<gt_array_size(layout->custom_tracks);i++)
    {
      GtCustomTrack *ct = *(GtCustomTrack**) gt_array_get(layout->custom_tracks,
                                                          i);
      had_err = render_custom_tracks(NULL, ct, &rti, err);
    }
  }
  return had_err ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x52849
movq %rsi, %r15
testq %rsi, %rsi
je 0x52849
movq %rdx, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x52853
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x5283e
movq %r14, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4cb47
testl %eax, %eax
jne 0x5283e
cmpq $0x0, 0x58(%r14)
movq 0x20(%r14), %rdi
leaq 0x105(%rip), %rsi       # 0x528b9
je 0x527cc
leaq 0x11d(%rip), %rcx       # 0x528da
leaq 0x8(%rsp), %rdx
movq %rbx, %r8
callq 0x77193
jmp 0x527d9
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x7721f
testl %eax, %eax
jne 0x5283e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4cb68
testl %eax, %eax
jne 0x5283e
movq 0x18(%r14), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x5283c
xorl %r15d, %r15d
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5284e
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x8e42c
movl %eax, %ebp
incq %r15
movq 0x18(%r14), %rdi
callq 0x6ecda
cmpq %rax, %r15
jb 0x52800
xorl %eax, %eax
negl %ebp
sbbl %eax, %eax
jmp 0x5283e
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1750d
callq 0x17546
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/layout.c
// Function: layout_all_tracks
static int layout_all_tracks(GtLayout *layout, GtError *err)
{
  int had_err = 0;
  GtLayoutTraverseInfo lti;
  gt_assert(layout && layout->blocks);
  gt_error_check(err);

  if (!layout->layout_done) {
    lti.layout = layout;
    lti.twc = layout->twc;
    had_err = gt_hashmap_foreach(layout->blocks, layout_tracks, &lti, err);
    layout->layout_done = true;
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x528af
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x52878
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x528b4
xorl %eax, %eax
cmpb $0x0, 0x11(%rbx)
jne 0x528a7
leaq 0x8(%rsp), %rdx
movq %rbx, 0x8(%rdx)
movq 0x8(%rbx), %rax
movq %rax, (%rdx)
movq 0x28(%rbx), %rdi
leaq 0x461(%rip), %rsi       # 0x52cfc
movq %r14, %rcx
callq 0x771f5
movb $0x1, 0x11(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x175b8
callq 0x1757f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/layout.c
// Function: blocklist_block_compare
static int blocklist_block_compare(const void *item1, const void *item2,
                                   void *data)
{
  gt_assert(item1 && item2);
  GtLayout *l = (GtLayout*) data;
  return l->block_ordering_func(*(GtBlock**) item1, *(GtBlock**) item2,
                                l->b_cmp_data);
}

// Assembly:
testq %rdi, %rdi
je 0x52f4d
testq %rsi, %rsi
je 0x52f4d
movq (%rdi), %rdi
movq (%rsi), %rsi
movq 0x60(%rdx), %rax
movq 0x70(%rdx), %rdx
jmpq *%rax
pushq %rax
callq 0x17829
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_captions.c
// Function: calculate_drawing_range
int calculate_drawing_range(GtLineBreakerCaptions *lbc, GtDrawingRange *rng,
                            GtBlock* block, GtError *err)
{
  double textwidth = 0.0;
  GtDrawingRange drange;
  gt_assert(block && lbc);
  drange = gt_coords_calc_generic_range(gt_block_get_range(block),
                                        gt_layout_get_range(lbc->layout));
  drange.start *= lbc->width-2*lbc->margins;
  drange.end *= lbc->width-2*lbc->margins;
  if (gt_block_get_caption(block))
  {
    textwidth = gt_text_width_calculator_get_text_width(
                                      gt_layout_get_twc(lbc->layout),
                                      gt_str_get(gt_block_get_caption(block)),
                                      err);
    if (gt_double_smaller_double(textwidth, 0))
      return -1;
    if (gt_double_smaller_double(gt_drawing_range_length(drange), textwidth))
      drange.end = drange.start + textwidth;
  }
  rng->start = drange.start;
  rng->end = drange.end;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
testq %rdi, %rdi
je 0x530a1
movq %rdx, %r15
testq %rdx, %rdx
je 0x530a1
movq %rcx, %r14
movq %rdi, %r12
movq %r15, %rdi
callq 0x8ac4f
movq %rax, %r13
movq %rdx, %rbp
movq 0x10(%r12), %rdi
callq 0x52960
movq %rdx, %r8
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x8e1f4
movsd 0x18(%r12), %xmm0
unpcklps 0x8e4bf(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8e4c7(%rip), %xmm0    # 0xe1490
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x20(%r12), %xmm0
addsd %xmm0, %xmm0
subsd %xmm0, %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd (%rbx), %xmm1
movapd %xmm1, (%rbx)
movq %r15, %rdi
callq 0x8ac63
testq %rax, %rax
je 0x53081
movq 0x10(%r12), %rdi
callq 0x52974
movq %rax, %rbx
movq %r15, %rdi
callq 0x8ac63
movq %rax, %rdi
callq 0x3c40b
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x55e11
xorpd %xmm1, %xmm1
movsd %xmm0, 0x18(%rsp)
callq 0x7a0a0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
jne 0x53092
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movapd 0x20(%rsp), %xmm0
movupd %xmm0, (%rsp)
callq 0x8e59b
movsd 0x18(%rsp), %xmm1
callq 0x7a0a0
testb %al, %al
je 0x53081
movsd 0x18(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movapd 0x20(%rsp), %xmm0
movq 0x40(%rsp), %rax
movupd %xmm0, (%rax)
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x17860
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_captions.c
// Function: gt_line_breaker_captions_is_line_occupied
int gt_line_breaker_captions_is_line_occupied(GtLineBreaker* lb, bool *result,
                                              GtLine *line, GtBlock *block,
                                              GtError *err)
{
  GtDrawingRange dr;
  GtLineBreakerCaptions *lbcap;
  int had_err = 0;
  double *num;
  gt_assert(lb && block && line);
  lbcap = gt_line_breaker_captions_cast(lb);
  had_err = calculate_drawing_range(lbcap, &dr, block, err);
  if (!had_err) {
    if (!(num = gt_hashmap_get(lbcap->linepositions, line)))
      *result = false;
    else
      *result = (dr.start <= *num);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0x53130
movq %rdi, %r13
testq %rdi, %rdi
je 0x53130
movq %rcx, %r12
testq %rcx, %rcx
je 0x53130
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %rbx
callq 0x53135
movq %rax, %rdi
movq %r13, %rsi
callq 0x8f81a
movq %rax, %r13
movq %rsp, %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x52f54
movl %eax, %ebp
testl %eax, %eax
jne 0x5311f
movq 0x28(%r13), %rdi
movq %r14, %rsi
callq 0x77109
testq %rax, %rax
je 0x5311b
movsd (%rax), %xmm0
ucomisd (%rsp), %xmm0
setae %al
jmp 0x5311d
xorl %eax, %eax
movb %al, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x17897
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_captions.c
// Function: gt_line_breaker_captions_class
const GtLineBreakerClass* gt_line_breaker_captions_class(void)
{
  static const GtLineBreakerClass *lbc = NULL;
  gt_class_alloc_lock_enter();
  if (!lbc)
  {
    lbc = gt_line_breaker_class_new(sizeof (GtLineBreakerCaptions),
                                   gt_line_breaker_captions_is_line_occupied,
                                   gt_line_breaker_captions_register_block,
                                   gt_line_breaker_captions_delete);
  }
  gt_class_alloc_lock_leave();
  return lbc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0xffa5d(%rip)     # 0x152ba0
jne 0x5316b
leaq -0xa6(%rip), %rsi       # 0x530a6
leaq 0x26(%rip), %rdx        # 0x53179
leaq 0xe6(%rip), %rcx        # 0x53240
movl $0x30, %edi
callq 0x8f68c
movq %rax, 0xffa35(%rip)     # 0x152ba0
callq 0x71db1
movq 0xffa29(%rip), %rax     # 0x152ba0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_captions.c
// Function: gt_line_breaker_captions_register_block
int gt_line_breaker_captions_register_block(GtLineBreaker *lb,
                                            GtLine *line,
                                            GtBlock *block,
                                            GtError *err)
{
  GtDrawingRange dr;
  GtLineBreakerCaptions *lbcap;
  int had_err = 0;
  double *num;
  gt_assert(lb && block && line);
  lbcap = gt_line_breaker_captions_cast(lb);
  if (!(num = gt_hashmap_get(lbcap->linepositions, line)))
  {
    num = gt_calloc(1, sizeof (double));
    gt_hashmap_add(lbcap->linepositions, line, num);
  }
  had_err = calculate_drawing_range(lbcap, &dr, block, err);
  if (!had_err)
    *num = floor(dr.end);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x5323b
movq %rdi, %r12
testq %rdi, %rdi
je 0x5323b
movq %rdx, %r14
testq %rdx, %rdx
je 0x5323b
movq %rcx, %rbx
movq %rsi, %r15
callq 0x53135
movq %rax, %rdi
movq %r12, %rsi
callq 0x8f81a
movq %rax, %r13
movq 0x28(%rax), %rdi
movq %r15, %rsi
callq 0x77109
movq %rax, %r12
testq %rax, %rax
jne 0x53201
leaq 0x98aaf(%rip), %rdx     # 0xebc8a
movl $0x1, %edi
movl $0x8, %esi
movl $0x64, %ecx
callq 0x3601f
movq %rax, %r12
movq 0x28(%r13), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x77144
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x52f54
movl %eax, %ebx
testl %eax, %eax
jne 0x5322b
movsd 0x10(%rsp), %xmm0
callq 0xbac0
movsd %xmm0, (%r12)
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x178ce
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_captions.c
// Function: gt_line_breaker_captions_new
GtLineBreaker* gt_line_breaker_captions_new(GtLayout *layout,
                                            GtUword width,
                                            GtStyle *style)
{
  GtLineBreakerCaptions *lbcap;
  GtLineBreaker *lb;
  gt_assert(layout);
  lb = gt_line_breaker_create(gt_line_breaker_captions_class());
  lbcap = gt_line_breaker_captions_cast(lb);
  lbcap->layout = layout;
  lbcap->width = width;
  if (!gt_style_get_num(style, "format", "margins", &lbcap->margins,
                        NULL, NULL)) {
    lbcap->margins = MARGINS_DEFAULT;
  }
  lbcap->linepositions = gt_hashmap_new(GT_HASH_DIRECT, NULL, gt_free_func);
  return lb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x53303
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x53135
movq %rax, %rdi
callq 0x8f6c5
movq %rax, %rbx
callq 0x53135
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8f81a
movq %rax, %r14
movq %r13, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r12
addq $0x20, %r12
leaq 0x8dede(%rip), %rsi     # 0xe1196
leaq 0x981c9(%rip), %rdx     # 0xeb488
movq %r15, %rdi
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x545d2
testl %eax, %eax
jne 0x532e2
movabsq $0x403e000000000000, %rax # imm = 0x403E000000000000
movq %rax, (%r12)
leaq -0x1cf8a(%rip), %rdx    # 0x3635f
xorl %edi, %edi
xorl %esi, %esi
callq 0x76f28
movq %rax, 0x28(%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x17905
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/rec_map.c
// Function: gt_rec_map_new
GtRecMap* gt_rec_map_new(double nw_x, double nw_y, double se_x, double se_y,
                         GtFeatureNode *node)
{
  GtRecMap *rm = gt_calloc(1, sizeof (GtRecMap));
  rm->nw_x = nw_x;
  rm->nw_y = nw_y;
  rm->se_x = se_x;
  rm->se_y = se_y;
  rm->fn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) node);
  rm->has_omitted_children = false;
  return rm;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x98a09(%rip), %rdx     # 0xebd3a
movl $0x1, %edi
movl $0x38, %esi
movl $0x23, %ecx
callq 0x3601f
movq %rax, %r14
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)
movq %rbx, %rdi
callq 0x41ca0
movq %rax, 0x20(%r14)
movb $0x0, 0x28(%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/rec_map.c
// Function: gt_rec_map_delete
void gt_rec_map_delete(GtRecMap *rm)
{
  if (!rm) return;
  if (rm->reference_count) {
    rm->reference_count--;
    return;
  }
  gt_genome_node_delete((GtGenomeNode*) rm->fn);
  gt_free(rm);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x53467
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x53469
decq %rax
movq %rax, 0x30(%rbx)
popq %rbx
retq
movq 0x20(%rbx), %rdi
callq 0x42ade
leaq 0x988c1(%rip), %rsi     # 0xebd3a
movq %rbx, %rdi
movl $0x6e, %edx
popq %rbx
jmp 0x362a0
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_new
GtStyle* gt_style_new(GtError *err)
{
  GtStyle *sty;
  GtStr *default_formats;
  int had_err = 0;
  gt_error_check(err);

  sty = gt_calloc(1, sizeof (GtStyle));
  sty->filename = NULL;
  sty->L = luaL_newstate();
  if (!sty->L) {
    gt_error_set(err, "out of memory (cannot create new Lua state)");
    gt_free(sty);
    return NULL;
  }
  else
    luaL_opencustomlibs(sty->L, luasecurelibs);
  sty->lock = gt_rwlock_new();
  sty->unsafe = false;
  sty->clone_lock = gt_rwlock_new();

  default_formats = gt_str_new_cstr(gt_default_format_style);
  had_err = gt_style_load_str(sty, default_formats, err);
  gt_assert(!had_err && !gt_error_is_set(err)); /* default style must run */
  gt_str_delete(default_formats);
  return (!had_err ? sty : NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x534a5
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x53569
leaq 0x98a49(%rip), %rdx     # 0xebef5
movl $0x1, %edi
movl $0x30, %esi
movl $0x83, %ecx
callq 0x3601f
movq %rax, %rbx
movq $0x0, 0x28(%rax)
callq 0x5bfe8
movq %rax, (%rbx)
testq %rax, %rax
je 0x53534
leaq 0xfb431(%rip), %rsi     # 0x14e910
movq %rax, %rdi
callq 0x5356e
callq 0x3d8a7
movq %rax, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
callq 0x3d8a7
movq %rax, 0x18(%rbx)
leaq 0x992d7(%rip), %rdi     # 0xec7db
callq 0x3c03d
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x535ba
testl %eax, %eax
jne 0x53564
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x53564
movq %r15, %rdi
callq 0x3d1eb
jmp 0x5355b
leaq 0x95598(%rip), %rsi     # 0xe8ad3
movq %r14, %rdi
xorl %eax, %eax
callq 0x3559f
leaq 0x989a9(%rip), %rsi     # 0xebef5
movq %rbx, %rdi
movl $0x88, %edx
callq 0x362a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x17b66
callq 0x17b2d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: luaL_opencustomlibs
static void luaL_opencustomlibs(lua_State *L, const luaL_Reg *lib)
{
  for (; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_pushstring(L, lib->name);
    lua_call(L, 1, 0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x535b2
movq %rdi, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x58930
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x58568
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x5948a
movq 0x18(%rbx), %rsi
addq $0x10, %rbx
testq %rsi, %rsi
jne 0x53581
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_load_str
int gt_style_load_str(GtStyle *sty, GtStr *instr, GtError *err)
{
#ifndef NDEBUG
  int stack_size;
#endif
  int had_err = 0;
  gt_error_check(err);
  gt_assert(sty && instr);
  gt_rwlock_wrlock(sty->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);;
#endif
  if (luaL_loadbuffer(sty->L, gt_str_get(instr), gt_str_length(instr), "str") ||
      lua_pcall(sty->L, 0, 0, 0)) {
    gt_error_set(err, "cannot run style buffer: %s",
              lua_tostring(sty->L, -1));
    had_err = -1;
    lua_pop(sty->L, 1);
  }
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x535e3
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x536b3
testq %rbx, %rbx
je 0x536a9
testq %r15, %r15
je 0x536a9
movq 0x10(%rbx), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %ebp
movq (%rbx), %r12
movq %r15, %rdi
callq 0x3c40b
movq %rax, %r13
movq %r15, %rdi
callq 0x3c434
leaq 0x903b1(%rip), %rcx     # 0xe39d6
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5bf6e
testl %eax, %eax
jne 0x5364c
movq (%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x59536
testl %eax, %eax
je 0x53682
movq (%rbx), %rdi
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58042
leaq 0x98c4a(%rip), %rsi     # 0xec2b2
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3559f
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq (%rbx), %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x536ae
movq 0x10(%rbx), %rdi
callq 0x3d94f
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x17bd8
callq 0x17c11
callq 0x17b9f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_new_with_state
GtStyle* gt_style_new_with_state(lua_State *L)
{
  GtStyle *sty;
  gt_assert(L && !lua_gettop(L)); /* make sure the Lua stack is empty */
  sty = gt_calloc(1, sizeof (GtStyle));
  sty->L = L;
  sty->unsafe = true;
  sty->lock = gt_rwlock_new();
  return sty;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x53706
movq %rdi, %rbx
callq 0x578c5
testl %eax, %eax
jne 0x53706
leaq 0x98821(%rip), %rdx     # 0xebef5
movl $0x1, %edi
movl $0x30, %esi
movl $0x9c, %ecx
callq 0x3601f
movq %rax, %r14
movq %rbx, (%rax)
movb $0x1, 0x20(%rax)
callq 0x3d8a7
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x17c4a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_ref
GtStyle* gt_style_ref(GtStyle *style)
{
  gt_assert(style);
  gt_rwlock_wrlock(style->lock);
  style->reference_count++;
  gt_rwlock_unlock(style->lock);
  return style;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x5372f
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
incq 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x3d94f
movq %rbx, %rax
popq %rbx
retq
callq 0x17c83
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_unsafe_mode
void gt_style_unsafe_mode(GtStyle *style)
{
  gt_assert(style);
  gt_rwlock_wrlock(style->lock);
  luaL_opencustomlibs(style->L, luainsecurelibs);
  style->unsafe = true;
  gt_rwlock_unlock(style->lock);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x53763
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq (%rbx), %rdi
leaq 0xfb220(%rip), %rsi     # 0x14e970
callq 0x5356e
movb $0x1, 0x20(%rbx)
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x3d94f
callq 0x17cbc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_safe_mode
void gt_style_safe_mode(GtStyle *style)
{
#ifndef NDEBUG
  int stack_size;
#endif
  const luaL_Reg *lib = luainsecurelibs;
  gt_assert(style);
  gt_rwlock_wrlock(style->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(style->L);
#endif
  for (; lib->name; lib++) {
    lua_pushnil(style->L);
    lua_setglobal(style->L, lib->name);
  }
  style->unsafe = false;
  gt_assert(lua_gettop(style->L) == stack_size);
  gt_rwlock_unlock(style->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x537df
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %ebp
leaq 0x9b271(%rip), %r14     # 0xeea02
leaq 0xfb1e8(%rip), %r15     # 0x14e980
movq (%rbx), %rdi
callq 0x5834e
movq (%rbx), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x59137
movq (%r15), %r14
addq $0x10, %r15
testq %r14, %r14
jne 0x53798
movb $0x0, 0x20(%rbx)
movq (%rbx), %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x537e4
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3d94f
callq 0x17d2e
callq 0x17cf5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_is_unsafe
bool gt_style_is_unsafe(GtStyle *sty)
{
#ifndef NDEBUG
  int stack_size;
#endif
  const luaL_Reg *lib = luainsecurelibs;
  bool safe = true;
  gt_assert(sty);
  gt_rwlock_wrlock(sty->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);
#endif
  for (; safe && lib->name; lib++) {
    lua_getglobal(sty->L, lib->name);
    if (!lua_isnil(sty->L, -1)) {
      safe = false;
    }
    lua_pop(sty->L, 1);
  }
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
  return !safe;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x53890
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %r14d
movb $0x1, %bpl
leaq 0x9b1e7(%rip), %rdx     # 0xeea02
leaq 0xfb15e(%rip), %r15     # 0x14e980
xorl %r12d, %r12d
movq (%rbx), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
movzbl %bpl, %ebp
cmovnel %r12d, %ebp
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
testb $0x1, %bpl
je 0x53868
movq (%r15), %rdx
addq $0x10, %r15
testq %rdx, %rdx
jne 0x53825
movq (%rbx), %rdi
callq 0x578c5
cmpl %r14d, %eax
jne 0x53895
movq 0x10(%rbx), %rdi
callq 0x3d94f
notb %bpl
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x17da0
callq 0x17d67
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_load_file
int gt_style_load_file(GtStyle *sty, const char *filename, GtError *err)
{
#ifndef NDEBUG
  int stack_size;
#endif
  int had_err = 0;
  gt_error_check(err);
  gt_rwlock_wrlock(sty->lock);
  gt_assert(sty && sty->L && filename);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);
#endif
  gt_rwlock_unlock(sty->lock);
  gt_rwlock_wrlock(sty->lock);
  sty->filename = gt_cstr_dup(filename);
  gt_log_log("Trying to load style file: %s...", filename);
  if (luaL_loadfile(sty->L, filename) || lua_pcall(sty->L, 0, 0, 0)) {
    gt_error_set(err, "cannot run style file: %s", lua_tostring(sty->L, -1));
    had_err = -1;
    lua_pop(sty->L, 1);
  }
  if (!had_err) {
    lua_getglobal(sty->L, "style");
    if (lua_isnil(sty->L, -1) || !lua_istable(sty->L, -1)) {
      gt_error_set(err, "'style' is not defined or is not a table in \"%s\"",
                   filename);
      had_err = -1;
    }
    lua_pop(sty->L, 1);
  }
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x538c0
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x539f8
movq 0x10(%rbx), %rdi
callq 0x3d934
testq %rbx, %rbx
je 0x539ee
testq %r15, %r15
je 0x539ee
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x539ee
callq 0x578c5
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x3d94f
movq 0x10(%rbx), %rdi
callq 0x3d934
movq %r15, %rdi
callq 0x722dc
movq %rax, 0x28(%rbx)
leaq 0x98706(%rip), %rdi     # 0xec019
movq %r15, %rsi
xorl %eax, %eax
callq 0x35a32
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x5bcaf
testl %eax, %eax
jne 0x5393e
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x59536
testl %eax, %eax
je 0x53995
movq (%rbx), %rdi
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58042
leaq 0x986e0(%rip), %rsi     # 0xec03a
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3559f
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq (%rbx), %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x539f3
movq 0x10(%rbx), %rdi
callq 0x3d94f
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0xaacc9(%rip), %rdx     # 0xfe668
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
je 0x539cf
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
xorl %r12d, %r12d
cmpl $0x5, %eax
je 0x53967
leaq 0x9867e(%rip), %rsi     # 0xec054
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x53967
callq 0x17e4b
callq 0x17e12
callq 0x17dd9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_reload
void gt_style_reload(GtStyle *sty)
{
  GT_UNUSED int rval;
  gt_assert(sty && sty->filename);
  rval = gt_style_load_file(sty, sty->filename, NULL);
  gt_assert(!rval); /* should not happen, file was loaded before */
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x53a19
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x53a19
xorl %edx, %edx
callq 0x5389a
testl %eax, %eax
jne 0x53a1e
popq %rax
retq
callq 0x17ebd
callq 0x17e84
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: style_find_section_for_getting
static int style_find_section_for_getting(const GtStyle *sty,
                                          const char *section)
{
  int depth = 0;
  gt_assert(sty && section);
  lua_getglobal(sty->L, "style");
  if (lua_isnil(sty->L, -1)) {
    gt_log_log("'style' is not defined");
    lua_pop(sty->L, 1);
    return -1;
  } else depth++;
  lua_getfield(sty->L, -1, section);
  if (lua_isnil(sty->L, -1) || !lua_istable(sty->L, -1)) {
    lua_pop(sty->L, 2);
    return -1;
  } else depth++;
  return depth;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xaa8b2(%rip), %rdx     # 0xfe668
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
je 0x53e12
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x58b98
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
testl %eax, %eax
je 0x53e25
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
movl %eax, %ecx
movl $0x2, %eax
cmpl $0x5, %ecx
jne 0x53e25
jmp 0x53e34
leaq 0x98ce1(%rip), %rdi     # 0xecafa
xorl %eax, %eax
callq 0x35a32
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x578d2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: style_find_section_for_setting
static int style_find_section_for_setting(GtStyle* sty, const char *section)
{
  int depth = 0;
  gt_assert(sty && section);
  lua_getglobal(sty->L, "style");
  if (lua_isnil(sty->L, -1)) {
    lua_pop(sty->L, 1);
    lua_newtable(sty->L);
    lua_setglobal(sty->L, "style");
    lua_getglobal(sty->L, "style");
  }
  depth++;
  lua_getfield(sty->L, -1, section);
  if (lua_isnil(sty->L, -1)) {
    lua_pop(sty->L, 1);
    style_lua_new_table(sty->L, section);
    lua_getfield(sty->L, -1, section);
  }
  depth++;
  return depth;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0xaa673(%rip), %rdx     # 0xfe668
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
jne 0x54050
movq (%r14), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq (%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq (%r14), %rdi
leaq 0xaa635(%rip), %r15     # 0xfe668
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r15, %rdx
callq 0x59137
movq (%r14), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r15, %rdx
callq 0x58b98
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
callq 0x58b98
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
je 0x54077
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x540a4
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x58b98
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_set_str
void gt_style_set_str(GtStyle *sty, const char *section, const char *key,
                      GtStr *value)
{
#ifndef NDEBUG
  int stack_size;
#endif
  int i = 0;
  gt_assert(sty && section && key && value);
  gt_rwlock_wrlock(sty->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);
#endif
  i = style_find_section_for_setting(sty, section);
  lua_pushstring(sty->L, key);
  lua_pushstring(sty->L, gt_str_get(value));
  lua_settable(sty->L, -3);
  lua_pop(sty->L, i);
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x543aa
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x53fe0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x58568
movq (%rbx), %r15
movq %r14, %rdi
callq 0x3c40b
movq %r15, %rdi
movq %rax, %rsi
callq 0x58568
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x578d2
movq (%rbx), %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x543af
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3d94f
callq 0x18214
callq 0x1824d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_set_num
void gt_style_set_num(GtStyle *sty, const char *section, const char *key,
                    double number)
{
#ifndef NDEBUG
  int stack_size;
#endif
  int i = 0;
  gt_assert(sty && section && key);
  gt_rwlock_wrlock(sty->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);
#endif
  i = style_find_section_for_setting(sty, section);
  lua_pushstring(sty->L, key);
  lua_pushnumber(sty->L, number);
  lua_settable(sty->L, -3);
  lua_pop(sty->L, i);
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
testq %rdi, %rdi
je 0x54681
movq %rsi, %r15
testq %rsi, %rsi
je 0x54681
movq %rdx, %r14
testq %rdx, %rdx
je 0x54681
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x53fe0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x58568
movq (%rbx), %rdi
movsd (%rsp), %xmm0
callq 0x58362
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x578d2
movq (%rbx), %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x54686
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3d94f
callq 0x183dc
callq 0x18415
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_set_bool
void gt_style_set_bool(GtStyle *sty, const char *section, const char *key,
                       bool val)
{
#ifndef NDEBUG
  int stack_size;
#endif
  int i = 0;
  gt_assert(sty && section && key);
  gt_rwlock_wrlock(sty->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);
#endif
  i = style_find_section_for_setting(sty, section);
  lua_pushstring(sty->L, key);
  lua_pushboolean(sty->L, val);
  lua_settable(sty->L, -3);
  lua_pop(sty->L, i);
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5492d
movq %rsi, %r12
testq %rsi, %rsi
je 0x5492d
movq %rdx, %r15
testq %rdx, %rdx
je 0x5492d
movl %ecx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x53fe0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x58568
movq (%rbx), %rdi
movzbl %bpl, %esi
callq 0x58a14
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x578d2
movq (%rbx), %rdi
callq 0x578c5
cmpl %r14d, %eax
jne 0x54932
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3d94f
callq 0x185a4
callq 0x185dd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_unset
void gt_style_unset(GtStyle *sty, const char *section, const char *key)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(sty && section && key);
  gt_rwlock_wrlock(sty->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);
#endif
  lua_getglobal(sty->L, "style");
  if (!lua_isnil(sty->L, -1)) {
    gt_assert(lua_istable(sty->L, -1));
    lua_getfield(sty->L, -1, section);
    if (!lua_isnil(sty->L, -1)) {
      gt_assert(lua_istable(sty->L, -1));
      lua_pushstring(sty->L, key);
      lua_pushnil(sty->L);
      lua_settable(sty->L, -3);
    }
    lua_pop(sty->L, 1);
  }
  lua_pop(sty->L, 1);
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x54a3c
movq %rsi, %r15
testq %rsi, %rsi
je 0x54a3c
movq %rdx, %r14
testq %rdx, %rdx
je 0x54a3c
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0xa9ce9(%rip), %rdx     # 0xfe668
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
je 0x54a10
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
cmpl $0x5, %eax
jne 0x54a46
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x58b98
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
je 0x54a03
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
cmpl $0x5, %eax
jne 0x54a4b
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x58568
movq (%rbx), %rdi
callq 0x5834e
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq (%rbx), %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x54a41
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3d94f
callq 0x18616
callq 0x186c1
callq 0x1864f
callq 0x18688
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_to_str
int gt_style_to_str(const GtStyle *sty, GtStr *outstr, GtError *err)
{
#ifndef NDEBUG
  int stack_size;
#endif
  int had_err = 0;
  gt_error_check(err);
  gt_assert(sty && outstr);
  gt_rwlock_wrlock(sty->lock);
#ifndef NDEBUG
  stack_size = lua_gettop(sty->L);
#endif
  lua_getglobal(sty->L, "style");
  gt_str_append_cstr(outstr, "style = {\n");
  if (lua_istable(sty->L, -1))
    had_err = gt_lua_table_to_str(sty->L, outstr, -1, err);
  else {
    gt_error_set(err, "'style' must be a table. Check whether a top-level"
                      "table of this name exists.");
    had_err = -1;
  }
  gt_str_append_cstr(outstr, "}");
  lua_pop(sty->L, 1);
  gt_assert(lua_gettop(sty->L) == stack_size);
  gt_rwlock_unlock(sty->lock);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x54a76
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0x54b46
testq %rbx, %rbx
je 0x54b3c
testq %r14, %r14
je 0x54b3c
movq 0x10(%rbx), %rdi
callq 0x3d934
movq (%rbx), %rdi
callq 0x578c5
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0xa9bc3(%rip), %rdx     # 0xfe668
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x58b98
leaq 0x97785(%rip), %rsi     # 0xec23b
movq %r14, %rdi
callq 0x3c067
movq (%rbx), %rdi
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
cmpl $0x5, %eax
jne 0x54aee
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0x8604c
movl %eax, %r12d
jmp 0x54aff
leaq 0x97751(%rip), %rsi     # 0xec246
movq %r15, %rdi
xorl %eax, %eax
callq 0x3559f
leaq 0x97fe7(%rip), %rsi     # 0xecaed
movq %r14, %rdi
callq 0x3c067
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq (%rbx), %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x54b41
movq 0x10(%rbx), %rdi
callq 0x3d94f
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x18733
callq 0x1876c
callq 0x186fa
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_clone
GtStyle* gt_style_clone(const GtStyle *sty, GtError *err)
{
  int had_err = 0;
  GtStr *sty_buffer = gt_str_new();
  GtStyle *new_sty;
  gt_assert(sty);
  if (!(new_sty = gt_style_new(err)))
    had_err = -1;
  gt_rwlock_wrlock(sty->clone_lock);
  if (!had_err)
    had_err = gt_style_to_str(sty, sty_buffer, err);
  if (!had_err)
    had_err = gt_style_load_str(new_sty, sty_buffer, err);
  gt_rwlock_unlock(sty->clone_lock);
  gt_str_delete(sty_buffer);
  if (had_err) {
    gt_style_delete(new_sty);
    return NULL;
  } else return new_sty;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0x3bfe0
testq %r15, %r15
je 0x54bdf
movq %rax, %r14
movq %r12, %rdi
callq 0x53488
movq %rax, %rbx
movq 0x18(%r15), %rdi
callq 0x3d934
testq %rbx, %rbx
je 0x54b91
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x54a50
testl %eax, %eax
je 0x54bb8
movq 0x18(%r15), %rdi
callq 0x3d94f
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rdi
callq 0x54be4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x535ba
movl %eax, %ebp
movq 0x18(%r15), %rdi
callq 0x3d94f
movq %r14, %rdi
callq 0x3d1eb
testl %ebp, %ebp
jne 0x54ba2
jmp 0x54bac
callq 0x187a5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_delete
void gt_style_delete(GtStyle *style)
{
  if (!style) return;
  gt_rwlock_wrlock(style->lock);
  if (style->reference_count)
  {
    style->reference_count--;
    gt_rwlock_unlock(style->lock);
    return;
  }
  if (style->L) lua_close(style->L);
  gt_rwlock_unlock(style->lock);
  gt_style_delete_without_state(style);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x54c10
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x54c12
decq %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x3d94f
popq %rbx
retq
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x54c1f
callq 0x5ac59
movq 0x10(%rbx), %rdi
callq 0x3d94f
movq %rbx, %rdi
popq %rbx
jmp 0x55c23
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/style.c
// Function: gt_style_delete_without_state
void gt_style_delete_without_state(GtStyle *sty)
{
  if (!sty) return;
  gt_rwlock_wrlock(sty->lock);
  if (sty->reference_count)
  {
    sty->reference_count--;
    gt_rwlock_unlock(sty->lock);
    return;
  }
  gt_free(sty->filename);
  gt_rwlock_unlock(sty->lock);
  gt_rwlock_delete(sty->lock);
  gt_rwlock_delete(sty->clone_lock);
  gt_free(sty);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x55c58
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x55c60
decq %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d94f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x28(%rbx), %rdi
leaq 0x9628a(%rip), %r14     # 0xebef5
movq %r14, %rsi
movl $0x3c2, %edx            # imm = 0x3C2
callq 0x362a0
movq 0x10(%rbx), %rdi
callq 0x3d94f
movq 0x10(%rbx), %rdi
callq 0x3d8f7
movq 0x18(%rbx), %rdi
callq 0x3d8f7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3c6, %edx            # imm = 0x3C6
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/text_width_calculator.c
// Function: gt_text_width_calculator_class_new
const GtTextWidthCalculatorClass* gt_text_width_calculator_class_new(
                                 size_t size,
                                 TextWidthCalculatorGetTextWidth get_text_width,
                                 TextWidthCalculatorFreeFunc free)
{
  GtTextWidthCalculatorClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->get_text_width = get_text_width;
  c_class->free = free;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x71ca4
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/text_width_calculator.c
// Function: gt_text_width_calculator_create
GtTextWidthCalculator* gt_text_width_calculator_create(
                                         const GtTextWidthCalculatorClass *twcc)
{
  GtTextWidthCalculator *twc;
  gt_assert(twcc && twcc->size);
  twc = gt_calloc(1, twcc->size);
  twc->c_class = twcc;
  twc->pvt = gt_calloc(1, sizeof (GtTextWidthCalculatorMembers));
  twc->pvt->lock = gt_rwlock_new();
  return twc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x55d3a
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x55d3a
leaq 0x96e53(%rip), %r14     # 0xecb44
movl $0x1, %edi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x3601f
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r14, %rdx
movl $0x38, %ecx
callq 0x3601f
movq %rax, 0x8(%r15)
callq 0x3d8a7
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x18817
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/text_width_calculator.c
// Function: gt_text_width_calculator_ref
GtTextWidthCalculator* gt_text_width_calculator_ref(GtTextWidthCalculator *twc)
{
  gt_assert(twc);
  gt_rwlock_wrlock(twc->pvt->lock);
  twc->pvt->reference_count++;
  gt_rwlock_unlock(twc->pvt->lock);
  return twc;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x55d69
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x3d94f
movq %rbx, %rax
popq %rbx
retq
callq 0x1884e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/text_width_calculator.c
// Function: gt_text_width_calculator_delete
void gt_text_width_calculator_delete(GtTextWidthCalculator *twc)
{
  if (!twc) return;
  gt_rwlock_wrlock(twc->pvt->lock);
  if (twc->pvt->reference_count) {
    twc->pvt->reference_count--;
    gt_rwlock_unlock(twc->pvt->lock);
    return;
  }
  gt_assert(twc->c_class);
  if (twc->c_class->free)
    twc->c_class->free(twc);
  gt_rwlock_unlock(twc->pvt->lock);
  gt_rwlock_delete(twc->pvt->lock);
  gt_free(twc->pvt);
  gt_free(twc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x55da5
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3d934
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x55dad
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d94f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x55e0c
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x55dc3
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d8f7
movq 0x8(%rbx), %rdi
leaq 0x96d5c(%rip), %r14     # 0xecb44
movq %r14, %rsi
movl $0x54, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x55, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0x18885
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/text_width_calculator.c
// Function: gt_text_width_calculator_get_text_width
double gt_text_width_calculator_get_text_width(GtTextWidthCalculator *twc,
                                               const char* text,
                                               GtError *err)
{
  double width;
  gt_assert(twc && text);
  gt_rwlock_rdlock(twc->pvt->lock);
  gt_assert(twc->c_class);
  width = twc->c_class->get_text_width(twc, text, err);
  gt_rwlock_unlock(twc->pvt->lock);
  return width;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x55e71
movq %rsi, %r15
testq %rsi, %rsi
je 0x55e71
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3d919
movq (%rbx), %rax
testq %rax, %rax
je 0x55e76
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x8(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3d94f
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x188bc
callq 0x188f3