LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_add_tag_right
static reg_errcode_t
tre_add_tag_right(tre_mem_t mem, tre_ast_node_t *node, int tag_id)
{
  tre_catenation_t *c;

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

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

  c->left->obj = node->obj;
  c->left->type = node->type;
  c->left->nullable = -1;
  c->left->submatch_id = -1;
  c->left->firstpos = NULL;
  c->left->lastpos = NULL;
  c->left->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
pushq $0x10
popq %r8
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x75ecf
pushq $0xc
popq %rbp
testq %rax, %rax
je 0x7303f
movq %rax, %r14
pushq $-0x3
popq %rsi
pushq $-0x1
popq %rcx
movq %r15, %rdi
movl %r12d, %edx
callq 0x95a69
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x7303f
pushq $0x30
popq %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x75ecf
movq %rax, (%r14)
testq %rax, %rax
je 0x7303f
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movl (%rbx), %ecx
movl %ecx, (%rax)
orq $-0x1, 0x10(%rax)
xorps %xmm0, %xmm0
andl $0x0, 0x2c(%rax)
movups %xmm0, 0x1c(%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_O2/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_set_one
static tre_pos_and_tags_t *
tre_set_one(tre_mem_t mem, int position, int code_min, int code_max,
	    tre_ctype_t class, tre_ctype_t *neg_classes, int backref)
{
  tre_pos_and_tags_t *new_set;

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

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

  return new_set;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
pushq $0x1
popq %rcx
movl $0x80, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x75ecf
testq %rax, %rax
je 0x7337d
movl 0x30(%rsp), %ecx
movl %r12d, (%rax)
movl %r15d, 0x4(%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl %ecx, 0x30(%rax)
orq $-0x1, 0x40(%rax)
orl $-0x1, 0x48(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x1
popq %rcx
pushq $0x40
popq %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0x75ecf
testq %rax, %rax
je 0x733a4
orq $-0x1, (%rax)
orl $-0x1, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x75ec2
movq (%r14), %rdi
callq 0xb790
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0xb790
movq %r15, %r14
jmp 0x75ea4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb790
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_parse_int
static int
tre_parse_int(const tre_char_t **regex, const tre_char_t *regex_end)
{
  int num = -1;
  const tre_char_t *r = *regex;
  while (r < regex_end && *r >= L'0' && *r <= L'9')
    {
      if (num < 0)
	num = 0;
      num = num * 10 + *r - L'0';
      r++;
    }
  *regex = r;
  return num;
}

// Assembly:
movq (%rdi), %rcx
pushq $-0x1
popq %rax
xorl %edx, %edx
cmpq %rsi, %rcx
jae 0x779e3
movzbl (%rcx), %r8d
leal -0x30(%r8), %r9d
cmpb $0x9, %r9b
ja 0x779e3
testl %eax, %eax
cmovlel %edx, %eax
imull $0xa, %eax, %eax
addl %r8d, %eax
addl $-0x30, %eax
incq %rcx
jmp 0x779bd
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x77a57
pushq $0xc
popq %rbp
cmpl $0x400, %esi            # imm = 0x400
jg 0x77a7c
movq %r9, %r13
movl %edx, 0x4(%rsp)
leal (%rsi,%rsi), %eax
movl %eax, (%r8)
shlq $0x4, %rsi
movq %r14, %rdi
callq 0xba60
testq %rax, %rax
je 0x77a7c
movq %rax, %r14
movq %rax, (%r13)
movl 0x4(%rsp), %edx
pushq $-0x1
popq %rcx
movq %r12, %rdi
movl %r15d, %esi
callq 0x95a69
movslq (%rbx), %rcx
movq %rax, (%r14,%rcx,8)
xorl %edx, %edx
testq %rax, %rax
pushq $0xc
popq %rbp
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0xbce8
testq %rax, %rax
je 0x77adc
movq %rax, %rbx
movslq %r15d, %rdi
shlq $0x3, %rdi
callq 0xbce8
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x77ad4
movl %r15d, (%rbx)
movl %r14d, 0x4(%rbx)
movl %ebp, 0x8(%rbx)
andl $0x0, 0xc(%rbx)
jmp 0x77ade
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_O2/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, %rbx
movl (%rdi), %r12d
xorl %r15d, %r15d
pushq $0xc
popq %rbp
movslq 0xc(%rbx), %rax
cmpl %r12d, %eax
jl 0x77b63
movl 0x4(%rbx), %eax
cmpl %eax, %r12d
jge 0x77b70
addl 0x8(%rbx), %r12d
cmpl %eax, %r12d
cmovgel %eax, %r12d
movq 0x10(%rbx), %rdi
movslq %r12d, %rsi
shlq $0x3, %rsi
callq 0xba60
testq %rax, %rax
je 0x77b70
cmpl (%rbx), %r12d
jle 0x77b82
movl %r12d, (%rbx)
movq %rax, 0x10(%rbx)
movb $0x1, %r15b
jmp 0x77b21
movq 0x10(%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incl 0xc(%rbx)
xorl %ebp, %ebp
xorl %eax, %eax
testb $0x1, %r15b
cmovel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68dab(%rip), %rdi     # 0xe0934
leaq 0x68db7(%rip), %rsi     # 0xe0947
leaq 0x68dd1(%rip), %rcx     # 0xe0968
pushq $0x62
popq %rdx
callq 0xb400
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: prepare_new_block
static
void prepare_new_block ( EState* s )
{
   Int32 i;
   s->nblock = 0;
   s->numZ = 0;
   s->state_out_pos = 0;
   BZ_INITIALISE_CRC ( s->blockCRC );
   for (i = 0; i < 256; i++) s->inUse[i] = False;
   s->blockNo++;
}

// Assembly:
andl $0x0, 0x6c(%rdi)
andq $0x0, 0x74(%rdi)
orl $-0x1, 0x288(%rdi)
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x77e21
movb $0x0, 0x80(%rdi,%rax)
incq %rax
jmp 0x77e0c
incl 0x294(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $-0x2
popq %rax
testq %rdi, %rdi
je 0x782fb
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x782f4
cmpq %rbx, (%r14)
jne 0x782f4
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x782c2
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x782d2
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x782e2
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x30(%rbx), %rsi
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
andq $0x0, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $-0x2
popq %rax
cmpl $0x4, %esi
ja 0x783aa
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x783a6
movl %edx, %ebp
cmpl $0x1, %edx
ja 0x783a6
movl %esi, %ebx
movq 0x38(%r14), %rax
testq %rax, %rax
jne 0x78339
leaq -0x54e(%rip), %rax      # 0x77de7
movq %rax, 0x38(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x7834b
leaq -0x555(%rip), %rcx      # 0x77df2
movq %rcx, 0x40(%r14)
movq 0x48(%r14), %rdi
pushq $0x1
popq %rdx
movl $0xfa90, %esi           # imm = 0xFA90
callq *%rax
testq %rax, %rax
je 0x783a3
movq %r14, (%rax)
movq %rax, 0x30(%r14)
movl $0xa, 0x8(%rax)
andq $0x0, 0x20(%rax)
andl $0x0, 0xc74(%rax)
andq $0x0, 0xc(%r14)
andq $0x0, 0x24(%r14)
movb %bpl, 0x2c(%rax)
andl $0x0, 0x30(%rax)
andq $0x0, 0xc60(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xc50(%rax)
movl %ebx, 0x34(%rax)
xorl %eax, %eax
jmp 0x783a6
pushq $-0x3
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x783c4
movl %edx, %eax
jmp 0x783c6
movl %edx, %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl $0x1, %edx
jne 0x783b2
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $-0x2
popq %rax
testq %rdi, %rdi
je 0x79225
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x7921e
cmpq %rbx, (%r14)
jne 0x7921e
movq 0xc50(%r14), %rsi
testq %rsi, %rsi
je 0x791e6
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0xc58(%r14), %rsi
testq %rsi, %rsi
je 0x791f9
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0xc60(%r14), %rsi
testq %rsi, %rsi
je 0x7920c
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
movq 0x30(%rbx), %rsi
movq 0x48(%rbx), %rdi
callq *0x40(%rbx)
andq $0x0, 0x30(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x79247
andl $0x0, (%rbx)
cmpl $0x4, %ebp
ja 0x7927c
testq %r13, %r13
je 0x7927c
leal -0xa(%r15), %eax
cmpl $-0x9, %eax
jb 0x7927c
cmpl $0xfb, %r12d
jae 0x7927c
movq %r13, %rdi
callq 0xbc20
testl %eax, %eax
je 0x7929c
testq %rbx, %rbx
je 0x79287
movl $0xfffffffa, (%rbx)     # imm = 0xFFFFFFFA
jmp 0x79287
testq %rbx, %rbx
je 0x79287
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 0xbce8
testq %rax, %rax
je 0x79322
movq %rax, %r14
testq %rbx, %rbx
je 0x792b6
andl $0x0, (%rbx)
andl $0x0, 0x13e8(%r14)
movb $0x0, 0x13ec(%r14)
andl $0x0, 0x1390(%r14)
movq %r13, (%r14)
movb $0x1, 0x1394(%r14)
movq %r14, %rdi
addq $0x1398, %rdi           # imm = 0x1398
testl %r12d, %r12d
pushq $0x1e
popq %rcx
cmovnel %r12d, %ecx
xorps %xmm0, %xmm0
movups %xmm0, 0x13d0(%r14)
andq $0x0, 0x13e0(%r14)
movl %r15d, %esi
movl %ebp, %edx
callq 0x77c26
testl %eax, %eax
je 0x79336
testq %rbx, %rbx
je 0x79315
movl %eax, (%rbx)
movq %r14, %rdi
callq 0xb790
jmp 0x79287
testq %rbx, %rbx
je 0x79287
movl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
jmp 0x79287
andl $0x0, 0x13a0(%r14)
movb $0x1, 0x13ec(%r14)
jmp 0x7928a
// File: /workspace/github_c_makefile_star2_O2/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 0x7936a
andl $0x0, (%r14)
testq %rbx, %rbx
je 0x79376
andl $0x0, 0x13e8(%rbx)
testq %rbx, %rbx
je 0x7939d
testq %r12, %r12
je 0x7939d
testl %ebp, %ebp
js 0x7939d
cmpb $0x0, 0x1394(%rbx)
je 0x793b3
movq (%rbx), %rdi
callq 0xbc20
testl %eax, %eax
je 0x793d3
pushq $-0x6
jmp 0x793b5
testq %r14, %r14
je 0x793a9
movl $0xfffffffe, (%r14)     # imm = 0xFFFFFFFE
testq %rbx, %rbx
je 0x793c4
pushq $-0x2
popq %rax
jmp 0x793be
pushq $-0x1
popq %rax
testq %r14, %r14
je 0x793be
movl %eax, (%r14)
movl %eax, 0x13e8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x7945f
leaq 0x1398(%rbx), %r15
movl %ebp, 0x13a0(%rbx)
movq %r12, 0x1398(%rbx)
leaq 0x8(%rbx), %r12
pushq $0x1
popq %r13
movl $0x1388, 0x13b8(%rbx)   # imm = 0x1388
movq %r12, 0x13b0(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x77e28
cmpl $0x1, %eax
jne 0x793b6
movl 0x13b8(%rbx), %eax
cmpq $0x1387, %rax           # imm = 0x1387
ja 0x79456
movl $0x1388, %ebp           # imm = 0x1388
subq %rax, %rbp
movq (%rbx), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xbca0
cmpl %eax, %ebp
jne 0x79399
movq (%rbx), %rdi
callq 0xbc20
testl %eax, %eax
jne 0x79399
cmpl $0x0, 0x13a0(%rbx)
jne 0x793f7
xorl %eax, %eax
jmp 0x793b6
// File: /workspace/github_c_makefile_star2_O2/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 0x79856
andl $0x0, (%rdi)
testq %rbx, %rbx
je 0x79872
andl $0x0, 0x13e8(%rbx)
cmpb $0x0, 0x1394(%rbx)
je 0x79874
orl $-0x1, (%rdi)
jmp 0x7986b
testq %rbx, %rbx
je 0x79872
andl $0x0, 0x13e8(%rbx)
cmpb $0x0, 0x1394(%rbx)
je 0x79874
orl $-0x1, 0x13e8(%rbx)
popq %rbx
retq
cmpb $0x0, 0x13ec(%rbx)
je 0x79889
leaq 0x1398(%rbx), %rdi
callq 0x791b6
movq %rbx, %rdi
popq %rbx
jmp 0xb790
// File: /workspace/github_c_makefile_star2_O2/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 0x79ac9
cmpl $0x4, 0x13e8(%rsi)
jne 0x79ad5
testq %rdx, %rdx
setne %al
testq %rcx, %rcx
setne %r8b
testb %r8b, %al
jne 0x79ae5
testq %rdi, %rdi
je 0x79abe
movl $0xfffffffe, (%rdi)     # imm = 0xFFFFFFFE
movl $0xfffffffe, 0x13e8(%rsi) # imm = 0xFFFFFFFE
retq
testq %rdi, %rdi
je 0x79b06
movl $0xfffffffe, (%rdi)     # imm = 0xFFFFFFFE
retq
testq %rdi, %rdi
je 0x79add
orl $-0x1, (%rdi)
orl $-0x1, 0x13e8(%rsi)
retq
testq %rdi, %rdi
je 0x79aed
andl $0x0, (%rdi)
andl $0x0, 0x13e8(%rsi)
movl 0x13a0(%rsi), %eax
movl %eax, (%rcx)
movq 0x1398(%rsi), %rax
movq %rax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x2
popq %rbp
cmpl $0xfa, %eax
ja 0x79bbe
cmpl $0x4, %r9d
ja 0x79bbe
movq %rdi, %r12
testq %rdi, %rdi
je 0x79bbe
movq %rsi, %rbx
testq %rsi, %rsi
je 0x79bbe
movq %rdx, %r15
testq %rdx, %rdx
je 0x79bbe
movl %ecx, %r14d
leal -0xa(%r8), %ecx
cmpl $-0x9, %ecx
jb 0x79bbe
testl %eax, %eax
pushq $0x1e
popq %rcx
cmovnel %eax, %ecx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
movl %r8d, %esi
movl %r9d, %edx
callq 0x77c26
movl %eax, %ebp
testl %eax, %eax
jne 0x79bbe
movq %rsp, %rdi
movq %r15, (%rdi)
movq %r12, 0x18(%rdi)
movl %r14d, 0x8(%rdi)
movl (%rbx), %eax
movl %eax, 0x20(%rdi)
pushq $0x2
popq %rsi
callq 0x77e28
cmpl $0x3, %eax
je 0x79bb3
movl %eax, %ebp
cmpl $0x4, %eax
jne 0x79bb6
movl 0x20(%rsp), %eax
subl %eax, (%rbx)
xorl %ebp, %ebp
jmp 0x79bb6
pushq $-0x8
popq %rbp
movq %rsp, %rdi
callq 0x78295
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzBuffToBuffDecompress
int BZ_API(BZ2_bzBuffToBuffDecompress) 
                           ( char*         dest, 
                             unsigned int* destLen,
                             char*         source, 
                             unsigned int  sourceLen,
                             int           small,
                             int           verbosity )
{
   bz_stream strm;
   int ret;

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

   strm.bzalloc = NULL;
   strm.bzfree = NULL;
   strm.opaque = NULL;
   ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
   if (ret != BZ_OK) return ret;

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

   ret = BZ2_bzDecompress ( &strm );
   if (ret == BZ_OK) goto output_overflow_or_eof;
   if (ret != BZ_STREAM_END) goto errhandler;

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

   output_overflow_or_eof:
   if (strm.avail_out > 0) {
      BZ2_bzDecompressEnd ( &strm );
      return BZ_UNEXPECTED_EOF;
   } else {
      BZ2_bzDecompressEnd ( &strm );
      return BZ_OUTBUFF_FULL;
   };      

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
pushq $-0x2
popq %r14
jne 0x79c33
cmpl $0x2, %r8d
setae %al
cmpl $0x5, %r9d
setae %cl
orb %al, %cl
jne 0x79c33
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
movl %r9d, %esi
movl %r8d, %edx
callq 0x782fc
movl %eax, %r14d
testl %eax, %eax
je 0x79c43
movl %r14d, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rdi
movq %r15, (%rdi)
movq %r12, 0x18(%rdi)
movl %ebp, 0x8(%rdi)
movl (%rbx), %eax
movl %eax, 0x20(%rdi)
callq 0x783d0
testl %eax, %eax
je 0x79c78
movl %eax, %r14d
movq %rsp, %rdi
cmpl $0x4, %eax
jne 0x79c90
movl 0x20(%rdi), %eax
subl %eax, (%rbx)
callq 0x791b6
xorl %r14d, %r14d
jmp 0x79c33
movq %rsp, %rdi
movl 0x20(%rdi), %ebx
callq 0x791b6
cmpl $0x1, %ebx
pushq $-0x7
popq %r14
sbbl $0x0, %r14d
jmp 0x79c33
callq 0x791b6
jmp 0x79c33
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzclose
void BZ_API(BZ2_bzclose) (BZFILE* b)
{
   int bzerr;
   FILE *fp;
   
   if (b==NULL) {return;}
   fp = ((bzFile *)b)->handle;
   if(((bzFile*)b)->writing){
      BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
      if(bzerr != BZ_OK){
         BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
      }
   }else{
      BZ2_bzReadClose(&bzerr,b);
   }
   if(fp!=stdin && fp!=stdout){
      fclose(fp);
   }
}

// Assembly:
testq %rdi, %rdi
je 0x79f22
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
cmpb $0x0, 0x1394(%rdi)
je 0x79eec
leaq 0xc(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x79466
cmpl $0x0, (%r15)
je 0x79ef9
pushq $0x1
popq %rdx
xorl %edi, %edi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x79466
jmp 0x79ef9
leaq 0xc(%rsp), %rdi
movq %r14, %rsi
callq 0x79830
movq 0xb4080(%rip), %rax     # 0x12df80
cmpq (%rax), %rbx
je 0x79f19
movq 0xb403c(%rip), %rax     # 0x12df48
cmpq (%rax), %rbx
je 0x79f19
movq %rbx, %rdi
callq 0xb690
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzerror
const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum)
{
   int err = ((bzFile *)b)->lastErr;

   if(err>0) err = 0;
   *errnum = err;
   return bzerrorstrings[err*-1];
}

// Assembly:
movl 0x13e8(%rdi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
movl %ecx, (%rsi)
negl %ecx
leaq 0x66a81(%rip), %rdx     # 0xe09bc
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: add_pair_to_block
static
void add_pair_to_block ( EState* s )
{
   Int32 i;
   UChar ch = (UChar)(s->state_in_ch);
   for (i = 0; i < s->state_in_len; i++) {
      BZ_UPDATE_CRC( s->blockCRC, ch );
   }
   s->inUse[s->state_in_ch] = True;
   switch (s->state_in_len) {
      case 1:
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         break;
      case 2:
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         break;
      case 3:
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         break;
      default:
         s->inUse[s->state_in_len-4] = True;
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         s->block[s->nblock] = (UChar)ch; s->nblock++;
         s->block[s->nblock] = ((UChar)(s->state_in_len-4));
         s->nblock++;
         break;
   }
}

// Assembly:
movl 0x5c(%rdi), %eax
movslq 0x60(%rdi), %rcx
movzbl %al, %edx
xorl %esi, %esi
testl %ecx, %ecx
cmovgl %ecx, %esi
leaq 0xb4be5(%rip), %r8      # 0x12eb40
subl $0x1, %esi
jb 0x79f82
movl 0x288(%rdi), %r9d
movl %r9d, %r10d
shll $0x8, %r10d
shrl $0x18, %r9d
xorl %edx, %r9d
xorl (%r8,%r9,4), %r10d
movl %r10d, 0x288(%rdi)
jmp 0x79f5b
movb $0x1, 0x80(%rdi,%rax)
cmpl $0x3, %ecx
je 0x79fba
cmpl $0x2, %ecx
je 0x79fa9
cmpl $0x1, %ecx
jne 0x79fea
leaq 0x40(%rdi), %rcx
movl 0x6c(%rdi), %edx
addq $0x6c, %rdi
jmp 0x7a048
leaq 0x40(%rdi), %rcx
movq 0x40(%rdi), %rdx
movslq 0x6c(%rdi), %rsi
movb %al, (%rdx,%rsi)
jmp 0x79fdc
leaq 0x40(%rdi), %rcx
movq 0x40(%rdi), %rdx
movslq 0x6c(%rdi), %rsi
movb %al, (%rdx,%rsi)
movslq 0x6c(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x6c(%rdi)
movq 0x40(%rdi), %rsi
movb %al, 0x1(%rsi,%rdx)
movl 0x6c(%rdi), %edx
incl %edx
movl %edx, 0x6c(%rdi)
addq $0x6c, %rdi
jmp 0x7a048
movb $0x1, 0x7c(%rdi,%rcx)
leaq 0x40(%rdi), %rcx
movq 0x40(%rdi), %rdx
movslq 0x6c(%rdi), %rsi
movb %al, (%rdx,%rsi)
movslq 0x6c(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x6c(%rdi)
movq 0x40(%rdi), %rsi
movb %al, 0x1(%rsi,%rdx)
movslq 0x6c(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x6c(%rdi)
movq 0x40(%rdi), %rsi
movb %al, 0x1(%rsi,%rdx)
movslq 0x6c(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x6c(%rdi)
movq 0x40(%rdi), %rsi
movb %al, 0x1(%rsi,%rdx)
movl 0x6c(%rdi), %edx
incl %edx
movl %edx, 0x6c(%rdi)
movb 0x60(%rdi), %al
addq $0x6c, %rdi
addb $-0x4, %al
movq (%rcx), %rcx
movslq %edx, %rdx
movb %al, (%rcx,%rdx)
incl (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gzdopen
gzFile ZEXPORT gzdopen(int fd, const char *mode) {
    char *path;         /* identifier for error messages */
    gzFile gz;

    if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
        return NULL;
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
    (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
#else
    sprintf(path, "<fd:%d>", fd);   /* for debugging */
#endif
    gz = gz_open(path, fd, mode);
    free(path);
    return gz;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x7a346
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x13
popq %rdi
callq 0xbce8
testq %rax, %rax
je 0x7a346
movq %rax, %r14
leaq 0x66dca(%rip), %rdx     # 0xe10e4
pushq $0x13
popq %rsi
movq %rax, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0xba00
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x7a078
movq %rax, %rbx
movq %r14, %rdi
callq 0xb790
movq %rbx, %rax
jmp 0x7a348
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gzrewind
int ZEXPORT gzrewind(gzFile file) {
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;

    /* check that we're reading and that there's no error */
    if (state->mode != GZ_READ ||
            (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return -1;

    /* back up and start over */
    if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
        return -1;
    gz_reset(state);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x7a3c5
movq %rdi, %r14
cmpl $0x1c4f, 0x18(%rdi)     # imm = 0x1C4F
jne 0x7a3c5
movl 0x74(%r14), %eax
testl %eax, %eax
je 0x7a3a6
cmpl $-0x5, %eax
jne 0x7a3c5
movl 0x1c(%r14), %edi
movq 0x48(%r14), %rsi
xorl %edx, %edx
callq 0xb570
cmpq $-0x1, %rax
je 0x7a3c5
movq %r14, %rdi
callq 0x7a3cf
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gz_reset
local void gz_reset(gz_statep state) {
    state->x.have = 0;              /* no output data available */
    if (state->mode == GZ_READ) {   /* for reading ... */
        state->eof = 0;             /* not at end of file */
        state->past = 0;            /* have not read past end yet */
        state->how = LOOK;          /* look for gzip header */
    }
    else                            /* for writing ... */
        state->reset = 0;           /* no deflateReset pending */
    state->seek = 0;                /* no seek request pending */
    gz_error(state, Z_OK, NULL);    /* clear error */
    state->x.pos = 0;               /* no uncompressed data yet */
    state->strm.avail_in = 0;       /* no input data yet */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andl $0x0, (%rdi)
cmpl $0x1c4f, 0x18(%rdi)     # imm = 0x1C4F
jne 0x7a3ea
andq $0x0, 0x50(%rbx)
andl $0x0, 0x44(%rbx)
jmp 0x7a3ee
andl $0x0, 0x60(%rbx)
andl $0x0, 0x70(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7a532
andq $0x0, 0x10(%rbx)
andl $0x0, 0x88(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gz_error
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg) {
    /* free previously allocated message and clear */
    if (state->msg != NULL) {
        if (state->err != Z_MEM_ERROR)
            free(state->msg);
        state->msg = NULL;
    }

    /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
    if (err != Z_OK && err != Z_BUF_ERROR)
        state->x.have = 0;

    /* set error code, and if no message, then done */
    state->err = err;
    if (msg == NULL)
        return;

    /* for an out of memory error, return literal string when requested */
    if (err == Z_MEM_ERROR)
        return;

    /* construct error message with path */
    if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
            NULL) {
        state->err = Z_MEM_ERROR;
        return;
    }
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
    (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
                   "%s%s%s", state->path, ": ", msg);
#else
    strcpy(state->msg, state->path);
    strcat(state->msg, ": ");
    strcat(state->msg, msg);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x7a55c
cmpl $-0x4, 0x74(%r14)
je 0x7a557
callq 0xb790
andq $0x0, 0x78(%r14)
cmpl $-0x5, %ebp
je 0x7a569
testl %ebp, %ebp
je 0x7a569
andl $0x0, (%r14)
movl %ebp, 0x74(%r14)
testq %rbx, %rbx
sete %al
cmpl $-0x4, %ebp
sete %cl
orb %al, %cl
jne 0x7a5f6
movq 0x20(%r14), %r15
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
movq %rbx, %rdi
callq 0xb260
leaq (%r12,%rax), %rdi
addq $0x3, %rdi
callq 0xbce8
movq %rax, 0x78(%r14)
testq %rax, %rax
je 0x7a5ee
movq %rax, %r12
movq %r15, %rdi
callq 0xb260
movq %rax, %r14
movq %rbx, %rdi
callq 0xb260
leaq (%r14,%rax), %rsi
addq $0x3, %rsi
leaq 0x66b1d(%rip), %rdx     # 0xe10ec
leaq 0x6afce(%rip), %r8      # 0xe55a4
movq %r12, %rdi
movq %r15, %rcx
movq %rbx, %r9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xba00
movl $0xfffffffc, 0x74(%r14) # imm = 0xFFFFFFFC
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gztell64
z_off64_t ZEXPORT gztell64(gzFile file) {
    gz_statep state;

    /* get internal structure and check integrity */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
        return -1;

    /* return position */
    return state->x.pos + (state->seek ? state->skip : 0);
}

// Assembly:
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x7a634
movl 0x18(%rdi), %ecx
cmpl $0x79b1, %ecx           # imm = 0x79B1
je 0x7a61f
cmpl $0x1c4f, %ecx           # imm = 0x1C4F
jne 0x7a634
movq 0x10(%rdi), %rcx
cmpl $0x0, 0x70(%rdi)
je 0x7a62f
movq 0x68(%rdi), %rax
jmp 0x7a631
xorl %eax, %eax
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gzoffset64
z_off64_t ZEXPORT gzoffset64(gzFile file) {
    z_off64_t offset;
    gz_statep state;

    /* get internal structure and check integrity */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
        return -1;

    /* compute and return effective offset in file */
    offset = LSEEK(state->fd, 0, SEEK_CUR);
    if (offset == -1)
        return -1;
    if (state->mode == GZ_READ)             /* reading */
        offset -= state->strm.avail_in;     /* don't count buffered input */
    return offset;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x7a688
movq %rdi, %r14
movl 0x18(%rdi), %eax
cmpl $0x79b1, %eax           # imm = 0x79B1
je 0x7a65a
cmpl $0x1c4f, %eax           # imm = 0x1C4F
jne 0x7a688
movl 0x1c(%r14), %edi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0xb570
cmpq $-0x1, %rax
je 0x7a688
cmpl $0x1c4f, 0x18(%r14)     # imm = 0x1C4F
movq %rax, %rbx
jne 0x7a688
movl 0x88(%r14), %ecx
subq %rcx, %rax
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gzerror
const char * ZEXPORT gzerror(gzFile file, int *errnum) {
    gz_statep state;

    /* get internal structure and check integrity */
    if (file == NULL)
        return NULL;
    state = (gz_statep)file;
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
        return NULL;

    /* return error information */
    if (errnum != NULL)
        *errnum = state->err;
    return state->err == Z_MEM_ERROR ? "out of memory" :
                                       (state->msg == NULL ? "" : state->msg);
}

// Assembly:
testq %rdi, %rdi
je 0x7a6d9
movl 0x18(%rdi), %eax
cmpl $0x79b1, %eax           # imm = 0x79B1
je 0x7a6c2
cmpl $0x1c4f, %eax           # imm = 0x1C4F
jne 0x7a6d9
movl 0x74(%rdi), %eax
testq %rsi, %rsi
je 0x7a6cc
movl %eax, (%rsi)
cmpl $-0x4, %eax
jne 0x7a6dc
leaq 0x626b2(%rip), %rax     # 0xdcd8a
retq
xorl %eax, %eax
retq
movq 0x78(%rdi), %rcx
testq %rcx, %rcx
leaq 0x5d3f5(%rip), %rax     # 0xd7adf
cmovneq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gzread
int ZEXPORT gzread(gzFile file, voidp buf, unsigned len) {
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
            (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return -1;

    /* since an int is returned, make sure len fits in one, otherwise return
       with an error (this avoids a flaw in the interface) */
    if ((int)len < 0) {
        gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
        return -1;
    }

    /* read len or fewer bytes to buf */
    len = (unsigned)gz_read(state, buf, len);

    /* check for an error */
    if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
        return -1;

    /* return the number of bytes read (this is assured to fit in an int) */
    return (int)len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x7a761
movq %rdi, %r14
cmpl $0x1c4f, 0x18(%rdi)     # imm = 0x1C4F
jne 0x7a761
movl 0x74(%r14), %eax
testl %eax, %eax
je 0x7a739
cmpl $-0x5, %eax
jne 0x7a761
testl %edx, %edx
js 0x7a74f
movl %edx, %edx
movq %r14, %rdi
callq 0x7a77a
testl %eax, %eax
je 0x7a76b
movl %eax, %ebx
jmp 0x7a761
leaq 0x669ba(%rip), %rdx     # 0xe1110
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x7a532
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x74(%r14), %ecx
testl %ecx, %ecx
je 0x7a74b
cmpl $-0x5, %ecx
je 0x7a74b
jmp 0x7a761
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gzfread
z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems, gzFile file) {
    z_size_t len;
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
            (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return 0;

    /* compute bytes to read -- error on overflow */
    len = nitems * size;
    if (size && len / size != nitems) {
        gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
        return 0;
    }

    /* read len or fewer bytes to buf, return the number of full items read */
    return len ? gz_read(state, buf, len) / size : 0;
}

// Assembly:
testq %rcx, %rcx
je 0x7a8fc
cmpl $0x1c4f, 0x18(%rcx)     # imm = 0x1C4F
jne 0x7a8fc
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movl 0x74(%rcx), %eax
testl %eax, %eax
je 0x7a8d6
cmpl $-0x5, %eax
jne 0x7a916
movq %rbx, %rax
mulq %rdx
seto %dl
testq %rbx, %rbx
je 0x7a8ff
testb %dl, %dl
je 0x7a8ff
leaq 0x66840(%rip), %rdx     # 0xe112f
pushq $-0x2
popq %rsi
movq %rcx, %rdi
callq 0x7a532
jmp 0x7a916
xorl %eax, %eax
retq
testq %rax, %rax
je 0x7a916
movq %rcx, %rdi
movq %rax, %rdx
callq 0x7a77a
xorl %edx, %edx
divq %rbx
jmp 0x7a918
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gzgetc
int ZEXPORT gzgetc(gzFile file) {
    unsigned char buf[1];
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
        (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return -1;

    /* try output buffer (no need to check for skip request) */
    if (state->x.have) {
        state->x.have--;
        state->x.pos++;
        return *(state->x.next)++;
    }

    /* nothing there -- try gz_read() */
    return gz_read(state, buf, 1) < 1 ? -1 : buf[0];
}

// Assembly:
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x7a97f
cmpl $0x1c4f, 0x18(%rdi)     # imm = 0x1C4F
jne 0x7a97f
movl 0x74(%rdi), %ecx
testl %ecx, %ecx
je 0x7a937
cmpl $-0x5, %ecx
jne 0x7a97f
movl (%rdi), %eax
testl %eax, %eax
je 0x7a955
decl %eax
movl %eax, (%rdi)
incq 0x10(%rdi)
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
retq
pushq %rbx
subq $0x10, %rsp
leaq 0xf(%rsp), %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x7a77a
movq %rax, %rcx
movzbl (%rbx), %edx
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %edx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gz_skip
local int gz_skip(gz_statep state, z_off64_t len) {
    unsigned n;

    /* skip over len bytes or reach end-of-file, whichever comes first */
    while (len)
        /* skip over whatever is in output buffer */
        if (state->x.have) {
            n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
                (unsigned)len : state->x.have;
            state->x.have -= n;
            state->x.next += n;
            state->x.pos += n;
            len -= n;
        }

        /* output buffer empty -- return if we're at the end of the input */
        else if (state->eof && state->strm.avail_in == 0)
            break;

        /* need more data to skip -- load up output buffer */
        else {
            /* get more output, looking for header if required */
            if (gz_fetch(state) == -1)
                return -1;
        }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x7ac72
movl (%r14), %eax
testq %rax, %rax
jne 0x7ac58
cmpl $0x0, 0x50(%r14)
je 0x7ac38
cmpl $0x0, 0x88(%r14)
je 0x7ac72
movq %r14, %rdi
callq 0x7adc9
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
negl %eax
cmpl $-0x1, %ecx
je 0x7ac74
testq %rbx, %rbx
jne 0x7ac1f
jmp 0x7ac74
cmpq %rax, %rbx
movl %ebx, %ecx
cmovgel %eax, %ecx
subl %ecx, %eax
movl %eax, (%r14)
addq %rcx, 0x8(%r14)
addq %rcx, 0x10(%r14)
subq %rcx, %rbx
jmp 0x7ac1a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq