LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_compare_items
static int
tre_compare_items(const void *a, const void *b)
{
  const tre_ast_node_t *node_a = *(tre_ast_node_t * const *)a;
  const tre_ast_node_t *node_b = *(tre_ast_node_t * const *)b;
  tre_literal_t *l_a = node_a->obj, *l_b = node_b->obj;
  int a_min = l_a->code_min, b_min = l_b->code_min;

  if (a_min < b_min)
    return -1;
  else if (a_min > b_min)
    return 1;
  else
    return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rax
movq (%rax), %rax
movl %eax, -0x3c(%rsp)
movq -0x38(%rsp), %rax
movq (%rax), %rax
movl %eax, -0x40(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0x40(%rsp), %eax
jge 0xc759c
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xc75b8
movl -0x3c(%rsp), %eax
cmpl -0x40(%rsp), %eax
jle 0xc75b0
movl $0x1, -0x4(%rsp)
jmp 0xc75b8
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_expand_ctype
static reg_errcode_t
tre_expand_ctype(tre_mem_t mem, tre_ctype_t class, tre_ast_node_t ***items,
		 int *i, int *max_i, int cflags)
{
  reg_errcode_t status = REG_OK;
  tre_cint_t c;
  int j, min = -1, max = 0;
  assert(TRE_MB_CUR_MAX == 1);

  DPRINT(("  expanding class to character ranges\n"));
  for (j = 0; (j < 256) && (status == REG_OK); j++)
    {
      c = (tre_cint_t) j;
      if (tre_isctype(c, class)
	  || ((cflags & REG_ICASE)
	      && (tre_isctype(tre_tolower(c), class)
		  || tre_isctype(tre_toupper(c), class))))
{
	  if (min < 0)
	    min = c;
	  max = c;
	}
      else if (min >= 0)
	{
	  DPRINT(("  range %c (%d) to %c (%d)\n", min, min, max, max));
	  status = tre_new_item(mem, min, max, i, max_i, items);
	  min = -1;
	}
    }
  if (min >= 0 && status == REG_OK)
    status = tre_new_item(mem, min, max, i, max_i, items);
  return status;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x18(%rsp)
jmp 0xc75fc
movl $0x0, 0x20(%rsp)
xorl %eax, %eax
cmpl $0x100, 0x20(%rsp)      # imm = 0x100
movb %al, 0x17(%rsp)
jge 0xc7620
cmpl $0x0, 0x28(%rsp)
sete %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xc762d
jmp 0xc7702
movl 0x20(%rsp), %eax
movw %ax, 0x26(%rsp)
movq 0x48(%rsp), %rax
movswl 0x26(%rsp), %edi
callq *%rax
cmpl $0x0, %eax
jne 0xc769b
movl 0x2c(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc76b6
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movswl 0x26(%rsp), %edi
callq 0xb8c0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movswl %cx, %edi
callq *%rax
cmpl $0x0, %eax
jne 0xc769b
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movswl 0x26(%rsp), %edi
callq 0xbbb0
movl %eax, %ecx
movq (%rsp), %rax
movswl %cx, %edi
callq *%rax
cmpl $0x0, %eax
je 0xc76b6
cmpl $0x0, 0x1c(%rsp)
jge 0xc76ab
movswl 0x26(%rsp), %eax
movl %eax, 0x1c(%rsp)
movswl 0x26(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0xc76f0
cmpl $0x0, 0x1c(%rsp)
jl 0xc76ee
jmp 0xc76bf
jmp 0xc76c1
movq 0x50(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x40(%rsp), %r9
callq 0xc7740
movl %eax, 0x28(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
jmp 0xc76f0
jmp 0xc76f2
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xc7604
cmpl $0x0, 0x1c(%rsp)
jl 0xc7735
cmpl $0x0, 0x28(%rsp)
jne 0xc7735
movq 0x50(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x40(%rsp), %r9
callq 0xc7740
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jl 0xc77e2
jmp 0xc777f
jmp 0xc7781
movq 0x20(%rsp), %rax
cmpl $0x400, (%rax)          # imm = 0x400
jle 0xc779b
movl $0xc, 0x44(%rsp)
jmp 0xc7844
movq 0x20(%rsp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq (%rax), %rsi
shlq $0x3, %rsi
callq 0xba30
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xc77d1
movl $0xc, 0x44(%rsp)
jmp 0xc7844
movq (%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xfc1a0
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdx
xorl %eax, %eax
movl $0xc, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0x18, %edi
callq 0xbcb8
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc78e1
movslq 0x1c(%rsp), %rdi
shlq $0x3, %rdi
callq 0xbcb8
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc78b2
movq 0x8(%rsp), %rdi
callq 0xb760
movq $0x0, 0x20(%rsp)
jmp 0xc78eb
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc79ad
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0xc(%rcx), %rcx
movq 0x18(%rsp), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0xc7a8e
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jl 0xc79cf
jmp 0xc79c0
jmp 0xc79c2
movl $0xc, 0x24(%rsp)
jmp 0xc7a96
jmp 0xc79d1
jmp 0xc79d3
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
addl 0x8(%rcx), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jle 0xc7a00
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x4(%rsp), %rsi
shlq $0x3, %rsi
callq 0xba30
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc7a32
jmp 0xc7a26
jmp 0xc7a28
movl $0xc, 0x24(%rsp)
jmp 0xc7a96
jmp 0xc7a34
jmp 0xc7a36
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jle 0xc7a45
jmp 0xc7a64
leaq 0xadf58(%rip), %rdi     # 0x1759a4
leaq 0xadf64(%rip), %rsi     # 0x1759b7
movl $0x62, %edx
leaq 0xadf79(%rip), %rcx     # 0x1759d8
callq 0xb3e0
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xc7960
jmp 0xc7a8e
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x6c(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x74(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x78(%rax)
movq -0x8(%rsp), %rax
movl $0xffffffff, 0x288(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rsp)
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
jge 0xc8029
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb $0x0, 0x80(%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc8000
movq -0x8(%rsp), %rax
movl 0x294(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x294(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc84be
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xc85a1
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xc84df
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xc85a1
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
je 0xc84fa
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xc85a1
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc8521
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq (%rsp), %rcx
movq 0x18(%rcx), %rsi
callq *%rax
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0xc8548
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq (%rsp), %rcx
movq 0x20(%rcx), %rsi
callq *%rax
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0xc856f
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq (%rsp), %rcx
movq 0x28(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x30(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x100, -0x18(%rsp)     # imm = 0x100
movl -0x14(%rsp), %eax
addl -0x18(%rsp), %eax
sarl %eax
movl %eax, -0x1c(%rsp)
movl -0x4(%rsp), %eax
movq -0x10(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0xc87c4
movl -0x1c(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0xc87cc
movl -0x1c(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0xc87ce
movl -0x18(%rsp), %eax
subl -0x14(%rsp), %eax
cmpl $0x1, %eax
jne 0xc8799
movl -0x14(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xca48e
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xca583
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xca4af
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xca583
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
je 0xca4ca
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xca583
movq (%rsp), %rax
cmpq $0x0, 0xc50(%rax)
je 0xca4f7
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq (%rsp), %rcx
movq 0xc50(%rcx), %rsi
callq *%rax
movq (%rsp), %rax
cmpq $0x0, 0xc58(%rax)
je 0xca524
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq (%rsp), %rcx
movq 0xc58(%rcx), %rsi
callq *%rax
movq (%rsp), %rax
cmpq $0x0, 0xc60(%rax)
je 0xca551
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq (%rsp), %rcx
movq 0xc60(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x30(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xcb1ca
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
cmpq $0x0, (%rsp)
je 0xcb1df
movq (%rsp), %rax
movl $0x0, 0x13e8(%rax)
cmpq $0x0, (%rsp)
jne 0xcb210
cmpq $0x0, 0x10(%rsp)
je 0xcb1f9
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
cmpq $0x0, (%rsp)
je 0xcb20e
movq (%rsp), %rax
movl $0x0, 0x13e8(%rax)
jmp 0xcb26d
movq (%rsp), %rax
cmpb $0x0, 0x1394(%rax)
je 0xcb247
cmpq $0x0, 0x10(%rsp)
je 0xcb230
movq 0x10(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
cmpq $0x0, (%rsp)
je 0xcb245
movq (%rsp), %rax
movl $0xffffffff, 0x13e8(%rax) # imm = 0xFFFFFFFF
jmp 0xcb26d
movq (%rsp), %rax
cmpb $0x0, 0x13ec(%rax)
je 0xcb264
movq (%rsp), %rdi
addq $0x1398, %rdi           # imm = 0x1398
callq 0xca470
movq (%rsp), %rdi
callq 0xb760
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: myfeof
static Bool myfeof ( FILE* f )
{
   Int32 c = fgetc ( f );
   if (c == EOF) return True;
   ungetc ( c, f );
   return False;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xb9a0
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0xcb635
movb $0x1, 0x17(%rsp)
jmp 0xcb648
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0xb0c0
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
jne 0xcb6b5
cmpq $0x0, -0x8(%rsp)
je 0xcb699
movq -0x8(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
cmpq $0x0, -0x28(%rsp)
je 0xcb6b0
movq -0x28(%rsp), %rax
movl $0xfffffffe, 0x13e8(%rax) # imm = 0xFFFFFFFE
jmp 0xcb77e
movq -0x28(%rsp), %rax
cmpl $0x4, 0x13e8(%rax)
je 0xcb6f2
cmpq $0x0, -0x8(%rsp)
je 0xcb6d6
movq -0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
cmpq $0x0, -0x28(%rsp)
je 0xcb6ed
movq -0x28(%rsp), %rax
movl $0xffffffff, 0x13e8(%rax) # imm = 0xFFFFFFFF
jmp 0xcb77e
cmpq $0x0, -0x18(%rsp)
je 0xcb702
cmpq $0x0, -0x20(%rsp)
jne 0xcb72e
cmpq $0x0, -0x8(%rsp)
je 0xcb715
movq -0x8(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
cmpq $0x0, -0x28(%rsp)
je 0xcb72c
movq -0x28(%rsp), %rax
movl $0xfffffffe, 0x13e8(%rax) # imm = 0xFFFFFFFE
jmp 0xcb77e
cmpq $0x0, -0x8(%rsp)
je 0xcb741
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x28(%rsp)
je 0xcb758
movq -0x28(%rsp), %rax
movl $0x0, 0x13e8(%rax)
movq -0x28(%rsp), %rax
movl 0x13a0(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x28(%rsp), %rax
movq 0x1398(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movl %r8d, 0x60(%rsp)
movl %r9d, 0x5c(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0xcb978
cmpq $0x0, 0x70(%rsp)
je 0xcb978
cmpq $0x0, 0x68(%rsp)
je 0xcb978
cmpl $0x0, 0x60(%rsp)
je 0xcb96a
cmpl $0x1, 0x60(%rsp)
jne 0xcb978
cmpl $0x0, 0x5c(%rsp)
jl 0xcb978
cmpl $0x4, 0x5c(%rsp)
jle 0xcb988
movl $0xfffffffe, 0x84(%rsp) # imm = 0xFFFFFFFE
jmp 0xcba87
movq $0x0, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movl 0x5c(%rsp), %esi
movl 0x60(%rsp), %edx
leaq 0x8(%rsp), %rdi
callq 0xc85b0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0xcb9d0
movl 0x4(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0xcba87
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xc87e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xcba0e
jmp 0xcba3d
cmpl $0x4, 0x4(%rsp)
je 0xcba17
jmp 0xcba72
movl 0x28(%rsp), %edx
movq 0x70(%rsp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0xca470
movl $0x0, 0x84(%rsp)
jmp 0xcba87
cmpl $0x0, 0x28(%rsp)
jbe 0xcba5b
leaq 0x8(%rsp), %rdi
callq 0xca470
movl $0xfffffff9, 0x84(%rsp) # imm = 0xFFFFFFF9
jmp 0xcba87
leaq 0x8(%rsp), %rdi
callq 0xca470
movl $0xfffffff8, 0x84(%rsp) # imm = 0xFFFFFFF8
jmp 0xcba87
leaq 0x8(%rsp), %rdi
callq 0xca470
movl 0x4(%rsp), %eax
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzread
int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
{
   int bzerr, nread;
   if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
   nread = BZ2_bzRead(&bzerr,b,buf,len);
   if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
      return nread;
   } else {
      return -1;
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x4, 0x13e8(%rax)
jne 0xcbe2a
movl $0x0, 0x24(%rsp)
jmp 0xcbe66
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0xcb280
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0xcbe54
cmpl $0x4, 0x8(%rsp)
jne 0xcbe5e
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xcbe66
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: BZ2_bzwrite
int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len )
{
   int bzerr;

   BZ2_bzWrite(&bzerr,b,buf,len);
   if(bzerr == BZ_OK){
      return len;
   }else{
      return -1;
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0xca820
cmpl $0x0, 0x8(%rsp)
jne 0xcbeab
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xcbeb3
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xcbee6
jmp 0xcbf74
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, 0x1394(%rax)
je 0xcbf3c
movq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0xcaae0
cmpl $0x0, 0xc(%rsp)
je 0xcbf3a
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movl $0x1, %edx
movq %r8, %rdi
movq %r8, %rcx
callq 0xcaae0
jmp 0xcbf4b
movq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdi
callq 0xcb1a0
movq (%rsp), %rax
movq 0xe8072(%rip), %rcx     # 0x1b3fc8
cmpq (%rcx), %rax
je 0xcbf74
movq (%rsp), %rax
movq 0xe804a(%rip), %rcx     # 0x1b3fb0
cmpq (%rcx), %rax
je 0xcbf74
movq (%rsp), %rdi
callq 0xb670
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x13e8(%rax), %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jle 0xcbfa8
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
imull $-0x1, -0x14(%rsp), %eax
movslq %eax, %rcx
leaq 0xe8e3e(%rip), %rax     # 0x1b4e00
movq (%rax,%rcx,8), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/bzlib.c
// Function: copy_output_until_stop
static
Bool copy_output_until_stop ( EState* s )
{
   Bool progress_out = False;

   while (True) {

      /*-- no output space? --*/
      if (s->strm->avail_out == 0) break;

      /*-- block done? --*/
      if (s->state_out_pos >= s->numZ) break;

      progress_out = True;
      *(s->strm->next_out) = s->zbits[s->state_out_pos];
      s->state_out_pos++;
      s->strm->avail_out--;
      s->strm->next_out++;
      s->strm->total_out_lo32++;
      if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
   }

   return progress_out;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movb $0x0, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xcbfed
jmp 0xcc094
movq -0x8(%rsp), %rax
movl 0x78(%rax), %eax
movq -0x8(%rsp), %rcx
cmpl 0x74(%rcx), %eax
jl 0xcc004
jmp 0xcc094
movb $0x1, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x78(%rcx), %rcx
movb (%rax,%rcx), %cl
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movl 0x78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x78(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x24(%rax)
jne 0xcc08f
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0xcbfda
movb -0x9(%rsp), %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzclose.c
// Function: gzclose
int ZEXPORT gzclose(gzFile file) {
#ifndef NO_GZCOMPRESS
    gz_statep state;

    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;

    return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
#else
    return gzclose_r(file);
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xcc73b
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcc779
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcc763
movq 0x18(%rsp), %rdi
callq 0xce650
movl %eax, 0xc(%rsp)
jmp 0xcc771
movq 0x18(%rsp), %rdi
callq 0xcfdd0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $-0x1, 0x1c(%rsp)
je 0xccc39
movl $0x13, %edi
callq 0xbcb8
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xccc44
movq $0x0, 0x20(%rsp)
jmp 0xccc8a
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %ecx
movl $0x13, %esi
leaq 0xa95bf(%rip), %rdx     # 0x176218
movb $0x0, %al
callq 0xb9d0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xcc7c0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xb760
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gzbuffer
int ZEXPORT gzbuffer(gzFile file, unsigned size) {
    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;

    /* make sure we haven't already allocated memory */
    if (state->size != 0)
        return -1;

    /* check and set requested size */
    if ((size << 1) < size)
        return -1;              /* need to be able to double it */
    if (size < 8)
        size = 8;               /* needed to behave well with flushing */
    state->want = size;
    return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xcccbb
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xccd39
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
je 0xccceb
movq -0x20(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
je 0xccceb
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xccd39
movq -0x20(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0xccd00
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xccd39
movl -0x14(%rsp), %eax
shll %eax
cmpl -0x14(%rsp), %eax
jae 0xccd16
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xccd39
cmpl $0x8, -0x14(%rsp)
jae 0xccd25
movl $0x8, -0x14(%rsp)
movl -0x14(%rsp), %ecx
movq -0x20(%rsp), %rax
movl %ecx, 0x2c(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xccd5b
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0xccdc6
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xccd85
movq (%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xccd8f
movq (%rsp), %rax
cmpl $-0x5, 0x74(%rax)
je 0xccd8f
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0xccdc6
movq (%rsp), %rax
movl 0x1c(%rax), %edi
movq (%rsp), %rax
movq 0x48(%rax), %rsi
xorl %edx, %edx
callq 0xb550
cmpq $-0x1, %rax
jne 0xccdb5
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0xccdc6
movq (%rsp), %rdi
callq 0xccdd0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcce0f
movq (%rsp), %rax
movl $0x0, 0x50(%rax)
movq (%rsp), %rax
movl $0x0, 0x54(%rax)
movq (%rsp), %rax
movl $0x0, 0x44(%rax)
jmp 0xcce1a
movq (%rsp), %rax
movl $0x0, 0x60(%rax)
movq (%rsp), %rax
movl $0x0, 0x70(%rax)
movq (%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd150
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movl $0x0, 0x88(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0xcd194
movq 0x30(%rsp), %rax
cmpl $-0x4, 0x74(%rax)
je 0xcd187
movq 0x30(%rsp), %rax
movq 0x78(%rax), %rdi
callq 0xb760
movq 0x30(%rsp), %rax
movq $0x0, 0x78(%rax)
cmpl $0x0, 0x2c(%rsp)
je 0xcd1ad
cmpl $-0x5, 0x2c(%rsp)
je 0xcd1ad
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x74(%rax)
cmpq $0x0, 0x20(%rsp)
jne 0xcd1c6
jmp 0xcd27c
cmpl $-0x4, 0x2c(%rsp)
jne 0xcd1d2
jmp 0xcd27c
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xb240
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb240
movq 0x18(%rsp), %rdi
addq %rax, %rdi
addq $0x3, %rdi
callq 0xbcb8
movq 0x30(%rsp), %rcx
movq %rax, 0x78(%rcx)
cmpq $0x0, %rax
jne 0xcd21d
movq 0x30(%rsp), %rax
movl $0xfffffffc, 0x74(%rax) # imm = 0xFFFFFFFC
jmp 0xcd27c
movq 0x30(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xb240
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb240
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq %rax, %rsi
addq $0x3, %rsi
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x20(%rsp), %r9
leaq 0xa8fb2(%rip), %rdx     # 0x176220
leaq 0xad4c7(%rip), %r8      # 0x17a73c
movb $0x0, %al
callq 0xb9d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xcd308
movq $-0x1, -0x8(%rsp)
jmp 0xcd37d
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
je 0xcd339
movq -0x18(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
je 0xcd339
movq $-0x1, -0x8(%rsp)
jmp 0xcd37d
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x0, 0x70(%rax)
je 0xcd362
movq -0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0xcd36b
xorl %eax, %eax
movq %rax, -0x28(%rsp)
jmp 0xcd36b
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xcd3ff
movq $-0x1, 0x20(%rsp)
jmp 0xcd490
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
je 0xcd430
movq 0x8(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
je 0xcd430
movq $-0x1, 0x20(%rsp)
jmp 0xcd490
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xb550
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x10(%rsp)
jne 0xcd45e
movq $-0x1, 0x20(%rsp)
jmp 0xcd490
movq 0x8(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcd486
movq 0x8(%rsp), %rax
movl 0x88(%rax), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gzeof
int ZEXPORT gzeof(gzFile file) {
    gz_statep state;

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

    /* return end-of-file state */
    return state->mode == GZ_READ ? state->past : 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xcd507
movl $0x0, -0x4(%rsp)
jmp 0xcd563
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
je 0xcd537
movq -0x18(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
je 0xcd537
movl $0x0, -0x4(%rsp)
jmp 0xcd563
movq -0x18(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcd553
movq -0x18(%rsp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x1c(%rsp)
jmp 0xcd55b
xorl %eax, %eax
movl %eax, -0x1c(%rsp)
jmp 0xcd55b
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xcd590
movq $0x0, -0x8(%rsp)
jmp 0xcd62d
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
je 0xcd5c1
movq -0x20(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
je 0xcd5c1
movq $0x0, -0x8(%rsp)
jmp 0xcd62d
cmpq $0x0, -0x18(%rsp)
je 0xcd5d8
movq -0x20(%rsp), %rax
movl 0x74(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x20(%rsp), %rax
cmpl $-0x4, 0x74(%rax)
jne 0xcd5f1
leaq 0xa4654(%rip), %rax     # 0x171c3e
movq %rax, -0x28(%rsp)
jmp 0xcd623
movq -0x20(%rsp), %rax
cmpq $0x0, 0x78(%rax)
jne 0xcd60b
leaq 0x9e8df(%rip), %rax     # 0x16bee3
movq %rax, -0x30(%rsp)
jmp 0xcd619
movq -0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzlib.c
// Function: gzclearerr
void ZEXPORT gzclearerr(gzFile file) {
    gz_statep state;

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

    /* clear error and end-of-file */
    if (state->mode == GZ_READ) {
        state->eof = 0;
        state->past = 0;
    }
    gz_error(state, Z_OK, NULL);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xcd653
jmp 0xcd6b1
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
je 0xcd67b
movq 0x8(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
je 0xcd67b
jmp 0xcd6b1
movq 0x8(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcd6a1
movq 0x8(%rsp), %rax
movl $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x54(%rax)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd150
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xcd6e7
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xcd786
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcd711
movq (%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xcd71b
movq (%rsp), %rax
cmpl $-0x5, 0x74(%rax)
je 0xcd71b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xcd786
cmpl $0x0, 0xc(%rsp)
jge 0xcd741
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xa8af5(%rip), %rdx     # 0x176227
callq 0xcd150
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xcd786
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0xcd790
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xcd77e
movq (%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xcd77e
movq (%rsp), %rax
cmpl $-0x5, 0x74(%rax)
je 0xcd77e
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xcd786
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xcda0e
movq $0x0, 0x40(%rsp)
jmp 0xcdad7
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcda3c
movq 0x10(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xcda4a
movq 0x10(%rsp), %rax
cmpl $-0x5, 0x74(%rax)
je 0xcda4a
movq $0x0, 0x40(%rsp)
jmp 0xcdad7
movq 0x28(%rsp), %rax
imulq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0xcda98
movq 0x18(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x30(%rsp)
cmpq 0x28(%rsp), %rax
je 0xcda98
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xa87be(%rip), %rdx     # 0x176246
callq 0xcd150
movq $0x0, 0x40(%rsp)
jmp 0xcdad7
cmpq $0x0, 0x18(%rsp)
je 0xcdac4
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xcd790
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x30(%rsp)
movq %rax, 0x8(%rsp)
jmp 0xcdacd
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xcdacd
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)