LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/drawing_range.c
// Function: gt_drawing_range_compare
int gt_drawing_range_compare(GtDrawingRange range_a, GtDrawingRange range_b)
{
  gt_assert(range_a.start <= range_a.end && range_b.start <= range_b.end);

  if (gt_double_equals_double(range_a.start, range_b.start) &&
      gt_double_equals_double(range_a.end, range_b.end))
    return 0; /* range_a == range_b */

  if (gt_double_smaller_double(range_a.start, range_b.start) ||
      (gt_double_equals_double(range_a.start, range_b.start)
       && gt_double_smaller_double(range_a.end, range_b.end)))
    return -1; /* range_a < range_b */

  return 1; /* range_a > range_b */
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jb 0x8e021
leaq 0x48(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm2
movsd %xmm2, (%rsp)
ucomisd %xmm1, %xmm2
jb 0x8e021
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x7a34f
testb %al, %al
je 0x8dfd1
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x7a34f
xorl %ebx, %ebx
testb %al, %al
jne 0x8e019
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x7a42f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testb %al, %al
jne 0x8e019
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x7a34f
testb %al, %al
je 0x8e014
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x7a42f
testb %al, %al
jne 0x8e019
movl $0x1, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x2183b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_new
GtElement* gt_element_new(GtFeatureNode *node)
{
  GtElement *element;
  gt_assert(node);
  element = gt_element_new_empty();
  gt_element_set_type(element, gt_feature_node_get_type(node));
  gt_element_set_range(element, gt_genome_node_get_range((GtGenomeNode*) node));
  element->strand = gt_feature_node_get_strand(node);
  element->mark = gt_feature_node_is_marked(node);
  element->gn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) node);
  return element;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8e103
movq %rdi, %rbx
leaq 0x687ca(%rip), %rdx     # 0xf6861
movl $0x1, %edi
movl $0x50, %esi
movl $0x3c, %ecx
callq 0x359a6
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f914
movq %r14, %rdi
movq %rax, %rsi
callq 0x8e123
movq %rbx, %rdi
callq 0x415e5
movq %r14, %rdi
movq %rax, %rsi
callq 0x8e132
movq %rbx, %rdi
callq 0x3f462
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x40ad2
movb %al, 0x48(%r14)
movq %rbx, %rdi
callq 0x4130c
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x21872
// File: /workspace/github_c_makefile_star2_O3/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 0x8e56c
testq %rsi, %rsi
je 0x8e56c
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x8e564
addq $0x20, %rdi
addq $0x20, %rsi
callq 0x7e09c
testl %eax, %eax
je 0x8e568
xorl %eax, %eax
popq %rcx
retq
movb $0x1, %al
jmp 0x8e566
callq 0x21acf
// File: /workspace/github_c_makefile_star2_O3/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 0x8e58a
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x8e58c
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x4210c
leaq 0x682c5(%rip), %rsi     # 0xf6861
movq %rbx, %rdi
movl $0xb4, %edx
popq %rbx
jmp 0x35c27
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x6849a(%rip), %rdx     # 0xf6a4e
movl $0x1, %edi
movl $0x10, %esi
movl $0x26, %ecx
callq 0x359a6
movq %rax, %rbx
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x8(%rbx)
movb $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8e626
testq %rsi, %rsi
je 0x8e626
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x8e60d
movq %rsi, %rdi
callq 0x8a747
testq %rax, %rax
je 0x8e60d
movb $0x1, (%rbx)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6f240
addq $0x10, %rsp
popq %rbx
retq
callq 0x21b06
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8e6ca
movq %rsi, %r15
testq %rsi, %rsi
je 0x8e6ca
movq %rdx, %rbx
movq %rdi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4bf43
testl %eax, %eax
jne 0x8e6a5
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
callq 0x6f310
cmpq %r12, %rax
jbe 0x8e6b1
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x8ad99
incq %r12
testl %eax, %eax
je 0x8e676
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4bf64
callq 0x21bab
// File: /workspace/github_c_makefile_star2_O3/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 0x8e7ca
movq %rdx, %r15
testq %rdx, %rdx
je 0x8e7ca
movq %rcx, %r14
movq %rdi, %r12
movq %rsi, 0x10(%rsp)
movq 0x8(%rdi), %rdi
callq 0x6f310
xorps %xmm0, %xmm0
testq %rax, %rax
je 0x8e79f
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 0x6f037
movq (%rax), %rbx
cmpb $0x0, (%r12)
jne 0x8e757
movq %rbx, %rdi
callq 0x8a747
testq %rax, %rax
je 0x8e757
movb $0x1, (%r12)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x8abf5
testl %eax, %eax
js 0x8e7b6
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
callq 0x7a42f
testb %al, %al
je 0x8e78b
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
incq %r13
movq 0x8(%r12), %rdi
callq 0x6f310
cmpq %rax, %r13
jb 0x8e71f
jmp 0x8e7a4
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
xorl %eax, %eax
jmp 0x8e7bb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x21be2
// File: /workspace/github_c_makefile_star2_O3/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 0x8f0a2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6f310
testq %rax, %rax
je 0x8f07e
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x8b7c2
incq %r14
movq 0x8(%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x8f059
movq 0x8(%rbx), %rdi
callq 0x6f768
leaq 0x679c0(%rip), %rsi     # 0xf6a4e
movq %rbx, %rdi
movl $0xd6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x8f135
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x8f135
leaq 0x67b2d(%rip), %r14     # 0xf6c26
movl $0x1, %edi
movq %r14, %rdx
movl $0x34, %ecx
callq 0x359a6
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x359a6
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x21c50
// File: /workspace/github_c_makefile_star2_O3/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 0x8f169
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
testl %eax, %eax
je 0x8f171
decl %eax
movl %eax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x8f1b6
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x8f18b
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x67a94(%rip), %r14     # 0xf6c26
movq %r14, %rsi
movl $0x4b, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4c, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0x21cbe
// File: /workspace/github_c_makefile_star2_O3/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 0x8f2c2
movq %rdi, %r13
testq %rdi, %rdi
je 0x8f2c2
testq %rcx, %rcx
je 0x8f2c2
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
callq 0x8a733
movq %rax, %r15
movq %rdx, %r12
callq 0x8f2c7
movq %rax, %rdi
movq %r13, %rsi
callq 0x8f232
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x775ed
testq %rax, %rax
je 0x8f2b2
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7934a
testq %rax, %rax
setne %al
jmp 0x8f2b4
xorl %eax, %eax
movb %al, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x21d9a
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0xc397b(%rip)     # 0x152c50
jne 0x8f2fd
leaq -0x92(%rip), %rsi       # 0x8f24c
leaq 0x26(%rip), %rdx        # 0x8f30b
leaq 0xbb(%rip), %rcx        # 0x8f3a7
movl $0x18, %edi
callq 0x8f0a4
movq %rax, 0xc3953(%rip)     # 0x152c50
callq 0x7237d
movq 0xc3947(%rip), %rax     # 0x152c50
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8f3a2
movq %rdi, %r14
testq %rdi, %rdi
je 0x8f3a2
movq %rdx, %r15
testq %rdx, %rdx
je 0x8f3a2
movq %rsi, %rbx
callq 0x8f2c7
movq %rax, %rdi
movq %r14, %rsi
callq 0x8f232
movq %rax, %r14
movq %r15, %rdi
callq 0x8aad1
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rax, %rdi
callq 0x79288
movq %rax, %r15
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x775ed
movq %rax, %r12
testq %rax, %rax
jne 0x8f389
xorl %edi, %edi
callq 0x792c3
movq %rax, %r12
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x77628
movq %r12, %rdi
movq %r15, %rsi
callq 0x794f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x21dd1
// File: /workspace/github_c_makefile_star2_O3/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 0x8f2c7
movq %rax, %rdi
callq 0x8f0dd
movq %rax, %rbx
callq 0x8f2c7
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8f232
movq %rax, %r14
leaq -0x15d63(%rip), %rdx    # 0x79696
xorl %edi, %edi
xorl %esi, %esi
callq 0x7740c
movq %rax, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x8f47d
movl %edi, %eax
leaq 0x67948(%rip), %rcx     # 0xf6dbc
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
jmp 0x8f484
leaq 0x67970(%rip), %r15     # 0xf6df4
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
incq %r12
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x8f4c9
cmpq %r14, %r12
jbe 0x8f4be
leaq -0x1(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2d0
movb $0x0, -0x1(%rbx,%r14)
jmp 0x8f4c9
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_O3/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 0x91ae1
cmpl $0x2, %eax
je 0x91ac9
cmpl $0x3, %eax
jne 0x91b53
movq 0x8(%rdi), %r12
jmp 0x91b08
movq 0x8(%rdi), %r12
movl 0xc(%r12), %eax
cmpl $-0x1, %eax
je 0x91b24
cmpl $0x1, %eax
je 0x91b4a
jmp 0x91b61
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 0x92811
testl %eax, %eax
jne 0x91b55
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x91a9d
testl %eax, %eax
jne 0x91b55
addq $0x8, %r12
jmp 0x91b4a
cmpl $0x2, 0x8(%r12)
jae 0x91b80
movq (%r12), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x92811
testl %eax, %eax
jne 0x91b55
movq (%r12), %rdi
jmp 0x91aae
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x65784(%rip), %rdi     # 0xf72ec
leaq 0x65514(%rip), %rsi     # 0xf7083
leaq 0x65798(%rip), %rcx     # 0xf730e
movl $0x721, %edx            # imm = 0x721
callq 0xb400
leaq 0x657de(%rip), %rdi     # 0xf7365
leaq 0x654f5(%rip), %rsi     # 0xf7083
leaq 0x65779(%rip), %rcx     # 0xf730e
movl $0x725, %edx            # imm = 0x725
callq 0xb400
// File: /workspace/github_c_makefile_star2_O3/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 0x91cd9
cmpl $0x0, 0x8(%rbx)
je 0x91c0a
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
cmpq $0x0, 0x8(%rax,%r14)
je 0x91bfb
movq 0x18(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x91bda
callq 0xb790
movq (%rbx), %rax
movq 0x38(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x91bec
callq 0xb790
movq (%rbx), %rax
movq 0x20(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x91bfb
callq 0xb790
incq %r15
movl 0x8(%rbx), %eax
addq $0x40, %r14
cmpq %rax, %r15
jb 0x91bbd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x91c17
callq 0xb790
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x91c5d
cmpq $0x0, 0x8(%r14)
je 0x91c55
addq $0x18, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x91c38
callq 0xb790
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x91c46
callq 0xb790
cmpq $0x0, 0x30(%r14)
leaq 0x40(%r14), %r14
jne 0x91c2b
movq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0xb790
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x91ca2
movl 0x34(%rbx), %eax
testl %eax, %eax
je 0x91c9d
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rcx
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0x91c8b
callq 0xb790
movl 0x34(%rbx), %eax
incq %r15
movl %eax, %ecx
addq $0x10, %r14
cmpq %rcx, %r15
jb 0x91c76
movq 0x20(%rbx), %rdi
callq 0xb790
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x91cb0
callq 0xb790
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x91cbe
callq 0xb790
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x91ccc
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_O3/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 0x95072
movl $0xc, %ebp
testq %rax, %rax
je 0x91de7
movq %rax, %r14
movq %r15, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl %r12d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb1cf6
movq %rax, (%r14)
testq %rax, %rax
je 0x91de7
movl $0x30, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x95072
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x91de7
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_O3/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 0x95065
movq (%r14), %rdi
callq 0xb790
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0xb790
movq %r15, %r14
testq %r15, %r15
jne 0x95049
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb790
// File: /workspace/github_c_makefile_star2_O3/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 0xbc7c4(%rip), %r15     # 0x151a80
movq (%r15), %rsi
testq %rsi, %rsi
je 0x952f9
movq %rdi, %rbx
callq 0xb890
testl %eax, %eax
je 0x952f3
leaq 0xbc7a9(%rip), %r15     # 0x151a80
xorl %r14d, %r14d
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x952fc
movq %rbx, %rdi
callq 0xb890
addq $0x10, %r15
testl %eax, %eax
jne 0x952da
movq 0x8(%r15), %r14
jmp 0x952fc
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %esi, %r15d
movq %rdi, %r12
movq (%r9), %r14
movslq (%r8), %rsi
cmpl %esi, (%rcx)
jl 0x96ff1
movl $0xc, %ebp
cmpl $0x400, %esi            # imm = 0x400
jg 0x9701a
movq %r9, %r13
movl %edx, 0x4(%rsp)
leal (%rsi,%rsi), %eax
movl %eax, (%r8)
shlq $0x4, %rsi
movq %r14, %rdi
callq 0xba70
testq %rax, %rax
je 0x9701a
movq %rax, %r14
movq %rax, (%r13)
movl 0x4(%rsp), %edx
movq %r12, %rdi
movl %r15d, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb1cf6
movslq (%rbx), %rcx
movq %rax, (%r14,%rcx,8)
xorl %edx, %edx
testq %rax, %rax
movl $0xc, %ebp
cmovnel %edx, %ebp
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
testq %rax, %rax
je 0x9707d
movq %rax, %rbx
movslq %r15d, %rdi
shlq $0x3, %rdi
callq 0xb810
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x97075
movl %r15d, (%rbx)
movl %r14d, 0x4(%rbx)
movl %ebp, 0x8(%rbx)
movl $0x0, 0xc(%rbx)
jmp 0x9707f
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_O3/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %r15d
movl 0xc(%rdi), %ecx
cmpl %r15d, %ecx
jge 0x970e0
movq 0x10(%rbx), %rax
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
incl 0xc(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rbx), %eax
movl $0xc, %ebp
cmpl %eax, %r15d
jge 0x970d3
addl 0x8(%rbx), %r15d
cmpl %eax, %r15d
cmovgel %eax, %r15d
movq 0x10(%rbx), %rdi
movslq %r15d, %rsi
shlq $0x3, %rsi
callq 0xba70
testq %rax, %rax
je 0x970d3
cmpl (%rbx), %r15d
jle 0x97128
movl %r15d, (%rbx)
movq %rax, 0x10(%rbx)
movl 0xc(%rbx), %ecx
cmpl %r15d, %ecx
jl 0x970c7
movl 0x4(%rbx), %eax
xorl %ebp, %ebp
jmp 0x970e8
leaq 0x604b5(%rip), %rdi     # 0xf75e4
leaq 0x604c1(%rip), %rsi     # 0xf75f7
leaq 0x604db(%rip), %rcx     # 0xf7618
movl $0x62, %edx
callq 0xb400
// File: /workspace/github_c_makefile_star2_O3/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 0x97905
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x978fe
cmpq %rbx, (%r14)
jne 0x978fe
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x978c9
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x978d9
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x978e9
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_O3/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 0x979b7
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x979b3
movl %edx, %ebp
cmpl $0x1, %edx
ja 0x979b3
movl %esi, %ebx
movq 0x38(%r14), %rax
testq %rax, %rax
jne 0x97945
leaq -0x584(%rip), %rax      # 0x973bd
movq %rax, 0x38(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x97957
leaq -0x58b(%rip), %rcx      # 0x973c8
movq %rcx, 0x40(%r14)
movq 0x48(%r14), %rdi
movl $0xfa90, %esi           # imm = 0xFA90
movl $0x1, %edx
callq *%rax
testq %rax, %rax
je 0x979ae
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 0x979b3
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x979d1
movl %edx, %eax
jmp 0x979d3
movl %edx, %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl $0x1, %edx
jne 0x979bf
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9895a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x98953
cmpq %rbx, (%r14)
jne 0x98953
movq 0xc50(%r14), %rsi
testq %rsi, %rsi
je 0x98918
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0xc58(%r14), %rsi
testq %rsi, %rsi
je 0x9892b
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0xc60(%r14), %rsi
testq %rsi, %rsi
je 0x9893e
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_O3/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 0x9897f
movl $0x0, (%rbx)
cmpl $0x4, %ebp
ja 0x989b4
testq %r13, %r13
je 0x989b4
leal -0xa(%r15), %eax
cmpl $-0x9, %eax
jb 0x989b4
cmpl $0xfb, %r12d
jae 0x989b4
movq %r13, %rdi
callq 0xbc30
testl %eax, %eax
je 0x989d4
testq %rbx, %rbx
je 0x989bf
movl $0xfffffffa, (%rbx)     # imm = 0xFFFFFFFA
jmp 0x989bf
testq %rbx, %rbx
je 0x989bf
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 0x98a62
movq %rax, %r14
testq %rbx, %rbx
je 0x989f1
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 0x971d2
testl %eax, %eax
je 0x98a76
testq %rbx, %rbx
je 0x98a55
movl %eax, (%rbx)
movq %r14, %rdi
callq 0xb790
jmp 0x989bf
testq %rbx, %rbx
je 0x989bf
movl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
jmp 0x989bf
movl $0x0, 0x13a0(%r14)
movb $0x1, 0x13ec(%r14)
jmp 0x989c2
// File: /workspace/github_c_makefile_star2_O3/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 0x98ab0
movl $0x0, (%r14)
testq %rbx, %rbx
je 0x98ace
movl $0x0, 0x13e8(%rbx)
testq %r12, %r12
setne %al
testl %ebp, %ebp
setns %cl
testb %cl, %al
jne 0x98af2
testq %r14, %r14
je 0x98ada
movl $0xfffffffe, (%r14)     # imm = 0xFFFFFFFE
testq %rbx, %rbx
je 0x98bef
movl $0xfffffffe, 0x13e8(%rbx) # imm = 0xFFFFFFFE
jmp 0x98bef
cmpb $0x0, 0x1394(%rbx)
je 0x98b22
movq (%rbx), %rdi
callq 0xbc30
testl %eax, %eax
je 0x98b3d
testq %r14, %r14
je 0x98b13
movl $0xfffffffa, (%r14)     # imm = 0xFFFFFFFA
movl $0xfffffffa, 0x13e8(%rbx) # imm = 0xFFFFFFFA
jmp 0x98bef
testq %r14, %r14
je 0x98b2e
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x13e8(%rbx) # imm = 0xFFFFFFFF
jmp 0x98bef
testl %ebp, %ebp
je 0x98bc9
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 0x973d6
cmpl $0x1, %eax
jne 0x98be1
movl 0x13b8(%rbx), %eax
cmpq $0x1387, %rax           # imm = 0x1387
ja 0x98bc0
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 0x98b07
movq (%rbx), %rdi
callq 0xbc30
testl %eax, %eax
jne 0x98b07
cmpl $0x0, 0x13a0(%rbx)
jne 0x98b5d
testq %r14, %r14
je 0x98bd5
movl $0x0, (%r14)
movl $0x0, 0x13e8(%rbx)
jmp 0x98bef
testq %r14, %r14
je 0x98be9
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_O3/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 0x99016
movl $0x0, (%rdi)
testq %rbx, %rbx
je 0x99038
movl $0x0, 0x13e8(%rbx)
cmpb $0x0, 0x1394(%rbx)
je 0x9903a
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
jmp 0x9902e
testq %rbx, %rbx
je 0x99038
movl $0x0, 0x13e8(%rbx)
cmpb $0x0, 0x1394(%rbx)
je 0x9903a
movl $0xffffffff, 0x13e8(%rbx) # imm = 0xFFFFFFFF
popq %rbx
retq
cmpb $0x0, 0x13ec(%rbx)
je 0x9904f
leaq 0x1398(%rbx), %rdi
callq 0x988e6
movq %rbx, %rdi
popq %rbx
jmp 0xb790
// File: /workspace/github_c_makefile_star2_O3/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 0x992b5
cmpl $0x4, 0x13e8(%rsi)
jne 0x992c1
testq %rdx, %rdx
setne %al
testq %rcx, %rcx
setne %r8b
testb %r8b, %al
jne 0x992d7
testq %rdi, %rdi
je 0x992aa
movl $0xfffffffe, (%rdi)     # imm = 0xFFFFFFFE
movl $0xfffffffe, 0x13e8(%rsi) # imm = 0xFFFFFFFE
retq
testq %rdi, %rdi
je 0x992fe
movl $0xfffffffe, (%rdi)     # imm = 0xFFFFFFFE
retq
testq %rdi, %rdi
je 0x992cc
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x13e8(%rsi) # imm = 0xFFFFFFFF
retq
testq %rdi, %rdi
je 0x992e2
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_O3/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 0x993c5
cmpl $0x4, %r9d
ja 0x993c5
movq %rdi, %r12
testq %rdi, %rdi
je 0x993c5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x993c5
movq %rdx, %r15
testq %rdx, %rdx
je 0x993c5
movl %ecx, %r14d
leal -0xa(%r8), %ecx
cmpl $-0x9, %ecx
jb 0x993c5
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 0x971d2
movl %eax, %ebp
testl %eax, %eax
jne 0x993c5
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 0x973d6
cmpl $0x3, %eax
je 0x993b8
movl %eax, %ebp
cmpl $0x4, %eax
jne 0x993bd
movl 0x20(%rsp), %eax
subl %eax, (%rbx)
xorl %ebp, %ebp
jmp 0x993bd
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %rsp, %rdi
callq 0x9789a
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq