LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x51bce
movq %rsi, %r15
testq %rsi, %rsi
je 0x51bce
movq %rdx, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x51bd8
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x51bc3
movq %r14, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4beb7
testl %eax, %eax
jne 0x51bc3
cmpq $0x0, 0x58(%r14)
movq 0x20(%r14), %rdi
leaq 0x105(%rip), %rsi       # 0x51c3e
je 0x51b51
leaq 0x11d(%rip), %rcx       # 0x51c5f
leaq 0x8(%rsp), %rdx
movq %rbx, %r8
callq 0x77677
jmp 0x51b5e
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x77703
testl %eax, %eax
jne 0x51bc3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4bed8
testl %eax, %eax
jne 0x51bc3
movq 0x18(%r14), %rdi
callq 0x6f310
testq %rax, %rax
je 0x51bc1
xorl %r15d, %r15d
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rdi
testq %rdi, %rdi
je 0x51bd3
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x8df08
movl %eax, %ebp
incq %r15
movq 0x18(%r14), %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x51b85
xorl %eax, %eax
negl %ebp
sbbl %eax, %eax
jmp 0x51bc3
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x173bb
callq 0x173f4
// File: /workspace/github_c_makefile_star2_O3/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 0x51c34
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x51bfd
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x51c39
xorl %eax, %eax
cmpb $0x0, 0x11(%rbx)
jne 0x51c2c
leaq 0x8(%rsp), %rdx
movq %rbx, 0x8(%rdx)
movq 0x8(%rbx), %rax
movq %rax, (%rdx)
movq 0x28(%rbx), %rdi
leaq 0x45a(%rip), %rsi       # 0x5207a
movq %r14, %rcx
callq 0x776d9
movb $0x1, 0x11(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x17466
callq 0x1742d
// File: /workspace/github_c_makefile_star2_O3/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 0x522bf
testq %rsi, %rsi
je 0x522bf
movq (%rdi), %rdi
movq (%rsi), %rsi
movq 0x60(%rdx), %rax
movq 0x70(%rdx), %rdx
jmpq *%rax
pushq %rax
callq 0x176d7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 $0x58, %rsp
movq %rsi, 0x38(%rsp)
testq %rdi, %rdi
je 0x52429
movq %rdx, %r15
testq %rdx, %rdx
je 0x52429
movq %rcx, %r14
movq %rdi, %r12
movq %r15, %rdi
callq 0x8a733
movq %rax, %r13
movq %rdx, %rbp
movq 0x10(%r12), %rdi
callq 0x51ce5
movq %rdx, %r8
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x8dcd0
movsd 0x18(%r12), %xmm0
unpcklps 0x8f14b(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8f153(%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, 0x20(%rsp)
movapd %xmm1, (%rbx)
movq %r15, %rdi
callq 0x8a747
testq %rax, %rax
je 0x523f4
movq 0x10(%r12), %rdi
callq 0x51cf9
movq %rax, %rbx
movq %r15, %rdi
callq 0x8a747
movq %rax, %rdi
callq 0x3bb5d
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x55049
xorpd %xmm1, %xmm1
movapd %xmm0, 0x20(%rsp)
callq 0x7a42f
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
jne 0x5241a
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x8e077
movaps 0x20(%rsp), %xmm1
callq 0x7a42f
movsd 0x40(%rsp), %xmm1
testb %al, %al
je 0x52404
movapd 0x20(%rsp), %xmm0
addsd %xmm1, %xmm0
jmp 0x5240a
movapd 0x20(%rsp), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
jmp 0x5240a
movsd 0x48(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1770e
// File: /workspace/github_c_makefile_star2_O3/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 0x524b8
movq %rdi, %r13
testq %rdi, %rdi
je 0x524b8
movq %rcx, %r12
testq %rcx, %rcx
je 0x524b8
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %rbx
callq 0x524bd
movq %rax, %rdi
movq %r13, %rsi
callq 0x8f232
movq %rax, %r13
movq %rsp, %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x522c8
movl %eax, %ebp
testl %eax, %eax
jne 0x524a7
movq 0x28(%r13), %rdi
movq %r14, %rsi
callq 0x775ed
testq %rax, %rax
je 0x524a3
movsd (%rax), %xmm0
ucomisd (%rsp), %xmm0
setae %al
jmp 0x524a5
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 0x17745
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x1006d5(%rip)    # 0x152ba0
jne 0x524f3
leaq -0xa6(%rip), %rsi       # 0x5242e
leaq 0x26(%rip), %rdx        # 0x52501
leaq 0xe6(%rip), %rcx        # 0x525c8
movl $0x30, %edi
callq 0x8f0a4
movq %rax, 0x1006ad(%rip)    # 0x152ba0
callq 0x7237d
movq 0x1006a1(%rip), %rax    # 0x152ba0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x525c3
movq %rdi, %r12
testq %rdi, %rdi
je 0x525c3
movq %rdx, %r14
testq %rdx, %rdx
je 0x525c3
movq %rcx, %rbx
movq %rsi, %r15
callq 0x524bd
movq %rax, %rdi
movq %r12, %rsi
callq 0x8f232
movq %rax, %r13
movq 0x28(%rax), %rdi
movq %r15, %rsi
callq 0x775ed
movq %rax, %r12
testq %rax, %rax
jne 0x52589
leaq 0x996d7(%rip), %rdx     # 0xebc3a
movl $0x1, %edi
movl $0x8, %esi
movl $0x64, %ecx
callq 0x359a6
movq %rax, %r12
movq 0x28(%r13), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x77628
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x522c8
movl %eax, %ebx
testl %eax, %eax
jne 0x525b3
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 0x1777c
// File: /workspace/github_c_makefile_star2_O3/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 0x5268b
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x524bd
movq %rax, %rdi
callq 0x8f0dd
movq %rax, %rbx
callq 0x524bd
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8f232
movq %rax, %r14
movq %r13, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r12
addq $0x20, %r12
leaq 0x8eb56(%rip), %rsi     # 0xe1196
leaq 0x98df1(%rip), %rdx     # 0xeb438
movq %r15, %rdi
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5393e
testl %eax, %eax
jne 0x5266a
movabsq $0x403e000000000000, %rax # imm = 0x403E000000000000
movq %rax, (%r12)
leaq -0x1c98b(%rip), %rdx    # 0x35ce6
xorl %edi, %edi
xorl %esi, %esi
callq 0x7740c
movq %rax, 0x28(%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x177b3
// File: /workspace/github_c_makefile_star2_O3/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 0x99631(%rip), %rdx     # 0xebcea
movl $0x1, %edi
movl $0x38, %esi
movl $0x23, %ecx
callq 0x359a6
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 0x4130c
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_O3/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 0x527ef
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x527f1
decq %rax
movq %rax, 0x30(%rbx)
popq %rbx
retq
movq 0x20(%rbx), %rdi
callq 0x4210c
leaq 0x994e9(%rip), %rsi     # 0xebcea
movq %rbx, %rdi
movl $0x6e, %edx
popq %rbx
jmp 0x35c27
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5282d
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x528f1
leaq 0x99671(%rip), %rdx     # 0xebea5
movl $0x1, %edi
movl $0x30, %esi
movl $0x83, %ecx
callq 0x359a6
movq %rax, %rbx
movq $0x0, 0x28(%rax)
callq 0x5b65a
movq %rax, (%rbx)
testq %rax, %rax
je 0x528bc
leaq 0xfc0a9(%rip), %rsi     # 0x14e910
movq %rax, %rdi
callq 0x528f6
callq 0x3cf33
movq %rax, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
callq 0x3cf33
movq %rax, 0x18(%rbx)
leaq 0x99eff(%rip), %rdi     # 0xec78b
callq 0x3b785
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x52942
testl %eax, %eax
jne 0x528ec
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x528ec
movq %r15, %rdi
callq 0x3c87b
jmp 0x528e3
leaq 0x961be(%rip), %rsi     # 0xe8a81
movq %r14, %rdi
xorl %eax, %eax
callq 0x34f1f
leaq 0x995d1(%rip), %rsi     # 0xebea5
movq %rbx, %rdi
movl $0x88, %edx
callq 0x35c27
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x17a14
callq 0x179db
// File: /workspace/github_c_makefile_star2_O3/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 0x5293a
movq %rdi, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x57d08
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x5790a
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x5881f
movq 0x18(%rbx), %rsi
addq $0x10, %rbx
testq %rsi, %rsi
jne 0x52909
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5296b
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x52a3b
testq %rbx, %rbx
je 0x52a31
testq %r15, %r15
je 0x52a31
movq 0x10(%rbx), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %ebp
movq (%rbx), %r12
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %r13
movq %r15, %rdi
callq 0x3bb86
leaq 0x91006(%rip), %rcx     # 0xe39b3
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5b5e0
testl %eax, %eax
jne 0x529d4
movq (%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x588cb
testl %eax, %eax
je 0x52a0a
movq (%rbx), %rdi
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x573f8
leaq 0x99872(%rip), %rsi     # 0xec262
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x52a36
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x17a86
callq 0x17abf
callq 0x17a4d
// File: /workspace/github_c_makefile_star2_O3/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 0x52a8e
movq %rdi, %rbx
callq 0x56afc
testl %eax, %eax
jne 0x52a8e
leaq 0x99449(%rip), %rdx     # 0xebea5
movl $0x1, %edi
movl $0x30, %esi
movl $0x9c, %ecx
callq 0x359a6
movq %rax, %r14
movq %rbx, (%rax)
movb $0x1, 0x20(%rax)
callq 0x3cf33
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x17af8
// File: /workspace/github_c_makefile_star2_O3/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 0x52ab7
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
incq 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movq %rbx, %rax
popq %rbx
retq
callq 0x17b31
// File: /workspace/github_c_makefile_star2_O3/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 0x52aeb
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
leaq 0xfbe98(%rip), %rsi     # 0x14e970
callq 0x528f6
movb $0x1, 0x20(%rbx)
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x3cfdb
callq 0x17b6a
// File: /workspace/github_c_makefile_star2_O3/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 0x52b67
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %ebp
leaq 0x9bea1(%rip), %r14     # 0xee9ba
leaq 0xfbe60(%rip), %r15     # 0x14e980
movq (%rbx), %rdi
callq 0x57704
movq (%rbx), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x584c8
movq (%r15), %r14
addq $0x10, %r15
testq %r14, %r14
jne 0x52b20
movb $0x0, 0x20(%rbx)
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x52b6c
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x17bdc
callq 0x17ba3
// File: /workspace/github_c_makefile_star2_O3/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 0x52c05
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %ebp
leaq 0xfbdd1(%rip), %r12     # 0x14e970
movq (%r12), %r14
testq %r14, %r14
je 0x52bde
movq (%rbx), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x57f56
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
movl %eax, %r15d
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
addq $0x10, %r12
testl %r15d, %r15d
je 0x52b9f
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x52c0a
testq %r14, %r14
setne %bpl
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x17c4e
callq 0x17c15
// File: /workspace/github_c_makefile_star2_O3/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 0x52c35
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x52d64
movq 0x10(%rbx), %rdi
callq 0x3cfc0
testq %r15, %r15
je 0x52d5a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x52d5a
callq 0x56afc
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movq 0x10(%rbx), %rdi
callq 0x3cfc0
movq %r15, %rdi
callq 0x728c0
movq %rax, 0x28(%rbx)
leaq 0x9934a(%rip), %rdi     # 0xebfc9
movq %r15, %rsi
xorl %eax, %eax
callq 0x353ae
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x5b1f2
testl %eax, %eax
jne 0x52caa
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x588cb
testl %eax, %eax
je 0x52d01
movq (%rbx), %rdi
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x573f8
leaq 0x99324(%rip), %rsi     # 0xebfea
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x52d5f
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0xab8fd(%rip), %rdx     # 0xfe608
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x57f56
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
je 0x52d3b
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
xorl %r12d, %r12d
cmpl $0x5, %eax
je 0x52cd3
leaq 0x992c2(%rip), %rsi     # 0xec004
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x52cd3
callq 0x17cc0
callq 0x17cf9
callq 0x17c87
// File: /workspace/github_c_makefile_star2_O3/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 0x52d85
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x52d85
xorl %edx, %edx
callq 0x52c0f
testl %eax, %eax
jne 0x52d8a
popq %rax
retq
callq 0x17d6b
callq 0x17d32
// File: /workspace/github_c_makefile_star2_O3/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 0xab4e6(%rip), %rdx     # 0xfe608
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x57f56
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
je 0x5317e
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x57f56
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
testl %eax, %eax
je 0x53191
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
movl %eax, %ecx
movl $0x2, %eax
cmpl $0x5, %ecx
jne 0x53191
jmp 0x531a0
leaq 0x99925(%rip), %rdi     # 0xecaaa
xorl %eax, %eax
callq 0x353ae
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x56b09
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xab2a7(%rip), %rdx     # 0xfe608
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x57f56
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
jne 0x533bc
movq (%r14), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq (%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58130
movq (%r14), %rdi
leaq 0xab269(%rip), %r15     # 0xfe608
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r15, %rdx
callq 0x584c8
movq (%r14), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r15, %rdx
callq 0x57f56
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
callq 0x57f56
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
je 0x533e3
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x53410
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x57f56
// File: /workspace/github_c_makefile_star2_O3/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 0x53716
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5334c
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x5790a
movq (%rbx), %r15
movq %r14, %rdi
callq 0x3bb5d
movq %r15, %rdi
movq %rax, %rsi
callq 0x5790a
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x56b09
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x5371b
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x180c2
callq 0x180fb
// File: /workspace/github_c_makefile_star2_O3/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 0x539ed
movq %rsi, %r15
testq %rsi, %rsi
je 0x539ed
movq %rdx, %r14
testq %rdx, %rdx
je 0x539ed
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5334c
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x5790a
movq (%rbx), %rdi
movsd (%rsp), %xmm0
callq 0x57718
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x56b09
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x539f2
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x1828a
callq 0x182c3
// File: /workspace/github_c_makefile_star2_O3/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 0x53c99
movq %rsi, %r12
testq %rsi, %rsi
je 0x53c99
movq %rdx, %r15
testq %rdx, %rdx
je 0x53c99
movl %ecx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5334c
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x5790a
movq (%rbx), %rdi
movzbl %bpl, %esi
callq 0x57df3
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x56b09
movq (%rbx), %rdi
callq 0x56afc
cmpl %r14d, %eax
jne 0x53c9e
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x18452
callq 0x1848b
// File: /workspace/github_c_makefile_star2_O3/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 0x53da8
movq %rsi, %r15
testq %rsi, %rsi
je 0x53da8
movq %rdx, %r14
testq %rdx, %rdx
je 0x53da8
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0xaa91d(%rip), %rdx     # 0xfe608
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x57f56
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
je 0x53d7c
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
cmpl $0x5, %eax
jne 0x53db2
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x57f56
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
je 0x53d6f
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
cmpl $0x5, %eax
jne 0x53db7
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x5790a
movq (%rbx), %rdi
callq 0x57704
movq (%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x53dad
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3cfdb
callq 0x184c4
callq 0x1856f
callq 0x184fd
callq 0x18536
// File: /workspace/github_c_makefile_star2_O3/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 0x53de2
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0x53eb2
testq %rbx, %rbx
je 0x53ea8
testq %r14, %r14
je 0x53ea8
movq 0x10(%rbx), %rdi
callq 0x3cfc0
movq (%rbx), %rdi
callq 0x56afc
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0xaa7f7(%rip), %rdx     # 0xfe608
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x57f56
leaq 0x983c9(%rip), %rsi     # 0xec1eb
movq %r14, %rdi
callq 0x3b7af
movq (%rbx), %rdi
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
cmpl $0x5, %eax
jne 0x53e5a
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
callq 0x85b20
movl %eax, %r12d
jmp 0x53e6b
leaq 0x98395(%rip), %rsi     # 0xec1f6
movq %r15, %rdi
xorl %eax, %eax
callq 0x34f1f
leaq 0x98c2b(%rip), %rsi     # 0xeca9d
movq %r14, %rdi
callq 0x3b7af
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq (%rbx), %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x53ead
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x185e1
callq 0x1861a
callq 0x185a8
// File: /workspace/github_c_makefile_star2_O3/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 0x3b728
testq %r15, %r15
je 0x53f4b
movq %rax, %r14
movq %r12, %rdi
callq 0x52810
movq %rax, %rbx
movq 0x18(%r15), %rdi
callq 0x3cfc0
testq %rbx, %rbx
je 0x53efd
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53dbc
testl %eax, %eax
je 0x53f24
movq 0x18(%r15), %rdi
callq 0x3cfdb
movq %r14, %rdi
callq 0x3c87b
movq %rbx, %rdi
callq 0x53f50
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 0x52942
movl %eax, %ebp
movq 0x18(%r15), %rdi
callq 0x3cfdb
movq %r14, %rdi
callq 0x3c87b
testl %ebp, %ebp
jne 0x53f0e
jmp 0x53f18
callq 0x18653
// File: /workspace/github_c_makefile_star2_O3/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 0x53f7c
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x53f7e
decq %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x3cfdb
popq %rbx
retq
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x53f8b
callq 0x5a089
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movq %rbx, %rdi
popq %rbx
jmp 0x54e5c
// File: /workspace/github_c_makefile_star2_O3/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 0x54e91
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x54e99
decq %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x28(%rbx), %rdi
leaq 0x97001(%rip), %r14     # 0xebea5
movq %r14, %rsi
movl $0x3c2, %edx            # imm = 0x3C2
callq 0x35c27
movq 0x10(%rbx), %rdi
callq 0x3cfdb
movq 0x10(%rbx), %rdi
callq 0x3cf83
movq 0x18(%rbx), %rdi
callq 0x3cf83
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3c6, %edx            # imm = 0x3C6
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x72274
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x54f72
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x54f72
leaq 0x97bcb(%rip), %r14     # 0xecaf4
movl $0x1, %edi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x359a6
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r14, %rdx
movl $0x38, %ecx
callq 0x359a6
movq %rax, 0x8(%r15)
callq 0x3cf33
movq 0x8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x186c5
// File: /workspace/github_c_makefile_star2_O3/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 0x54fa1
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq %rbx, %rax
popq %rbx
retq
callq 0x186fc
// File: /workspace/github_c_makefile_star2_O3/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 0x54fdd
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x54fe5
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cfdb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x55044
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x54fff
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cf83
movq 0x8(%rbx), %rdi
leaq 0x97ad4(%rip), %r14     # 0xecaf4
movq %r14, %rsi
movl $0x54, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x55, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0x18733
// File: /workspace/github_c_makefile_star2_O3/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 0x550a9
movq %rsi, %r15
testq %rsi, %rsi
je 0x550a9
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
testq %rax, %rax
je 0x550ae
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 0x3cfdb
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1876a
callq 0x187a1