LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/tyr-map.c
// Function: gt_determinetyrbckpfxlen
int gt_determinetyrbckpfxlen(unsigned int *prefixlength,
                          const Tyrindex *tyrindex,
                          const Definedunsignedint *callprefixlength,
                          GtError *err)
{
  gt_error_check(err);
  if (callprefixlength->defined)
  {
    unsigned int maxprefixlen
      = gt_whatisthemaximalprefixlength(tyrindex->alphasize,
                                     (GtUword) tyrindex->numofmers,
                                     0,true);
    if (maxprefixlen > (unsigned int) tyrindex->mersize)
    {
      maxprefixlen = (unsigned int) tyrindex->mersize;
    }
    if (gt_checkprefixlength(maxprefixlen,callprefixlength->valueunsignedint,
                          err) != 0)
    {
      return -1;
    }
    *prefixlength = callprefixlength->valueunsignedint;
  } else
  {
    unsigned int recommendedprefixlength
      = gt_recommendedprefixlength(tyrindex->alphasize,
                                   (GtUword) tyrindex->numofmers,
                                   GT_RECOMMENDED_MULTIPLIER_DEFAULT,
                                   true);
    if (recommendedprefixlength > (unsigned int) tyrindex->mersize)
    {
      recommendedprefixlength = (unsigned int) tyrindex->mersize;
    }
    *prefixlength = recommendedprefixlength;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rcx, %rcx
je 0x2cd815
movq %r12, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2cd87a
movl 0x10(%r15), %edi
movq 0x18(%r15), %rsi
cmpb $0x1, (%r14)
jne 0x2cd84b
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x191dc4
movl 0x20(%r15), %edi
cmpl %edi, %eax
cmovbl %eax, %edi
movl 0x4(%r14), %esi
movq %r12, %rdx
callq 0x191e4e
testl %eax, %eax
je 0x2cd866
pushq $-0x1
popq %rax
jmp 0x2cd86e
movsd 0x23e95(%rip), %xmm0    # 0x2f16e8
pushq $0x1
popq %rdx
callq 0x191cf8
movl 0x20(%r15), %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
jmp 0x2cd86a
movl 0x4(%r14), %ecx
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x16a6e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17788(%rip), %rsi     # 0x2e5013
leaq 0x1792d(%rip), %rdx     # 0x2e51bf
leaq 0xb8906(%rip), %rcx     # 0x38619f
leaq 0xb8714(%rip), %r8      # 0x385fb4
movl $0x199, %r9d            # imm = 0x199
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_free
void gt_ltr_cluster_prepare_seq_visitor_free(GtNodeVisitor *v)
{
  GtLTRClusterPrepareSeqVisitor *lcv;
  lcv = gt_ltr_cluster_prepare_seq_visitor_cast(v);
  gt_encseq_delete(lcv->src_encseq);
  gt_str_array_delete(lcv->feat_to_encseq_keys);
  gt_hashmap_delete(lcv->feat_to_encseq);
  gt_hashmap_delete(lcv->encseq_builders);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2cd8f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x735fd
movq 0x28(%rbx), %rdi
callq 0xae662
movq 0x18(%rbx), %rdi
callq 0x8f933
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x8f933
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_class
const GtNodeVisitorClass* gt_ltr_cluster_prepare_seq_visitor_class(void)
{
  static const GtNodeVisitorClass *nvc;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof(GtLTRClusterPrepareSeqVisitor),
                                gt_ltr_cluster_prepare_seq_visitor_free,
                                NULL,
                                gt_ltr_cluster_prepare_seq_visitor_feature_node,
                                NULL,
                                NULL,
                                NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x1706ba(%rip)    # 0x43dfb8
jne 0x2cd92a
andq $0x0, (%rsp)
leaq -0x58(%rip), %rsi       # 0x2cd8b4
leaq 0x25(%rip), %rcx        # 0x2cd938
pushq $0x30
popq %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x17068e(%rip)    # 0x43dfb8
callq 0x69ede
movq 0x170682(%rip), %rax    # 0x43dfb8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_new
GtNodeVisitor* gt_ltr_cluster_prepare_seq_visitor_new(GtEncseq *encseq,
                                                      GT_UNUSED GtError *err)
{
  GtNodeVisitor *nv;
  GtLTRClusterPrepareSeqVisitor *lcv;
  nv = gt_node_visitor_create(gt_ltr_cluster_prepare_seq_visitor_class());
  lcv = gt_ltr_cluster_prepare_seq_visitor_cast(nv);
  gt_assert(lcv);
  lcv->src_encseq = gt_encseq_ref(encseq);
  lcv->feat_to_encseq = NULL;
  lcv->encseq_builders = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                        (GtFree) gt_encseq_builder_delete);
  lcv->feat_to_encseq_keys = gt_str_array_new();
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x2cd8f0
movq %rax, %rdi
callq 0x102da0
movq %rax, %rbx
callq 0x2cd8f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
testq %rax, %rax
je 0x2cde53
movq %rax, %r14
movq %r15, %rdi
callq 0x73cbe
movq %rax, 0x10(%r14)
andq $0x0, 0x18(%r14)
leaq -0x23a5ef(%rip), %rsi   # 0x9383f
leaq -0x24c36d(%rip), %rdx   # 0x81ac8
pushq $0x1
popq %rdi
callq 0x8f330
movq %rax, 0x20(%r14)
callq 0xae154
movq %rax, 0x28(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x16a10e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x171af(%rip), %rsi     # 0x2e5013
leaq 0xb834d(%rip), %rdx     # 0x3861b8
leaq 0xb834a(%rip), %rcx     # 0x3861bc
leaq 0xb836a(%rip), %r8      # 0x3861e3
movl $0xd2, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_finish_encseqs
int gt_ltr_cluster_prepare_seq_finish_encseqs(void *key, void *value,
                                              void *data, GtError *err)
{
  GtLTRClusterPrepareSeqVisitor *v = (GtLTRClusterPrepareSeqVisitor*) data;
  GtEncseqBuilder *eb = (GtEncseqBuilder*) value;
  GtEncseq *encseq;
  int had_err = 0;
  const char *feature = (const char*) key;
  gt_assert(key && value);
  gt_error_check(err);

  encseq = gt_encseq_builder_build(eb, err);
  if (!encseq)
    had_err = -1;
  if (!had_err) {
    if (!v->feat_to_encseq) {
      v->feat_to_encseq = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                         (GtFree) gt_encseq_delete);
    }
    gt_assert(!gt_hashmap_get(v->feat_to_encseq, feature));
    gt_hashmap_add(v->feat_to_encseq, gt_cstr_dup(feature), encseq);
    gt_log_log("added encseq %p to hash for feature %s", encseq, feature);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2cdf52
movq %rsi, %r12
testq %rsi, %rsi
je 0x2cdf52
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x2cdec6
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2cdf80
movq %r12, %rdi
movq %r15, %rsi
callq 0x7e427
movq %rax, %r15
testq %rax, %rax
je 0x2cdf3e
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x2cdeff
leaq -0x23a6aa(%rip), %rsi   # 0x9383f
leaq -0x25a8f3(%rip), %rdx   # 0x735fd
pushq $0x1
popq %rdi
callq 0x8f330
movq %rax, %rdi
movq %rax, 0x18(%r14)
movq %rbx, %rsi
callq 0x8f482
testq %rax, %rax
jne 0x2cdfae
movq 0x18(%r14), %r14
movq %rbx, %rdi
callq 0x6c2be
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8f4bd
leaq 0xb8332(%rip), %rdi     # 0x386263
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x92a82
xorl %eax, %eax
cmpq $0x1, %r15
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x16a00f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x170b0(%rip), %rsi     # 0x2e5013
leaq 0x986fc(%rip), %rdx     # 0x366666
leaq 0xb829c(%rip), %rcx     # 0x38620d
leaq 0xb826b(%rip), %r8      # 0x3861e3
movl $0xe3, %r9d
jmp 0x2cdfda
movq 0x169fe1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17082(%rip), %rsi     # 0x2e5013
leaq 0x17227(%rip), %rdx     # 0x2e51bf
leaq 0xb826e(%rip), %rcx     # 0x38620d
leaq 0xb823d(%rip), %r8      # 0x3861e3
movl $0xe4, %r9d
jmp 0x2cdfda
movq 0x169fb3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17054(%rip), %rsi     # 0x2e5013
leaq 0xb8271(%rip), %rdx     # 0x386237
leaq 0xb8240(%rip), %rcx     # 0x38620d
leaq 0xb820f(%rip), %r8      # 0x3861e3
movl $0xee, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: gt_ltr_cluster_prepare_seq_visitor_get_encseqs
GtHashmap* gt_ltr_cluster_prepare_seq_visitor_get_encseqs(
                                              GtLTRClusterPrepareSeqVisitor *v)
{
  gt_assert(v && v->encseq_builders);
  gt_log_log("finishing encseqs");
  if (!v->feat_to_encseq) {
    gt_log_log("starting...");
    (void) gt_hashmap_foreach(v->encseq_builders,
                              gt_ltr_cluster_prepare_seq_finish_encseqs,
                              v,
                              NULL);
  }
  return gt_hashmap_ref(v->feat_to_encseq);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2ce03a
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x2ce03a
leaq 0xb82d4(%rip), %rdi     # 0x3862d1
xorl %eax, %eax
callq 0x92a82
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x2ce034
leaq 0xb82cf(%rip), %rdi     # 0x3862e3
xorl %eax, %eax
callq 0x92a82
movq 0x20(%rbx), %rdi
leaq -0x19b(%rip), %rsi      # 0x2cde8b
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x8f56e
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x8f47d
movq 0x169f27(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x16fc8(%rip), %rsi     # 0x2e5013
leaq 0xb8238(%rip), %rdx     # 0x38628a
leaq 0xb8249(%rip), %rcx     # 0x3862a2
leaq 0xb8183(%rip), %r8      # 0x3861e3
movl $0xf8, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/ltr/ltr_cluster_prepare_seq_visitor.c
// Function: extract_feature_seq
static int extract_feature_seq(GtEncseqBuilder *b, const char *header,
                               GtStr *seqid, GtEncseq *encseq, GtRange range,
                               GT_UNUSED const char *fnt, GtError *err)
{
  char *buffer;
  int had_err = 0,
      rval;
  GtUword seqnum,
                startpos;

  rval = sscanf(gt_str_get(seqid), "seq"GT_WU"", &seqnum);
  if (rval != 1) {
    gt_error_set(err, "expected sequence ID of format 'seqX' but "
                      "encountered '%s'",gt_str_get(seqid));
    had_err = -1;
  }
  if (!had_err && (seqnum >= gt_encseq_num_of_sequences(encseq))) {
    gt_error_set(err, "annotation encountered for sequence "GT_WU", but the "
                      "supplied encoded sequence only contains sequences "
                      "0-"GT_WU"", seqnum,
                    gt_encseq_num_of_sequences(encseq)-1);
    had_err = -1;
  }

  if (!had_err) {
    buffer = gt_calloc((size_t) gt_range_length(&range) + 1, sizeof (char));
    startpos = gt_encseq_seqstartpos(encseq, seqnum);
    gt_encseq_extract_decoded(encseq, buffer, startpos + range.start - 1,
                              startpos + range.end - 1);
    gt_encseq_builder_add_cstr(b, buffer, gt_range_length(&range), header);
    gt_free(buffer);
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsp), %r12
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %rdx, %rdi
callq 0xad1fa
leaq 0x621d0(%rip), %rsi     # 0x3302c5
movq %rsp, %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x177b0
cmpl $0x1, %eax
jne 0x2ce19a
movq (%rsp), %r13
movq %r15, %rdi
callq 0x705a1
cmpq %rax, %r13
jae 0x2ce1b8
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xa31ee
leaq 0x1(%rax), %rdi
leaq 0xb80ab(%rip), %r12     # 0x3861e3
pushq $0x1
popq %rsi
pushq $0x42
popq %rcx
movq %r12, %rdx
callq 0x9334a
movq %rax, %rbp
movq (%rsp), %rsi
movq %r15, %rdi
callq 0x74d9c
leaq -0x1(%rax), %rcx
movq (%r13), %rdx
addq %rcx, %rdx
addq 0x8(%r13), %rcx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x7239d
movq %r13, %rdi
callq 0xa31ee
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x7d964
pushq $0x47
popq %rdx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x936f9
xorl %eax, %eax
jmp 0x2ce1df
movq %r13, %rdi
callq 0xad1fa
leaq 0xb81e2(%rip), %rsi     # 0x38638b
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x89dbb
jmp 0x2ce1dc
movq (%rsp), %rbx
movq %r15, %rdi
callq 0x705a1
leaq -0x1(%rax), %rcx
leaq 0xb81f7(%rip), %rsi     # 0x3863c6
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/mgth/mg_codon.c
// Function: mg_codon2amino
char mg_codon2amino(char n0, char n1, char n2)
{
  static char aminos[] = "FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRR"
    "IIIMTTTTNNKKSSRRVVVVAAAADDEEGGGGX";
  unsigned int code = 0;

  switch (n0)
  {
    case 'A':
    case 'a':
      code = A_CODE << 4;
      break;
    case 'C':
    case 'c':
      code = C_CODE << 4;
      break;
    case 'G':
    case 'g':
      code = G_CODE << 4;
      break;
    case 'T':
    case 't':
    case 'U':
    case 'u':
      code = T_CODE << 4;
      break;
    default:
      code = G_CODE << 4;
  }

  switch (n1)
  {
    case 'A':
    case 'a':
      code += A_CODE << 2;
      break;
    case 'C':
    case 'c':
      code += C_CODE << 2;
      break;
    case 'G':
    case 'g':
      code += G_CODE << 2;
      break;
    case 'T':
    case 't':
    case 'U':
    case 'u':
      /* code += T_CODE << 2; */
      break;
    default:
      code = G_CODE << 2;
  }

  switch (n2)
  {
    case 'A':
    case 'a':
    case 'R':
    case 'r':
      code += A_CODE;
      break;
    case 'C':
    case 'c':
      code += C_CODE;
      break;
    case 'G':
    case 'g':
      code += G_CODE;
      break;
    case 'T':
    case 't':
    case 'U':
    case 'u':
    case 'N':
    case 'n':
    case 'Y':
    case 'y':
      code += T_CODE;
      break;
    default:
      code += X_CODE;
  }

  return aminos[code];
}

// Assembly:
leal -0x54(%rdi), %eax
cmpl $0x2, %eax
jb 0x2ce369
leal -0x74(%rdi), %eax
cmpl $0x2, %eax
jb 0x2ce369
pushq $0x20
popq %rax
cmpl $0x41, %edi
je 0x2ce370
cmpl $0x43, %edi
je 0x2ce365
cmpl $0x47, %edi
je 0x2ce36d
cmpl $0x61, %edi
je 0x2ce370
cmpl $0x67, %edi
je 0x2ce36d
cmpl $0x63, %edi
jne 0x2ce36d
pushq $0x10
jmp 0x2ce36f
xorl %eax, %eax
jmp 0x2ce370
pushq $0x30
popq %rax
movsbl %sil, %ecx
leal -0x54(%rcx), %esi
cmpl $0x2, %esi
jb 0x2ce3b4
leal -0x74(%rcx), %esi
cmpl $0x2, %esi
jb 0x2ce3b4
cmpl $0x41, %ecx
je 0x2ce3a2
cmpl $0x43, %ecx
je 0x2ce3ac
cmpl $0x47, %ecx
je 0x2ce3a7
cmpl $0x67, %ecx
je 0x2ce3a7
cmpl $0x63, %ecx
je 0x2ce3ac
cmpl $0x61, %ecx
jne 0x2ce3b1
orl $0x8, %eax
jmp 0x2ce3b4
orl $0xc, %eax
jmp 0x2ce3b4
orl $0x4, %eax
jmp 0x2ce3b4
pushq $0xc
popq %rax
movsbl %dl, %ecx
leal -0x67(%rcx), %edx
cmpl $0x12, %edx
jbe 0x2ce3f4
leal -0x54(%rcx), %edx
cmpl $0x2, %edx
jb 0x2ce413
cmpl $0x41, %ecx
je 0x2ce407
cmpl $0x43, %ecx
je 0x2ce40c
cmpl $0x47, %ecx
je 0x2ce410
cmpl $0x4e, %ecx
je 0x2ce413
cmpl $0x52, %ecx
je 0x2ce407
cmpl $0x59, %ecx
je 0x2ce413
cmpl $0x63, %ecx
je 0x2ce40c
cmpl $0x61, %ecx
je 0x2ce407
addl $0x4, %eax
jmp 0x2ce413
movl $0x46080, %esi          # imm = 0x46080
btl %edx, %esi
jb 0x2ce413
testl %edx, %edx
je 0x2ce410
cmpl $0xb, %edx
jne 0x2ce3bf
addl $0x2, %eax
jmp 0x2ce413
incl %eax
jmp 0x2ce413
addl $0x3, %eax
movl %eax, %eax
leaq 0xb8084(%rip), %rcx     # 0x3864a0
movb (%rax,%rcx), %al
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/mgth/mg_combinedscore.c
// Function: add_scores
static void add_scores(ParseStruct *parsestruct_ptr,
                       double *matrix_row,
                       GtUword *count_row_fct,
                       short current_row_fct,
                       GtUword hit_number,
                       GtUword position,
                       unsigned short k, double score)
{
  /* Wenn der Query-Leserahmen negativ ist, muessen die Combined-Scores
     von Rechts nach Links in die Combined-Score Matrix eingetragen werden
     - also ausgehend vom Query-to Wert */
  if (current_row_fct > 3)
  {
    matrix_row[POSITION(MATRIXSTRUCT(query_to), hit_number, -position, -k)]
      += score;
    count_row_fct[POSITION
                  (MATRIXSTRUCT(query_to), hit_number, -position, -k)] +=
      1;
  }
  else
  {
    matrix_row[POSITION(MATRIXSTRUCT(query_from), hit_number, position, k)]
      += score;
    count_row_fct[POSITION
                  (MATRIXSTRUCT(query_from), hit_number, position, k)] +=
      1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %r9, %r15
movq %r8, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movzwl 0x40(%rsp), %ebp
cmpw $0x4, %cx
jb 0x2cf254
movq 0x118(%r12), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rax
addq %r15, %rbp
notq %rbp
leaq (,%rax,8), %rax
addq %r13, %rax
movsd (%rsp), %xmm0
addsd (%rax,%rbp,8), %xmm0
movsd %xmm0, (%rax,%rbp,8)
movq 0x118(%r12), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rax
leaq (%rbx,%rax,8), %rax
leaq (%rax,%rbp,8), %rax
jmp 0x2cf2ac
movq 0x110(%r12), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
leaq (%rax,%r15,8), %rax
shll $0x3, %ebp
movsd (%rsp), %xmm0
addsd -0x8(%rbp,%rax), %xmm0
movsd %xmm0, -0x8(%rbp,%rax)
movq 0x110(%r12), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rax
leaq (%rbx,%rax,8), %rax
leaq (%rax,%r15,8), %rax
addq %rbp, %rax
addq $-0x8, %rax
incq (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/mgth/mg_compute_gene_prediction.c
// Function: gt_check_stopcodon
short gt_check_stopcodon(char *contig_seq_ptrfct)
{
  unsigned short codon_status = 0;

  /* jeder if-Zweig ueberprueft entsprechend des
     Metagenomethreader-Arguments zur Verwendung alternativer Start-Codons
     auf Start-Codons */
  if (!strcmp(contig_seq_ptrfct, "tga")
      || !strcmp(contig_seq_ptrfct, "taa")
      || !strcmp(contig_seq_ptrfct, "tag")
      || !strcmp(contig_seq_ptrfct, "tar")
      || !strcmp(contig_seq_ptrfct, "uga")
      || !strcmp(contig_seq_ptrfct, "uaa")
      || !strcmp(contig_seq_ptrfct, "uag")
      || !strcmp(contig_seq_ptrfct, "uar"))
  {
    codon_status = 1;
  }

  return codon_status;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6429c(%rip), %rsi     # 0x334878
callq 0x179e0
testl %eax, %eax
je 0x2d0672
leaq 0xb4f18(%rip), %rsi     # 0x385508
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x2d0672
leaq 0xb9cdf(%rip), %rsi     # 0x38a2e2
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x2d0672
leaq 0x89390(%rip), %rsi     # 0x3599a6
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x2d0672
leaq 0xb6015(%rip), %rsi     # 0x38663e
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x2d0672
leaq 0xb6006(%rip), %rsi     # 0x386642
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x2d0672
leaq 0xb5ff7(%rip), %rsi     # 0x386646
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x2d0672
leaq 0xb5fe8(%rip), %rsi     # 0x38664a
movq %rbx, %rdi
callq 0x179e0
testl %eax, %eax
je 0x2d0672
xorl %eax, %eax
jmp 0x2d0676
movw $0x1, %ax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/canvas_cairo_context.c
// Function: gt_canvas_cairo_context_class
const GtCanvasClass* gt_canvas_cairo_context_class(void)
{
  static const GtCanvasClass *canvas_class = NULL;
  gt_class_alloc_lock_enter();
  if (!canvas_class) {
    canvas_class = gt_canvas_class_new(sizeof (GtCanvasCairoContext),
                                       gt_canvas_cairo_visit_layout_pre,
                                       gt_canvas_cairo_visit_layout_post,
                                       gt_canvas_cairo_visit_track_pre,
                                       gt_canvas_cairo_visit_track_post,
                                       gt_canvas_cairo_visit_line_pre,
                                       gt_canvas_cairo_visit_line_post,
                                       gt_canvas_cairo_visit_block,
                                       gt_canvas_cairo_visit_element,
                                       gt_canvas_cairo_visit_custom_track,
                                       gt_canvas_cairo_draw_ruler,
                                       NULL);
  }
  gt_class_alloc_lock_leave();
  return canvas_class;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x69e97
cmpq $0x0, 0x16d037(%rip)    # 0x43dfc0
jne 0x2d0fee
leaq 0x10b99(%rip), %rax     # 0x2e1b2b
leaq 0x108ab(%rip), %r10     # 0x2e1844
leaq 0xfd70(%rip), %r11      # 0x2e0d10
leaq 0xf553(%rip), %rbx      # 0x2e04fa
leaq 0xf454(%rip), %r14      # 0x2e0402
leaq 0xede7(%rip), %rsi      # 0x2dfd9c
leaq 0xee7e(%rip), %rdx      # 0x2dfe3a
leaq 0xee7a(%rip), %rcx      # 0x2dfe3d
leaq 0xf1af(%rip), %r8       # 0x2e0179
leaq 0xf24f(%rip), %r9       # 0x2e0220
pushq $0x18
popq %rdi
pushq $0x0
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
callq 0x1cd8d0
addq $0x30, %rsp
movq %rax, 0x16cfd2(%rip)    # 0x43dfc0
callq 0x69ede
movq 0x16cfc6(%rip), %rax    # 0x43dfc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: gt_custom_track_gc_content_class
const GtCustomTrackClass* gt_custom_track_gc_content_class(void)
{
  static const GtCustomTrackClass *ctc = NULL;
  gt_class_alloc_lock_enter();
  if (!ctc)
  {
    ctc = gt_custom_track_class_new(sizeof (GtCustomTrackGcContent),
                                    gt_custom_track_gc_content_sketch,
                                    gt_custom_track_gc_content_get_height,
                                    gt_custom_track_gc_content_get_title,
                                    gt_custom_track_gc_content_delete);
  }
  gt_class_alloc_lock_leave();
  return ctc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x16bef0(%rip)    # 0x43dfd0
jne 0x2d210d
leaq -0x6ad(%rip), %rsi      # 0x2d1a3c
leaq 0xbc(%rip), %rdx        # 0x2d21ac
leaq 0xcf(%rip), %rcx        # 0x2d21c6
leaq 0xe6(%rip), %r8         # 0x2d21e4
pushq $0x48
popq %rdi
callq 0x2d1710
movq %rax, 0x16bec3(%rip)    # 0x43dfd0
callq 0x69ede
movq 0x16beb7(%rip), %rax    # 0x43dfd0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: get_val_for_pos
static double get_val_for_pos(GtCustomTrackGcContent *ctgc, GtUword pos)
{
  GtUword i,
                gc_count = 0,
                bases = 0;
  for (i=0;i<ctgc->windowsize;i++)
  {
    if (pos + i > ctgc->seqlen)
      return -1;
    if (ctgc->seq[pos+i] == 'g' || ctgc->seq[pos+i] == 'c'
         || ctgc->seq[pos+i] == 'G' || ctgc->seq[pos+i] == 'C')
    {
      gc_count++;
    }
    bases++;
  }
  return ((double) gc_count)/((double) GT_MIN(ctgc->windowsize, bases));
}

// Assembly:
movq 0x10(%rdi), %rax
xorl %ecx, %ecx
movsd 0x39bc7(%rip), %xmm0    # 0x30bcf0
movl $0x303, %edx            # imm = 0x303
movq %rax, %r8
subq $0x1, %r8
jb 0x2d2165
cmpq 0x40(%rdi), %rsi
ja 0x2d21ab
movq 0x38(%rdi), %r9
movb (%r9,%rsi), %r9b
addb $-0x43, %r9b
rolb $0x6, %r9b
cmpb $0x9, %r9b
ja 0x2d2160
movzbl %r9b, %r9d
btl %r9d, %edx
jae 0x2d2160
incq %rcx
incq %rsi
jmp 0x2d2131
movq %rcx, %xmm1
movq 0x1576e(%rip), %xmm2    # 0x2e78e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x15772(%rip), %xmm3    # 0x2e78f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: gt_custom_track_gc_content_new
GtCustomTrack* gt_custom_track_gc_content_new(const char *seq,
                                              GtUword seqlen,
                                              GtUword windowsize,
                                              GtUword height,
                                              double avg,
                                              bool show_scale)
{
  GtCustomTrackGcContent *ctgc;
  GtCustomTrack *ct;
  char buf[BUFSIZ];
  ct = gt_custom_track_create(gt_custom_track_gc_content_class());
  ctgc = gt_custom_track_gc_content_cast(ct);
  ctgc->windowsize = windowsize;
  ctgc->height = height;
  ctgc->seq = seq;
  ctgc->seqlen = seqlen;
  ctgc->avg = avg;
  ctgc->show_scale = show_scale;
  ctgc->title = gt_str_new_cstr("GC content (window size ");
  gt_str_append_uword(ctgc->title, ctgc->windowsize);
  if (gt_double_smaller_double(0, avg))
  {
    (void) snprintf(buf, BUFSIZ, ", average: %.1f%%", avg*100);
    gt_str_append_cstr(ctgc->title, buf);
  }
  gt_str_append_cstr(ctgc->title, ")");
  return ct;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
movl %r8d, %ebp
movsd %xmm0, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x2d20d2
movq %rax, %rdi
callq 0x2d174d
movq %rax, %r14
callq 0x2d20d2
movq %rax, %rdi
movq %r14, 0x8(%rsp)
movq %r14, %rsi
callq 0x2d19ef
movq %rax, %r14
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rbx, 0x38(%rax)
movq %r13, 0x40(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movb %bpl, 0x28(%rax)
leaq 0xb48c4(%rip), %rdi     # 0x386b3e
callq 0xacbd1
movq %rax, 0x30(%r14)
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0xace26
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
callq 0x955e2
testb %al, %al
je 0x2d22d5
movsd (%rsp), %xmm0
mulsd 0x17532(%rip), %xmm0    # 0x2e97e0
leaq 0xb48a2(%rip), %rdx     # 0x386b57
leaq 0x10(%rsp), %rbx
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdi
movb $0x1, %al
callq 0x17bf0
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0xacbfb
movq 0x30(%r14), %rdi
leaq 0xa6220(%rip), %rsi     # 0x378500
callq 0xacbfb
movq 0x8(%rsp), %rax
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_bgzf
int bgzf_check_bgzf(const char *fn)
{
    BGZF *fp;
    uint8_t buf[10],magic[10]="\037\213\010\4\0\0\0\0\0\377";
    int n;

    if ((fp = bgzf_open(fn, "r")) == 0) 
    {
        fprintf(stderr, "[bgzf_check_bgzf] failed to open the file: %s\n",fn);
        return -1;
    }

#ifdef _USE_KNETFILE
    n = knet_read(fp->x.fpr, buf, 10);
#else
    n = fread(buf, 1, 10, fp->file);
#endif
    bgzf_close(fp);

    if ( n!=10 ) 
        return -1;

    if ( !memcmp(magic, buf, 10) ) return 1;
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x25040(%rip), %rsi     # 0x2fae2d
callq 0x2d5e63
testq %rax, %rax
je 0x2d5e3d
movq %rax, %r14
movq 0x10(%rax), %rcx
leaq 0xe(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0xa
popq %rdx
callq 0x17ad0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d5f61
cmpl $0xa, %ebx
jne 0x2d5e58
leaq 0xb180b(%rip), %rdi     # 0x387630
leaq 0xe(%rsp), %rsi
pushq $0xa
popq %rdx
callq 0x177e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x2d5e5b
movq 0x162124(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0xb1872(%rip), %rsi     # 0x3876c0
movq %rbx, %rdx
xorl %eax, %eax
callq 0x17a50
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_open
BGZF*
bgzf_open(const char* __restrict path, const char* __restrict mode)
{
    BGZF* fp = NULL;
    if (strchr(mode, 'r') || strchr(mode, 'R')) { /* The reading mode is preferred. */
#ifdef _USE_KNETFILE
		knetFile *file = knet_open(path, mode);
		if (file == 0) return 0;
		fp = bgzf_read_init();
		fp->file_descriptor = -1;
		fp->open_mode = 'r';
		fp->x.fpr = file;
#else
		int fd, oflag = O_RDONLY;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag);
		if (fd == -1) return 0;
        fp = open_read(fd);
#endif
    } else if (strchr(mode, 'w') || strchr(mode, 'W')) {
		int fd, compress_level = -1, oflag = O_WRONLY | O_CREAT | O_TRUNC;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag, 0666);
		if (fd == -1) return 0;
		{ // set compress_level
			int i;
			for (i = 0; mode[i]; ++i)
				if (mode[i] >= '0' && mode[i] <= '9') break;
			if (mode[i]) compress_level = (int)mode[i] - '0';
			if (strchr(mode, 'u')) compress_level = 0;
		}
        fp = open_write(fd, compress_level);
    }
    if (fp != NULL) fp->owned_file = 1;
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x72
popq %rsi
movq %rbx, %rdi
callq 0x17260
testq %rax, %rax
jne 0x2d5e90
pushq $0x52
popq %rsi
movq %rbx, %rdi
callq 0x17260
testq %rax, %rax
je 0x2d5ec7
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x17ce0
cmpl $-0x1, %eax
je 0x2d5f53
movl %eax, %edi
callq 0x2d607a
movq %rax, %r14
testq %rax, %rax
je 0x2d5f50
movw $0x1, 0x6(%r14)
jmp 0x2d5f53
pushq $0x77
popq %rsi
movq %rbx, %rdi
callq 0x17260
testq %rax, %rax
jne 0x2d5ee7
pushq $0x57
popq %rsi
movq %rbx, %rdi
callq 0x17260
testq %rax, %rax
je 0x2d5f50
xorl %r14d, %r14d
movq %r15, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x17ce0
cmpl $-0x1, %eax
je 0x2d5f53
movl %eax, %ebp
movq %rbx, %rcx
movzbl (%rcx), %eax
testl %eax, %eax
je 0x2d5f1a
leal -0x30(%rax), %edx
incq %rcx
cmpb $0x9, %dl
ja 0x2d5f08
leal -0x30(%rax), %ecx
xorl %r15d, %r15d
cmpl $0x1, %eax
movl $0x0, %r14d
sbbl %r14d, %r14d
orl %ecx, %r14d
pushq $0x75
popq %rsi
movq %rbx, %rdi
callq 0x17260
testq %rax, %rax
cmovnel %r15d, %r14d
movl %ebp, %edi
movl %r14d, %esi
callq 0x2d60fe
jmp 0x2d5eaf
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_read
static
BGZF*
open_read(int fd)
{
#ifdef _USE_KNETFILE
    knetFile *file = knet_dopen(fd, "r");
#else
    FILE* file = fdopen(fd, "r");
#endif
    BGZF* fp;
	if (file == 0) return 0;
	fp = bgzf_read_init();
    fp->file_descriptor = fd;
    fp->open_mode = 'r';
#ifdef _USE_KNETFILE
    fp->x.fpr = file;
#else
    fp->file = file;
#endif
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
leaq 0x24da2(%rip), %rsi     # 0x2fae2d
callq 0x17810
testq %rax, %rax
je 0x2d60ef
movq %rax, %r14
pushq $0x1
popq %r12
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x174c0
movq %rax, %r15
movl $0x10000, %ebp          # imm = 0x10000
movl %ebp, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17f50
movq %rax, 0x20(%r15)
movl %ebp, 0x1c(%r15)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17f50
movq %rax, 0x28(%r15)
pushq $0x28
popq %rsi
movq %r12, %rdi
callq 0x174c0
movq %rax, 0x50(%r15)
movl %ebx, (%r15)
movb $0x72, 0x4(%r15)
movq %r14, 0x10(%r15)
jmp 0x2d60f2
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_write
static
BGZF*
open_write(int fd, int compress_level) // compress_level==-1 for the default level
{
    FILE* file = fdopen(fd, "w");
    BGZF* fp;
	if (file == 0) return 0;
	fp = malloc(sizeof(BGZF));
    fp->file_descriptor = fd;
    fp->open_mode = 'w';
    fp->owned_file = 0;
	fp->compress_level = compress_level < 0? Z_DEFAULT_COMPRESSION : compress_level; // Z_DEFAULT_COMPRESSION==-1
	if (fp->compress_level > 9) fp->compress_level = Z_DEFAULT_COMPRESSION;
#ifdef _USE_KNETFILE
    fp->x.fpw = file;
#else
    fp->file = file;
#endif
    fp->uncompressed_block_size = DEFAULT_BLOCK_SIZE;
    fp->uncompressed_block = NULL;
    fp->compressed_block_size = MAX_BLOCK_SIZE;
    fp->compressed_block = malloc(MAX_BLOCK_SIZE);
    fp->block_address = 0;
    fp->block_offset = 0;
    fp->block_length = 0;
    fp->error = NULL;
    return fp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r15d
leaq 0x5d7fd(%rip), %rsi     # 0x33390e
callq 0x17810
testq %rax, %rax
je 0x2d6180
movq %rax, %r14
pushq $0x58
popq %rdi
callq 0x17f50
movq %rax, %rbx
movl %r15d, (%rax)
movb $0x77, 0x4(%rax)
andw $0x0, 0x6(%rax)
testl %ebp, %ebp
pushq $-0x1
popq %rax
cmovnsl %ebp, %eax
cmpw $0xa, %ax
movl $0xffff, %ecx           # imm = 0xFFFF
cmovll %eax, %ecx
movw %cx, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movabsq $0x1000000010000, %rax  # imm = 0x1000000010000
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movl $0x10000, %edi          # imm = 0x10000
callq 0x17f50
movq %rax, 0x28(%rbx)
andq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
jmp 0x2d6182
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_fdopen
BGZF*
bgzf_fdopen(int fd, const char * __restrict mode)
{
	if (fd == -1) return 0;
    if (mode[0] == 'r' || mode[0] == 'R') {
        return open_read(fd);
    } else if (mode[0] == 'w' || mode[0] == 'W') {
		int i, compress_level = -1;
		for (i = 0; mode[i]; ++i)
			if (mode[i] >= '0' && mode[i] <= '9') break;
		if (mode[i]) compress_level = (int)mode[i] - '0';
		if (strchr(mode, 'u')) compress_level = 0;
        return open_write(fd, compress_level);
    } else {
        return NULL;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x2d61fd
movl %edi, %ebx
movzbl (%rsi), %ecx
cmpl $0x52, %ecx
je 0x2d6204
movq %rsi, %rax
cmpl $0x77, %ecx
je 0x2d61b8
cmpl $0x72, %ecx
je 0x2d6204
movq %rsi, %rax
cmpl $0x57, %ecx
jne 0x2d61fd
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x2d61ca
leal -0x30(%rcx), %edx
incq %rax
cmpb $0x9, %dl
ja 0x2d61b8
leal -0x30(%rcx), %eax
xorl %r14d, %r14d
cmpl $0x1, %ecx
movl $0x0, %ebp
sbbl %ebp, %ebp
orl %eax, %ebp
pushq $0x75
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x17260
testq %rax, %rax
cmovnel %r14d, %ebp
movl %ebx, %edi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2d60fe
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2d607a
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_read
int
bgzf_read(BGZF* fp, void* data, int length)
{
    if (length <= 0) {
        return 0;
    }
    if (fp->open_mode != 'r') {
        report_error(fp, "file not open for reading");
        return -1;
    }

    int bytes_read = 0;
    bgzf_byte_t* output = data;
    while (bytes_read < length) {
        int copy_length, available = fp->block_length - fp->block_offset;
		bgzf_byte_t *buffer;
        if (available <= 0) {
            if (bgzf_read_block(fp) != 0) {
                return -1;
            }
            available = fp->block_length - fp->block_offset;
            if (available <= 0) {
                break;
            }
        }
        copy_length = bgzf_min(length-bytes_read, available);
        buffer = fp->uncompressed_block;
        memcpy(output, buffer + fp->block_offset, copy_length);
        fp->block_offset += copy_length;
        output += copy_length;
        bytes_read += copy_length;
    }
    if (fp->block_offset == fp->block_length) {
#ifdef _USE_KNETFILE
        fp->block_address = knet_tell(fp->x.fpr);
#else
        fp->block_address = ftello(fp->file);
#endif
        fp->block_offset = 0;
        fp->block_length = 0;
    }
    return bytes_read;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x2d69cb
movq %rdi, %r14
cmpb $0x72, 0x4(%rdi)
jne 0x2d69cf
movl %edx, %ebp
movq %rsi, %r15
movl 0x3c(%r14), %eax
xorl %ebx, %ebx
pushq $-0x1
popq %r13
movl %ebp, %r12d
movl 0x38(%r14), %ecx
subl %ebx, %r12d
jle 0x2d69df
subl %eax, %ecx
jg 0x2d699c
movq %r14, %rdi
callq 0x2d620f
testl %eax, %eax
jne 0x2d69f9
movl 0x38(%r14), %edx
movl 0x3c(%r14), %eax
movl %edx, %ecx
subl %eax, %ecx
jle 0x2d69e1
cmpl %ecx, %r12d
cmovll %r12d, %ecx
movslq %eax, %rsi
addq 0x20(%r14), %rsi
movslq %ecx, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x17630
movl 0x3c(%r14), %eax
addl %r12d, %eax
movl %eax, 0x3c(%r14)
addq %r12, %r15
addl %r12d, %ebx
jmp 0x2d6972
xorl %ebx, %ebx
jmp 0x2d69fc
leaq 0xb0d3a(%rip), %rax     # 0x387710
movq %rax, 0x48(%r14)
pushq $-0x1
popq %rbx
jmp 0x2d69fc
movl %ecx, %edx
cmpl %edx, %eax
jne 0x2d69fc
movq 0x10(%r14), %rdi
callq 0x17b50
movq %rax, 0x30(%r14)
andq $0x0, 0x38(%r14)
jmp 0x2d69fc
movl %r13d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_flush
int bgzf_flush(BGZF* fp)
{
    while (fp->block_offset > 0) {
        int count, block_length;
		block_length = deflate_block(fp, fp->block_offset);
        if (block_length < 0) return -1;
#ifdef _USE_KNETFILE
        count = fwrite(fp->compressed_block, 1, block_length, fp->x.fpw);
#else
        count = fwrite(fp->compressed_block, 1, block_length, fp->file);
#endif
        if (count != block_length) {
            report_error(fp, "write failed");
            return -1;
        }
        fp->block_address += block_length;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
pushq $-0x1
popq %rbx
pushq $0x1
popq %r15
movl 0x3c(%r14), %esi
testl %esi, %esi
jle 0x2d6a55
movq %r14, %rdi
callq 0x2d6a6f
testl %eax, %eax
js 0x2d6a64
movl %eax, %ebp
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdi
movl %eax, %r12d
movq %r15, %rsi
movq %r12, %rdx
callq 0x17f00
cmpl %eax, %ebp
jne 0x2d6a59
addq %r12, 0x30(%r14)
jmp 0x2d6a1f
xorl %ebx, %ebx
jmp 0x2d6a64
leaq 0xb0cca(%rip), %rax     # 0x38772a
movq %rax, 0x48(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_write
int bgzf_write(BGZF* fp, const void* data, int length)
{
	const bgzf_byte_t *input = data;
	int block_length, bytes_written;
    if (fp->open_mode != 'w') {
        report_error(fp, "file not open for writing");
        return -1;
    }

    if (fp->uncompressed_block == NULL)
        fp->uncompressed_block = malloc(fp->uncompressed_block_size);

    input = data;
    block_length = fp->uncompressed_block_size;
    bytes_written = 0;
    while (bytes_written < length) {
        int copy_length = bgzf_min(block_length - fp->block_offset, length - bytes_written);
        bgzf_byte_t* buffer = fp->uncompressed_block;
        memcpy(buffer + fp->block_offset, input, copy_length);
        fp->block_offset += copy_length;
        input += copy_length;
        bytes_written += copy_length;
        if (fp->block_offset == block_length) {
            if (bgzf_flush(fp) != 0) {
                break;
            }
        }
    }
    return bytes_written;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x77, 0x4(%rdi)
jne 0x2d6cdc
movl %edx, %ebp
movq %rsi, %r14
cmpq $0x0, 0x20(%rbx)
movslq 0x18(%rbx), %r15
jne 0x2d6c90
movq %r15, %rdi
callq 0x17f50
movq %rax, 0x20(%rbx)
xorl %r12d, %r12d
movl %ebp, %eax
subl %r12d, %eax
jle 0x2d6ceb
movslq 0x3c(%rbx), %rdi
movl %r15d, %ecx
subl %edi, %ecx
cmpl %eax, %ecx
cmovgel %eax, %ecx
addq 0x20(%rbx), %rdi
movslq %ecx, %r13
movq %r14, %rsi
movq %r13, %rdx
callq 0x17630
movl 0x3c(%rbx), %eax
addl %r13d, %eax
movl %eax, 0x3c(%rbx)
addq %r13, %r14
addl %r13d, %r12d
cmpl %r15d, %eax
jne 0x2d6c93
movq %rbx, %rdi
callq 0x2d6a0d
testl %eax, %eax
je 0x2d6c93
jmp 0x2d6ceb
leaq 0xb0a54(%rip), %rax     # 0x387737
movq %rax, 0x48(%rbx)
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_EOF
int bgzf_check_EOF(BGZF *fp)
{
	static uint8_t magic[28] = "\037\213\010\4\0\0\0\0\0\377\6\0\102\103\2\0\033\0\3\0\0\0\0\0\0\0\0\0";
	uint8_t buf[28];
	off_t offset;
#ifdef _USE_KNETFILE
	offset = knet_tell(fp->x.fpr);
	if (knet_seek(fp->x.fpr, -28, SEEK_END) != 0) return -1;
	knet_read(fp->x.fpr, buf, 28);
	knet_seek(fp->x.fpr, offset, SEEK_SET);
#else
	offset = ftello(fp->file);
	if (fseeko(fp->file, -28, SEEK_END) != 0) return -1;
	fread(buf, 1, 28, fp->file);
	fseeko(fp->file, offset, SEEK_SET);
#endif
	return (memcmp(magic, buf, 28) == 0)? 1 : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x17b50
movq %rax, %r14
movq 0x10(%rbx), %rdi
pushq $-0x1c
popq %rsi
pushq $0x2
popq %rdx
callq 0x17c70
testl %eax, %eax
je 0x2d6d38
pushq $-0x1
popq %rax
jmp 0x2d6d7a
movq 0x10(%rbx), %rcx
movq %rsp, %r15
pushq $0x1
popq %rsi
pushq $0x1c
popq %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x17ad0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x17c70
leaq 0x165a8a(%rip), %rdi    # 0x43c7f0
movq %r15, %rsi
movq %r12, %rdx
callq 0x177e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_write
int razf_write(RAZF* rz, const void *data, int size){
	int ori_size, n;
	int64_t next_block;
	ori_size = size;
	next_block = ((rz->in / RZ_BLOCK_SIZE) + 1) * RZ_BLOCK_SIZE;
	while(rz->in + rz->buf_len + size >= next_block){
		n = next_block - rz->in - rz->buf_len;
		_razf_buffered_write(rz, data, n);
		data += n;
		size -= n;
		razf_flush(rz);
		add_zindex(rz, rz->in, rz->out);
		next_block = ((rz->in / RZ_BLOCK_SIZE) + 1) * RZ_BLOCK_SIZE;
	}
	_razf_buffered_write(rz, data, size);
	return ori_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movl $0x8000, %ebx           # imm = 0x8000
pushq $0x3
popq %rbp
movl %edx, 0x4(%rsp)
movq 0x20(%r15), %rcx
movq %rcx, %rax
cqto
idivq %rbx
movq %rax, %r13
shlq $0xf, %r13
addq %rbx, %r13
movslq 0x84(%r15), %rax
addq %rcx, %rax
movslq %r12d, %rcx
addq %rax, %rcx
cmpq %r13, %rcx
jl 0x2d8277
subq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x2d8298
movl 0x84(%r15), %edx
testl %edx, %edx
je 0x2d815b
movq 0x60(%r15), %rsi
movq %r15, %rdi
callq 0x2d914f
andq $0x0, 0x80(%r15)
movslq %r13d, %rax
addq %rax, %r14
subl %r13d, %r12d
movq 0x10(%r15), %rdi
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x2d8183
movl 0x8(%r15), %edi
movq 0x68(%r15), %rsi
movl $0x1000, %edx           # imm = 0x1000
subl %eax, %edx
jmp 0x2d8220
xorl %r13d, %r13d
movl %ebp, %esi
callq 0x21822a
movq 0x10(%r15), %rax
movl 0x20(%rax), %eax
subl %eax, %r13d
addq 0x28(%r15), %r13
movq %r13, 0x28(%r15)
testl %eax, %eax
je 0x2d8213
movq %r13, 0x48(%r15)
andq $0x0, 0x50(%r15)
movq 0x18(%r15), %rcx
movl 0x10(%rcx), %edx
cmpl 0x14(%rcx), %edx
jne 0x2d8243
cvtsi2sd %edx, %xmm0
mulsd 0xaf738(%rip), %xmm0    # 0x387900
addsd 0x31138(%rip), %xmm0    # 0x309308
cvttsd2si %xmm0, %eax
movl %eax, 0x14(%rcx)
movq (%rcx), %rdi
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x17f58
movq 0x18(%r15), %rcx
movq %rax, (%rcx)
movq 0x8(%rcx), %rdi
movslq 0x14(%rcx), %rax
shrq $0x11, %rax
leaq 0x8(,%rax,8), %rsi
callq 0x17f58
movq 0x18(%r15), %rcx
movq %rax, 0x8(%rcx)
movl 0x10(%rcx), %edx
jmp 0x2d8247
movl 0x8(%r15), %edi
movq 0x68(%r15), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x17250
movq 0x10(%r15), %rdi
movl $0x1000, 0x20(%rdi)     # imm = 0x1000
movq 0x68(%r15), %rax
movq %rax, 0x18(%rdi)
movl $0x1000, %r13d          # imm = 0x1000
jmp 0x2d8186
movq 0x8(%rcx), %rax
movslq %edx, %rdx
testl $0x1ffff, %edx          # imm = 0x1FFFF
jne 0x2d825d
movq %rdx, %rsi
shrq $0xe, %rsi
movq %r13, (%rax,%rsi)
movq %rdx, %rsi
shrq $0x11, %rsi
subl (%rax,%rsi,8), %r13d
movq (%rcx), %rax
movl %r13d, (%rax,%rdx,4)
incl 0x10(%rcx)
jmp 0x2d80fc
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x2d8298
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_buffered_write
static void _razf_buffered_write(RAZF *rz, const void *data, int size){
	int i, n;
	while(1){
		if(rz->buf_len == RZ_BUFFER_SIZE){
			_razf_write(rz, rz->inbuf, rz->buf_len);
			rz->buf_len = 0;
		}
		if(size + rz->buf_len < RZ_BUFFER_SIZE){
			for(i=0;i<size;i++) ((char*)rz->inbuf + rz->buf_len)[i] = ((char*)data)[i];
			rz->buf_len += size;
			return;
		} else {
			n = RZ_BUFFER_SIZE - rz->buf_len;
			for(i=0;i<n;i++) ((char*)rz->inbuf + rz->buf_len)[i] = ((char*)data)[i];
			size -= n;
			data += n;
			rz->buf_len += n;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x84(%rdi), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2d82cd
movq 0x60(%r14), %rsi
movq %r14, %rdi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2d914f
andl $0x0, 0x84(%r14)
xorl %eax, %eax
leal (%rax,%rbx), %ecx
cmpl $0xfff, %ecx            # imm = 0xFFF
jle 0x2d831b
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
xorl %esi, %esi
movslq 0x84(%r14), %rax
cmpq %rsi, %rdx
je 0x2d8308
movb (%r15,%rsi), %dil
addq 0x60(%r14), %rax
movb %dil, (%rsi,%rax)
incq %rsi
jmp 0x2d82eb
subl %ecx, %ebx
movslq %ecx, %rdx
addq %rdx, %r15
addl %ecx, %eax
movl %eax, 0x84(%r14)
jmp 0x2d82ab
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
cmpq %rax, %rcx
je 0x2d8343
movb (%r15,%rax), %dl
movslq 0x84(%r14), %rsi
addq 0x60(%r14), %rsi
movb %dl, (%rax,%rsi)
incq %rax
jmp 0x2d8327
addl %ebx, 0x84(%r14)
popq %rbx
popq %r14
popq %r15
retq