LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: get_val_for_pos
static double get_val_for_pos(GtCustomTrackGcContent *ctgc, GtUword pos)
{
  GtUword i,
                gc_count = 0,
                bases = 0;
  for (i=0;i<ctgc->windowsize;i++)
  {
    if (pos + i > ctgc->seqlen)
      return -1;
    if (ctgc->seq[pos+i] == 'g' || ctgc->seq[pos+i] == 'c'
         || ctgc->seq[pos+i] == 'G' || ctgc->seq[pos+i] == 'C')
    {
      gc_count++;
    }
    bases++;
  }
  return ((double) gc_count)/((double) GT_MIN(ctgc->windowsize, bases));
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
movq $0x0, -0x30(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4f07f0
movq -0x18(%rsp), %rax
addq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0x4f0751
movsd 0x4ccca(%rip), %xmm0    # 0x53d410
movsd %xmm0, -0x8(%rsp)
jmp 0x4f0884
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
addq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x67, %eax
je 0x4f07c1
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
addq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x63, %eax
je 0x4f07c1
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
addq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x47, %eax
je 0x4f07c1
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
addq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x43, %eax
jne 0x4f07cf
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x4f0715
movaps 0x28139(%rip), %xmm1    # 0x518930
movq -0x28(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x28137(%rip), %xmm1    # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpq -0x30(%rsp), %rax
jae 0x4f083e
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rsp)
jmp 0x4f0848
movq -0x30(%rsp), %rax
movq %rax, -0x40(%rsp)
movsd -0x38(%rsp), %xmm0
movq -0x40(%rsp), %rax
movq %rax, %xmm1
movaps 0x280d1(%rip), %xmm2    # 0x518930
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x280d5(%rip), %xmm2    # 0x518940
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/custom_track_gc_content.c
// Function: gt_custom_track_gc_content_new
GtCustomTrack* gt_custom_track_gc_content_new(const char *seq,
                                              GtUword seqlen,
                                              GtUword windowsize,
                                              GtUword height,
                                              double avg,
                                              bool show_scale)
{
  GtCustomTrackGcContent *ctgc;
  GtCustomTrack *ct;
  char buf[BUFSIZ];
  ct = gt_custom_track_create(gt_custom_track_gc_content_class());
  ctgc = gt_custom_track_gc_content_cast(ct);
  ctgc->windowsize = windowsize;
  ctgc->height = height;
  ctgc->seq = seq;
  ctgc->seqlen = seqlen;
  ctgc->avg = avg;
  ctgc->show_scale = show_scale;
  ctgc->title = gt_str_new_cstr("GC content (window size ");
  gt_str_append_uword(ctgc->title, ctgc->windowsize);
  if (gt_double_smaller_double(0, avg))
  {
    (void) snprintf(buf, BUFSIZ, ", average: %.1f%%", avg*100);
    gt_str_append_cstr(ctgc->title, buf);
  }
  gt_str_append_cstr(ctgc->title, ")");
  return ct;
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movb %r8b, %al
movq %rdi, 0x2040(%rsp)
movq %rsi, 0x2038(%rsp)
movq %rdx, 0x2030(%rsp)
movq %rcx, 0x2028(%rsp)
movsd %xmm0, 0x2020(%rsp)
andb $0x1, %al
movb %al, 0x201f(%rsp)
callq 0x4f06a0
movq %rax, %rdi
callq 0x4ef7f0
movq %rax, 0x2008(%rsp)
callq 0x4f06a0
movq %rax, %rdi
movq 0x2008(%rsp), %rsi
callq 0x4efc00
movq %rax, 0x2010(%rsp)
movq 0x2030(%rsp), %rcx
movq 0x2010(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x2028(%rsp), %rcx
movq 0x2010(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x2040(%rsp), %rcx
movq 0x2010(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x2038(%rsp), %rcx
movq 0x2010(%rsp), %rax
movq %rcx, 0x40(%rax)
movsd 0x2020(%rsp), %xmm0
movq 0x2010(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movb 0x201f(%rsp), %cl
movq 0x2010(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x28(%rax)
leaq 0xcb97e(%rip), %rdi     # 0x5bc3ae
callq 0x11d510
movq %rax, %rcx
movq 0x2010(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x2010(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x2010(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x11d930
movsd 0x2020(%rsp), %xmm1
xorps %xmm0, %xmm0
callq 0xec2f0
testb $0x1, %al
jne 0x4f0a78
jmp 0x4f0ab3
movq %rsp, %rdi
movsd 0x29db5(%rip), %xmm0    # 0x51a838
mulsd 0x2020(%rsp), %xmm0
movl $0x2000, %esi           # imm = 0x2000
leaq 0xcb92f(%rip), %rdx     # 0x5bc3c7
movb $0x1, %al
callq 0x19b90
movq 0x2010(%rsp), %rax
movq 0x30(%rax), %rdi
movq %rsp, %rsi
callq 0x11d550
movq 0x2010(%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0xbcab4(%rip), %rsi     # 0x5ad57a
callq 0x11d550
movq 0x2008(%rsp), %rax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_bgzf
int bgzf_check_bgzf(const char *fn)
{
    BGZF *fp;
    uint8_t buf[10],magic[10]="\037\213\010\4\0\0\0\0\0\377";
    int n;

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

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

    if ( n!=10 ) 
        return -1;

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0xc62c0(%rip), %rax     # 0x5bcc00
movq %rax, 0xc(%rsp)
movw 0xc62bc(%rip), %ax      # 0x5bcc08
movw %ax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x3567d(%rip), %rsi     # 0x52bfda
callq 0x4f6a10
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
jne 0x4f6994
movq 0x14562c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0xc630d(%rip), %rsi     # 0x5bcc90
movb $0x0, %al
callq 0x199f0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f69fb
leaq 0x16(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %esi
movl $0xa, %edx
callq 0x19a70
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4f6bd0
cmpl $0xa, 0x8(%rsp)
je 0x4f69d0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f69fb
leaq 0xc(%rsp), %rdi
leaq 0x16(%rsp), %rsi
movl $0xa, %edx
callq 0x192c0
cmpl $0x0, %eax
jne 0x4f69f3
movl $0x1, 0x34(%rsp)
jmp 0x4f69fb
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_open
BGZF*
bgzf_open(const char* __restrict path, const char* __restrict mode)
{
    BGZF* fp = NULL;
    if (strchr(mode, 'r') || strchr(mode, 'R')) { /* The reading mode is preferred. */
#ifdef _USE_KNETFILE
		knetFile *file = knet_open(path, mode);
		if (file == 0) return 0;
		fp = bgzf_read_init();
		fp->file_descriptor = -1;
		fp->open_mode = 'r';
		fp->x.fpr = file;
#else
		int fd, oflag = O_RDONLY;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag);
		if (fd == -1) return 0;
        fp = open_read(fd);
#endif
    } else if (strchr(mode, 'w') || strchr(mode, 'W')) {
		int fd, compress_level = -1, oflag = O_WRONLY | O_CREAT | O_TRUNC;
#ifdef _WIN32
		oflag |= O_BINARY;
#endif
		fd = open(path, oflag, 0666);
		if (fd == -1) return 0;
		{ // set compress_level
			int i;
			for (i = 0; mode[i]; ++i)
				if (mode[i] >= '0' && mode[i] <= '9') break;
			if (mode[i]) compress_level = (int)mode[i] - '0';
			if (strchr(mode, 'u')) compress_level = 0;
		}
        fp = open_write(fd, compress_level);
    }
    if (fp != NULL) fp->owned_file = 1;
    return fp;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x72, %esi
callq 0x19240
cmpq $0x0, %rax
jne 0x4f6a51
movq 0x20(%rsp), %rdi
movl $0x52, %esi
callq 0x19240
cmpq $0x0, %rax
je 0x4f6a95
movl $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %esi
movb $0x0, %al
callq 0x19c80
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x4f6a82
movq $0x0, 0x30(%rsp)
jmp 0x4f6bbb
movl 0x14(%rsp), %edi
callq 0x4f6ce0
movq %rax, 0x18(%rsp)
jmp 0x4f6b9e
movq 0x20(%rsp), %rdi
movl $0x77, %esi
callq 0x19240
cmpq $0x0, %rax
jne 0x4f6ac3
movq 0x20(%rsp), %rdi
movl $0x57, %esi
callq 0x19240
cmpq $0x0, %rax
je 0x4f6b9c
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movl $0x241, 0x4(%rsp)       # imm = 0x241
movq 0x28(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x19c80
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x4f6b01
movq $0x0, 0x30(%rsp)
jmp 0x4f6bbb
movl $0x0, (%rsp)
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4f6b4a
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x4f6b3d
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x4f6b3d
jmp 0x4f6b4a
jmp 0x4f6b3f
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x4f6b08
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4f6b6d
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x75, %esi
callq 0x19240
cmpq $0x0, %rax
je 0x4f6b8a
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq 0x4f6d50
movq %rax, 0x18(%rsp)
jmp 0x4f6b9e
cmpq $0x0, 0x18(%rsp)
je 0x4f6bb1
movq 0x18(%rsp), %rax
movw $0x1, 0x6(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_read
static
BGZF*
open_read(int fd)
{
#ifdef _USE_KNETFILE
    knetFile *file = knet_dopen(fd, "r");
#else
    FILE* file = fdopen(fd, "r");
#endif
    BGZF* fp;
	if (file == 0) return 0;
	fp = bgzf_read_init();
    fp->file_descriptor = fd;
    fp->open_mode = 'r';
#ifdef _USE_KNETFILE
    fp->x.fpr = file;
#else
    fp->file = file;
#endif
    return fp;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
leaq 0x352e7(%rip), %rsi     # 0x52bfda
callq 0x197b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4f6d10
movq $0x0, 0x20(%rsp)
jmp 0x4f6d46
callq 0x4f8190
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movb $0x72, 0x4(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: open_write
static
BGZF*
open_write(int fd, int compress_level) // compress_level==-1 for the default level
{
    FILE* file = fdopen(fd, "w");
    BGZF* fp;
	if (file == 0) return 0;
	fp = malloc(sizeof(BGZF));
    fp->file_descriptor = fd;
    fp->open_mode = 'w';
    fp->owned_file = 0;
	fp->compress_level = compress_level < 0? Z_DEFAULT_COMPRESSION : compress_level; // Z_DEFAULT_COMPRESSION==-1
	if (fp->compress_level > 9) fp->compress_level = Z_DEFAULT_COMPRESSION;
#ifdef _USE_KNETFILE
    fp->x.fpw = file;
#else
    fp->file = file;
#endif
    fp->uncompressed_block_size = DEFAULT_BLOCK_SIZE;
    fp->uncompressed_block = NULL;
    fp->compressed_block_size = MAX_BLOCK_SIZE;
    fp->compressed_block = malloc(MAX_BLOCK_SIZE);
    fp->block_address = 0;
    fp->block_offset = 0;
    fp->block_length = 0;
    fp->error = NULL;
    return fp;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movl 0x1c(%rsp), %edi
leaq 0x6f15e(%rip), %rsi     # 0x565ec5
callq 0x197b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4f6d87
movq $0x0, 0x20(%rsp)
jmp 0x4f6e7d
movl $0x58, %edi
callq 0x19ef8
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movb $0x77, 0x4(%rax)
movq 0x8(%rsp), %rax
movw $0x0, 0x6(%rax)
cmpl $0x0, 0x18(%rsp)
jge 0x4f6dc7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rsp)
jmp 0x4f6dcf
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x8(%rax)
movq 0x8(%rsp), %rax
movswl 0x8(%rax), %eax
cmpl $0x9, %eax
jle 0x4f6df8
movq 0x8(%rsp), %rax
movw $0xffff, 0x8(%rax)      # imm = 0xFFFF
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x10000, 0x18(%rax)    # imm = 0x10000
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x10000, 0x1c(%rax)    # imm = 0x10000
movl $0x10000, %edi          # imm = 0x10000
callq 0x19ef8
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x3c(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%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/samtools-0.1.18/bgzf.c
// Function: bgzf_fdopen
BGZF*
bgzf_fdopen(int fd, const char * __restrict mode)
{
	if (fd == -1) return 0;
    if (mode[0] == 'r' || mode[0] == 'R') {
        return open_read(fd);
    } else if (mode[0] == 'w' || mode[0] == 'W') {
		int i, compress_level = -1;
		for (i = 0; mode[i]; ++i)
			if (mode[i] >= '0' && mode[i] <= '9') break;
		if (mode[i]) compress_level = (int)mode[i] - '0';
		if (strchr(mode, 'u')) compress_level = 0;
        return open_write(fd, compress_level);
    } else {
        return NULL;
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x4f6eb2
movq $0x0, 0x20(%rsp)
jmp 0x4f6fb3
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
je 0x4f6ecc
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
jne 0x4f6edf
movl 0x1c(%rsp), %edi
callq 0x4f6ce0
movq %rax, 0x20(%rsp)
jmp 0x4f6fb3
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x77, %eax
je 0x4f6efd
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x57, %eax
jne 0x4f6faa
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4f6f54
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x4f6f45
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x4f6f45
jmp 0x4f6f54
jmp 0x4f6f47
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4f6f0d
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4f6f79
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x75, %esi
callq 0x19240
cmpq $0x0, %rax
je 0x4f6f96
movl $0x0, 0x8(%rsp)
movl 0x1c(%rsp), %edi
movl 0x8(%rsp), %esi
callq 0x4f6d50
movq %rax, 0x20(%rsp)
jmp 0x4f6fb3
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: load_block_from_cache
static int load_block_from_cache(BGZF *fp, int64_t block_address)
{
	khint_t k;
	cache_t *p;
	khash_t(cache) *h = (khash_t(cache)*)fp->cache;
	k = kh_get(cache, h, block_address);
	if (k == kh_end(h)) return 0;
	p = &kh_val(h, k);
	if (fp->block_length != 0) fp->block_offset = 0;
	fp->block_address = block_address;
	fp->block_length = p->size;
	memcpy(fp->uncompressed_block, p->block, MAX_BLOCK_SIZE);
#ifdef _USE_KNETFILE
	knet_seek(fp->x.fpr, p->end_offset, SEEK_SET);
#else
	fseeko(fp->file, p->end_offset, SEEK_SET);
#endif
	return p->size;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4f8230
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x4f7249
movl $0x0, 0x34(%rsp)
jmp 0x4f72d6
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x38(%rax)
je 0x4f7279
movq 0x28(%rsp), %rax
movl $0x0, 0x3c(%rax)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x38(%rax)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x19610
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0x19c10
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: check_header
static
int
check_header(const bgzf_byte_t* header)
{
    return (header[0] == GZIP_ID1 &&
            header[1] == (bgzf_byte_t) GZIP_ID2 &&
            header[2] == Z_DEFLATED &&
            (header[3] & FLG_FEXTRA) != 0 &&
            unpackInt16((uint8_t*)&header[10]) == BGZF_XLEN &&
            header[12] == BGZF_ID1 &&
            header[13] == BGZF_ID2 &&
            unpackInt16((uint8_t*)&header[14]) == BGZF_LEN);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x1f, %ecx
movb %al, 0xf(%rsp)
jne 0x4f73be
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $-0x75, %ecx
movb %al, 0xf(%rsp)
jne 0x4f73be
movq 0x10(%rsp), %rax
movsbl 0x2(%rax), %ecx
xorl %eax, %eax
cmpl $0x8, %ecx
movb %al, 0xf(%rsp)
jne 0x4f73be
movq 0x10(%rsp), %rax
movsbl 0x3(%rax), %ecx
andl $0x4, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x4f73be
movq 0x10(%rsp), %rdi
addq $0xa, %rdi
callq 0x4f73d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x6, %ecx
movb %al, 0xf(%rsp)
jne 0x4f73be
movq 0x10(%rsp), %rax
movsbl 0xc(%rax), %ecx
xorl %eax, %eax
cmpl $0x42, %ecx
movb %al, 0xf(%rsp)
jne 0x4f73be
movq 0x10(%rsp), %rax
movsbl 0xd(%rax), %ecx
xorl %eax, %eax
cmpl $0x43, %ecx
movb %al, 0xf(%rsp)
jne 0x4f73be
movq 0x10(%rsp), %rdi
addq $0xe, %rdi
callq 0x4f73d0
cmpl $0x2, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: inflate_block
static
int
inflate_block(BGZF* fp, int block_length)
{
    // Inflate the block in fp->compressed_block into fp->uncompressed_block

    z_stream zs;
	int status;
    zs.zalloc = NULL;
    zs.zfree = NULL;
    zs.next_in = fp->compressed_block + 18;
    zs.avail_in = block_length - 16;
    zs.next_out = fp->uncompressed_block;
    zs.avail_out = fp->uncompressed_block_size;

    status = inflateInit2(&zs, GZIP_WINDOW_BITS);
    if (status != Z_OK) {
        report_error(fp, "inflate init failed");
        return -1;
    }
    status = inflate(&zs, Z_FINISH);
    if (status != Z_STREAM_END) {
        inflateEnd(&zs);
        report_error(fp, "inflate failed");
        return -1;
    }
    status = inflateEnd(&zs);
    if (status != Z_OK) {
        report_error(fp, "inflate failed");
        return -1;
    }
    return zs.total_out;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
addq $0x12, %rax
movq %rax, 0x10(%rsp)
movl 0x84(%rsp), %eax
subl $0x10, %eax
movl %eax, 0x18(%rsp)
movq 0x88(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x88(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x30(%rsp)
leaq 0x10(%rsp), %rdi
movl $0xfffffff1, %esi       # imm = 0xFFFFFFF1
leaq 0xab9a0(%rip), %rdx     # 0x5a2e0c
movl $0x70, %ecx
callq 0x3b9ca0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x4f74a5
movq 0x88(%rsp), %rdi
leaq 0xc58db(%rip), %rsi     # 0x5bcd6b
callq 0x4f72e0
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f752c
leaq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x3b9f40
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
je 0x4f74ea
leaq 0x10(%rsp), %rdi
callq 0x3bd8c0
movq 0x88(%rsp), %rdi
leaq 0xc58a7(%rip), %rsi     # 0x5bcd7f
callq 0x4f72e0
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f752c
leaq 0x10(%rsp), %rdi
callq 0x3bd8c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x4f7520
movq 0x88(%rsp), %rdi
leaq 0xc5871(%rip), %rsi     # 0x5bcd7f
callq 0x4f72e0
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f752c
movq 0x38(%rsp), %rax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: cache_block
static void cache_block(BGZF *fp, int size)
{
	int ret;
	khint_t k;
	cache_t *p;
	khash_t(cache) *h = (khash_t(cache)*)fp->cache;
	if (MAX_BLOCK_SIZE >= fp->cache_size) return;
	if ((kh_size(h) + 1) * MAX_BLOCK_SIZE > fp->cache_size) {
		/* A better way would be to remove the oldest block in the
		 * cache, but here we remove a random one for simplicity. This
		 * should not have a big impact on performance. */
		for (k = kh_begin(h); k < kh_end(h); ++k)
			if (kh_exist(h, k)) break;
		if (k < kh_end(h)) {
			free(kh_val(h, k).block);
			kh_del(cache, h, k);
		}
	}
	k = kh_put(cache, h, fp->block_address, &ret);
	if (ret == 0) return; // if this happens, a bug!
	p = &kh_val(h, k);
	p->size = fp->block_length;
	p->end_offset = fp->block_address + size;
	p->block = malloc(MAX_BLOCK_SIZE);
	memcpy(kh_val(h, k).block, fp->uncompressed_block, MAX_BLOCK_SIZE);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movl $0x10000, %eax          # imm = 0x10000
cmpl 0x40(%rcx), %eax
jl 0x4f756e
jmp 0x4f76b4
movq (%rsp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
shll $0x10, %eax
movq 0x20(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jbe 0x4f760c
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq (%rsp), %rcx
cmpl (%rcx), %eax
jae 0x4f75d5
movq (%rsp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rsp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl 0x14(%rsp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x4f75c6
jmp 0x4f75d5
jmp 0x4f75c8
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f7591
movl 0x14(%rsp), %eax
movq (%rsp), %rcx
cmpl (%rcx), %eax
jae 0x4f760a
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl 0x14(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x19ef0
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4f83d0
jmp 0x4f760c
movq (%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rsi
leaq 0x18(%rsp), %rdx
callq 0x4f8450
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x4f7633
jmp 0x4f76b4
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl 0x14(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x38(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rcx
movslq 0x1c(%rsp), %rax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x19ef8
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl 0x14(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x19610
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_flush
int bgzf_flush(BGZF* fp)
{
    while (fp->block_offset > 0) {
        int count, block_length;
		block_length = deflate_block(fp, fp->block_offset);
        if (block_length < 0) return -1;
#ifdef _USE_KNETFILE
        count = fwrite(fp->compressed_block, 1, block_length, fp->x.fpw);
#else
        count = fwrite(fp->compressed_block, 1, block_length, fp->file);
#endif
        if (count != block_length) {
            report_error(fp, "write failed");
            return -1;
        }
        fp->block_address += block_length;
    }
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x3c(%rax)
jle 0x4f792b
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %esi
callq 0x4f7940
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jge 0x4f78cd
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f7933
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
movslq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %esi
callq 0x19ea0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
je 0x4f7915
movq 0x8(%rsp), %rdi
leaq 0xc53f4(%rip), %rsi     # 0x5bccfa
callq 0x4f72e0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f7933
movslq (%rsp), %rcx
movq 0x8(%rsp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
jmp 0x4f7899
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/samtools-0.1.18/bgzf.c
// Function: bgzf_write
int bgzf_write(BGZF* fp, const void* data, int length)
{
	const bgzf_byte_t *input = data;
	int block_length, bytes_written;
    if (fp->open_mode != 'w') {
        report_error(fp, "file not open for writing");
        return -1;
    }

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

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x77, %eax
je 0x4f7e18
movq 0x38(%rsp), %rdi
leaq 0xc4f01(%rip), %rsi     # 0x5bcd07
callq 0x4f72e0
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f7f12
movq 0x38(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x4f7e3e
movq 0x38(%rsp), %rax
movslq 0x18(%rax), %rdi
callq 0x19ef8
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x4f7f0a
movl 0x1c(%rsp), %edi
movq 0x38(%rsp), %rax
subl 0x3c(%rax), %edi
movl 0x2c(%rsp), %esi
subl 0x18(%rsp), %esi
callq 0x4f7860
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x3c(%rax), %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x19610
movl 0x14(%rsp), %ecx
movq 0x38(%rsp), %rax
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movl 0x3c(%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0x4f7f05
movq 0x38(%rsp), %rdi
callq 0x4f7890
cmpl $0x0, %eax
je 0x4f7f03
jmp 0x4f7f0a
jmp 0x4f7f05
jmp 0x4f7e5c
movl 0x18(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: free_cache
static void free_cache(BGZF *fp)
{
	khint_t k;
	khash_t(cache) *h = (khash_t(cache)*)fp->cache;
	if (fp->open_mode != 'r') return;
	for (k = kh_begin(h); k < kh_end(h); ++k)
		if (kh_exist(h, k)) free(kh_val(h, k).block);
	kh_destroy(cache, h);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x72, %eax
je 0x4f7f46
jmp 0x4f7fb5
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq (%rsp), %rcx
cmpl (%rcx), %eax
jae 0x4f7fac
movq (%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl 0xc(%rsp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x4f7f9d
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x19ef0
jmp 0x4f7f9f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4f7f4e
movq (%rsp), %rdi
callq 0x4f8d70
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/bgzf.c
// Function: bgzf_check_EOF
int bgzf_check_EOF(BGZF *fp)
{
	static uint8_t magic[28] = "\037\213\010\4\0\0\0\0\0\377\6\0\102\103\2\0\033\0\3\0\0\0\0\0\0\0\0\0";
	uint8_t buf[28];
	off_t offset;
#ifdef _USE_KNETFILE
	offset = knet_tell(fp->x.fpr);
	if (knet_seek(fp->x.fpr, -28, SEEK_END) != 0) return -1;
	knet_read(fp->x.fpr, buf, 28);
	knet_seek(fp->x.fpr, offset, SEEK_SET);
#else
	offset = ftello(fp->file);
	if (fseeko(fp->file, -28, SEEK_END) != 0) return -1;
	fread(buf, 1, 28, fp->file);
	fseeko(fp->file, offset, SEEK_SET);
#endif
	return (memcmp(magic, buf, 28) == 0)? 1 : 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x19af0
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
movq $-0x1c, %rsi
movl $0x2, %edx
callq 0x19c10
cmpl $0x0, %eax
je 0x4f8025
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f8080
leaq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %esi
movl $0x1c, %edx
callq 0x19a70
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x19c10
leaq 0x10(%rsp), %rsi
leaq 0x149dfd(%rip), %rdi    # 0x641e60
movl $0x1c, %edx
callq 0x192c0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %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/samtools-0.1.18/bgzf.c
// Function: bgzf_read_init
static BGZF *bgzf_read_init()
{
	BGZF *fp;
	fp = calloc(1, sizeof(BGZF));
    fp->uncompressed_block_size = MAX_BLOCK_SIZE;
    fp->uncompressed_block = malloc(MAX_BLOCK_SIZE);
    fp->compressed_block_size = MAX_BLOCK_SIZE;
    fp->compressed_block = malloc(MAX_BLOCK_SIZE);
	fp->cache_size = 0;
	fp->cache = kh_init(cache);
	return fp;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x58, %esi
callq 0x194a0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x10000, 0x18(%rax)    # imm = 0x10000
movl $0x10000, %edi          # imm = 0x10000
callq 0x19ef8
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movl $0x10000, 0x1c(%rax)    # imm = 0x10000
movl $0x10000, %edi          # imm = 0x10000
callq 0x19ef8
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movl $0x0, 0x40(%rax)
callq 0x4f8210
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_write
int razf_write(RAZF* rz, const void *data, int size){
	int ori_size, n;
	int64_t next_block;
	ori_size = size;
	next_block = ((rz->in / RZ_BLOCK_SIZE) + 1) * RZ_BLOCK_SIZE;
	while(rz->in + rz->buf_len + size >= next_block){
		n = next_block - rz->in - rz->buf_len;
		_razf_buffered_write(rz, data, n);
		data += n;
		size -= n;
		razf_flush(rz);
		add_zindex(rz, rz->in, rz->out);
		next_block = ((rz->in / RZ_BLOCK_SIZE) + 1) * RZ_BLOCK_SIZE;
	}
	_razf_buffered_write(rz, data, size);
	return ori_size;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl $0x8000, %ecx           # imm = 0x8000
cqto
idivq %rcx
addq $0x1, %rax
shlq $0xf, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x84(%rcx), %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
addq %rcx, %rax
cmpq (%rsp), %rax
jl 0x4fb5c2
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
subq 0x20(%rcx), %rax
movq 0x20(%rsp), %rcx
movslq 0x84(%rcx), %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x4fb5e0
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0xc(%rsp), %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4fb750
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdx
callq 0x4fb8e0
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl $0x8000, %ecx           # imm = 0x8000
cqto
idivq %rcx
addq $0x1, %rax
shlq $0xf, %rax
movq %rax, (%rsp)
jmp 0x4fb4f9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x4fb5e0
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_buffered_write
static void _razf_buffered_write(RAZF *rz, const void *data, int size){
	int i, n;
	while(1){
		if(rz->buf_len == RZ_BUFFER_SIZE){
			_razf_write(rz, rz->inbuf, rz->buf_len);
			rz->buf_len = 0;
		}
		if(size + rz->buf_len < RZ_BUFFER_SIZE){
			for(i=0;i<size;i++) ((char*)rz->inbuf + rz->buf_len)[i] = ((char*)data)[i];
			rz->buf_len += size;
			return;
		} else {
			n = RZ_BUFFER_SIZE - rz->buf_len;
			for(i=0;i<n;i++) ((char*)rz->inbuf + rz->buf_len)[i] = ((char*)data)[i];
			size -= n;
			data += n;
			rz->buf_len += n;
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1000, 0x84(%rax)     # imm = 0x1000
jne 0x4fb630
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x20(%rsp), %rax
movl 0x84(%rax), %edx
callq 0x4fd6c0
movq 0x20(%rsp), %rax
movl $0x0, 0x84(%rax)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
addl 0x84(%rcx), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x4fb6ac
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x4fb692
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x84(%rcx), %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4fb64e
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
addl 0x84(%rax), %ecx
movl %ecx, 0x84(%rax)
addq $0x28, %rsp
retq
movq 0x20(%rsp), %rcx
movl $0x1000, %eax           # imm = 0x1000
subl 0x84(%rcx), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x4fb70c
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x84(%rcx), %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4fb6c8
movl 0xc(%rsp), %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
addl 0x84(%rax), %ecx
movl %ecx, 0x84(%rax)
jmp 0x4fb5f2
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_flush
static void razf_flush(RAZF *rz){
	uint32_t tout;
	if(rz->buf_len){
		_razf_write(rz, rz->inbuf, rz->buf_len);
		rz->buf_off = rz->buf_len = 0;
	}
	if(rz->stream->avail_out){
#ifdef _USE_KNETFILE    
		write(rz->x.fpw, rz->outbuf, RZ_BUFFER_SIZE - rz->stream->avail_out);
#else        
		write(rz->filedes, rz->outbuf, RZ_BUFFER_SIZE - rz->stream->avail_out);
#endif
		rz->stream->avail_out = RZ_BUFFER_SIZE;
		rz->stream->next_out  = rz->outbuf;
	}
	while(1){
		tout = rz->stream->avail_out;
		deflate(rz->stream, Z_FULL_FLUSH);
		rz->out += tout - rz->stream->avail_out;
		if(rz->stream->avail_out == 0){
#ifdef _USE_KNETFILE    
			write(rz->x.fpw, rz->outbuf, RZ_BUFFER_SIZE - rz->stream->avail_out);
#else            
			write(rz->filedes, rz->outbuf, RZ_BUFFER_SIZE - rz->stream->avail_out);
#endif
			rz->stream->avail_out = RZ_BUFFER_SIZE;
			rz->stream->next_out  = rz->outbuf;
		} else break;
	}
	rz->block_pos = rz->out;
	rz->block_off = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x84(%rax)
je 0x4fb7a3
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x84(%rax), %edx
callq 0x4fd6c0
movq 0x10(%rsp), %rax
movl $0x0, 0x84(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x80(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x20(%rax)
je 0x4fb803
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edi
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1000, %eax           # imm = 0x1000
subl 0x20(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x19230
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl $0x1000, 0x20(%rax)     # imm = 0x1000
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x4fb805
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0x3, %esi
callq 0x3b13f0
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
subl 0x20(%rcx), %eax
movl %eax, %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0x4fb8ab
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edi
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1000, %eax           # imm = 0x1000
subl 0x20(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x19230
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl $0x1000, 0x20(%rax)     # imm = 0x1000
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x4fb8ad
jmp 0x4fb8b2
jmp 0x4fb805
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x50(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: add_zindex
static void add_zindex(RAZF *rz, int64_t in, int64_t out){
	if(rz->index->size == rz->index->cap){
		rz->index->cap = rz->index->cap * 1.5 + 2;
		rz->index->cell_offsets = realloc(rz->index->cell_offsets, sizeof(int) * rz->index->cap);
		rz->index->bin_offsets  = realloc(rz->index->bin_offsets, sizeof(int64_t) * (rz->index->cap/RZ_BIN_SIZE + 1));
	}
	if(rz->index->size % RZ_BIN_SIZE == 0) rz->index->bin_offsets[rz->index->size / RZ_BIN_SIZE] = out;
	rz->index->cell_offsets[rz->index->size] = out - rz->index->bin_offsets[rz->index->size / RZ_BIN_SIZE];
	rz->index->size ++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %eax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x14(%rcx), %eax
jne 0x4fb9b2
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cvtsi2sdl 0x14(%rax), %xmm0
movsd 0xc159a(%rip), %xmm1    # 0x5bcec0
mulsd %xmm1, %xmm0
movsd 0x1d42e(%rip), %xmm1    # 0x518d60
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x14(%rax), %rsi
shlq $0x2, %rsi
callq 0x19f00
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x14(%rax), %rsi
shrq $0x11, %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x19f00
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x10(%rax), %rax
andq $0x1ffff, %rax          # imm = 0x1FFFF
cmpq $0x0, %rax
jne 0x4fb9f1
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x10(%rcx), %rcx
shrq $0x11, %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rsp), %rdx
movq 0x18(%rdx), %rdx
movslq 0x10(%rdx), %rdx
shrq $0x11, %rdx
subq (%rcx,%rdx,8), %rax
movl %eax, %edx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x10(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/samtools-0.1.18/razf.c
// Function: razf_open
static inline RAZF* _razf_open(const char *filename, const char *mode, int _load_index){
	int fd;
	RAZF *rz;
	if(strstr(mode, "r")){
#ifdef _USE_KNETFILE
        knetFile *fd = knet_open(filename, "r");
        if (fd == 0) {
            fprintf(stderr, "[_razf_open] fail to open %s\n", filename);
            return NULL;
        }
#else
#ifdef _WIN32
		fd = open(filename, O_RDONLY | O_BINARY);
#else
		fd = open(filename, O_RDONLY);
#endif
#endif
		if(fd < 0) return NULL;
		rz = razf_open_r(fd, _load_index);
	} else if(strstr(mode, "w")){
#ifdef _WIN32
		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
#else
		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
#endif
		if(fd < 0) return NULL;
		rz = razf_open_w(fd);
	} else return NULL;
	return rz;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x2fd1c(%rip), %rsi     # 0x52bfda
callq 0x19130
cmpq $0x0, %rax
je 0x4fc300
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x19c80
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x4fc2ed
movq $0x0, 0x20(%rsp)
jmp 0x4fc368
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x4fbac0
movq %rax, (%rsp)
jmp 0x4fc35f
movq 0x10(%rsp), %rdi
leaq 0x69bb9(%rip), %rsi     # 0x565ec5
callq 0x19130
cmpq $0x0, %rax
je 0x4fc352
movq 0x18(%rsp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x19c80
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x4fc343
movq $0x0, 0x20(%rsp)
jmp 0x4fc368
movl 0x8(%rsp), %edi
callq 0x4fbfd0
movq %rax, (%rsp)
jmp 0x4fc35d
movq $0x0, 0x20(%rsp)
jmp 0x4fc368
jmp 0x4fc35f
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/samtools-0.1.18/razf.c
// Function: razf_get_data_size
int razf_get_data_size(RAZF *rz, int64_t *u_size, int64_t *c_size){
	int64_t n;
	if(rz->mode != 'r' && rz->mode != 'R') return 0;
	switch(rz->file_type){
		case FILE_TYPE_PLAIN:
			if(rz->end == 0x7fffffffffffffffLL){
#ifdef _USE_KNETFILE
				if(knet_seek(rz->x.fpr, 0, SEEK_CUR) == -1) return 0;
                n = knet_tell(rz->x.fpr);
				knet_seek(rz->x.fpr, 0, SEEK_END);
                rz->end = knet_tell(rz->x.fpr);
				knet_seek(rz->x.fpr, n, SEEK_SET);
#else
				if((n = lseek(rz->filedes, 0, SEEK_CUR)) == -1) return 0;
				rz->end = lseek(rz->filedes, 0, SEEK_END);
				lseek(rz->filedes, n, SEEK_SET);
#endif                
			}
			*u_size = *c_size = rz->end;
			return 1;
		case FILE_TYPE_GZ:
			return 0;
		case FILE_TYPE_RZ:
			if(rz->src_end == rz->end) return 0;
			*u_size = rz->src_end;
			*c_size = rz->end;
			return 1;
		default:
			return 0;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
je 0x4fc3ea
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0x4fc3ea
movl $0x0, 0x34(%rsp)
jmp 0x4fc516
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x4fc4c4
jmp 0x4fc401
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x4fc41e
jmp 0x4fc40c
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x4fc4ba
jmp 0x4fc50e
movq 0x28(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x30(%rax)
jne 0x4fc497
movq 0x28(%rsp), %rax
movl 0x8(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x19660
movq %rax, 0x10(%rsp)
cmpq $-0x1, %rax
jne 0x4fc461
movl $0x0, 0x34(%rsp)
jmp 0x4fc516
movq 0x28(%rsp), %rax
movl 0x8(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x19660
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %edi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x19660
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0x34(%rsp)
jmp 0x4fc516
movl $0x0, 0x34(%rsp)
jmp 0x4fc516
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x4fc4e2
movl $0x0, 0x34(%rsp)
jmp 0x4fc516
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0x34(%rsp)
jmp 0x4fc516
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop