LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_get_indexes
static GtCstrTable* gt_rdb_sqlite_get_indexes(GtRDB *rdb, GtError *err)
{
  GtRDBStmt *stmt;
  GtCstrTable *tab;
  int rval = 0;
  gt_assert(rdb);
  gt_error_check(err);
  if ((stmt = gt_rdb_prepare(rdb, "SELECT name FROM sqlite_master "
                                  "WHERE type='index'",
                                  0,
                                  err)) == NULL)
    return NULL;
  tab = gt_cstr_table_new();
  while (!rval) {
    GtStr *key;
    rval = gt_rdb_stmt_exec(stmt, err);
    if (rval) break;
    key = gt_str_new();
    gt_rdb_stmt_get_string(stmt, 0, key, err);
    gt_cstr_table_add(tab, gt_str_get(key));
    gt_str_delete(key);
  }
  if (rval < 0) {
    gt_cstr_table_delete(tab);
    gt_rdb_stmt_delete(stmt);
    return NULL;
  }
  gt_rdb_stmt_delete(stmt);
  return tab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10dd95
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x10dd06
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10ddc3
leaq 0x221e94(%rip), %rsi    # 0x32fba1
xorl %r14d, %r14d
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x10d490
testq %rax, %rax
je 0x10dd86
movq %rax, %r15
callq 0x6ca6c
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10d688
testl %eax, %eax
jne 0x10dd71
callq 0xacb84
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x10d7fc
movq %r12, %rdi
callq 0xad1fa
movq %r14, %rdi
movq %rax, %rsi
callq 0x6cacc
movq %r12, %rdi
callq 0xae103
jmp 0x10dd2d
jns 0x10dd7e
movq %r14, %rdi
callq 0x6cf6b
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x10d6dc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x32a1cc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d726d(%rip), %rsi    # 0x2e5013
leaq 0x221d99(%rip), %rdx    # 0x32fb46
leaq 0x221dd3(%rip), %rcx    # 0x32fb87
leaq 0x221d13(%rip), %r8     # 0x32face
movl $0x149, %r9d            # imm = 0x149
jmp 0x10ddef
movq 0x32a19e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d723f(%rip), %rsi    # 0x2e5013
leaq 0x1d73e4(%rip), %rdx    # 0x2e51bf
leaq 0x221da5(%rip), %rcx    # 0x32fb87
leaq 0x221ce5(%rip), %r8     # 0x32face
movl $0x14a, %r9d            # imm = 0x14A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_sqlite_get_tables
static GtCstrTable* gt_rdb_sqlite_get_tables(GtRDB *rdb, GtError *err)
{
  GtRDBStmt *stmt;
  GtCstrTable *tab;
  int rval = 0;
  gt_assert(rdb);
  gt_error_check(err);
  if ((stmt = gt_rdb_prepare(rdb, "SELECT name FROM sqlite_master "
                                  "WHERE type='table'",
                                  0,
                                  err)) == NULL)
    return NULL;
  tab = gt_cstr_table_new();
  while (!rval) {
    GtStr *key;
    rval = gt_rdb_stmt_exec(stmt, err);
    if (rval) break;
    key = gt_str_new();
    gt_rdb_stmt_get_string(stmt, 0, key, err);
    gt_cstr_table_add(tab, gt_str_get(key));
    gt_str_delete(key);
  }
  if (rval < 0) {
    gt_cstr_table_delete(tab);
    gt_rdb_stmt_delete(stmt);
    return NULL;
  }
  gt_rdb_stmt_delete(stmt);
  return tab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10deb6
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x10de27
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10dee4
leaq 0x221dbe(%rip), %rsi    # 0x32fbec
xorl %r14d, %r14d
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x10d490
testq %rax, %rax
je 0x10dea7
movq %rax, %r15
callq 0x6ca6c
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10d688
testl %eax, %eax
jne 0x10de92
callq 0xacb84
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x10d7fc
movq %r12, %rdi
callq 0xad1fa
movq %r14, %rdi
movq %rax, %rsi
callq 0x6cacc
movq %r12, %rdi
callq 0xae103
jmp 0x10de4e
jns 0x10de9f
movq %r14, %rdi
callq 0x6cf6b
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x10d6dc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x32a0ab(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d714c(%rip), %rsi    # 0x2e5013
leaq 0x221c78(%rip), %rdx    # 0x32fb46
leaq 0x221cfe(%rip), %rcx    # 0x32fbd3
leaq 0x221bf2(%rip), %r8     # 0x32face
movl $0x168, %r9d            # imm = 0x168
jmp 0x10df10
movq 0x32a07d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d711e(%rip), %rsi    # 0x2e5013
leaq 0x1d72c3(%rip), %rdx    # 0x2e51bf
leaq 0x221cd0(%rip), %rcx    # 0x32fbd3
leaq 0x221bc4(%rip), %r8     # 0x32face
movl $0x169, %r9d            # imm = 0x169
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_class
const GtRDBStmtClass* gt_rdb_stmt_sqlite_class(void)
{
  static const GtRDBStmtClass *rdbss = NULL;
  gt_class_alloc_lock_enter();
  if (!rdbss) {
    rdbss = gt_rdb_stmt_class_new(sizeof (GtRDBStmtSqlite),
                                  gt_rdb_stmt_sqlite_reset,
                                  gt_rdb_stmt_sqlite_bind_int,
                                  gt_rdb_stmt_sqlite_bind_ulong,
                                  gt_rdb_stmt_sqlite_bind_string,
                                  gt_rdb_stmt_sqlite_bind_double,
                                  gt_rdb_stmt_sqlite_exec,
                                  gt_rdb_stmt_sqlite_get_int,
                                  gt_rdb_stmt_sqlite_get_ulong,
                                  gt_rdb_stmt_sqlite_get_string,
                                  gt_rdb_stmt_sqlite_get_double,
                                  gt_rdb_stmt_sqlite_delete);
  }
  gt_class_alloc_lock_leave();
  return rdbss;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x69e97
cmpq $0x0, 0x32f8ba(%rip)    # 0x43d7e8
jne 0x10df9a
leaq 0xa74(%rip), %rax       # 0x10e9ab
leaq 0x994(%rip), %r10       # 0x10e8d2
leaq 0x89b(%rip), %r11       # 0x10e7e0
leaq 0x7ba(%rip), %rbx       # 0x10e706
leaq 0x6dc(%rip), %r14       # 0x10e62f
leaq 0x5f4(%rip), %r15       # 0x10e54e
leaq 0x4b(%rip), %rsi        # 0x10dfac
leaq 0x128(%rip), %rdx       # 0x10e090
leaq 0x246(%rip), %rcx       # 0x10e1b5
leaq 0x366(%rip), %r8        # 0x10e2dc
leaq 0x4a6(%rip), %r9        # 0x10e423
pushq $0x20
popq %rdi
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq %r15
callq 0x10d068
addq $0x30, %rsp
movq %rax, 0x32f84e(%rip)    # 0x43d7e8
callq 0x69ede
movq 0x32f842(%rip), %rax    # 0x43d7e8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_reset
static int gt_rdb_stmt_sqlite_reset(GtRDBStmt *st, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  rval = sqlite3_reset(sts->stmt);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  if (!had_err) {
    rval = sqlite3_clear_bindings(sts->stmt);
    if (rval != SQLITE_OK) {
      gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
      had_err = -1;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x10e02a
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x10dfd0
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e058
callq 0x10df1c
movq %rax, %rdi
movq %r14, %rsi
callq 0x10d444
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0x22419f
testl %eax, %eax
jne 0x10dffd
movq 0x8(%r14), %rdi
callq 0x2242d3
testl %eax, %eax
je 0x10e026
movl %eax, %ebp
movq 0x10(%r14), %rdi
callq 0x2280b1
leaq 0x221b1e(%rip), %rsi    # 0x32fb2d
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x10e021
movq 0x329f37(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6fd8(%rip), %rsi    # 0x2e5013
leaq 0x26846c(%rip), %rdx    # 0x3764ae
leaq 0x221bd5(%rip), %rcx    # 0x32fc1e
leaq 0x221a7e(%rip), %r8     # 0x32face
movl $0x85, %r9d
jmp 0x10e084
movq 0x329f09(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6faa(%rip), %rsi    # 0x2e5013
leaq 0x1d714f(%rip), %rdx    # 0x2e51bf
leaq 0x221ba7(%rip), %rcx    # 0x32fc1e
leaq 0x221a50(%rip), %r8     # 0x32face
movl $0x86, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_bind_int
static int gt_rdb_stmt_sqlite_bind_int(GtRDBStmt *st, GtUword param_no,
                                       int val, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  gt_assert(param_no < sts->num_params);
  rval = sqlite3_bind_int(sts->stmt, param_no + 1, val);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10e121
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x10e0c0
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e17d
callq 0x10df1c
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d444
cmpq %r14, 0x18(%rax)
jbe 0x10e14f
movq %rax, %r15
movq 0x8(%rax), %rdi
incl %r14d
movl %r14d, %esi
movl %ebp, %edx
callq 0x225def
testl %eax, %eax
je 0x10e114
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x2280b1
leaq 0x221a2d(%rip), %rsi    # 0x32fb2d
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0x10e116
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x329e40(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6ee1(%rip), %rsi    # 0x2e5013
leaq 0x268375(%rip), %rdx    # 0x3764ae
leaq 0x221af7(%rip), %rcx    # 0x32fc37
leaq 0x221987(%rip), %r8     # 0x32face
movl $0xa5, %r9d
jmp 0x10e1a9
movq 0x329e12(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6eb3(%rip), %rsi    # 0x2e5013
leaq 0x221aec(%rip), %rdx    # 0x32fc53
leaq 0x221ac9(%rip), %rcx    # 0x32fc37
leaq 0x221959(%rip), %r8     # 0x32face
movl $0xa8, %r9d
jmp 0x10e1a9
movq 0x329de4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6e85(%rip), %rsi    # 0x2e5013
leaq 0x1d702a(%rip), %rdx    # 0x2e51bf
leaq 0x221a9b(%rip), %rcx    # 0x32fc37
leaq 0x22192b(%rip), %r8     # 0x32face
movl $0xa6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_bind_string
static int gt_rdb_stmt_sqlite_bind_string(GtRDBStmt *st, GtUword param_no,
                                          const char *val, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  gt_assert(param_no < sts->num_params);
  rval = sqlite3_bind_text(sts->stmt, param_no + 1, val, strlen(val),
                           SQLITE_STATIC);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10e38f
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x10e311
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e3eb
callq 0x10df1c
movq %rax, %rdi
movq %r12, %rsi
callq 0x10d444
cmpq %r15, 0x18(%rax)
jbe 0x10e3bd
movq %rax, %r12
movq 0x8(%rax), %rbp
incl %r15d
movq %r14, %rdi
callq 0x172d0
xorl %r13d, %r13d
movq %rbp, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x225ec9
testl %eax, %eax
je 0x10e37d
movl %eax, %ebp
movq 0x10(%r12), %rdi
callq 0x2280b1
leaq 0x2217c3(%rip), %rsi    # 0x32fb2d
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %r13
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x329bd2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6c73(%rip), %rsi    # 0x2e5013
leaq 0x268107(%rip), %rdx    # 0x3764ae
leaq 0x2218de(%rip), %rcx    # 0x32fc8c
leaq 0x221719(%rip), %r8     # 0x32face
movl $0xc7, %r9d
jmp 0x10e417
movq 0x329ba4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6c45(%rip), %rsi    # 0x2e5013
leaq 0x22187e(%rip), %rdx    # 0x32fc53
leaq 0x2218b0(%rip), %rcx    # 0x32fc8c
leaq 0x2216eb(%rip), %r8     # 0x32face
movl $0xca, %r9d
jmp 0x10e417
movq 0x329b76(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6c17(%rip), %rsi    # 0x2e5013
leaq 0x1d6dbc(%rip), %rdx    # 0x2e51bf
leaq 0x221882(%rip), %rcx    # 0x32fc8c
leaq 0x2216bd(%rip), %r8     # 0x32face
movl $0xc8, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_bind_double
static int gt_rdb_stmt_sqlite_bind_double(GtRDBStmt *st, GtUword param_no,
                                          double val, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  gt_assert(param_no < sts->num_params);
  rval = sqlite3_bind_double(sts->stmt, param_no + 1, val);
  if (rval != SQLITE_OK) {
    gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10e4ba
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, (%rsp)
testq %rdx, %rdx
je 0x10e456
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e516
callq 0x10df1c
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d444
cmpq %r14, 0x18(%rax)
jbe 0x10e4e8
movq %rax, %r15
movq 0x8(%rax), %rdi
incl %r14d
movl %r14d, %esi
movsd (%rsp), %xmm0
callq 0x225cad
testl %eax, %eax
je 0x10e4ad
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x2280b1
leaq 0x221694(%rip), %rsi    # 0x32fb2d
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0x10e4af
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x329aa7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6b48(%rip), %rsi    # 0x2e5013
leaq 0x267fdc(%rip), %rdx    # 0x3764ae
leaq 0x2217d2(%rip), %rcx    # 0x32fcab
leaq 0x2215ee(%rip), %r8     # 0x32face
movl $0xd9, %r9d
jmp 0x10e542
movq 0x329a79(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6b1a(%rip), %rsi    # 0x2e5013
leaq 0x221753(%rip), %rdx    # 0x32fc53
leaq 0x2217a4(%rip), %rcx    # 0x32fcab
leaq 0x2215c0(%rip), %r8     # 0x32face
movl $0xdc, %r9d
jmp 0x10e542
movq 0x329a4b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6aec(%rip), %rsi    # 0x2e5013
leaq 0x1d6c91(%rip), %rdx    # 0x2e51bf
leaq 0x221776(%rip), %rcx    # 0x32fcab
leaq 0x221592(%rip), %r8     # 0x32face
movl $0xda, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_exec
static int gt_rdb_stmt_sqlite_exec(GtRDBStmt *st, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int rval, had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  switch ((rval = sqlite3_step(sts->stmt))) {
    case SQLITE_ROW:
      break;
    case SQLITE_DONE:
      had_err = 1;  /* last row read */
      break;
    default:
      gt_error_set(err, GT_SQLITE_ERRMSG, rval, sqlite3_errmsg(sts->db));
      had_err = -1;
      break;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x10e5c9
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x10e572
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e5f7
callq 0x10df1c
movq %rax, %rdi
movq %r14, %rsi
callq 0x10d444
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0x224bf7
cmpl $0x64, %eax
je 0x10e59e
movl %eax, %ebp
cmpl $0x65, %eax
jne 0x10e5a2
pushq $0x1
jmp 0x10e5c3
xorl %eax, %eax
jmp 0x10e5c4
movq 0x10(%r14), %rdi
callq 0x2280b1
leaq 0x22157b(%rip), %rsi    # 0x32fb2d
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x329998(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6a39(%rip), %rsi    # 0x2e5013
leaq 0x267ecd(%rip), %rdx    # 0x3764ae
leaq 0x2216e2(%rip), %rcx    # 0x32fcca
leaq 0x2214df(%rip), %r8     # 0x32face
movl $0xe9, %r9d
jmp 0x10e623
movq 0x32996a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6a0b(%rip), %rsi    # 0x2e5013
leaq 0x1d6bb0(%rip), %rdx    # 0x2e51bf
leaq 0x2216b4(%rip), %rcx    # 0x32fcca
leaq 0x2214b1(%rip), %r8     # 0x32face
movl $0xea, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_int
static int gt_rdb_stmt_sqlite_get_int(GtRDBStmt *st, GtUword field_no,
                                      int *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    *result = sqlite3_column_int(sts->stmt, field_no);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10e6a0
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x10e659
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e6ce
callq 0x10df1c
movq %rax, %rdi
movq %r12, %rsi
callq 0x10d444
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x10e680
movl %r15d, %esi
callq 0x225a3c
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0x10e694
leaq 0x221676(%rip), %rsi    # 0x32fcfd
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3298c1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6962(%rip), %rsi    # 0x2e5013
leaq 0x267df6(%rip), %rdx    # 0x3764ae
leaq 0x221623(%rip), %rcx    # 0x32fce2
leaq 0x221408(%rip), %r8     # 0x32face
movl $0xff, %r9d
jmp 0x10e6fa
movq 0x329893(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6934(%rip), %rsi    # 0x2e5013
leaq 0x1d6ad9(%rip), %rdx    # 0x2e51bf
leaq 0x2215f5(%rip), %rcx    # 0x32fce2
leaq 0x2213da(%rip), %r8     # 0x32face
movl $0x100, %r9d            # imm = 0x100
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_ulong
static int gt_rdb_stmt_sqlite_get_ulong(GtRDBStmt *st, GtUword field_no,
                                        GtUword *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    *result = (GtUword) sqlite3_column_int(sts->stmt, field_no);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10e77a
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x10e730
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e7a8
callq 0x10df1c
movq %rax, %rdi
movq %r12, %rsi
callq 0x10d444
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x10e75a
movl %r15d, %esi
callq 0x225a3c
cltq
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x10e76e
leaq 0x22159c(%rip), %rsi    # 0x32fcfd
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3297e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6888(%rip), %rsi    # 0x2e5013
leaq 0x267d1c(%rip), %rdx    # 0x3764ae
leaq 0x22157c(%rip), %rcx    # 0x32fd15
leaq 0x22132e(%rip), %r8     # 0x32face
movl $0x111, %r9d            # imm = 0x111
jmp 0x10e7d4
movq 0x3297b9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d685a(%rip), %rsi    # 0x2e5013
leaq 0x1d69ff(%rip), %rdx    # 0x2e51bf
leaq 0x22154e(%rip), %rcx    # 0x32fd15
leaq 0x221300(%rip), %r8     # 0x32face
movl $0x112, %r9d            # imm = 0x112
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_string
static int gt_rdb_stmt_sqlite_get_string(GtRDBStmt *st, GtUword field_no,
                                         GtStr *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    gt_str_reset(result);
    gt_str_append_cstr(result,
                       (const char*) sqlite3_column_text(sts->stmt, field_no));
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10e86c
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %rcx, %rcx
je 0x10e80e
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e89a
callq 0x10df1c
movq %rax, %rdi
movq %r12, %rsi
callq 0x10d444
cmpq $0x0, 0x8(%rax)
je 0x10e84c
movq %rax, %r12
movq %rbx, %rdi
callq 0xad357
movq 0x8(%r12), %rdi
movl %r14d, %esi
callq 0x225a90
movq %rbx, %rdi
movq %rax, %rsi
callq 0xacbfb
xorl %eax, %eax
jmp 0x10e860
leaq 0x2214aa(%rip), %rsi    # 0x32fcfd
movq %r15, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3296f5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6796(%rip), %rsi    # 0x2e5013
leaq 0x267c2a(%rip), %rdx    # 0x3764ae
leaq 0x2214a7(%rip), %rcx    # 0x32fd32
leaq 0x22123c(%rip), %r8     # 0x32face
movl $0x123, %r9d            # imm = 0x123
jmp 0x10e8c6
movq 0x3296c7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6768(%rip), %rsi    # 0x2e5013
leaq 0x1d690d(%rip), %rdx    # 0x2e51bf
leaq 0x221479(%rip), %rcx    # 0x32fd32
leaq 0x22120e(%rip), %r8     # 0x32face
movl $0x124, %r9d            # imm = 0x124
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_sqlite.c
// Function: gt_rdb_stmt_sqlite_get_double
static int gt_rdb_stmt_sqlite_get_double(GtRDBStmt *st, GtUword field_no,
                                         double *result, GtError *err)
{
  GtRDBStmtSqlite *sts;
  int had_err = 0;
  gt_assert(st);
  gt_error_check(err);
  sts = gt_rdb_stmt_sqlite_cast(st);
  if (!sts->stmt) {
    gt_error_set(err, "uninitialized statement");
    had_err = -1;
  }
  if (!had_err) {
    *result = sqlite3_column_double(sts->stmt, field_no);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10e945
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x10e8fc
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10e973
callq 0x10df1c
movq %rax, %rdi
movq %r12, %rsi
callq 0x10d444
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x10e925
movl %r15d, %esi
callq 0x225a0d
movsd %xmm0, (%rbx)
xorl %eax, %eax
jmp 0x10e939
leaq 0x2213d1(%rip), %rsi    # 0x32fcfd
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x32961c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d66bd(%rip), %rsi    # 0x2e5013
leaq 0x267b51(%rip), %rdx    # 0x3764ae
leaq 0x2213ec(%rip), %rcx    # 0x32fd50
leaq 0x221163(%rip), %r8     # 0x32face
movl $0x137, %r9d            # imm = 0x137
jmp 0x10e99f
movq 0x3295ee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d668f(%rip), %rsi    # 0x2e5013
leaq 0x1d6834(%rip), %rdx    # 0x2e51bf
leaq 0x2213be(%rip), %rcx    # 0x32fd50
leaq 0x221135(%rip), %r8     # 0x32face
movl $0x138, %r9d            # imm = 0x138
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_visitor.c
// Function: gt_rdb_visitor_class_new
const GtRDBVisitorClass*
gt_rdb_visitor_class_new(size_t size,
                          GtRDBVisitorFreeFunc free,
                          GtRDBVisitorSqliteFunc sqlite_func,
                          GtRDBVisitorMySQLFunc mysql_func)
{
  GtRDBVisitorClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->sqlite_func = sqlite_func;
  c_class->mysql_func = mysql_func;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10ea10
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x292a70
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x329551(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d65f2(%rip), %rsi    # 0x2e5013
leaq 0x1f4dc5(%rip), %rdx    # 0x3037ed
leaq 0x22133f(%rip), %rcx    # 0x32fd6e
leaq 0x221351(%rip), %r8     # 0x32fd87
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_visitor.c
// Function: gt_rdb_visitor_create
GtRDBVisitor* gt_rdb_visitor_create(const GtRDBVisitorClass *rdbvc)
{
  GtRDBVisitor *rdbv;
  gt_assert(rdbvc && rdbvc->size);
  rdbv = gt_calloc(1, rdbvc->size);
  rdbv->c_class = rdbvc;
  return rdbv;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x10ea6e
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x10ea6e
leaq 0x221329(%rip), %rdx    # 0x32fd87
pushq $0x1
popq %rdi
pushq $0x35
popq %rcx
callq 0x9334a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x3294f3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6594(%rip), %rsi    # 0x2e5013
leaq 0x22131c(%rip), %rdx    # 0x32fda2
leaq 0x22132a(%rip), %rcx    # 0x32fdb7
leaq 0x2212f3(%rip), %r8     # 0x32fd87
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_visitor.c
// Function: gt_rdb_visitor_visit_sqlite
int gt_rdb_visitor_visit_sqlite(GtRDBVisitor *rdbv, GtRDBSqlite *rdbs,
                                GtError *err)
{
  gt_error_check(err);
  gt_assert(rdbv && rdbs && rdbv->c_class);
  if (rdbv->c_class->sqlite_func)
    return rdbv->c_class->sqlite_func(rdbv, rdbs, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x10eb0d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10eb6a
testq %r15, %r15
je 0x10eb40
testq %r14, %r14
je 0x10eb40
movq (%r15), %rax
testq %rax, %rax
je 0x10eb40
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x10eb38
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x329421(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d64c2(%rip), %rsi    # 0x2e5013
leaq 0x2212cd(%rip), %rdx    # 0x32fe25
leaq 0x2212aa(%rip), %rcx    # 0x32fe09
leaq 0x221221(%rip), %r8     # 0x32fd87
pushq $0x45
jmp 0x10eb92
movq 0x3293f7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6498(%rip), %rsi    # 0x2e5013
leaq 0x1d663d(%rip), %rdx    # 0x2e51bf
leaq 0x221280(%rip), %rcx    # 0x32fe09
leaq 0x2211f7(%rip), %r8     # 0x32fd87
pushq $0x44
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_visitor.c
// Function: gt_rdb_visitor_visit_mysql
int gt_rdb_visitor_visit_mysql(GtRDBVisitor *rdbv, GtRDBMySQL *rdbm,
                               GtError *err)
{
  gt_error_check(err);
  gt_assert(rdbv && rdbm && rdbv->c_class);
  if (rdbv->c_class->mysql_func)
    return rdbv->c_class->mysql_func(rdbv, rdbm, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x10ebbf
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x10ec1c
testq %r15, %r15
je 0x10ebf2
testq %r14, %r14
je 0x10ebf2
movq (%r15), %rax
testq %rax, %rax
je 0x10ebf2
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x10ebea
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x32936f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d6410(%rip), %rsi    # 0x2e5013
leaq 0x221254(%rip), %rdx    # 0x32fe5e
leaq 0x221232(%rip), %rcx    # 0x32fe43
leaq 0x22116f(%rip), %r8     # 0x32fd87
pushq $0x4f
jmp 0x10ec44
movq 0x329345(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d63e6(%rip), %rsi    # 0x2e5013
leaq 0x1d658b(%rip), %rdx    # 0x2e51bf
leaq 0x221208(%rip), %rcx    # 0x32fe43
leaq 0x221145(%rip), %r8     # 0x32fd87
pushq $0x4e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rdb_visitor.c
// Function: gt_rdb_visitor_delete
void gt_rdb_visitor_delete(GtRDBVisitor *rdbv)
{
  if (!rdbv) return;
  gt_assert(rdbv->c_class);
  if (rdbv->c_class->free)
    rdbv->c_class->free(rdbv);
  gt_free(rdbv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x10ec84
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x10ec86
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x10ec71
movq %rbx, %rdi
callq *%rax
leaq 0x22110f(%rip), %rsi    # 0x32fd87
pushq $0x5b
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
popq %rbx
retq
movq 0x3292db(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d637c(%rip), %rsi    # 0x2e5013
leaq 0x2211d0(%rip), %rdx    # 0x32fe6e
leaq 0x2211d7(%rip), %rcx    # 0x32fe7c
leaq 0x2210db(%rip), %r8     # 0x32fd87
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/reconstructalignment.c
// Function: gt_reconstructalignment_trivial_deletion
GtUword gt_reconstructalignment_trivial_deletion(GtAlignment *align,
                                                 GtUword len,
                                                 GtUword gapcost)
{
  GtUword idx;

  for (idx = 0; idx < len; idx ++)
  {
    gt_alignment_add_deletion(align);
  }
  return len * gapcost;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %r12
subq $0x1, %r12
jb 0x10ece0
movq %r15, %rdi
callq 0xb5258
jmp 0x10ecd0
imulq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/reconstructalignment.c
// Function: gt_reconstructalignment_trivial_insertion
GtUword gt_reconstructalignment_trivial_insertion(GtAlignment *align,
                                                  GtUword len,
                                                  GtUword gapcost)
{
  GtUword idx;

  for (idx = 0; idx < len; idx ++)
  {
    gt_alignment_add_insertion(align);
  }

  return len * gapcost;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %r12
subq $0x1, %r12
jb 0x10ed17
movq %r15, %rdi
callq 0xb52a8
jmp 0x10ed07
imulq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_node_builder.c
// Function: gt_region_node_builder_add_region
void gt_region_node_builder_add_region(GtRegionNodeBuilder *rnb,
                                       const char *region_name,
                                       GtRange region_range)
{
  GtRange *rangeptr;
  gt_assert(rnb && region_name);
  if ((rangeptr = gt_hashmap_get(rnb->sequence_region_to_range, region_name))) {
    /* sequence region is already defined -> update range */
    *rangeptr = gt_range_join(&region_range, rangeptr);
  }
  else {
    /* sequence region is not already defined -> define it */
    rangeptr = gt_malloc(sizeof (GtRange));
    *rangeptr = region_range;
    gt_hashmap_add(rnb->sequence_region_to_range, gt_cstr_dup(region_name),
                   rangeptr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
testq %rdi, %rdi
je 0x1113a8
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1113a8
movq %rdi, %r14
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x8f482
testq %rax, %rax
je 0x11136a
movq %rax, %r15
movq %rsp, %rdi
movq %rax, %rsi
callq 0xa33f9
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21f324(%rip), %rsi    # 0x330695
pushq $0x10
popq %rdi
pushq $0x38
popq %rdx
callq 0x93160
movq %rax, %r15
movups (%rsp), %xmm0
movups %xmm0, (%rax)
movq (%r14), %r14
movq %rbx, %rdi
callq 0x6c2be
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8f4bd
movq 0x326bb9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3c5a(%rip), %rsi    # 0x2e5013
leaq 0x21f2f8(%rip), %rdx    # 0x3306b8
leaq 0x21f304(%rip), %rcx    # 0x3306cb
leaq 0x21f2c7(%rip), %r8     # 0x330695
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_node_builder.c
// Function: gt_region_node_builder_build
void gt_region_node_builder_build(const GtRegionNodeBuilder *rnb,
                                  GtQueue *genome_nodes)
{
  GT_UNUSED int had_err;
  gt_assert(rnb && genome_nodes);
  had_err = gt_hashmap_foreach(rnb->sequence_region_to_range,
                               build_region_nodes, genome_nodes, NULL);
  gt_assert(!had_err); /* build_region_nodes() is sane */
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x111403
movq %rsi, %rdx
testq %rsi, %rsi
je 0x111403
movq (%rdi), %rdi
leaq 0x6d(%rip), %rsi        # 0x111463
xorl %ecx, %ecx
callq 0x8f56e
testl %eax, %eax
jne 0x11142d
popq %rax
retq
movq 0x326b5e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3bff(%rip), %rsi    # 0x2e5013
leaq 0x21f2d2(%rip), %rdx    # 0x3306ed
leaq 0x21f2df(%rip), %rcx    # 0x330701
leaq 0x21f26c(%rip), %r8     # 0x330695
pushq $0x54
jmp 0x111455
movq 0x326b34(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3bd5(%rip), %rsi    # 0x2e5013
leaq 0x1d423a(%rip), %rdx    # 0x2e567f
leaq 0x21f2b5(%rip), %rcx    # 0x330701
leaq 0x21f242(%rip), %r8     # 0x330695
pushq $0x57
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/region_node_builder.c
// Function: build_region_nodes
static int build_region_nodes(void *key, void *value, void *data,
                              GT_UNUSED GtError *err)
{
  GtStr *seqid;
  GtRange range;
  GtGenomeNode *gn;
  GtQueue *genome_nodes = (GtQueue*) data;
  gt_error_check(err);
  gt_assert(key && value && data);
  seqid = gt_str_new_cstr(key);
  range = *(GtRange*) value;
  gn = gt_region_node_new(seqid, range.start, range.end);
  gt_queue_add(genome_nodes, gn);
  gt_str_delete(seqid);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x111482
movq %rcx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1114f0
testq %r15, %r15
je 0x1114c6
testq %r14, %r14
je 0x1114c6
testq %rbx, %rbx
je 0x1114c6
movq %r15, %rdi
callq 0xacbd1
movq %rax, %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x1110cc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9e2d1
movq %r15, %rdi
callq 0xae103
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x326a9b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3b3c(%rip), %rsi    # 0x2e5013
leaq 0x1f8e92(%rip), %rdx    # 0x30a370
leaq 0x21f25a(%rip), %rcx    # 0x33073f
leaq 0x21f1a9(%rip), %r8     # 0x330695
pushq $0x47
jmp 0x111518
movq 0x326a71(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3b12(%rip), %rsi    # 0x2e5013
leaq 0x1d3cb7(%rip), %rdx    # 0x2e51bf
leaq 0x21f230(%rip), %rcx    # 0x33073f
leaq 0x21f17f(%rip), %r8     # 0x330695
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/regioncov_visitor.c
// Function: gt_regioncov_visitor_class
const GtNodeVisitorClass* gt_regioncov_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtRegionCovVisitor),
                                    gt_regioncov_visitor_free,
                                    NULL,
                                    gt_regioncov_visitor_feature_node,
                                    gt_regioncov_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x32c27e(%rip)    # 0x43d7f8
jne 0x1115aa
andq $0x0, (%rsp)
leaq 0x30(%rip), %rsi        # 0x1115b8
leaq 0x47(%rip), %rcx        # 0x1115d6
leaq 0x176(%rip), %r8        # 0x11170c
pushq $0x20
popq %rdi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x32c24e(%rip)    # 0x43d7f8
callq 0x69ede
movq 0x32c242(%rip), %rax    # 0x43d7f8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/regioncov_visitor.c
// Function: gt_regioncov_visitor_feature_node
static int gt_regioncov_visitor_feature_node(GtNodeVisitor *nv,
                                             GtFeatureNode *fn,
                                             GT_UNUSED GtError *err)
{
  GtRange *old_range_ptr, old_range, new_range;
  GtArray *ranges;
  GtRegionCovVisitor *regioncov_visitor;
  gt_error_check(err);
  regioncov_visitor = gt_regioncov_visitor_cast(nv);
  ranges = gt_hashmap_get(regioncov_visitor->region2rangelist,
                       gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*)
                                                           fn)));
  gt_assert(ranges);
  new_range = gt_genome_node_get_range((GtGenomeNode*) fn);
  if (!gt_array_size(ranges))
    gt_array_add(ranges, new_range);
  else {
    old_range_ptr = gt_array_get_last(ranges);
    old_range = *old_range_ptr;
    old_range.end += regioncov_visitor->max_feature_dist;
    if (gt_range_overlap(&old_range, &new_range)) {
      old_range_ptr->end = GT_MAX(old_range_ptr->end, new_range.end);
    }
    else
      gt_array_add(ranges, new_range);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1115fa
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1116d6
callq 0x11156c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
movq %rax, %r14
movq 0x18(%rax), %rbx
movq %r15, %rdi
callq 0xdd14a
movq %rax, %rdi
callq 0xad1fa
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8f482
testq %rax, %rax
je 0x1116ac
movq %rax, %rbx
movq %r15, %rdi
callq 0xdd1f4
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x586a4
testq %rax, %rax
je 0x111692
movq %rbx, %rdi
callq 0x581ff
movq %rax, %r15
movups (%rax), %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq 0x10(%r14), %rax
addq %rax, 0x8(%rdi)
movq %rsp, %rsi
callq 0xa3234
testb %al, %al
je 0x111692
movq 0x8(%r15), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rcx, 0x8(%r15)
jmp 0x1116a0
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x5851d
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x3268b5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3956(%rip), %rsi    # 0x2e5013
leaq 0x1d9a84(%rip), %rdx    # 0x2eb148
leaq 0x21f0cb(%rip), %rcx    # 0x330796
leaq 0x21f0a3(%rip), %r8     # 0x330775
pushq $0x38
jmp 0x1116fe
movq 0x32688b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d392c(%rip), %rsi    # 0x2e5013
leaq 0x1d3ad1(%rip), %rdx    # 0x2e51bf
leaq 0x21f0a1(%rip), %rcx    # 0x330796
leaq 0x21f079(%rip), %r8     # 0x330775
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/regioncov_visitor.c
// Function: gt_regioncov_visitor_region_node
static int gt_regioncov_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                         GT_UNUSED GtError *err)
{
  GtRegionCovVisitor *regioncov_visitor;
  GtArray *rangelist;
  gt_error_check(err);
  regioncov_visitor = gt_regioncov_visitor_cast(nv);
  rangelist = gt_array_new(sizeof (GtRange));
  gt_hashmap_add(regioncov_visitor->region2rangelist,
              gt_cstr_dup(gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*)
                                                              rn))),
              rangelist);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x111728
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x111778
callq 0x11156c
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x5809c
movq %rax, %r15
movq 0x18(%r14), %r14
movq %rbx, %rdi
callq 0xdd14a
movq %rax, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x6c2be
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8f4bd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3267e9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d388a(%rip), %rsi    # 0x2e5013
leaq 0x1d3a2f(%rip), %rdx    # 0x2e51bf
leaq 0x21f021(%rip), %rcx    # 0x3307b8
leaq 0x21efd7(%rip), %r8     # 0x330775
pushq $0x4e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/regioncov_visitor.c
// Function: gt_regioncov_visitor_new
GtNodeVisitor* gt_regioncov_visitor_new(GtUword max_feature_dist)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_regioncov_visitor_class());
  GtRegionCovVisitor *regioncov_visitor = gt_regioncov_visitor_cast(nv);
  regioncov_visitor->max_feature_dist = max_feature_dist;
  regioncov_visitor->region2rangelist =
    gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_array_delete);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x11156c
movq %rax, %rdi
callq 0x102da0
movq %rax, %r14
callq 0x11156c
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rax, %r15
movq %rbx, 0x10(%rax)
leaq -0x7dfa5(%rip), %rsi    # 0x9383f
leaq -0xb8932(%rip), %rdx    # 0x58eb9
pushq $0x1
popq %rdi
callq 0x8f330
movq %rax, 0x18(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/regioncov_visitor.c
// Function: gt_regioncov_visitor_show_coverage
void gt_regioncov_visitor_show_coverage(GtNodeVisitor *nv)
{
  GtRegionCovVisitor *regioncov_visitor = gt_regioncov_visitor_cast(nv);
  GT_UNUSED int had_err;
  had_err = gt_hashmap_foreach_in_key_order(regioncov_visitor->region2rangelist,
                                         show_rangelist, NULL, NULL);
  gt_assert(!had_err); /* show_rangelist() is sane */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x11156c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
movq 0x18(%rax), %rdi
leaq 0x47(%rip), %rsi        # 0x111866
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8f595
testl %eax, %eax
jne 0x11182e
popq %rbx
retq
movq 0x326733(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d37d4(%rip), %rsi    # 0x2e5013
leaq 0x1d3e39(%rip), %rdx    # 0x2e567f
leaq 0x21ef05(%rip), %rcx    # 0x330752
leaq 0x21ef21(%rip), %r8     # 0x330775
movl $0x8d, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/regioncov_visitor.c
// Function: show_rangelist
static int show_rangelist(void *key, void *value, GT_UNUSED void *data,
                          GT_UNUSED GtError *err)
{
  GtUword i;
  GtArray *rangelist;
  GtRange *rangeptr;
  gt_error_check(err);
  gt_assert(key && value);
  rangelist = (GtArray*) value;
  if (gt_array_size(rangelist)) {
    gt_assert(gt_ranges_are_sorted_and_do_not_overlap(rangelist));
    printf("%s:\n", (char*) key);
    for (i = 0; i < gt_array_size(rangelist); i++) {
      rangeptr = gt_array_get(rangelist, i);
      printf(""GT_WU", "GT_WU"\n", rangeptr->start, rangeptr->end);
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0x111886
movq %rcx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x111928
testq %r14, %r14
je 0x1118fe
testq %rbx, %rbx
je 0x1118fe
movq %rbx, %rdi
callq 0x586a4
testq %rax, %rax
je 0x1118f6
movq %rbx, %rdi
callq 0xa3efd
testb %al, %al
je 0x111952
leaq 0x21ef67(%rip), %rdi    # 0x33081b
movq %r14, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x21ef5b(%rip), %r14    # 0x330820
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x586a4
cmpq %rax, %r15
jae 0x1118f6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x581aa
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
incq %r15
jmp 0x1118c8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x326663(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3704(%rip), %rsi    # 0x2e5013
leaq 0x254d50(%rip), %rdx    # 0x366666
leaq 0x21eebc(%rip), %rcx    # 0x3307d9
leaq 0x21ee51(%rip), %r8     # 0x330775
pushq $0x7a
jmp 0x11197a
movq 0x326639(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d36da(%rip), %rsi    # 0x2e5013
leaq 0x1d387f(%rip), %rdx    # 0x2e51bf
leaq 0x21ee92(%rip), %rcx    # 0x3307d9
leaq 0x21ee27(%rip), %r8     # 0x330775
pushq $0x79
jmp 0x11197a
movq 0x32660f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d36b0(%rip), %rsi    # 0x2e5013
leaq 0x21ee7e(%rip), %rdx    # 0x3307e8
leaq 0x21ee68(%rip), %rcx    # 0x3307d9
leaq 0x21edfd(%rip), %r8     # 0x330775
pushq $0x7d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/regular_seqid.c
// Function: gt_regular_seqid_save
void gt_regular_seqid_save(GtStr *seqid, GtStr *description)
{
  GtUword i, len;
  unsigned char *desc, cc;

  gt_assert(seqid && description);

  len  = gt_str_length(description);
  desc = (GtUchar*) gt_str_get(description);

  i = 0;

  if ((len >= 2) && (desc[0] == 'g') && (desc[1] == 'i') && (desc[2] == '|')) {
    /* skip 'gi|' */
    i = 3;
  }
  else if ((len >= 2) && (desc[0] == 'S') && (desc[1] == 'Q') &&
           (desc[2] == ';')) {
    /* skip 'SQ;' */
    i = 3;
  }
  else if ((len >= 3) && (desc[0] == '(') && (desc[1] == 'g') &&
           (desc[2] == 'i') && (desc[3] == '|')) {
    /* skip '(gi|' */
    i = 4;
  }
  else if ((len >= 3) && (desc[0] == 'r') && (desc[1] == 'e') &&
           (desc[2] == 'f') && (desc[3] == '|')) {
    /* skip 'ref|' */
    i = 4;
  }

  for (/* init already done */ ; i < len; i++) {
    cc = desc[i];
    if (cc == ':' || cc == '|' || cc == '\t' || cc == ' ')
      break;
    gt_str_append_char(seqid, desc[i]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x111a82
movq %rsi, %r15
testq %rsi, %rsi
je 0x111a82
movq %rdi, %rbx
movq %r15, %rdi
callq 0xad289
movq %rax, %r14
movq %r15, %rdi
callq 0xad1fa
movq %rax, %r15
cmpq $0x2, %r14
jb 0x111a40
movzbl (%r15), %eax
cmpl $0x53, %eax
je 0x1119e3
cmpl $0x67, %eax
jne 0x1119f7
cmpb $0x69, 0x1(%r15)
jne 0x1119f7
cmpb $0x7c, 0x2(%r15)
je 0x1119f1
jmp 0x1119f7
cmpb $0x51, 0x1(%r15)
jne 0x1119f7
cmpb $0x3b, 0x2(%r15)
jne 0x1119f7
pushq $0x3
popq %r12
jmp 0x111a43
cmpq $0x2, %r14
je 0x111a40
cmpl $0x72, %eax
je 0x111a20
cmpl $0x28, %eax
jne 0x111a40
cmpb $0x67, 0x1(%r15)
jne 0x111a40
cmpb $0x69, 0x2(%r15)
jne 0x111a40
cmpb $0x7c, 0x3(%r15)
jne 0x111a40
pushq $0x4
jmp 0x1119f3
cmpb $0x65, 0x1(%r15)
jne 0x111a40
cmpb $0x66, 0x2(%r15)
jne 0x111a40
xorl %r12d, %r12d
cmpb $0x7c, 0x3(%r15)
sete %r12b
shll $0x2, %r12d
jmp 0x111a43
xorl %r12d, %r12d
movabsq $0x400000100000200, %r13 # imm = 0x400000100000200
cmpq %r14, %r12
jae 0x111a78
movzbl (%r15,%r12), %eax
cmpq $0x3a, %rax
ja 0x111a63
btq %rax, %r13
jb 0x111a78
cmpl $0x7c, %eax
je 0x111a78
movsbl %al, %esi
movq %rbx, %rdi
callq 0xaced9
incq %r12
jmp 0x111a4d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x3264df(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d3580(%rip), %rsi    # 0x2e5013
leaq 0x21ed90(%rip), %rdx    # 0x33082a
leaq 0x21ed9e(%rip), %rcx    # 0x33083f
leaq 0x21edad(%rip), %r8     # 0x330855
pushq $0x1a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390