LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/element.c
// Function: elements_are_equal
static bool elements_are_equal(const GtElement *e1, const GtElement *e2)
{
  gt_assert(e1 && e2);
  if (e1->type == e2->type && !gt_range_compare(&e1->range, &e2->range))
    return true;
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x8ea8b
testq %rsi, %rsi
je 0x8ea8b
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x8ea83
addq $0x20, %rdi
addq $0x20, %rsi
callq 0x7df58
testl %eax, %eax
je 0x8ea87
xorl %eax, %eax
popq %rcx
retq
movb $0x1, %al
jmp 0x8ea85
callq 0x21ba7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_delete
void gt_element_delete(GtElement *element)
{
  if (!element) return;
  if (element->refcount) {
    element->refcount--;
    return;
  }
  gt_genome_node_delete((GtGenomeNode*) element->gn);
  gt_free(element);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8eaa9
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x8eaab
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x42ade
leaq 0x67e21(%rip), %rsi     # 0xf68dc
movq %rbx, %rdi
movl $0xb4, %edx
popq %rbx
jmp 0x362a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_new
GtLine* gt_line_new(void)
{
  GtLine *line;
  line = gt_calloc(1, sizeof (GtLine));
  line->blocks = gt_array_new(sizeof (GtBlock*));
  line->has_captions = false;
  return line;
}

// Assembly:
pushq %rbx
leaq 0x67ff5(%rip), %rdx     # 0xf6ac9
movl $0x1, %edi
movl $0x10, %esi
movl $0x26, %ecx
callq 0x3601f
movq %rax, %rbx
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x8(%rbx)
movb $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_insert_block
void gt_line_insert_block(GtLine *line, GtBlock *block)
{
  gt_assert(line && block);
  if (!line->has_captions && gt_block_get_caption(block) != NULL)
    line->has_captions = true;
  gt_array_add(line->blocks, block);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x8eb46
testq %rsi, %rsi
je 0x8eb46
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x8eb2d
movq %rsi, %rdi
callq 0x8ac63
testq %rax, %rax
je 0x8eb2d
movb $0x1, (%rbx)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
retq
callq 0x21bde
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_sketch
int gt_line_sketch(GtLine *line, GtCanvas *canvas, GtError *err)
{
  int i = 0, had_err = 0;
  gt_assert(line && canvas);
  had_err = gt_canvas_visit_line_pre(canvas, line, err);
  if (!had_err)
  {
    for (i = 0; !had_err && i < gt_array_size(line->blocks); i++) {
      GtBlock *block;
      block = *(GtBlock**) gt_array_get(line->blocks, i);
      had_err = gt_block_sketch(block, canvas, err);
    }
  }
  if (!had_err)
    had_err = gt_canvas_visit_line_post(canvas, line, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8ebf5
movq %rsi, %r15
testq %rsi, %rsi
je 0x8ebf5
movq %rdx, %rbx
movq %rdi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4cbd3
testl %eax, %eax
jne 0x8ebc9
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rdi
callq 0x6ecda
cmpq %r13, %rax
jbe 0x8ebcc
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x8b2b0
incq %r13
testl %eax, %eax
je 0x8eb9a
movl %eax, %r12d
testl %r12d, %r12d
je 0x8ebde
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4cbf4
callq 0x21c83
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_get_height
int gt_line_get_height(GtLine *line, double *height, const GtStyle *sty,
                       GtError *err)
{
  double line_height = 0;
  GtUword i;
  gt_assert(line && sty);
  for (i = 0; i < gt_array_size(line->blocks); i++) {
    GtBlock *block;
    double myheight = BAR_HEIGHT_DEFAULT;
    block = *(GtBlock**) gt_array_get(line->blocks, i);
    /* check again for caption presence, may have changed in the meantime */
    if (!line->has_captions && gt_block_get_caption(block) != NULL) {
      line->has_captions = true;
    }
    if (gt_block_get_max_height(block, &myheight, sty, err) < 0) {
      return -1;
    }
    if (gt_double_smaller_double(line_height, myheight)) {
      line_height = myheight;
    }
  }
  *height = line_height;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x8ecff
movq %rdx, %r15
testq %rdx, %rdx
je 0x8ecff
movq %rcx, %r14
movq %rdi, %r12
movq %rsi, 0x10(%rsp)
movq 0x8(%rdi), %rdi
callq 0x6ecda
xorps %xmm0, %xmm0
testq %rax, %rax
je 0x8ecd4
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
leaq 0x8(%rsp), %rbp
movabsq $0x4030000000000000, %rax # imm = 0x4030000000000000
movq %rax, 0x8(%rsp)
movq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0x6e9fa
movq (%rax), %rbx
cmpb $0x0, (%r12)
jne 0x8ec82
movq %rbx, %rdi
callq 0x8ac63
testq %rax, %rax
je 0x8ec82
movb $0x1, (%r12)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x8b111
movl %eax, %ebx
testl %eax, %eax
js 0x8ecb8
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
callq 0x7a0a0
testb %al, %al
je 0x8ecb8
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
testl %ebx, %ebx
js 0x8eceb
incq %r13
movq 0x8(%r12), %rdi
callq 0x6ecda
cmpq %rax, %r13
jb 0x8ec4a
jmp 0x8ecd9
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
xorl %eax, %eax
jmp 0x8ecf0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x21cba
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line.c
// Function: gt_line_delete
void gt_line_delete(GtLine *line)
{
  GtUword i;
  if (!line) return;
  for (i = 0; i < gt_array_size(line->blocks); i++)
    gt_block_delete(*(GtBlock**) gt_array_get(line->blocks, i));
  gt_array_delete(line->blocks);
  gt_free(line);
}

// Assembly:
testq %rdi, %rdi
je 0x8f68a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x8f666
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x8bcd2
incq %r14
movq 0x8(%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r14
jb 0x8f641
movq 0x8(%rbx), %rdi
callq 0x6f134
leaq 0x67453(%rip), %rsi     # 0xf6ac9
movq %rbx, %rdi
movl $0xd6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_class_new
const GtLineBreakerClass* gt_line_breaker_class_new(size_t size,
                                  GtLineBreakerIsOccupiedFunc is_occupied,
                                  GtLineBreakerRegisterBlockFunc register_block,
                                  GtLineBreakerFreeFunc free)
{
  GtLineBreakerClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->is_occupied = is_occupied;
  c_class->register_block = register_block;
  c_class->free = free;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x71ca4
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
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_create
GtLineBreaker* gt_line_breaker_create(const GtLineBreakerClass *lbc)
{
  GtLineBreaker *lb;
  gt_assert(lbc && lbc->size);
  lb = gt_calloc(1, lbc->size);
  lb->c_class = lbc;
  lb->pvt = gt_calloc(1, sizeof (GtLineBreakerMembers));
  return lb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8f71d
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x8f71d
leaq 0x675c0(%rip), %r14     # 0xf6ca1
movl $0x1, %edi
movq %r14, %rdx
movl $0x34, %ecx
callq 0x3601f
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x3601f
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x21d28
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker.c
// Function: gt_line_breaker_delete
void gt_line_breaker_delete(GtLineBreaker *lb)
{
  if (!lb) return;
  if (lb->pvt->reference_count) {
    lb->pvt->reference_count--;
    return;
  }
  gt_assert(lb->c_class);
  if (lb->c_class->free)
    lb->c_class->free(lb);
  gt_free(lb->pvt);
  gt_free(lb);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8f751
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x8f759
decl %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x8f79e
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x8f76f
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x67527(%rip), %r14     # 0xf6ca1
movq %r14, %rsi
movl $0x4b, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4c, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0x21d96
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_is_line_occupied
int gt_line_breaker_bases_is_line_occupied(GtLineBreaker* lb, bool *result,
                                           GtLine *line, GtBlock *block,
                                           GT_UNUSED GtError *err)
{
  GtLineBreakerBases *lbb;
  GtRange r;
  GtIntervalTree *t;
  gt_assert(lb && block && line);
  r = gt_block_get_range(block);
  lbb = gt_line_breaker_bases_cast(lb);
  if (!(t = gt_hashmap_get(lbb->itrees, line)))
    *result = false;
  else
    *result = (gt_interval_tree_find_first_overlapping(t, r.start, r.end));
  return 0; /* gt_line_breaker_bases_is_line_occupied() is sane */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x8f8aa
movq %rdi, %r13
testq %rdi, %rdi
je 0x8f8aa
testq %rcx, %rcx
je 0x8f8aa
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
callq 0x8ac4f
movq %rax, %r15
movq %rdx, %r12
callq 0x8f8af
movq %rax, %rdi
movq %r13, %rsi
callq 0x8f81a
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x77109
testq %rax, %rax
je 0x8f89a
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x78eaa
testq %rax, %rax
setne %al
jmp 0x8f89c
xorl %eax, %eax
movb %al, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x21e72
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_class
const GtLineBreakerClass* gt_line_breaker_bases_class(void)
{
  static const GtLineBreakerClass *lbc = NULL;
  gt_class_alloc_lock_enter();
  if (!lbc)
  {
    lbc = gt_line_breaker_class_new(sizeof (GtLineBreakerBases),
                                    gt_line_breaker_bases_is_line_occupied,
                                    gt_line_breaker_bases_register_block,
                                    gt_line_breaker_bases_delete);
  }
  gt_class_alloc_lock_leave();
  return lbc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0xc3393(%rip)     # 0x152c50
jne 0x8f8e5
leaq -0x92(%rip), %rsi       # 0x8f834
leaq 0x26(%rip), %rdx        # 0x8f8f3
leaq 0xbb(%rip), %rcx        # 0x8f98f
movl $0x18, %edi
callq 0x8f68c
movq %rax, 0xc336b(%rip)     # 0x152c50
callq 0x71db1
movq 0xc335f(%rip), %rax     # 0x152c50
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_register_block
int gt_line_breaker_bases_register_block(GtLineBreaker *lb,
                                         GtLine *line,
                                         GtBlock *block,
                                         GT_UNUSED GtError *err)
{
  GtLineBreakerBases *lbb;
  GtIntervalTree *t;
  GtIntervalTreeNode *new_node;
  GtRange *rng;
  gt_assert(lb && block && line);
  lbb = gt_line_breaker_bases_cast(lb);
  rng = gt_block_get_range_ptr(block);
  new_node = gt_interval_tree_node_new(rng, rng->start, rng->end);
  if (!(t = gt_hashmap_get(lbb->itrees, line)))
  {
    t = gt_interval_tree_new(NULL);
    gt_hashmap_add(lbb->itrees, line, t);
  }
  gt_interval_tree_insert(t, new_node);
  return 0; /* gt_line_breaker_bases_register_block() is sane */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x8f98a
movq %rdi, %r14
testq %rdi, %rdi
je 0x8f98a
movq %rdx, %r15
testq %rdx, %rdx
je 0x8f98a
movq %rsi, %rbx
callq 0x8f8af
movq %rax, %rdi
movq %r14, %rsi
callq 0x8f81a
movq %rax, %r14
movq %r15, %rdi
callq 0x8afed
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rax, %rdi
callq 0x78de8
movq %rax, %r15
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x77109
movq %rax, %r12
testq %rax, %rax
jne 0x8f971
xorl %edi, %edi
callq 0x78e23
movq %rax, %r12
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x77144
movq %r12, %rdi
movq %r15, %rsi
callq 0x7904d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x21ea9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/line_breaker_bases.c
// Function: gt_line_breaker_bases_new
GtLineBreaker* gt_line_breaker_bases_new()
{
  GtLineBreakerBases *lbb;
  GtLineBreaker *lb;
  lb = gt_line_breaker_create(gt_line_breaker_bases_class());
  lbb = gt_line_breaker_bases_cast(lb);
  lbb->itrees = gt_hashmap_new(GT_HASH_DIRECT, NULL,
                               (GtFree) gt_interval_tree_delete);
  return lb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x8f8af
movq %rax, %rdi
callq 0x8f6c5
movq %rax, %rbx
callq 0x8f8af
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8f81a
movq %rax, %r14
leaq -0x167fc(%rip), %rdx    # 0x791e5
xorl %edi, %edi
xorl %esi, %esi
callq 0x76f28
movq %rax, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/regerror.c
// Function: tre_regerror
size_t
tre_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
{
  const char *err;
  size_t err_len;

  /*LINTED*/(void)&preg;
  if (errcode >= 0
      && errcode < (int)(sizeof(tre_error_messages)
			 / sizeof(*tre_error_messages)))
    err = gettext(tre_error_messages[errcode]);
  else
    err = gettext("Unknown error");

  err_len = strlen(err) + 1;
  if (errbuf_size > 0 && errbuf != NULL)
    {
      if (err_len > errbuf_size)
	{
	  strncpy(errbuf, err, errbuf_size - 1);
	  errbuf[errbuf_size - 1] = '\0';
	}
      else
	{
	  strcpy(errbuf, err);
	}
    }
  return err_len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
cmpl $0xd, %edi
ja 0x8fa61
movl %edi, %eax
leaq 0x673e0(%rip), %rcx     # 0xf6e38
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
jmp 0x8fa68
leaq 0x67408(%rip), %r15     # 0xf6e70
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
incq %r12
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x8faad
cmpq %r14, %r12
jbe 0x8faa2
leaq -0x1(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2d0
movb $0x0, -0x1(%rbx,%r14)
jmp 0x8faad
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb600
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_ast_to_tnfa
static reg_errcode_t
tre_ast_to_tnfa(tre_ast_node_t *node, tre_tnfa_transition_t *transitions,
		int *counts, int *offs)
{
  tre_union_t *uni;
  tre_catenation_t *cat;
  tre_iteration_t *iter;
  reg_errcode_t errcode = REG_OK;

  /* XXX - recurse using a stack!. */
  switch (node->type)
    {
    case LITERAL:
      break;
    case UNION:
      uni = (tre_union_t *)node->obj;
      errcode = tre_ast_to_tnfa(uni->left, transitions, counts, offs);
      if (errcode != REG_OK)
	return errcode;
      errcode = tre_ast_to_tnfa(uni->right, transitions, counts, offs);
      break;

    case CATENATION:
      cat = (tre_catenation_t *)node->obj;
      /* Add a transition from each position in cat->left->lastpos
	 to each position in cat->right->firstpos. */
      errcode = tre_make_trans(cat->left->lastpos, cat->right->firstpos,
			       transitions, counts, offs);
      if (errcode != REG_OK)
	return errcode;
      errcode = tre_ast_to_tnfa(cat->left, transitions, counts, offs);
      if (errcode != REG_OK)
	return errcode;
      errcode = tre_ast_to_tnfa(cat->right, transitions, counts, offs);
      break;

    case ITERATION:
      iter = (tre_iteration_t *)node->obj;
      assert(iter->max == -1 || iter->max == 1);

      if (iter->max == -1)
	{
	  assert(iter->min == 0 || iter->min == 1);
	  /* Add a transition from each last position in the iterated
	     expression to each first position. */
	  errcode = tre_make_trans(iter->arg->lastpos, iter->arg->firstpos,
				   transitions, counts, offs);
	  if (errcode != REG_OK)
	    return errcode;
	}
      errcode = tre_ast_to_tnfa(iter->arg, transitions, counts, offs);
      break;
    }
  return errcode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x9218f
cmpl $0x2, %eax
je 0x92177
cmpl $0x3, %eax
jne 0x92201
movq 0x8(%rdi), %r12
jmp 0x921b6
movq 0x8(%rdi), %r12
movl 0xc(%r12), %eax
cmpl $-0x1, %eax
je 0x921d2
cmpl $0x1, %eax
je 0x921f8
jmp 0x9220f
movq 0x8(%rdi), %r12
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq 0x28(%rax), %rdi
movq 0x20(%rcx), %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x92ed9
testl %eax, %eax
jne 0x92203
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x9214b
testl %eax, %eax
jne 0x92203
addq $0x8, %r12
jmp 0x921f8
cmpl $0x2, 0x8(%r12)
jae 0x9222e
movq (%r12), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x92ed9
testl %eax, %eax
jne 0x92203
movq (%r12), %rdi
jmp 0x9215c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x65156(%rip), %rdi     # 0xf736c
leaq 0x64ee6(%rip), %rsi     # 0xf7103
leaq 0x6516a(%rip), %rcx     # 0xf738e
movl $0x721, %edx            # imm = 0x721
callq 0xb400
leaq 0x651b0(%rip), %rdi     # 0xf73e5
leaq 0x64ec7(%rip), %rsi     # 0xf7103
leaq 0x6514b(%rip), %rcx     # 0xf738e
movl $0x725, %edx            # imm = 0x725
callq 0xb400
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_free
void
tre_free(regex_t *preg)
{
  tre_tnfa_t *tnfa;
  unsigned int i;
  tre_tnfa_transition_t *trans;

  tnfa = (void *)preg->TRE_REGEX_T_FIELD;
  if (!tnfa)
    return;

  for (i = 0; i < tnfa->num_transitions; i++)
    if (tnfa->transitions[i].state)
      {
	if (tnfa->transitions[i].tags)
	  xfree(tnfa->transitions[i].tags);
	if (tnfa->transitions[i].neg_classes)
	  xfree(tnfa->transitions[i].neg_classes);
	if (tnfa->transitions[i].params)
	  xfree(tnfa->transitions[i].params);
      }
  if (tnfa->transitions)
    xfree(tnfa->transitions);

  if (tnfa->initial)
    {
      for (trans = tnfa->initial; trans->state; trans++)
	{
	  if (trans->tags)
	    xfree(trans->tags);
	  if (trans->params)
	    xfree(trans->params);
	}
      xfree(tnfa->initial);
    }

  if (tnfa->submatch_data)
    {
      for (i = 0; i < tnfa->num_submatches; i++)
	if (tnfa->submatch_data[i].parents)
	  xfree(tnfa->submatch_data[i].parents);
      xfree(tnfa->submatch_data);
    }

  if (tnfa->tag_directions)
    xfree(tnfa->tag_directions);
  if (tnfa->firstpos_chars)
    xfree(tnfa->firstpos_chars);
  if (tnfa->minimal_tags)
    xfree(tnfa->minimal_tags);
  xfree(tnfa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x9237f
cmpl $0x0, 0x8(%rbx)
je 0x922b8
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
cmpq $0x0, 0x8(%rax,%r14)
je 0x922a9
movq 0x18(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x92285
callq 0xb790
movq (%rbx), %rax
movq 0x38(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x92297
callq 0xb790
movq (%rbx), %rax
movq 0x20(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x922a9
callq 0xb790
incq %r15
movl 0x8(%rbx), %eax
addq $0x40, %r14
cmpq %rax, %r15
jb 0x9226b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x922c5
callq 0xb790
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x92308
cmpq $0x0, 0x8(%r14)
je 0x922ff
addq $0x18, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x922e6
callq 0xb790
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x922f4
callq 0xb790
cmpq $0x0, 0x30(%r14)
leaq 0x40(%r14), %r14
jne 0x922d9
movq 0x10(%rbx), %rdi
callq 0xb790
cmpq $0x0, 0x20(%rbx)
je 0x92348
cmpl $0x0, 0x34(%rbx)
je 0x9233f
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x92330
callq 0xb790
incq %r15
movl 0x34(%rbx), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x9231e
movq 0x20(%rbx), %rdi
callq 0xb790
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x92356
callq 0xb790
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x92364
callq 0xb790
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x92372
callq 0xb790
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb790
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_add_tag_left
static reg_errcode_t
tre_add_tag_left(tre_mem_t mem, tre_ast_node_t *node, int tag_id)
{
  tre_catenation_t *c;

  DPRINT(("add_tag_left: tag %d\n", tag_id));

  c = tre_mem_alloc(mem, sizeof(*c));
  if (c == NULL)
    return REG_ESPACE;
  c->left = tre_ast_new_literal(mem, TAG, tag_id, -1);
  if (c->left == NULL)
    return REG_ESPACE;
  c->right = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
  if (c->right == NULL)
    return REG_ESPACE;

  c->right->obj = node->obj;
  c->right->type = node->type;
  c->right->nullable = -1;
  c->right->submatch_id = -1;
  c->right->firstpos = NULL;
  c->right->lastpos = NULL;
  c->right->num_tags = 0;
  node->obj = c;
  node->type = CATENATION;
  return REG_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
movl $0x10, %r8d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x955ee
movl $0xc, %ebp
testq %rax, %rax
je 0x9248d
movq %rax, %r14
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl %r12d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb282e
movq %rax, (%r14)
testq %rax, %rax
je 0x9248d
movl $0x30, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x955ee
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x9248d
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movl (%rbx), %ecx
movl %ecx, (%rax)
movq $-0x1, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rax)
movl $0x0, 0x2c(%rax)
movq %r14, 0x8(%rbx)
movl $0x1, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_purge_regset
static void
tre_purge_regset(int *regset, tre_tnfa_t *tnfa, int tag)
{
  int i;

  for (i = 0; regset[i] >= 0; i++)
    {
      int id = regset[i] / 2;
      int start = !(regset[i] % 2);
      DPRINT(("  Using tag %d for %s offset of "
	      "submatch %d\n", tag,
	      start ? "start" : "end", id));
      if (start)
	tnfa->submatch_data[id].so_tag = tag;
      else
	tnfa->submatch_data[id].eo_tag = tag;
    }
  regset[0] = -1;
}

// Assembly:
movl (%rdi), %ecx
testl %ecx, %ecx
js 0x924d2
leaq 0x4(%rdi), %rax
movl %ecx, %r8d
shrl %r8d
testb $0x1, %cl
jne 0x924bb
movq 0x20(%rsi), %rcx
shlq $0x4, %r8
movl %edx, (%rcx,%r8)
jmp 0x924c8
movq 0x20(%rsi), %rcx
shlq $0x4, %r8
movl %edx, 0x4(%rcx,%r8)
movl (%rax), %ecx
addq $0x4, %rax
testl %ecx, %ecx
jns 0x924a2
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_set_empty
static tre_pos_and_tags_t *
tre_set_empty(tre_mem_t mem)
{
  tre_pos_and_tags_t *new_set;

  new_set = tre_mem_calloc(mem, sizeof(*new_set));
  if (new_set == NULL)
    return NULL;

  new_set[0].position = -1;
  new_set[0].code_min = -1;
  new_set[0].code_max = -1;

  return new_set;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
movl $0x40, %r8d
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x955ee
testq %rax, %rax
je 0x9287f
movq $-0x1, (%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-mem.c
// Function: tre_mem_destroy
void
tre_mem_destroy(tre_mem_t mem)
{
  tre_list_t *tmp, *l = mem->blocks;

  while (l != NULL)
    {
      xfree(l->data);
      tmp = l->next;
      xfree(l);
      l = tmp;
    }
  xfree(mem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x955e1
movq (%r14), %rdi
callq 0xb790
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0xb790
movq %r15, %r14
testq %r15, %r15
jne 0x955c5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb790
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_ctype
tre_ctype_t tre_ctype(const char *name)
{
  int i;
  for (i = 0; tre_ctype_map[i].name != NULL; i++)
    {
      if (strcmp(name, tre_ctype_map[i].name) == 0)
	return tre_ctype_map[i].func;
    }
  return (tre_ctype_t)0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xbc244(%rip), %r15     # 0x151a80
movq (%r15), %rsi
testq %rsi, %rsi
je 0x95879
movq %rdi, %rbx
callq 0xb890
testl %eax, %eax
je 0x95873
leaq 0xbc229(%rip), %r15     # 0x151a80
xorl %r14d, %r14d
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x9587c
movq %rbx, %rdi
callq 0xb890
addq $0x10, %r15
testl %eax, %eax
jne 0x9585a
movq 0x8(%r15), %r14
jmp 0x9587c
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_new_item
static reg_errcode_t
tre_new_item(tre_mem_t mem, int min, int max, int *i, int *max_i,
	 tre_ast_node_t ***items)
{
  reg_errcode_t status;
  tre_ast_node_t **array = *items;
  /* Allocate more space if necessary. */
  if (*i >= *max_i)
    {
      tre_ast_node_t **new_items;
      DPRINT(("out of array space, i = %d\n", *i));
      /* If the array is already 1024 items large, give up -- there's
	 probably an error in the regexp (e.g. not a '\0' terminated
	 string and missing ']') */
      if (*max_i > 1024)
	return REG_ESPACE;
      *max_i *= 2;
      new_items = xrealloc(array, sizeof(*items) * *max_i);
      if (new_items == NULL)
	return REG_ESPACE;
      *items = array = new_items;
    }
  array[*i] = tre_ast_new_literal(mem, min, max, -1);
  status = array[*i] == NULL ? REG_ESPACE : REG_OK;
  (*i)++;
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
movq (%r9), %r14
movslq (%r8), %rsi
cmpl %esi, (%rcx)
jl 0x97ab9
cmpl $0x400, %esi            # imm = 0x400
jg 0x97aae
movq %r9, %r13
leal (%rsi,%rsi), %eax
movl %eax, (%r8)
shlq $0x4, %rsi
movq %r14, %rdi
callq 0xba70
testq %rax, %rax
je 0x97aae
movq %rax, (%r13)
movb $0x1, %cl
movq %rax, %r14
jmp 0x97ab0
xorl %ecx, %ecx
movl $0xc, %eax
testb %cl, %cl
je 0x97ae3
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb282e
movslq (%rbx), %rcx
movq %rax, (%r14,%rcx,8)
xorl %edx, %edx
testq %rax, %rax
movl $0xc, %eax
cmovnel %edx, %eax
incl %ecx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-stack.c
// Function: tre_stack_new
tre_stack_t *
tre_stack_new(int size, int max_size, int increment)
{
  tre_stack_t *s;

  s = xmalloc(sizeof(*s));
  if (s != NULL)
    {
      s->stack = xmalloc(sizeof(*s->stack) * size);
      if (s->stack == NULL)
	{
	  xfree(s);
	  return NULL;
	}
      s->size = size;
      s->max_size = max_size;
      s->increment = increment;
      s->ptr = 0;
    }
  return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl $0x18, %edi
callq 0xb810
movq %rax, %rbx
testq %rax, %rax
je 0x97b47
movslq %r15d, %rdi
shlq $0x3, %rdi
callq 0xb810
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x97b3d
movl %r15d, (%rbx)
movl %r14d, 0x4(%rbx)
movl %ebp, 0x8(%rbx)
movl $0x0, 0xc(%rbx)
jmp 0x97b47
movq %rbx, %rdi
callq 0xb790
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/tre/lib/tre-stack.c
// Function: tre_stack_push
static reg_errcode_t
tre_stack_push(tre_stack_t *s, union tre_stack_item value)
{
  if (s->ptr < s->size)
    {
      s->stack[s->ptr] = value;
      s->ptr++;
    }
  else
    {
      if (s->size >= s->max_size)
	{
	  DPRINT(("tre_stack_push: stack full\n"));
	  return REG_ESPACE;
	}
      else
	{
	  union tre_stack_item *new_buffer;
	  int new_size;
	  DPRINT(("tre_stack_push: trying to realloc more space\n"));
	  new_size = s->size + s->increment;
	  if (new_size > s->max_size)
	    new_size = s->max_size;
	  new_buffer = xrealloc(s->stack, sizeof(*new_buffer) * new_size);
	  if (new_buffer == NULL)
	    {
	      DPRINT(("tre_stack_push: realloc failed.\n"));
	      return REG_ESPACE;
	    }
	  DPRINT(("tre_stack_push: realloc succeeded.\n"));
	  assert(new_size > s->size);
	  s->size = new_size;
	  s->stack = new_buffer;
	  tre_stack_push(s, value);
	}
    }
  return REG_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq 0xc(%rdi), %rax
movl (%rdi), %ebp
cmpl %ebp, %eax
jge 0x97b9b
movq 0x10(%r15), %rcx
movq %r14, (%rcx,%rax,8)
incl 0xc(%r15)
xorl %ebx, %ebx
jmp 0x97be5
movl 0x4(%r15), %eax
movl $0xc, %ebx
cmpl %eax, %ebp
jge 0x97be5
addl 0x8(%r15), %ebp
cmpl %eax, %ebp
cmovgel %eax, %ebp
movq 0x10(%r15), %rdi
movslq %ebp, %rsi
shlq $0x3, %rsi
callq 0xba70
testq %rax, %rax
je 0x97be5
cmpl (%r15), %ebp
jle 0x97bf0
movq %rax, %r12
movl %ebp, (%r15)
movq %rax, 0x10(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x97b73
testq %r12, %r12
jne 0x97b97
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5fa6d(%rip), %rdi     # 0xf7664
leaq 0x5fa79(%rip), %rsi     # 0xf7677
leaq 0x5fa93(%rip), %rcx     # 0xf7698
movl $0x62, %edx
callq 0xb400
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzCompressEnd
int BZ_API(BZ2_bzCompressEnd)  ( bz_stream *strm )
{
   EState* s;
   if (strm == NULL) return BZ_PARAM_ERROR;
   s = strm->state;
   if (s == NULL) return BZ_PARAM_ERROR;
   if (s->strm != strm) return BZ_PARAM_ERROR;

   if (s->arr1 != NULL) BZFREE(s->arr1);
   if (s->arr2 != NULL) BZFREE(s->arr2);
   if (s->ftab != NULL) BZFREE(s->ftab);
   BZFREE(strm->state);

   strm->state = NULL;   

   return BZ_OK;
}

// Assembly:
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x98399
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x98392
cmpq %rbx, (%r14)
jne 0x98392
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x9835d
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x9836d
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x9837d
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x30(%rbx), %rsi
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq $0x0, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzDecompressInit
int BZ_API(BZ2_bzDecompressInit) 
                     ( bz_stream* strm, 
                       int        verbosity,
                       int        small )
{
   DState* s;

   if (!bz_config_ok()) return BZ_CONFIG_ERROR;

   if (strm == NULL) return BZ_PARAM_ERROR;
   if (small != 0 && small != 1) return BZ_PARAM_ERROR;
   if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR;

   if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
   if (strm->bzfree == NULL) strm->bzfree = default_bzfree;

   s = BZALLOC( sizeof(DState) );
   if (s == NULL) return BZ_MEM_ERROR;
   s->strm                  = strm;
   strm->state              = s;
   s->state                 = BZ_X_MAGIC_1;
   s->bsLive                = 0;
   s->bsBuff                = 0;
   s->calculatedCombinedCRC = 0;
   strm->total_in_lo32      = 0;
   strm->total_in_hi32      = 0;
   strm->total_out_lo32     = 0;
   strm->total_out_hi32     = 0;
   s->smallDecompress       = (Bool)small;
   s->ll4                   = NULL;
   s->ll16                  = NULL;
   s->tt                    = NULL;
   s->currBlockNo           = 0;
   s->verbosity             = verbosity;

   return BZ_OK;
}

// Assembly:
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x4, %esi
ja 0x9844b
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x98447
movl %edx, %ebp
cmpl $0x1, %edx
ja 0x98447
movl %esi, %ebx
cmpq $0x0, 0x38(%r14)
jne 0x983d7
leaq -0x543(%rip), %rax      # 0x97e90
movq %rax, 0x38(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x983e9
leaq -0x54a(%rip), %rax      # 0x97e9b
movq %rax, 0x40(%r14)
movq 0x48(%r14), %rdi
movl $0xfa90, %esi           # imm = 0xFA90
movl $0x1, %edx
callq *0x38(%r14)
testq %rax, %rax
je 0x98442
movq %rax, %rcx
movq %r14, (%rax)
movq %rax, 0x30(%r14)
movl $0xa, 0x8(%rax)
xorl %eax, %eax
movq %rax, 0x20(%rcx)
movl %eax, 0xc74(%rcx)
movq %rax, 0xc(%r14)
movq %rax, 0x24(%r14)
movb %bpl, 0x2c(%rcx)
movl %eax, 0x30(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc50(%rcx)
movq %rax, 0xc60(%rcx)
movl %ebx, 0x34(%rcx)
jmp 0x98447
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_indexIntoF
__inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
{
   Int32 nb, na, mid;
   nb = 0;
   na = 256;
   do {
      mid = (nb + na) >> 1;
      if (indx >= cftab[mid]) nb = mid; else na = mid;
   }
   while (na - nb != 1);
   return nb;
}

// Assembly:
xorl %eax, %eax
movl $0x100, %ecx            # imm = 0x100
leal (%rax,%rcx), %edx
sarl %edx
movslq %edx, %r8
cmpl %edi, (%rsi,%r8,4)
jg 0x98465
movl %edx, %eax
jmp 0x98467
movl %edx, %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl $0x1, %edx
jne 0x98453
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzDecompressEnd
int BZ_API(BZ2_bzDecompressEnd)  ( bz_stream *strm )
{
   DState* s;
   if (strm == NULL) return BZ_PARAM_ERROR;
   s = strm->state;
   if (s == NULL) return BZ_PARAM_ERROR;
   if (s->strm != strm) return BZ_PARAM_ERROR;

   if (s->tt   != NULL) BZFREE(s->tt);
   if (s->ll16 != NULL) BZFREE(s->ll16);
   if (s->ll4  != NULL) BZFREE(s->ll4);

   BZFREE(strm->state);
   strm->state = NULL;

   return BZ_OK;
}

// Assembly:
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x993fa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x993f3
cmpq %rbx, (%r14)
jne 0x993f3
movq 0xc50(%r14), %rsi
testq %rsi, %rsi
je 0x993b8
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0xc58(%r14), %rsi
testq %rsi, %rsi
je 0x993cb
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0xc60(%r14), %rsi
testq %rsi, %rsi
je 0x993de
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x30(%rbx), %rsi
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq $0x0, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzWriteOpen
BZFILE* BZ_API(BZ2_bzWriteOpen) 
                    ( int*  bzerror,      
                      FILE* f, 
                      int   blockSize100k, 
                      int   verbosity,
                      int   workFactor )
{
   Int32   ret;
   bzFile* bzf = NULL;

   BZ_SETERR(BZ_OK);

   if (f == NULL ||
       (blockSize100k < 1 || blockSize100k > 9) ||
       (workFactor < 0 || workFactor > 250) ||
       (verbosity < 0 || verbosity > 4))
      { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };

   if (ferror(f))
      { BZ_SETERR(BZ_IO_ERROR); return NULL; };

   bzf = malloc ( sizeof(bzFile) );
   if (bzf == NULL)
      { BZ_SETERR(BZ_MEM_ERROR); return NULL; };

   BZ_SETERR(BZ_OK);
   bzf->initialisedOk = False;
   bzf->bufN          = 0;
   bzf->handle        = f;
   bzf->writing       = True;
   bzf->strm.bzalloc  = NULL;
   bzf->strm.bzfree   = NULL;
   bzf->strm.opaque   = NULL;

   if (workFactor == 0) workFactor = 30;
   ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k, 
                              verbosity, workFactor );
   if (ret != BZ_OK)
      { BZ_SETERR(ret); free(bzf); return NULL; };

   bzf->strm.avail_in = 0;
   bzf->initialisedOk = True;
   return bzf;   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
testq %rdi, %rdi
je 0x9941f
movl $0x0, (%rbx)
cmpl $0x4, %ebp
ja 0x99454
testq %r13, %r13
je 0x99454
leal -0xa(%r15), %eax
cmpl $-0x9, %eax
jb 0x99454
cmpl $0xfb, %r12d
jae 0x99454
movq %r13, %rdi
callq 0xbc30
testl %eax, %eax
je 0x99474
testq %rbx, %rbx
je 0x9945f
movl $0xfffffffa, (%rbx)     # imm = 0xFFFFFFFA
jmp 0x9945f
testq %rbx, %rbx
je 0x9945f
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x13f0, %edi           # imm = 0x13F0
callq 0xb810
testq %rax, %rax
je 0x9950d
movq %rax, %r14
testq %rbx, %rbx
je 0x99495
movl $0x0, (%rbx)
xorl %eax, %eax
movl %eax, 0x13e8(%r14)
movb $0x0, 0x13ec(%r14)
movl %eax, 0x1390(%r14)
movq %r13, (%r14)
movq %r14, %rdi
addq $0x1398, %rdi           # imm = 0x1398
testl %r12d, %r12d
movl $0x1e, %ecx
cmovnel %r12d, %ecx
movb $0x1, 0x1394(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x13d0(%r14)
movq $0x0, 0x13e0(%r14)
movl %r15d, %esi
movl %ebp, %edx
callq 0x97c9a
testl %eax, %eax
je 0x99521
testq %rbx, %rbx
je 0x994f9
movl %eax, (%rbx)
movl %eax, 0x13e8(%r14)
movq %r14, %rdi
callq 0xb790
jmp 0x9945f
testq %rbx, %rbx
je 0x9945f
movl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
jmp 0x9945f
movl $0x0, 0x13a0(%r14)
movb $0x1, 0x13ec(%r14)
jmp 0x99462
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzWrite
void BZ_API(BZ2_bzWrite)
             ( int*    bzerror, 
               BZFILE* b, 
               void*   buf, 
               int     len )
{
   Int32 n, n2, ret;
   bzFile* bzf = (bzFile*)b;

   BZ_SETERR(BZ_OK);
   if (bzf == NULL || buf == NULL || len < 0)
      { BZ_SETERR(BZ_PARAM_ERROR); return; };
   if (!(bzf->writing))
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   if (ferror(bzf->handle))
      { BZ_SETERR(BZ_IO_ERROR); return; };

   if (len == 0)
      { BZ_SETERR(BZ_OK); return; };

   bzf->strm.avail_in = len;
   bzf->strm.next_in  = buf;

   while (True) {
      bzf->strm.avail_out = BZ_MAX_UNUSED;
      bzf->strm.next_out = bzf->buf;
      ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN );
      if (ret != BZ_RUN_OK)
         { BZ_SETERR(ret); return; };

      if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
         n = BZ_MAX_UNUSED - bzf->strm.avail_out;
         n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), 
                       n, bzf->handle );
         if (n != n2 || ferror(bzf->handle))
            { BZ_SETERR(BZ_IO_ERROR); return; };
      }

      if (bzf->strm.avail_in == 0)
         { BZ_SETERR(BZ_OK); return; };
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x9955b
movl $0x0, (%r14)
testq %rbx, %rbx
je 0x9956a
movl $0x0, 0x13e8(%rbx)
testq %rbx, %rbx
je 0x99597
testq %r12, %r12
je 0x99597
testl %ebp, %ebp
js 0x99597
cmpb $0x0, 0x1394(%rbx)
je 0x995b6
movq (%rbx), %rdi
callq 0xbc30
testl %eax, %eax
je 0x995c0
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x9964e
testq %r14, %r14
je 0x995a3
movl $0xfffffffe, (%r14)     # imm = 0xFFFFFFFE
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testq %rbx, %rbx
jne 0x99656
jmp 0x9965c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x9964e
testl %ebp, %ebp
je 0x9964c
leaq 0x1398(%rbx), %r15
movl %ebp, 0x13a0(%rbx)
movq %r12, 0x1398(%rbx)
leaq 0x8(%rbx), %r12
movl $0x1388, 0x13b8(%rbx)   # imm = 0x1388
movq %r12, 0x13b0(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x97ea9
cmpl $0x1, %eax
jne 0x9964e
movl 0x13b8(%rbx), %eax
cmpq $0x1387, %rax           # imm = 0x1387
ja 0x99643
movl $0x1388, %r13d          # imm = 0x1388
subq %rax, %r13
movq (%rbx), %rcx
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0xbcb0
cmpl %eax, %r13d
jne 0x9958d
movq (%rbx), %rdi
callq 0xbc30
testl %eax, %eax
jne 0x9958d
cmpl $0x0, 0x13a0(%rbx)
jne 0x995e0
xorl %eax, %eax
testq %r14, %r14
je 0x99656
movl %eax, (%r14)
movl %eax, 0x13e8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzReadClose
void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
{
   bzFile* bzf = (bzFile*)b;

   BZ_SETERR(BZ_OK);
   if (bzf == NULL)
      { BZ_SETERR(BZ_OK); return; };

   if (bzf->writing)
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };

   if (bzf->initialisedOk)
      (void)BZ2_bzDecompressEnd ( &(bzf->strm) );
   free ( bzf );
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x99a5c
movl $0x0, (%rdi)
testq %rbx, %rbx
je 0x99a8b
movl $0x0, 0x13e8(%rbx)
cmpb $0x0, 0x1394(%rbx)
je 0x99a98
testq %rdi, %rdi
je 0x99a7f
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x13e8(%rbx) # imm = 0xFFFFFFFF
jmp 0x99a96
testq %rdi, %rdi
je 0x99a96
movl $0x0, (%rdi)
popq %rbx
retq
cmpb $0x0, 0x13ec(%rbx)
je 0x99aad
leaq 0x1398(%rbx), %rdi
callq 0x99386
movq %rbx, %rdi
popq %rbx
jmp 0xb790
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzReadGetUnused
void BZ_API(BZ2_bzReadGetUnused) 
                     ( int*    bzerror, 
                       BZFILE* b, 
                       void**  unused, 
                       int*    nUnused )
{
   bzFile* bzf = (bzFile*)b;
   if (bzf == NULL)
      { BZ_SETERR(BZ_PARAM_ERROR); return; };
   if (bzf->lastErr != BZ_STREAM_END)
      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
   if (unused == NULL || nUnused == NULL)
      { BZ_SETERR(BZ_PARAM_ERROR); return; };

   BZ_SETERR(BZ_OK);
   *nUnused = bzf->strm.avail_in;
   *unused = bzf->strm.next_in;
}

// Assembly:
testq %rsi, %rsi
je 0x99d0f
cmpl $0x4, 0x13e8(%rsi)
jne 0x99d1b
testq %rdx, %rdx
setne %al
testq %rcx, %rcx
setne %r8b
testb %r8b, %al
jne 0x99d31
testq %rdi, %rdi
je 0x99d04
movl $0xfffffffe, (%rdi)     # imm = 0xFFFFFFFE
movl $0xfffffffe, 0x13e8(%rsi) # imm = 0xFFFFFFFE
retq
testq %rdi, %rdi
je 0x99d58
movl $0xfffffffe, (%rdi)     # imm = 0xFFFFFFFE
retq
testq %rdi, %rdi
je 0x99d26
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x13e8(%rsi) # imm = 0xFFFFFFFF
retq
testq %rdi, %rdi
je 0x99d3c
movl $0x0, (%rdi)
movl $0x0, 0x13e8(%rsi)
movl 0x13a0(%rsi), %eax
movl %eax, (%rcx)
movq 0x1398(%rsi), %rax
movq %rax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzBuffToBuffCompress
int BZ_API(BZ2_bzBuffToBuffCompress) 
                         ( char*         dest, 
                           unsigned int* destLen,
                           char*         source, 
                           unsigned int  sourceLen,
                           int           blockSize100k, 
                           int           verbosity, 
                           int           workFactor )
{
   bz_stream strm;
   int ret;

   if (dest == NULL || destLen == NULL || 
       source == NULL ||
       blockSize100k < 1 || blockSize100k > 9 ||
       verbosity < 0 || verbosity > 4 ||
       workFactor < 0 || workFactor > 250) 
      return BZ_PARAM_ERROR;

   if (workFactor == 0) workFactor = 30;
   strm.bzalloc = NULL;
   strm.bzfree = NULL;
   strm.opaque = NULL;
   ret = BZ2_bzCompressInit ( &strm, blockSize100k, 
                              verbosity, workFactor );
   if (ret != BZ_OK) return ret;

   strm.next_in = source;
   strm.next_out = dest;
   strm.avail_in = sourceLen;
   strm.avail_out = *destLen;

   ret = BZ2_bzCompress ( &strm, BZ_FINISH );
   if (ret == BZ_FINISH_OK) goto output_overflow;
   if (ret != BZ_STREAM_END) goto errhandler;

   /* normal termination */
   *destLen -= strm.avail_out;   
   BZ2_bzCompressEnd ( &strm );
   return BZ_OK;

   output_overflow:
   BZ2_bzCompressEnd ( &strm );
   return BZ_OUTBUFF_FULL;

   errhandler:
   BZ2_bzCompressEnd ( &strm );
   return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl 0x80(%rsp), %eax
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
cmpl $0xfa, %eax
ja 0x99e1f
cmpl $0x4, %r9d
ja 0x99e1f
movq %rdi, %r12
testq %rdi, %rdi
je 0x99e1f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x99e1f
movq %rdx, %r15
testq %rdx, %rdx
je 0x99e1f
movl %ecx, %r14d
leal -0xa(%r8), %ecx
cmpl $-0x9, %ecx
jb 0x99e1f
testl %eax, %eax
movl $0x1e, %ecx
cmovnel %eax, %ecx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
movl %r8d, %esi
movl %r9d, %edx
callq 0x97c9a
movl %eax, %ebp
testl %eax, %eax
jne 0x99e1f
movq %rsp, %rdi
movq %r15, (%rdi)
movq %r12, 0x18(%rdi)
movl %r14d, 0x8(%rdi)
movl (%rbx), %eax
movl %eax, 0x20(%rdi)
movl $0x2, %esi
callq 0x97ea9
cmpl $0x3, %eax
je 0x99e12
movl %eax, %ebp
cmpl $0x4, %eax
jne 0x99e17
movl 0x20(%rsp), %eax
subl %eax, (%rbx)
xorl %ebp, %ebp
jmp 0x99e17
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %rsp, %rdi
callq 0x9832e
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq