LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x329ea
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x32b06
testq %rbx, %rbx
je 0x32aaa
testq %r15, %r15
je 0x32aaa
movq 0x10(%rbx), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %ebp
movq (%rbx), %r12
movq %r15, %rdi
callq 0x143d2
movq %rax, %r13
movq %r15, %rdi
callq 0x14461
leaq 0x99f87(%rip), %rcx     # 0xcc9b3
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3b9a4
testl %eax, %eax
jne 0x32a53
movq (%rbx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x39305
testl %eax, %eax
je 0x32a83
movq (%rbx), %rdi
pushq $-0x1
popq %r15
movl %r15d, %esi
xorl %edx, %edx
callq 0x37f9b
leaq 0xa27e7(%rip), %rsi     # 0xd5252
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xc007
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x377fa
movq (%rbx), %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x32ad8
movq 0x10(%rbx), %rdi
callq 0x15f0a
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xfb507(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x975ab(%rip), %rsi     # 0xca066
leaq 0xa2783(%rip), %rdx     # 0xd5245
leaq 0xa276a(%rip), %rcx     # 0xd5233
leaq 0xa23c5(%rip), %r8      # 0xd4e95
movl $0x318, %r9d            # imm = 0x318
jmp 0x32b32
movq 0xfb4d9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9757d(%rip), %rsi     # 0xca066
leaq 0xa247b(%rip), %rdx     # 0xd4f6b
leaq 0xa273c(%rip), %rcx     # 0xd5233
leaq 0xa2397(%rip), %r8      # 0xd4e95
movl $0x324, %r9d            # imm = 0x324
jmp 0x32b32
movq 0xfb4ab(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9754f(%rip), %rsi     # 0xca066
leaq 0x97b3b(%rip), %rdx     # 0xca659
leaq 0xa270e(%rip), %rcx     # 0xd5233
leaq 0xa2369(%rip), %r8      # 0xd4e95
movl $0x317, %r9d            # imm = 0x317
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x32b88
movq %rdi, %rbx
callq 0x377ed
testl %eax, %eax
jne 0x32b88
leaq 0xa233b(%rip), %rdx     # 0xd4e95
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
movl $0x9c, %ecx
callq 0xce9a
movq %rax, %r14
movq %rbx, (%rax)
movb $0x1, 0x20(%rax)
callq 0x15d09
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xfb429(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x974cd(%rip), %rsi     # 0xca066
leaq 0xa2334(%rip), %rdx     # 0xd4ed4
leaq 0xa2341(%rip), %rcx     # 0xd4ee8
leaq 0xa22e7(%rip), %r8      # 0xd4e95
movl $0x9b, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x32be4
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
incq 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x15f0a
movq %rbx, %rax
popq %rbx
retq
movq 0xfb3cd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x97471(%rip), %rsi     # 0xca066
leaq 0xb4d0c(%rip), %rdx     # 0xe7908
leaq 0xa22fd(%rip), %rcx     # 0xd4f00
leaq 0xa228b(%rip), %r8      # 0xd4e95
movl $0xa5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x32c4b
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq (%rbx), %rdi
leaq 0xf8d18(%rip), %rsi     # 0x12b950
callq 0x3297b
movb $0x1, 0x20(%rbx)
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x15f0a
movq 0xfb366(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9740a(%rip), %rsi     # 0xca066
leaq 0xb4ca5(%rip), %rdx     # 0xe7908
leaq 0xa22a3(%rip), %rcx     # 0xd4f0d
leaq 0xa2224(%rip), %r8      # 0xd4e95
movl $0xae, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x32cf5
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %ebp
leaq 0xf8ca4(%rip), %r15     # 0x12b950
movq (%r15), %r14
testq %r14, %r14
je 0x32cd2
movq (%rbx), %rdi
callq 0x3824a
movq (%rbx), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x38f41
addq $0x10, %r15
jmp 0x32cac
movb $0x0, 0x20(%rbx)
movq (%rbx), %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x32d23
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x15f0a
movq 0xfb2bc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x97360(%rip), %rsi     # 0xca066
leaq 0xb4bfb(%rip), %rdx     # 0xe7908
leaq 0xa220e(%rip), %rcx     # 0xd4f22
leaq 0xa217a(%rip), %r8      # 0xd4e95
movl $0xbb, %r9d
jmp 0x32d4f
movq 0xfb28e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x97332(%rip), %rsi     # 0xca066
leaq 0xa21fa(%rip), %rdx     # 0xd4f35
leaq 0xa21e0(%rip), %rcx     # 0xd4f22
leaq 0xa214c(%rip), %r8      # 0xd4e95
movl $0xc5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x32e03
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %ebp
movb $0x1, %r14b
leaq 0xf8bc1(%rip), %r13     # 0x12b950
pushq $-0x1
popq %r15
pushq $-0x2
popq %r12
testb $0x1, %r14b
je 0x32dd5
movq (%r13), %rdx
testq %rdx, %rdx
je 0x32dd5
movq (%rbx), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x38a63
movq (%rbx), %rdi
movl %r15d, %esi
callq 0x37b59
testl %eax, %eax
sete %r14b
movq (%rbx), %rdi
movl %r12d, %esi
callq 0x377fa
addq $0x10, %r13
jmp 0x32d97
movq (%rbx), %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x32e31
movq 0x10(%rbx), %rdi
callq 0x15f0a
notb %r14b
andb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xfb1ae(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x97252(%rip), %rsi     # 0xca066
leaq 0xad002(%rip), %rdx     # 0xdfe1d
leaq 0xa2136(%rip), %rcx     # 0xd4f58
leaq 0xa206c(%rip), %r8      # 0xd4e95
movl $0xd0, %r9d
jmp 0x32e5d
movq 0xfb180(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x97224(%rip), %rsi     # 0xca066
leaq 0xa2122(%rip), %rdx     # 0xd4f6b
leaq 0xa2108(%rip), %rcx     # 0xd4f58
leaq 0xa203e(%rip), %r8      # 0xd4e95
movl $0xdc, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x33068
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x33068
xorl %edx, %edx
callq 0x32e69
testl %eax, %eax
jne 0x33096
popq %rax
retq
movq 0xfaf49(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x96fed(%rip), %rsi     # 0xca066
leaq 0xa1fa5(%rip), %rdx     # 0xd5025
leaq 0xa1fb3(%rip), %rcx     # 0xd503a
leaq 0xa1e07(%rip), %r8      # 0xd4e95
movl $0x107, %r9d            # imm = 0x107
jmp 0x330c2
movq 0xfaf1b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x96fbf(%rip), %rsi     # 0xca066
leaq 0x97a39(%rip), %rdx     # 0xcaae7
leaq 0xa1f85(%rip), %rcx     # 0xd503a
leaq 0xa1dd9(%rip), %r8      # 0xd4e95
movl $0x109, %r9d            # imm = 0x109
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0xb43cc(%rip), %rdx     # 0xe7908
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x38a63
movq (%r14), %rdi
pushq $-0x1
popq %rbx
movl %ebx, %esi
callq 0x37b59
testl %eax, %eax
je 0x3358d
movq (%r14), %rdi
pushq $-0x1
popq %rbp
movl %ebp, %esi
movq %r15, %rdx
callq 0x38a63
movq (%r14), %rdi
movl %ebp, %esi
callq 0x37b59
pushq $-0x3
popq %rbp
testl %eax, %eax
je 0x3359e
movq (%r14), %rdi
pushq $-0x1
popq %rsi
callq 0x37b59
cmpl $0x5, %eax
jne 0x3359e
pushq $0x2
popq %rbx
jmp 0x335a8
leaq 0xa2506(%rip), %rdi     # 0xd5a9a
xorl %eax, %eax
callq 0xc5d2
pushq $-0x2
popq %rbp
movq (%r14), %rdi
movl %ebp, %esi
callq 0x377fa
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0xb4143(%rip), %rdx     # 0xe7908
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x38a63
movq (%r14), %rdi
pushq $-0x1
popq %rsi
callq 0x37b59
testl %eax, %eax
jne 0x3381c
movq (%r14), %rdi
pushq $-0x2
popq %rsi
callq 0x377fa
movq (%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38be5
movq (%r14), %rdi
leaq 0xb4109(%rip), %r15     # 0xe7908
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r15, %rdx
callq 0x38f41
movq (%r14), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r15, %rdx
callq 0x38a63
movq (%r14), %rdi
pushq $-0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
callq 0x38a63
movq (%r14), %rdi
movl %ebp, %esi
callq 0x37b59
testl %eax, %eax
je 0x33845
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
pushq $-0x2
popq %rsi
callq 0x377fa
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x33873
movq (%r14), %rdi
pushq $-0x1
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38a63
// File: /workspace/github_c_makefile_star2_O2/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 0x33c73
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x337ae
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x38431
movq (%rbx), %r15
movq %r14, %rdi
callq 0x143d2
movq %r15, %rdi
movq %rax, %rsi
callq 0x38431
movq (%rbx), %rdi
pushq $-0x3
popq %r14
movl %r14d, %esi
callq 0x38d5e
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x377fa
movq (%rbx), %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x33ca1
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15f0a
movq 0xfa33e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x963e2(%rip), %rsi     # 0xca066
leaq 0xa144c(%rip), %rdx     # 0xd50d7
leaq 0xa1464(%rip), %rcx     # 0xd50f6
leaq 0xa11fc(%rip), %r8      # 0xd4e95
movl $0x20b, %r9d            # imm = 0x20B
jmp 0x33ccd
movq 0xfa310(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x963b4(%rip), %rsi     # 0xca066
leaq 0xa12b2(%rip), %rdx     # 0xd4f6b
leaq 0xa1436(%rip), %rcx     # 0xd50f6
leaq 0xa11ce(%rip), %r8      # 0xd4e95
movl $0x215, %r9d            # imm = 0x215
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x340a7
movq %rsi, %r15
testq %rsi, %rsi
je 0x340a7
movq %rdx, %r14
testq %rdx, %rdx
je 0x340a7
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x337ae
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x38431
movq (%rbx), %rdi
movsd (%rsp), %xmm0
callq 0x3825b
movq (%rbx), %rdi
pushq $-0x3
popq %r14
movl %r14d, %esi
callq 0x38d5e
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x377fa
movq (%rbx), %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x340d5
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x15f0a
movq 0xf9f0a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95fae(%rip), %rsi     # 0xca066
leaq 0xa1081(%rip), %rdx     # 0xd5140
leaq 0xa1090(%rip), %rcx     # 0xd5156
leaq 0xa0dc8(%rip), %r8      # 0xd4e95
movl $0x26e, %r9d            # imm = 0x26E
jmp 0x34101
movq 0xf9edc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95f80(%rip), %rsi     # 0xca066
leaq 0xa0e7e(%rip), %rdx     # 0xd4f6b
leaq 0xa1062(%rip), %rcx     # 0xd5156
leaq 0xa0d9a(%rip), %r8      # 0xd4e95
movl $0x278, %r9d            # imm = 0x278
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x344aa
movq %rsi, %r12
testq %rsi, %rsi
je 0x344aa
movq %rdx, %r15
testq %rdx, %rdx
je 0x344aa
movl %ecx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x337ae
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x38431
movq (%rbx), %rdi
movzbl %bpl, %esi
callq 0x388fa
movq (%rbx), %rdi
pushq $-0x3
popq %rbp
movl %ebp, %esi
callq 0x38d5e
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x377fa
movq (%rbx), %rdi
callq 0x377ed
cmpl %r14d, %eax
jne 0x344d8
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15f0a
movq 0xf9b07(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95bab(%rip), %rsi     # 0xca066
leaq 0xa0c7e(%rip), %rdx     # 0xd5140
leaq 0xa0cbb(%rip), %rcx     # 0xd5184
leaq 0xa09c5(%rip), %r8      # 0xd4e95
movl $0x2cc, %r9d            # imm = 0x2CC
jmp 0x34504
movq 0xf9ad9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95b7d(%rip), %rsi     # 0xca066
leaq 0xa0a7b(%rip), %rdx     # 0xd4f6b
leaq 0xa0c8d(%rip), %rcx     # 0xd5184
leaq 0xa0997(%rip), %r8      # 0xd4e95
movl $0x2d6, %r9d            # imm = 0x2D6
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x3460c
movq %rsi, %r15
testq %rsi, %rsi
je 0x3460c
movq %rdx, %r14
testq %rdx, %rdx
je 0x3460c
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0xb33af(%rip), %rdx     # 0xe7908
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x38a63
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x37b59
testl %eax, %eax
je 0x345e4
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x37b59
cmpl $0x5, %eax
jne 0x3466b
movq (%rbx), %rdi
pushq $-0x1
popq %r12
movl %r12d, %esi
movq %r15, %rdx
callq 0x38a63
movq (%rbx), %rdi
movl %r12d, %esi
callq 0x37b59
testl %eax, %eax
je 0x345d9
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x37b59
cmpl $0x5, %eax
jne 0x34699
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x38431
movq (%rbx), %rdi
callq 0x3824a
movq (%rbx), %rdi
pushq $-0x3
popq %rsi
callq 0x38d5e
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x377fa
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x377fa
movq (%rbx), %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x3463d
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15f0a
movq 0xf99a5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95a49(%rip), %rsi     # 0xca066
leaq 0xa0b1c(%rip), %rdx     # 0xd5140
leaq 0xa0b6b(%rip), %rcx     # 0xd5196
leaq 0xa0863(%rip), %r8      # 0xd4e95
movl $0x2df, %r9d            # imm = 0x2DF
jmp 0x346c5
movq 0xf9974(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95a18(%rip), %rsi     # 0xca066
leaq 0xa0916(%rip), %rdx     # 0xd4f6b
leaq 0xa0b3a(%rip), %rcx     # 0xd5196
leaq 0xa0832(%rip), %r8      # 0xd4e95
movl $0x2f1, %r9d            # imm = 0x2F1
jmp 0x346c5
movq 0xf9946(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x959ea(%rip), %rsi     # 0xca066
leaq 0xa0b22(%rip), %rdx     # 0xd51a5
leaq 0xa0b0c(%rip), %rcx     # 0xd5196
leaq 0xa0804(%rip), %r8      # 0xd4e95
movl $0x2e6, %r9d            # imm = 0x2E6
jmp 0x346c5
movq 0xf9918(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x959bc(%rip), %rsi     # 0xca066
leaq 0xa0af4(%rip), %rdx     # 0xd51a5
leaq 0xa0ade(%rip), %rcx     # 0xd5196
leaq 0xa07d6(%rip), %r8      # 0xd4e95
movl $0x2e9, %r9d            # imm = 0x2E9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x346f7
movq %r15, %rdi
callq 0xc103
testb %al, %al
jne 0x34811
testq %rbx, %rbx
je 0x347b5
testq %r14, %r14
je 0x347b5
movq 0x10(%rbx), %rdi
callq 0x15e99
movq (%rbx), %rdi
callq 0x377ed
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0xb31e2(%rip), %rdx     # 0xe7908
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x38a63
leaq 0xa0aa4(%rip), %rsi     # 0xd51db
movq %r14, %rdi
callq 0x13dd3
movq (%rbx), %rdi
pushq $-0x1
popq %r12
movl %r12d, %esi
callq 0x37b59
cmpl $0x5, %eax
jne 0x34769
movq (%rbx), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
movq %r15, %rcx
callq 0x65958
movl %eax, %r12d
jmp 0x3477a
leaq 0xa0a76(%rip), %rsi     # 0xd51e6
movq %r15, %rdi
xorl %eax, %eax
callq 0xc007
leaq 0xa130c(%rip), %rsi     # 0xd5a8d
movq %r14, %rdi
callq 0x13dd3
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x377fa
movq (%rbx), %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x347e3
movq 0x10(%rbx), %rdi
callq 0x15f0a
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xf97fc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x958a0(%rip), %rsi     # 0xca066
leaq 0xa0a00(%rip), %rdx     # 0xd51cd
leaq 0xa09e9(%rip), %rcx     # 0xd51bd
leaq 0xa06ba(%rip), %r8      # 0xd4e95
movl $0x2fc, %r9d            # imm = 0x2FC
jmp 0x3483d
movq 0xf97ce(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95872(%rip), %rsi     # 0xca066
leaq 0xa0770(%rip), %rdx     # 0xd4f6b
leaq 0xa09bb(%rip), %rcx     # 0xd51bd
leaq 0xa068c(%rip), %r8      # 0xd4e95
movl $0x30c, %r9d            # imm = 0x30C
jmp 0x3483d
movq 0xf97a0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95844(%rip), %rsi     # 0xca066
leaq 0x95e30(%rip), %rdx     # 0xca659
leaq 0xa098d(%rip), %rcx     # 0xd51bd
leaq 0xa065e(%rip), %r8      # 0xd4e95
movl $0x2fb, %r9d            # imm = 0x2FB
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x13d5c
testq %r15, %r15
je 0x348dd
movq %rax, %r14
movq %r12, %rdi
callq 0x32840
movq %rax, %rbx
movq 0x18(%r15), %rdi
callq 0x15e99
testq %rbx, %rbx
je 0x3488f
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x346d1
testl %eax, %eax
je 0x348b6
movq 0x18(%r15), %rdi
callq 0x15f0a
movq %r14, %rdi
callq 0x152db
movq %rbx, %rdi
callq 0x34915
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 0x329c1
movl %eax, %ebp
movq 0x18(%r15), %rdi
callq 0x15f0a
movq %r14, %rdi
callq 0x152db
testl %ebp, %ebp
jne 0x348a0
jmp 0x348aa
movq 0xf96d4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x95778(%rip), %rsi     # 0xca066
leaq 0xab528(%rip), %rdx     # 0xdfe1d
leaq 0xa0972(%rip), %rcx     # 0xd526e
leaq 0xa0592(%rip), %r8      # 0xd4e95
movl $0x32e, %r9d            # imm = 0x32E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x34941
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x34943
decq %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x15f0a
popq %rbx
retq
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x34950
callq 0x3a8f3
movq 0x10(%rbx), %rdi
callq 0x15f0a
movq %rbx, %rdi
popq %rbx
jmp 0x3585c
// File: /workspace/github_c_makefile_star2_O2/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 0x35891
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x35899
decq %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15f0a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x28(%rbx), %rdi
leaq 0x9f5f1(%rip), %r14     # 0xd4e95
movq %r14, %rsi
movl $0x3c2, %edx            # imm = 0x3C2
callq 0xd249
movq 0x10(%rbx), %rdi
callq 0x15f0a
movq 0x10(%rbx), %rdi
callq 0x15dd5
movq 0x18(%rbx), %rdi
callq 0x15dd5
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3c6, %edx            # imm = 0x3C6
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x4f148
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x35975
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x35975
leaq 0xa01ba(%rip), %r14     # 0xd5ae4
pushq $0x1
popq %r15
pushq $0x36
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x10
popq %rsi
pushq $0x38
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, 0x8(%r12)
callq 0x15d09
movq 0x8(%r12), %rcx
movq %rax, 0x8(%rcx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xf863c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x946e0(%rip), %rsi     # 0xca066
leaq 0xa0124(%rip), %rdx     # 0xd5ab1
leaq 0xa0130(%rip), %rcx     # 0xd5ac4
leaq 0xa0149(%rip), %r8      # 0xd5ae4
pushq $0x35
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x359d5
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
incl (%rax)
movq 0x8(%rax), %rdi
callq 0x15f0a
movq %rbx, %rax
popq %rbx
retq
movq 0xf85dc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x94680(%rip), %rsi     # 0xca066
leaq 0xa01eb(%rip), %rdx     # 0xd5bd8
leaq 0xa011d(%rip), %rcx     # 0xd5b11
leaq 0xa00e9(%rip), %r8      # 0xd5ae4
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x35a42
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x15e99
movq 0x8(%rbx), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x35a4a
decl %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15f0a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x35aa5
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x35a64
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15f0a
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x15dd5
movq 0x8(%rbx), %rdi
leaq 0xa005f(%rip), %r14     # 0xd5ae4
pushq $0x54
popq %rdx
movq %r14, %rsi
callq 0xd249
pushq $0x55
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0xf850c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x945b0(%rip), %rsi     # 0xca066
leaq 0xa0071(%rip), %rdx     # 0xd5b2e
leaq 0xa0077(%rip), %rcx     # 0xd5b3b
leaq 0xa0019(%rip), %r8      # 0xd5ae4
pushq $0x4f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x35b3b
movq %rsi, %r15
testq %rsi, %rsi
je 0x35b3b
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x15e28
movq (%rbx), %rax
testq %rax, %rax
je 0x35b65
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 0x15f0a
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xf8476(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9451a(%rip), %rsi     # 0xca066
leaq 0xa0008(%rip), %rdx     # 0xd5b5b
leaq 0xa000d(%rip), %rcx     # 0xd5b67
leaq 0x9ff83(%rip), %r8      # 0xd5ae4
pushq $0x5d
jmp 0x35b8d
movq 0xf844c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x944f0(%rip), %rsi     # 0xca066
leaq 0x9ffb1(%rip), %rdx     # 0xd5b2e
leaq 0x9ffe3(%rip), %rcx     # 0xd5b67
leaq 0x9ff59(%rip), %r8      # 0xd5ae4
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/text_width_calculator_cairo.c
// Function: gt_text_width_calculator_cairo_get_text_width
double gt_text_width_calculator_cairo_get_text_width(GtTextWidthCalculator *twc,
                                                     const char *text,
                                                     GT_UNUSED GtError *err)
{
  GtTextWidthCalculatorCairo *twcc;
  PangoRectangle rect;
  gt_assert(twc && text);
  twcc = gt_text_width_calculator_cairo_cast(twc);

  /* redo layout */
  pango_layout_set_text(twcc->layout, text, -1);

  /* get extents */
  pango_layout_get_pixel_extents(twcc->layout, &rect, NULL);

  if (twcc->style)
    cairo_restore(twcc->context);
  gt_assert(gt_double_smaller_double(0, rect.width));
  return rect.width;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x35ca9
movq %rsi, %r14
testq %rsi, %rsi
je 0x35ca9
movq %rdi, %rbx
callq 0x35d09
movq %rax, %rdi
movq %rbx, %rsi
callq 0x35b9b
movq %rax, %rbx
movq 0x28(%rax), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
callq 0xb1a0
movq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xb3c0
cmpq $0x0, 0x10(%rbx)
je 0x35c89
movq 0x18(%rbx), %rdi
callq 0xba40
cvtsi2sdl 0x10(%rsp), %xmm1
xorps %xmm0, %xmm0
callq 0x58dba
testb %al, %al
je 0x35cd3
cvtsi2sdl 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0xf8308(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x943ac(%rip), %rsi     # 0xca066
leaq 0x9fe9a(%rip), %rdx     # 0xd5b5b
leaq 0x9ff36(%rip), %rcx     # 0xd5bfe
leaq 0x9ff5d(%rip), %r8      # 0xd5c2c
pushq $0x38
jmp 0x35cfb
movq 0xf82de(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x94382(%rip), %rsi     # 0xca066
leaq 0x9e7ce(%rip), %rdx     # 0xd44b9
leaq 0x9ff0c(%rip), %rcx     # 0xd5bfe
leaq 0x9ff33(%rip), %r8      # 0xd5c2c
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/text_width_calculator_cairo.c
// Function: gt_text_width_calculator_cairo_class
const GtTextWidthCalculatorClass* gt_text_width_calculator_cairo_class(void)
{
  static const GtTextWidthCalculatorClass *twcc = NULL;
  gt_class_alloc_lock_enter();
  if (!twcc)
  {
    twcc = gt_text_width_calculator_class_new(
                                  sizeof (GtTextWidthCalculatorCairo),
                                  gt_text_width_calculator_cairo_get_text_width,
                                  gt_text_width_calculator_cairo_delete);
  }
  gt_class_alloc_lock_leave();
  return twcc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0xf9e81(%rip)     # 0x12fb98
jne 0x35d36
leaq -0xf0(%rip), %rsi       # 0x35c30
leaq 0x1d(%rip), %rdx        # 0x35d44
pushq $0x40
popq %rdi
callq 0x358e4
movq %rax, 0xf9e62(%rip)     # 0x12fb98
callq 0x4f266
movq 0xf9e56(%rip), %rax     # 0x12fb98
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/text_width_calculator_cairo.c
// Function: gt_text_width_calculator_cairo_delete
void gt_text_width_calculator_cairo_delete(GtTextWidthCalculator *twc)
{
  GtTextWidthCalculatorCairo *twcc;
  if (!twc) return;
  twcc = gt_text_width_calculator_cairo_cast(twc);
  g_object_unref(twcc->layout);
  if (twcc->style)
    gt_style_delete(twcc->style);
  if (twcc->own_context)
  {
    cairo_destroy(twcc->context);
    cairo_surface_destroy(twcc->mysurf);
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x35d90
movq %rdi, %rbx
callq 0x35d09
movq %rax, %rdi
movq %rbx, %rsi
callq 0x35b9b
movq %rax, %rbx
movq 0x28(%rax), %rdi
callq 0xb990
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x35d77
callq 0x34915
cmpb $0x1, 0x38(%rbx)
jne 0x35d90
movq 0x18(%rbx), %rdi
callq 0xb8b0
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0xb7a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_new
GtTrack* gt_track_new(GtStr *title, GtUword max_num_lines,
                      bool split_lines, GtLineBreaker *lb)
{
  GtTrack *track;
  gt_assert(title && lb);
  track = gt_calloc(1, sizeof (GtTrack));
  gt_assert(track);
  track->title = gt_str_ref(title);
  track->lines = gt_array_new(sizeof (GtLine*));
  track->max_num_lines = max_num_lines;
  track->split = split_lines;
  track->lb = lb;
  track->y_index = GT_UNDEF_UWORD;
  return track;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x35f98
movq %rcx, %rbx
testq %rcx, %rcx
je 0x35f98
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x9fd91(%rip), %rdx     # 0xd5cd9
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
pushq $0x2d
popq %rcx
callq 0xce9a
testq %rax, %rax
je 0x35fc2
movq %rax, %r12
movq %r15, %rdi
callq 0x146aa
movq %rax, (%r12)
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x30(%r12)
movq %r14, 0x8(%r12)
movb %bpl, 0x20(%r12)
movq %rbx, 0x18(%r12)
orq $-0x1, 0x28(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xf8019(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x940bd(%rip), %rsi     # 0xca066
leaq 0x9fd10(%rip), %rdx     # 0xd5cc0
leaq 0x9fd15(%rip), %rcx     # 0xd5ccc
leaq 0x9fd1b(%rip), %r8      # 0xd5cd9
pushq $0x2c
jmp 0x35fea
movq 0xf7fef(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x94093(%rip), %rsi     # 0xca066
leaq 0x9ebc3(%rip), %rdx     # 0xd4b9d
leaq 0x9fceb(%rip), %rcx     # 0xd5ccc
leaq 0x9fcf1(%rip), %r8      # 0xd5cd9
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_insert_block
int gt_track_insert_block(GtTrack *track, GtBlock *block, GtError *err)
{
  GtLine *line = NULL;
  int had_err = 0;

  gt_assert(track && block);
  had_err = get_next_free_line(track, &line, block, err);
  if (!had_err)
  {
    if (line) {
      block = gt_block_ref(block);
      gt_line_insert_block(line, block);
      had_err = gt_line_breaker_register_block(track->lb, line, block, err);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x36211
movq %rsi, %r15
testq %rsi, %rsi
je 0x36211
movq %rdx, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0xf(%rsp), %rbp
movq 0x30(%r14), %rdi
callq 0x4b988
cmpq %rax, %r13
jae 0x36145
movq 0x30(%r14), %rdi
movq %r13, %rsi
callq 0x4b48e
movq (%rax), %r12
movq %r12, 0x10(%rsp)
movq 0x18(%r14), %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x70848
testl %eax, %eax
jne 0x36202
incq %r13
cmpb $0x0, 0xf(%rsp)
jne 0x360ec
testq %r12, %r12
jne 0x361da
xorl %eax, %eax
jmp 0x36202
cmpq $-0x1, 0x8(%r14)
je 0x3615f
movq 0x30(%r14), %rdi
callq 0x4b988
cmpq 0x8(%r14), %rax
jne 0x3615f
incq 0x10(%r14)
cmpb $0x0, 0x20(%r14)
je 0x36181
callq 0x6fb14
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x30(%r14), %rdi
pushq $0x8
popq %rdx
callq 0x4b801
jmp 0x361d0
movq 0x30(%r14), %rdi
callq 0x4b988
testq %rax, %rax
je 0x361a4
movq 0x30(%r14), %rdi
xorl %esi, %esi
callq 0x4b48e
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x361bd
callq 0x6fb14
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x30(%r14), %rdi
pushq $0x8
popq %rdx
callq 0x4b801
movq 0x30(%r14), %rdi
callq 0x4b988
cmpq $0x1, %rax
jne 0x36269
movq 0x10(%rsp), %r12
testq %r12, %r12
je 0x3623f
movq %r15, %rdi
callq 0x6b2de
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x6fb41
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x708cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xf7da0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x93e44(%rip), %rsi     # 0xca066
leaq 0x9fb1f(%rip), %rdx     # 0xd5d48
leaq 0x9fb27(%rip), %rcx     # 0xd5d57
leaq 0x9faa2(%rip), %r8      # 0xd5cd9
movl $0x84, %r9d
jmp 0x36293
movq 0xf7d72(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x93e16(%rip), %rsi     # 0xca066
leaq 0x9ea0f(%rip), %rdx     # 0xd4c66
leaq 0x9fe35(%rip), %rcx     # 0xd6093
leaq 0x9fa74(%rip), %r8      # 0xd5cd9
pushq $0x67
jmp 0x36291
movq 0xf7d48(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x93dec(%rip), %rsi     # 0xca066
leaq 0x9fe25(%rip), %rdx     # 0xd60a6
leaq 0x9fe0b(%rip), %rcx     # 0xd6093
leaq 0x9fa4a(%rip), %r8      # 0xd5cd9
pushq $0x60
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_sketch
int gt_track_sketch(GtTrack* track, GtCanvas *canvas, GtError *err)
{
  int i = 0, had_err = 0;
  gt_assert(track && canvas);
  had_err = gt_canvas_visit_track_pre(canvas, track, err);
  if (!had_err) {
    for (i = 0; i < gt_array_size(track->lines); i++) {
      had_err = gt_line_sketch(*(GtLine**) gt_array_get(track->lines, i),
                               canvas,
                               err);
      if (had_err)
        break;
    }
  }
  if (!had_err)
    had_err = gt_canvas_visit_track_post(canvas, track, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x36367
movq %rsi, %r15
testq %rsi, %rsi
je 0x36367
movq %rdx, %rbx
movq %rdi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a136
testl %eax, %eax
jne 0x36342
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
callq 0x4b988
cmpq %r12, %rax
jbe 0x3634e
movq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x4b48e
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6fc3a
incq %r12
testl %eax, %eax
je 0x36313
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a192
movq 0xf7c4a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x93cee(%rip), %rsi     # 0xca066
leaq 0xa96fd(%rip), %rdx     # 0xdfa7c
leaq 0x9fa10(%rip), %rcx     # 0xd5d96
leaq 0x9f94c(%rip), %r8      # 0xd5cd9
movl $0xa0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/track.c
// Function: gt_track_delete
void gt_track_delete(GtTrack *track)
{
  GtUword i;
  if (!track) return;
  if (track->lb)
    gt_line_breaker_delete(track->lb);
  for (i = 0; i < gt_array_size(track->lines); i++)
    gt_line_delete(*(GtLine**) gt_array_get(track->lines, i));
  gt_array_delete(track->lines);
  gt_str_delete(track->title);
  gt_free(track);
}

// Assembly:
testq %rdi, %rdi
je 0x375af
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x3755d
callq 0x707af
xorl %r14d, %r14d
movq 0x30(%rbx), %rdi
callq 0x4b988
movq 0x30(%rbx), %rdi
cmpq %rax, %r14
jae 0x37587
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x70647
incq %r14
jmp 0x37560
callq 0x4c19d
movq (%rbx), %rdi
callq 0x152db
leaq 0x9e73e(%rip), %rsi     # 0xd5cd9
movq %rbx, %rdi
movl $0x19e, %edx            # imm = 0x19E
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/lua-5.1.5/src/ldebug.c
// Function: currentline
static int currentline (lua_State *L, CallInfo *ci) {
  int pc = currentpc(L, ci);
  if (pc < 0)
    return -1;  /* only active lua functions have current-line information */
  else
    return lgetline(ci_func(ci)->l.p, pc);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x3c24c
testl %eax, %eax
js 0x3c2b1
movq 0x8(%rbx), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x3c2b6
movl %eax, %eax
movl (%rcx,%rax,4), %eax
jmp 0x3c2b8
pushq $-0x1
popq %rax
jmp 0x3c2b8
xorl %eax, %eax
popq %rbx
retq