LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1746f7
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x174668
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1746fc
leaq 0x224667(%rip), %rsi    # 0x398cd6
xorl %ebx, %ebx
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x174108
testq %rax, %rax
je 0x1746e8
movq %rax, %r15
callq 0xe8d9c
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1741ce
testl %eax, %eax
jne 0x1746d2
callq 0x1208f8
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x174276
movq %r12, %rdi
callq 0x120d23
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe8e02
movq %r12, %rdi
callq 0x121b03
jmp 0x17468e
testl %eax, %eax
jns 0x1746e0
movq %rbx, %rdi
callq 0xe9120
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x1741ef
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x519d8
callq 0x5199f
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x355125(%rip)    # 0x4c9838
jne 0x174781
leaq 0x67b(%rip), %rax       # 0x174d97
leaq 0x5e2(%rip), %r10       # 0x174d05
leaq 0x536(%rip), %r11       # 0x174c60
leaq 0x49c(%rip), %rbx       # 0x174bcd
leaq 0x405(%rip), %r14       # 0x174b3d
leaq 0x378(%rip), %r15       # 0x174ab7
leaq 0x4d(%rip), %rsi        # 0x174793
leaq 0xcc(%rip), %rdx        # 0x174819
leaq 0x15f(%rip), %rcx       # 0x1748b3
leaq 0x1f8(%rip), %r8        # 0x174953
leaq 0x2b1(%rip), %r9        # 0x174a13
movl $0x20, %edi
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq %r15
callq 0x173ed6
addq $0x30, %rsp
movq %rax, 0x3550b7(%rip)    # 0x4c9838
callq 0xe6a19
movq 0x3550ab(%rip), %rax    # 0x4c9838
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17480f
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1747b3
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174814
callq 0x174701
movq %rax, %rdi
movq %r14, %rsi
callq 0x1740ef
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0x28194a
testl %eax, %eax
jne 0x1747e0
movq 0x8(%r14), %rdi
callq 0x281a9b
testl %eax, %eax
je 0x17480b
movl %eax, %ebp
movq 0x10(%r14), %rdi
callq 0x286451
leaq 0x224425(%rip), %rsi    # 0x398c17
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x174806
callq 0x51a4a
callq 0x51a11
// File: /workspace/github_c_makefile_star2_O1/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 0x1748a4
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0x174841
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1748ae
callq 0x174701
movq %rax, %rdi
movq %r15, %rsi
callq 0x1740ef
cmpq %r14, 0x18(%rax)
jbe 0x1748a9
movq %rax, %r15
movq 0x8(%rax), %rdi
incl %r14d
movl %r14d, %esi
movl %ebp, %edx
callq 0x283b92
testl %eax, %eax
je 0x174897
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x286451
leaq 0x224396(%rip), %rsi    # 0x398c17
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x174899
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x51af5
callq 0x51abc
callq 0x51a83
// File: /workspace/github_c_makefile_star2_O1/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 0x174a04
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x174988
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174a0e
callq 0x174701
movq %rax, %rdi
movq %r12, %rsi
callq 0x1740ef
cmpq %r15, 0x18(%rax)
jbe 0x174a09
movq %rax, %r12
movq 0x8(%rax), %rbp
incl %r15d
movq %r14, %rdi
callq 0x172f0
xorl %r13d, %r13d
movq %rbp, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x283c82
testl %eax, %eax
je 0x1749f2
movl %eax, %ebp
movq 0x10(%r12), %rdi
callq 0x286451
leaq 0x22423a(%rip), %rsi    # 0x398c17
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x51c4b
callq 0x51c12
callq 0x51bd9
// File: /workspace/github_c_makefile_star2_O1/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 0x174aa8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, (%rsp)
testq %rdx, %rdx
je 0x174a42
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174ab2
callq 0x174701
movq %rax, %rdi
movq %r15, %rsi
callq 0x1740ef
cmpq %r14, 0x18(%rax)
jbe 0x174aad
movq %rax, %r15
movq 0x8(%rax), %rdi
incl %r14d
movl %r14d, %esi
movsd (%rsp), %xmm0
callq 0x2839f1
testl %eax, %eax
je 0x174a9b
movl %eax, %ebp
movq 0x10(%r15), %rdi
callq 0x286451
leaq 0x224192(%rip), %rsi    # 0x398c17
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x174a9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x51cf6
callq 0x51cbd
callq 0x51c84
// File: /workspace/github_c_makefile_star2_O1/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 0x174b33
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x174ad7
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174b38
callq 0x174701
movq %rax, %rdi
movq %r14, %rsi
callq 0x1740ef
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0x282502
cmpl $0x64, %eax
je 0x174b06
movl %eax, %ebp
cmpl $0x65, %eax
jne 0x174b0a
movl $0x1, %eax
jmp 0x174b2e
xorl %eax, %eax
jmp 0x174b2e
movq 0x10(%r14), %rdi
callq 0x286451
leaq 0x2240fd(%rip), %rsi    # 0x398c17
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x51d68
callq 0x51d2f
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x174bc3
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %rcx, %rcx
je 0x174b6a
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174bc8
callq 0x174701
movq %rax, %rdi
movq %r12, %rsi
callq 0x1740ef
movq %rax, %r12
movq 0x8(%rax), %r13
xorl %ebp, %ebp
testq %r13, %r13
jne 0x174b9e
leaq 0x224258(%rip), %rsi    # 0x398de7
movq %r15, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r13, %r13
je 0x174bb2
movq 0x8(%r12), %rdi
movl %r14d, %esi
callq 0x283702
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x51dda
callq 0x51da1
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x174c56
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %rcx, %rcx
je 0x174bfa
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174c5b
callq 0x174701
movq %rax, %rdi
movq %r12, %rsi
callq 0x1740ef
movq %rax, %r12
movq 0x8(%rax), %r13
xorl %ebp, %ebp
testq %r13, %r13
jne 0x174c2e
leaq 0x2241c8(%rip), %rsi    # 0x398de7
movq %r15, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r13, %r13
je 0x174c45
movq 0x8(%r12), %rdi
movl %r14d, %esi
callq 0x283702
cltq
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x51e4c
callq 0x51e13
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x174cfb
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %rcx, %rcx
je 0x174c91
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174d00
callq 0x174701
movq %rax, %rdi
movq %r12, %rsi
callq 0x1740ef
movq %rax, %r12
movq 0x8(%rax), %r13
xorl %ebp, %ebp
testq %r13, %r13
jne 0x174cc5
leaq 0x224131(%rip), %rsi    # 0x398de7
movq %r15, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r13, %r13
je 0x174cea
movq %rbx, %rdi
callq 0x120db4
movq 0x8(%r12), %rdi
movl %r14d, %esi
callq 0x283756
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12097f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x51ebe
callq 0x51e85
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x174d8d
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %rcx, %rcx
je 0x174d32
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174d92
callq 0x174701
movq %rax, %rdi
movq %r12, %rsi
callq 0x1740ef
movq %rax, %r12
movq 0x8(%rax), %r13
xorl %ebp, %ebp
testq %r13, %r13
jne 0x174d66
leaq 0x224090(%rip), %rsi    # 0x398de7
movq %r15, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r13, %r13
je 0x174d7c
movq 0x8(%r12), %rdi
movl %r14d, %esi
callq 0x2836d3
movsd %xmm0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x51f30
callq 0x51ef7
// File: /workspace/github_c_makefile_star2_O1/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 0x174dfe
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x301854
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
callq 0x51f69
// File: /workspace/github_c_makefile_star2_O1/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 0x174e2f
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x174e2f
leaq 0x224056(%rip), %rdx    # 0x398e71
movl $0x1, %edi
movl $0x35, %ecx
callq 0x1093ef
movq %rbx, (%rax)
popq %rbx
retq
callq 0x51fa0
// File: /workspace/github_c_makefile_star2_O1/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 0x174e6c
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174ea4
testq %r15, %r15
je 0x174e9f
testq %r14, %r14
je 0x174e9f
movq (%r15), %rax
testq %rax, %rax
je 0x174e9f
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x174e97
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
callq 0x52045
callq 0x5200e
// File: /workspace/github_c_makefile_star2_O1/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 0x174ec8
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x174f00
testq %r15, %r15
je 0x174efb
testq %r14, %r14
je 0x174efb
movq (%r15), %rax
testq %rax, %rax
je 0x174efb
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x174ef3
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
callq 0x520b3
callq 0x5207c
// File: /workspace/github_c_makefile_star2_O1/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 0x174f39
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x174f3b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x174f24
movq %rbx, %rdi
callq *%rax
leaq 0x223f46(%rip), %rsi    # 0x398e71
movq %rbx, %rdi
movl $0x5b, %edx
popq %rbx
jmp 0x109670
popq %rbx
retq
callq 0x520ea
// File: /workspace/github_c_makefile_star2_O1/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
testq %rsi, %rsi
je 0x174f66
movq %rdi, %r15
movq %r14, %r12
movq %r15, %rdi
callq 0x126d42
decq %r12
jne 0x174f59
imulq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rsi, %rsi
je 0x174f9f
movq %rdi, %r15
movq %r14, %r12
movq %r15, %rdi
callq 0x126d5f
decq %r12
jne 0x174f92
imulq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x176dc4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x176dc4
movq %rdi, %r14
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x105a11
testq %rax, %rax
je 0x176d82
movq %rax, %r15
movq %rsp, %rdi
movq %rax, %rsi
callq 0x117923
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2229f6(%rip), %rsi    # 0x39977f
movl $0x10, %edi
movl $0x38, %edx
callq 0x1092b2
movq %rax, %r15
movups (%rsp), %xmm0
movups %xmm0, (%rax)
movq (%r14), %r14
movq %rbx, %rdi
callq 0xe8760
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x105a4c
callq 0x52f72
// File: /workspace/github_c_makefile_star2_O1/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 0x176dee
movq %rsi, %rdx
testq %rsi, %rsi
je 0x176dee
movq (%rdi), %rdi
leaq 0x17(%rip), %rsi        # 0x176df8
xorl %ecx, %ecx
callq 0x105afd
testl %eax, %eax
jne 0x176df3
popq %rax
retq
callq 0x52fa9
callq 0x52fe0
// File: /workspace/github_c_makefile_star2_O1/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 0x176e17
movq %rcx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x176e60
testq %r15, %r15
je 0x176e5b
testq %r14, %r14
je 0x176e5b
testq %rbx, %rbx
je 0x176e5b
movq %r15, %rdi
callq 0x120955
movq %rax, %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x176bac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x112923
movq %r15, %rdi
callq 0x121b03
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5304e
callq 0x53017
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x3529c2(%rip)    # 0x4c9848
jne 0x176ebb
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x176ec9
leaq 0x49(%rip), %rcx        # 0x176ee7
leaq 0x124(%rip), %r8        # 0x176fc9
movl $0x20, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x35298d(%rip)    # 0x4c9848
callq 0xe6a19
movq 0x352981(%rip), %rax    # 0x4c9848
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x176f0b
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x176fc4
callq 0x176e78
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %r14
movq 0x18(%rax), %rbx
movq %r15, %rdi
callq 0x14b89b
movq %rax, %rdi
callq 0x120d23
movq %rbx, %rdi
movq %rax, %rsi
callq 0x105a11
testq %rax, %rax
je 0x176fbf
movq %rax, %rbx
movq %r15, %rdi
callq 0x14b8df
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rbx, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x176fa3
movq %rbx, %rdi
callq 0xd47de
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 0x117826
testb %al, %al
je 0x176fa3
movq 0x8(%r15), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rcx, 0x8(%r15)
jmp 0x176fb3
movq %rsp, %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0xd49ce
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x530f3
callq 0x530bc
// File: /workspace/github_c_makefile_star2_O1/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 0x176fe5
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x177037
callq 0x176e78
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
movl $0x10, %edi
callq 0xd46fc
movq %rax, %r15
movq 0x18(%r14), %r14
movq %rbx, %rdi
callq 0x14b89b
movq %rax, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0xe8760
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x105a4c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5312a
// File: /workspace/github_c_makefile_star2_O1/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 0x176e78
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r14
callq 0x176e78
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r15
movq %rbx, 0x10(%rax)
leaq -0x6d943(%rip), %rsi    # 0x10972f
leaq -0xa2185(%rip), %rdx    # 0xd4ef4
movl $0x1, %edi
callq 0x105830
movq %rax, 0x18(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x176e78
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq 0x18(%rax), %rdi
leaq 0x14(%rip), %rsi        # 0x1770c3
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x105b27
testl %eax, %eax
jne 0x1770be
popq %rbx
retq
callq 0x53161
// File: /workspace/github_c_makefile_star2_O1/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 0x1770e3
movq %rcx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x177167
testq %r14, %r14
je 0x177162
testq %rbx, %rbx
je 0x177162
movq %rbx, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x17715a
movq %rbx, %rdi
callq 0x1182b8
testb %al, %al
je 0x17716c
leaq 0x2227f8(%rip), %rdi    # 0x399905
movq %r14, %rsi
xorl %eax, %eax
callq 0x17070
movq %rbx, %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x17715a
leaq 0x2227df(%rip), %r14    # 0x39990a
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd47ba
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
incq %r15
movq %rbx, %rdi
callq 0xd4a9a
cmpq %rax, %r15
jb 0x17712e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x531d1
callq 0x5319a
callq 0x53208
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x17728a
movq %rsi, %r15
testq %rsi, %rsi
je 0x17728a
movq %rdi, %rbx
movq %r15, %rdi
callq 0x120d4c
movq %rax, %r14
movq %r15, %rdi
callq 0x120d23
movq %rax, %r15
cmpq $0x2, %r14
jb 0x1771eb
movzbl (%r15), %eax
cmpl $0x53, %eax
je 0x1771d7
cmpl $0x67, %eax
jne 0x1771eb
cmpb $0x69, 0x1(%r15)
jne 0x1771d3
movl $0x3, %r12d
cmpb $0x7c, 0x2(%r15)
je 0x177248
cmpb $0x53, %al
jne 0x1771eb
cmpb $0x51, 0x1(%r15)
jne 0x1771eb
movl $0x3, %r12d
cmpb $0x3b, 0x2(%r15)
je 0x177248
cmpq $0x3, %r14
jb 0x177245
movzbl (%r15), %eax
cmpl $0x72, %eax
je 0x177225
cmpl $0x28, %eax
jne 0x177245
cmpb $0x67, 0x1(%r15)
jne 0x177221
cmpb $0x69, 0x2(%r15)
jne 0x177221
movb 0x3(%r15), %cl
xorl %r12d, %r12d
cmpb $0x7c, %cl
sete %cl
jne 0x177221
movb %cl, %r12b
jmp 0x17723f
cmpb $0x72, %al
jne 0x177245
cmpb $0x65, 0x1(%r15)
jne 0x177245
cmpb $0x66, 0x2(%r15)
jne 0x177245
xorl %r12d, %r12d
cmpb $0x7c, 0x3(%r15)
sete %r12b
shll $0x2, %r12d
jmp 0x177248
xorl %r12d, %r12d
cmpq %r14, %r12
jae 0x177280
movabsq $0x400000100000200, %r13 # imm = 0x400000100000200
movzbl (%r15,%r12), %eax
cmpq $0x3a, %rax
ja 0x177268
btq %rax, %r13
jb 0x177280
cmpl $0x7c, %eax
je 0x177280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x120ba5
incq %r12
cmpq %r12, %r14
jne 0x177257
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5323f
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rmq.c
// Function: gt_rmq_delete
void gt_rmq_delete(GtRMQ *rmq)
{
  GtUword i;
  if (!rmq) return;
  gt_free(rmq->type);
  if (rmq->Prec != NULL)
  {
    for (i = 0;
         i < gt_rmq_catalan[GT_RMQ_microblocksize][GT_RMQ_microblocksize];
         i++)
    {
      gt_free(rmq->Prec[i]);
    }
    gt_free(rmq->Prec);
  }
  if (rmq->M != NULL)
  {
    for (i = 0; i < rmq->M_depth; i++)
    {
      gt_free(rmq->M[i]);
    }
    gt_free(rmq->M);
  }
  if (rmq->Mprime != NULL)
  {
    for (i = 0; i < rmq->Mprime_depth; i++)
    {
      gt_free(rmq->Mprime[i]);
    }
    gt_free(rmq->Mprime);
  }
  gt_free(rmq);
}

// Assembly:
testq %rdi, %rdi
je 0x177f63
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
leaq 0x221b79(%rip), %rsi    # 0x3999dc
movl $0x239, %edx            # imm = 0x239
callq 0x109670
cmpq $0x0, 0x38(%rbx)
je 0x177eb4
xorl %r15d, %r15d
leaq 0x221b5e(%rip), %r14    # 0x3999dc
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x240, %edx            # imm = 0x240
callq 0x109670
incq %r15
cmpq $0x596, %r15            # imm = 0x596
jne 0x177e7e
movq 0x38(%rbx), %rdi
leaq 0x221b32(%rip), %rsi    # 0x3999dc
movl $0x242, %edx            # imm = 0x242
callq 0x109670
cmpq $0x0, 0x10(%rbx)
je 0x177eff
cmpq $0x0, 0x18(%rbx)
je 0x177eea
xorl %r15d, %r15d
leaq 0x221b10(%rip), %r14    # 0x3999dc
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x248, %edx            # imm = 0x248
callq 0x109670
incq %r15
cmpq 0x18(%rbx), %r15
jb 0x177ecc
movq 0x10(%rbx), %rdi
leaq 0x221ae7(%rip), %rsi    # 0x3999dc
movl $0x24a, %edx            # imm = 0x24A
callq 0x109670
cmpq $0x0, 0x20(%rbx)
je 0x177f4a
cmpq $0x0, 0x28(%rbx)
je 0x177f35
xorl %r15d, %r15d
leaq 0x221ac5(%rip), %r14    # 0x3999dc
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x250, %edx            # imm = 0x250
callq 0x109670
incq %r15
cmpq 0x28(%rbx), %r15
jb 0x177f17
movq 0x20(%rbx), %rdi
leaq 0x221a9c(%rip), %rsi    # 0x3999dc
movl $0x252, %edx            # imm = 0x252
callq 0x109670
leaq 0x221a8b(%rip), %rsi    # 0x3999dc
movq %rbx, %rdi
movl $0x254, %edx            # imm = 0x254
popq %rbx
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/rmq.c
// Function: gt_rmq_unit_test
int gt_rmq_unit_test(GtError *err)
{
  int had_err = 0;
  GtRMQvaluetype *data;
  GtUword i;
  GtRMQ *rmq;
  gt_error_check(err);

  data = gt_calloc((size_t) GT_RMQ_TESTARRSIZE, sizeof (*data));

  for (i = 0; i < GT_RMQ_TESTARRSIZE; i++)
  {
    data[i] = (GtRMQvaluetype) gt_rand_max(GT_RMQ_TESTMAXVAL);
  }

  rmq = gt_rmq_new(data, GT_RMQ_TESTARRSIZE);

  for (i = 0; i < GT_RMQ_NOFTESTS; i++)
  {
    GtUword start, end, res_naive, res_efficient;
    start = gt_rand_max(GT_RMQ_TESTARRSIZE - GT_RMQ_MAXRANGELENGTH - 2UL);
    end = start + gt_rand_max(GT_RMQ_MAXRANGELENGTH) + 1UL;
    res_naive = gt_rmq_naive(data, GT_RMQ_TESTARRSIZE, start, end);
    res_efficient = gt_rmq_find_min_index(rmq, start, end);
    gt_ensure(data[res_efficient] == data[res_naive]);
  }

  gt_rmq_delete(rmq);
  gt_free(data);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x177f87
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1780d5
movq %rbx, (%rsp)
leaq 0x221a4a(%rip), %rdx    # 0x3999dc
movl $0xf4240, %edi          # imm = 0xF4240
movl $0x4, %esi
movl $0x27a, %ecx            # imm = 0x27A
callq 0x1093ef
movq %rax, %r14
xorl %ebx, %ebx
movl $0x989680, %edi         # imm = 0x989680
callq 0x10ae3c
movl %eax, (%r14,%rbx,4)
incq %rbx
cmpq $0xf4240, %rbx          # imm = 0xF4240
jne 0x177fab
movl $0xf4240, %esi          # imm = 0xF4240
movq %r14, %rdi
callq 0x1777dd
movq %rax, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movl $0xf1b2e, %edi          # imm = 0xF1B2E
callq 0x10ae3c
movq %rax, %rbx
movl $0x2710, %edi           # imm = 0x2710
callq 0x10ae3c
leaq (%rbx,%rax), %rdx
incq %rdx
cmpq $0xf423f, %rdx          # imm = 0xF423F
ja 0x1780d0
testq %r14, %r14
je 0x1780d0
cmpq %rdx, %rbx
jae 0x1780d0
movq %rbx, %rax
incq %rax
movq %rbx, %rbp
cmpq %rdx, %rax
ja 0x178042
movl (%r14,%rbx,4), %ecx
movq %rbx, %rbp
movl (%r14,%rax,4), %esi
cmpl %ecx, %esi
cmovbl %esi, %ecx
cmovbq %rax, %rbp
incq %rax
cmpq %rdx, %rax
jbe 0x17802d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x17731c
testl %r13d, %r13d
jne 0x17808c
movl (%r14,%rax,4), %eax
xorl %r13d, %r13d
cmpl (%r14,%rbp,4), %eax
je 0x178092
movq (%rsp), %rdi
leaq 0x1ef4d0(%rip), %rsi    # 0x36753a
leaq 0x2219ac(%rip), %rdx    # 0x399a1d
leaq 0x221994(%rip), %rcx    # 0x399a0c
leaq 0x22195d(%rip), %r8     # 0x3999dc
movl $0x28a, %r9d            # imm = 0x28A
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
incq %r12
cmpq $0x2710, %r12           # imm = 0x2710
jne 0x177fdb
movq %r15, %rdi
callq 0x177e47
leaq 0x22192b(%rip), %rsi    # 0x3999dc
movq %r14, %rdi
movl $0x28e, %edx            # imm = 0x28E
callq 0x109670
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5343a
callq 0x53401
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/safe_popen.c
// Function: gt_safe_pclose
int gt_safe_pclose(GT_WIN32_UNUSED GtSafePipe *p) {
#ifndef _WIN32
  int   status;
  pid_t pid = (pid_t) -1;

  if (p->child_pid != (pid_t) -1) {
    do {
      pid = waitpid(p->child_pid, &status, 0);
    } while (pid == (pid_t) -1 && errno == EINTR);
  }
  if (p->read_fd != NULL)
    (void) fclose(p->read_fd);
  if (p->write_fd != NULL)
    (void) fclose(p->write_fd);
  gt_free(p);
  if (pid != (pid_t) -1 && WIFEXITED(status))
    return WEXITSTATUS(status);
  else
    return (pid == (pid_t) -1 ? -1 : 0);
#else
  /* TODO: implement for Windows */
  gt_assert(0);
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x10(%rdi)
je 0x17834f
leaq 0xc(%rsp), %r14
movl 0x10(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x175f0
cmpl $-0x1, %eax
sete %bpl
jne 0x178352
callq 0x17060
cmpl $0x4, (%rax)
je 0x17832d
jmp 0x178352
movb $0x1, %bpl
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17835f
callq 0x17800
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x17836d
callq 0x17800
leaq 0x22251c(%rip), %rsi    # 0x39a890
movq %rbx, %rdi
movl $0x9a, %edx
callq 0x109670
testb %bpl, %bpl
jne 0x17838e
movl 0xc(%rsp), %eax
testb $0x7f, %al
je 0x17839d
movzbl %bpl, %eax
negl %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movzbl %ah, %eax
jmp 0x178394
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_alignment.c
// Function: gt_sam_alignment_new
GtSamAlignment *gt_sam_alignment_new(GtAlphabet *alphabet)
{
  GtSamAlignment *sam_alignment;
  gt_assert(alphabet != NULL);

  sam_alignment = gt_malloc(sizeof (GtSamAlignment));
  sam_alignment->s_alignment = bam_init1();
  sam_alignment->alphabet = gt_alphabet_ref(alphabet);
  sam_alignment->seq_buffer = NULL;
  sam_alignment->qual_buffer = NULL;
  sam_alignment->s_bufsize = 0;
  sam_alignment->q_bufsize = 0;
  sam_alignment->rightmost = GT_UNDEF_UWORD;
  return sam_alignment;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x178407
movq %rdi, %rbx
leaq 0x2225d8(%rip), %rsi    # 0x39a98f
movl $0x38, %edi
movl $0x29, %edx
callq 0x1092b2
movq %rax, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x174e0
movq %rax, (%r14)
movq %rbx, %rdi
callq 0xd3007
movq %rax, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movq $-0x1, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x53473
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_alignment.c
// Function: gt_sam_alignment_clone
GtSamAlignment *gt_sam_alignment_clone(GtSamAlignment *sam_alignment)
{
  GtSamAlignment *clone;
  gt_assert(sam_alignment != NULL);
  clone = gt_sam_alignment_new(sam_alignment->alphabet);
  (void)bam_copy1(clone->s_alignment, sam_alignment->s_alignment);
  clone->rightmost = sam_alignment->rightmost;
  return clone;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1784dd
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1783a4
movq %rax, %r14
movq (%rax), %r12
movq (%rbx), %r13
movq 0x30(%r12), %r15
movl 0x28(%r12), %ebp
movl 0x24(%r13), %eax
cmpl %eax, %ebp
jge 0x17847b
decl %eax
movl %eax, %ecx
sarl %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x8, %eax
orl %ecx, %eax
movl %eax, %ebp
sarl $0x10, %ebp
orl %eax, %ebp
incl %ebp
movslq %ebp, %rsi
movq %r15, %rdi
callq 0x17ff8
movq %rax, %r15
testq %r15, %r15
je 0x1784e2
movq 0x30(%r13), %rsi
movslq 0x24(%r13), %rdx
movq %r15, %rdi
callq 0x17660
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%r12)
movq 0x30(%r13), %rax
movq %rax, 0x30(%r12)
movups %xmm0, (%r12)
movups %xmm1, 0x10(%r12)
movl %ebp, 0x28(%r12)
movq %r15, 0x30(%r12)
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x534aa
leaq 0x20d60f(%rip), %rdi    # 0x385af8
leaq 0x222806(%rip), %rsi    # 0x39acf6
leaq 0x22286b(%rip), %rcx    # 0x39ad62
movl $0x2dc, %edx            # imm = 0x2DC
callq 0x174d0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_alignment.c
// Function: gt_sam_alignment_delete
void gt_sam_alignment_delete(GtSamAlignment *sam_alignment)
{
  if (sam_alignment != NULL) {
    bam_destroy1(sam_alignment->s_alignment);
    gt_alphabet_delete(sam_alignment->alphabet);
    gt_free(sam_alignment->qual_buffer);
    gt_free(sam_alignment->seq_buffer);
    gt_free(sam_alignment);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x17856f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x178526
movq 0x30(%rax), %rdi
callq 0x17fe8
movq (%rbx), %rdi
callq 0x17fe8
movq 0x8(%rbx), %rdi
callq 0xd335d
movq 0x18(%rbx), %rdi
leaq 0x222455(%rip), %r14    # 0x39a98f
movq %r14, %rsi
movl $0x43, %edx
callq 0x109670
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x44, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x45, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sam_alignment.c
// Function: gt_sam_alignment_rightmost_pos
GtUword gt_sam_alignment_rightmost_pos(GtSamAlignment *sam_alignment)
{
  gt_assert(sam_alignment != NULL);
  if (sam_alignment->rightmost == GT_UNDEF_UWORD)
  {
    sam_alignment->rightmost = (GtUword)bam_calend(
        &sam_alignment->s_alignment->core,
        bam1_cigar(sam_alignment->s_alignment));
  }
  return sam_alignment->rightmost;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1785d5
movq %rdi, %rbx
cmpq $-0x1, 0x30(%rdi)
jne 0x1785cf
movq (%rbx), %rdi
movzbl 0xb(%rdi), %esi
addq 0x30(%rdi), %rsi
callq 0x24aae0
movl %eax, %eax
movq %rax, 0x30(%rbx)
movq 0x30(%rbx), %rax
popq %rbx
retq
callq 0x53586