LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_import.c
// Function: _bam_get_lines
char **__bam_get_lines(const char *fn, int *_n) // for bam_plcmd.c only
{
	char **list = 0, *s;
	int n = 0, dret, m = 0;
	gzFile fp = (strcmp(fn, "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(fn, "r");
	kstream_t *ks;
	kstring_t *str;
	str = (kstring_t*)calloc(1, sizeof(kstring_t));
	ks = ks_init(fp);
	while (ks_getuntil(ks, '\n', str, &dret) > 0) {
		if (n == m) {
			m = m? m << 1 : 16;
			list = (char**)realloc(list, m * sizeof(char*));
		}
		if (str->s[str->l-1] == '\r')
			str->s[--str->l] = '\0';
		s = list[n++] = (char*)calloc(str->l + 1, 1);
		strcpy(s, str->s);
	}
	ks_destroy(ks);
	gzclose(fp);
	free(str->s); free(str);
	*_n = n;
	return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
cmpb $0x2d, (%rdi)
jne 0x13580
cmpb $0x0, 0x1(%rdi)
je 0x136dd
leaq 0x13b40(%rip), %rsi     # 0x270c7
callq 0x3380
movq %rax, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x3530
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x3530
movq %rax, %r12
movq %rbx, 0x10(%rsp)
movq %rbx, 0x18(%rax)
movl $0x2000, %edi           # imm = 0x2000
callq 0x31d0
movq %rax, (%r12)
leaq 0x4(%rsp), %rcx
movq %r12, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0x136ff
testl %eax, %eax
jle 0x13697
movq %r14, 0x8(%rsp)
xorl %ebx, %ebx
leaq 0x4(%rsp), %rbp
xorl %r13d, %r13d
xorl %r14d, %r14d
movq %r13, %rdx
movl %r14d, %eax
cmpq %rax, %rbx
jne 0x13634
movq %r12, %r13
movq %rbp, %r12
leal (%r14,%r14), %ebp
testl %r14d, %r14d
movl $0x10, %eax
cmovel %eax, %ebp
movslq %ebp, %rsi
shlq $0x3, %rsi
movq %rdx, %rdi
callq 0x3610
movq %rax, %rdx
movl %ebp, %r14d
movq %r12, %rbp
movq %r13, %r12
movq (%r15), %rdi
movq 0x10(%r15), %rax
cmpb $0xd, -0x1(%rax,%rdi)
jne 0x13651
leaq -0x1(%rdi), %rcx
movq %rcx, (%r15)
movb $0x0, -0x1(%rax,%rdi)
movq %rcx, %rdi
movq %rdx, %r13
incq %rdi
movl $0x1, %esi
callq 0x3530
movq %rax, (%r13,%rbx,8)
incq %rbx
movq 0x10(%r15), %rsi
movq %rax, %rdi
callq 0x3510
movq %r12, %rdi
movl $0xa, %esi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x136ff
testl %eax, %eax
jg 0x135f9
movq 0x8(%rsp), %r14
jmp 0x1369c
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r12), %rdi
callq 0x32c0
movq %r12, %rdi
callq 0x32c0
movq 0x10(%rsp), %rdi
callq 0x3150
movq 0x10(%r15), %rdi
callq 0x32c0
movq %r15, %rdi
callq 0x32c0
movl %ebx, (%r14)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1a8ec(%rip), %rax     # 0x2dfd0
movq (%rax), %rdi
callq 0x3030
leaq 0x139d4(%rip), %rsi     # 0x270c7
movl %eax, %edi
callq 0x3330
jmp 0x1358c
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_import.c
// Function: sam_header_parse
int sam_header_parse(bam_header_t *h)
{
	char **tmp;
	int i;
	free(h->target_len); free(h->target_name);
	h->n_targets = 0; h->target_len = 0; h->target_name = 0;
	if (h->l_text < 3) return 0;
	if (h->dict == 0) h->dict = sam_header_parse2(h->text);
	tmp = sam_header2list(h->dict, "SQ", "SN", &h->n_targets);
	if (h->n_targets == 0) return 0;
	h->target_name = calloc(h->n_targets, sizeof(void*));
	for (i = 0; i < h->n_targets; ++i)
		h->target_name[i] = strdup(tmp[i]);
	free(tmp);
	tmp = sam_header2list(h->dict, "SQ", "LN", &h->n_targets);
	h->target_len = calloc(h->n_targets, 4);
	for (i = 0; i < h->n_targets; ++i)
		h->target_len[i] = atoi(tmp[i]);
	free(tmp);
	return h->n_targets;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x32c0
movq 0x8(%rbx), %rdi
callq 0x32c0
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %ebp, %ebp
cmpl $0x3, 0x30(%rbx)
jl 0x13abf
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x13a01
movq 0x38(%rbx), %rdi
callq 0x1f7ab
movq %rax, %rdi
movq %rax, 0x18(%rbx)
leaq 0x11c42(%rip), %rsi     # 0x2564a
leaq 0x11c3e(%rip), %rdx     # 0x2564d
movq %rbx, %rcx
callq 0x20353
movslq (%rbx), %r15
testq %r15, %r15
je 0x13abf
movq %rax, %r14
leaq 0x8(%rbx), %r12
movl $0x8, %esi
movq %r15, %rdi
callq 0x3530
movq %rax, (%r12)
testl %r15d, %r15d
jle 0x13a5c
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdi
callq 0x34b0
movq (%r12), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0x13a43
movq %r14, %rdi
callq 0x32c0
movq 0x18(%rbx), %rdi
leaq 0x11bdb(%rip), %rsi     # 0x2564a
leaq 0x11bda(%rip), %rdx     # 0x25650
movq %rbx, %rcx
callq 0x20353
movq %rax, %r14
movslq (%rbx), %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x3530
movq %rax, 0x10(%rbx)
testq %r15, %r15
jle 0x13ab5
movq %rax, %r12
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdi
callq 0x3410
movl %eax, (%r12,%r13,4)
incq %r13
cmpq %r13, %r15
jne 0x13aa0
movq %r14, %rdi
callq 0x32c0
movl (%rbx), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_import.c
// Function: alloc_data
static inline uint8_t *alloc_data(bam1_t *b, int size)
{
	if (b->m_data < size) {
		b->m_data = size;
		kroundup32(b->m_data);
		b->data = (uint8_t*)realloc(b->data, b->m_data);
	}
	return b->data;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x28(%rdi)
jge 0x14b1b
decl %esi
movl %esi, %eax
sarl %eax
orl %esi, %eax
movl %eax, %ecx
sarl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x10, %eax
orl %ecx, %eax
incl %eax
movl %eax, 0x28(%rbx)
movq 0x30(%rbx), %rdi
movslq %eax, %rsi
callq 0x3610
movq %rax, 0x30(%rbx)
jmp 0x14b1f
movq 0x30(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_import.c
// Function: sam_open
tamFile sam_open(const char *fn)
{
	tamFile fp;
	gzFile gzfp = (strcmp(fn, "-") == 0)? gzdopen(fileno(stdin), "rb") : gzopen(fn, "rb");
	if (gzfp == 0) return 0;
	fp = (tamFile)calloc(1, sizeof(struct __tamFile_t));
	fp->str = (kstring_t*)calloc(1, sizeof(kstring_t));
	fp->fp = gzfp;
	fp->ks = ks_init(fp->fp);
	return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x2d, (%rdi)
jne 0x14b55
cmpb $0x0, 0x1(%rdi)
je 0x14bc6
leaq 0xf08b(%rip), %rsi      # 0x23be7
callq 0x3380
movq %rax, %rbx
testq %rax, %rax
je 0x14bba
movl $0x1, %edi
movl $0x28, %esi
callq 0x3530
movq %rax, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x3530
movq %rax, 0x10(%r14)
movq %rbx, (%r14)
movl $0x1, %edi
movl $0x20, %esi
callq 0x3530
movq %rax, %r15
movq %rbx, 0x18(%rax)
movl $0x2000, %edi           # imm = 0x2000
callq 0x31d0
movq %rax, (%r15)
movq %r15, 0x8(%r14)
jmp 0x14bbd
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x19403(%rip), %rax     # 0x2dfd0
movq (%rax), %rdi
callq 0x3030
leaq 0xf00b(%rip), %rsi      # 0x23be7
movl %eax, %edi
callq 0x3330
jmp 0x14b61
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_import.c
// Function: sam_close
void sam_close(tamFile fp)
{
	if (fp) {
		ks_destroy(fp->ks);
		gzclose(fp->fp);
		free(fp->str->s); free(fp->str);
		free(fp);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x14c3a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x14c0d
movq (%r14), %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x32c0
movq (%rbx), %rdi
callq 0x3150
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x32c0
movq 0x10(%rbx), %rdi
callq 0x32c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32c0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/sam.c
// Function: bam_header_dup
bam_header_t *bam_header_dup(const bam_header_t *h0)
{
	bam_header_t *h;
	int i;
	h = bam_header_init();
	*h = *h0;
	h->hash = h->dict = h->rg2lib = 0;
	h->text = (char*)calloc(h->l_text + 1, 1);
	memcpy(h->text, h0->text, h->l_text);
	h->target_len = (uint32_t*)calloc(h->n_targets, 4);
	h->target_name = (char**)calloc(h->n_targets, sizeof(void*));
	for (i = 0; i < h->n_targets; ++i) {
		h->target_len[i] = h0->target_len[i];
		h->target_name[i] = strdup(h0->target_name[i]);
	}
	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x122e6
movq %rax, %r14
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm3, 0x30(%rax)
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movslq 0x30(%rax), %r15
leaq 0x1(%r15), %rdi
movl $0x1, %esi
callq 0x3530
movq %rax, 0x38(%r14)
movq 0x38(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x3680
movslq (%r14), %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x3530
movq %rax, 0x10(%r14)
movl $0x8, %esi
movq %r15, %rdi
callq 0x3530
movq %rax, 0x8(%r14)
testq %r15, %r15
jle 0x14cfd
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movl (%rax,%r15,4), %eax
movq 0x10(%r14), %rcx
movl %eax, (%rcx,%r15,4)
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x34b0
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x14ccd
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/sam.c
// Function: samclose
void samclose(samfile_t *fp)
{
	if (fp == 0) return;
	if (fp->header) bam_header_destroy(fp->header);
	if (fp->type & TYPE_BAM) bam_close(fp->x.bam);
	else if (fp->type & TYPE_READ) sam_close(fp->x.tamr);
	else fclose(fp->x.tamw);
	free(fp);
}

// Assembly:
testq %rdi, %rdi
je 0x15108
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x150f3
callq 0x122ff
movl (%rbx), %eax
testb $0x1, %al
jne 0x15109
movq 0x8(%rbx), %rdi
testb $0x2, %al
jne 0x15114
callq 0x3560
jmp 0x15119
retq
movq 0x8(%rbx), %rdi
callq 0x10d25
jmp 0x15119
callq 0x14be8
movq %rbx, %rdi
popq %rbx
jmp 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/sam.c
// Function: samwrite
int samwrite(samfile_t *fp, const bam1_t *b)
{
	if (fp == 0 || (fp->type & TYPE_READ)) return -1; // not open for writing
	if (fp->type & TYPE_BAM) return bam_write1(fp->x.bam, b);
	else {
		char *s = bam_format1_core(fp->header, b, fp->type>>2&3);
		int l = strlen(s);
		fputs(s, fp->x.tamw); fputc('\n', fp->x.tamw);
		free(s);
		return l + 1;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x151b8
movq %rdi, %rbx
movl (%rdi), %edx
testb $0x2, %dl
jne 0x151b8
testb $0x1, %dl
jne 0x151c1
movq 0x10(%rbx), %rdi
shrl $0x2, %edx
andl $0x3, %edx
callq 0x12aa6
movq %rax, %r15
movq %rax, %rdi
callq 0x32d0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x33f0
movq 0x8(%rbx), %rsi
movl $0xa, %edi
callq 0x3290
movq %r15, %rdi
callq 0x32c0
incl %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12a9a
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/sam.c
// Function: sampileup
int sampileup(samfile_t *fp, int mask, bam_pileup_f func, void *func_data)
{
	bam_plbuf_t *buf;
	int ret;
	bam1_t *b;
	b = bam_init1();
	buf = bam_plbuf_init(func, func_data);
	bam_plbuf_set_mask(buf, mask);
	while ((ret = samread(fp, b)) >= 0)
		bam_plbuf_push(b, buf);
	bam_plbuf_push(0, buf);
	bam_plbuf_destroy(buf);
	bam_destroy1(b);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x3530
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x17783
movq %rax, %r15
movq %rax, %rdi
movl %ebp, %esi
callq 0x17770
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15122
testl %eax, %eax
js 0x15228
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17942
jmp 0x1520c
xorl %edi, %edi
movq %r15, %rsi
callq 0x17942
movq %r15, %rdi
callq 0x17806
testq %rbx, %rbx
je 0x15250
movq 0x30(%rbx), %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x32c0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/sam.c
// Function: samfaipath
char *samfaipath(const char *fn_ref)
{
	char *fn_list = 0;
	if (fn_ref == 0) return 0;
	fn_list = calloc(strlen(fn_ref) + 5, 1);
	strcat(strcpy(fn_list, fn_ref), ".fai");
	if (access(fn_list, R_OK) == -1) { // fn_list is unreadable
		if (access(fn_ref, R_OK) == -1) {
			fprintf(stderr, "[samfaipath] fail to read file %s.\n", fn_ref);
		} else {
			fprintf(stderr, "[samfaipath] build FASTA index...\n");
			if (fai_build(fn_ref) == -1) {
				fprintf(stderr, "[samfaipath] fail to build FASTA index.\n");
				free(fn_list); fn_list = 0;
			}
		}
	}
	return fn_list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x152e2
movq %rdi, %r14
callq 0x32d0
leaq 0x5(%rax), %rdi
movl $0x1, %esi
callq 0x3530
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3510
movq %rbx, %rdi
callq 0x32d0
movl $0x6961662e, (%rbx,%rax) # imm = 0x6961662E
movb $0x0, 0x4(%rbx,%rax)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x35e0
cmpl $-0x1, %eax
jne 0x152e4
movq %r14, %rdi
movl $0x4, %esi
callq 0x35e0
movq 0x18d21(%rip), %rcx     # 0x2dfe8
movq (%rcx), %rdi
cmpl $-0x1, %eax
jne 0x152f1
leaq 0x10607(%rip), %rsi     # 0x258dd
movq %r14, %rdx
xorl %eax, %eax
callq 0x3630
jmp 0x152e4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %r15
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x4670
movq (%r15), %rbx
jmp 0x152e4
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_index.c
// Function: bam_index_destroy
void bam_index_destroy(bam_index_t *idx)
{
	khint_t k;
	int i;
	if (idx == 0) return;
	for (i = 0; i < idx->n; ++i) {
		khash_t(i) *index = idx->index[i];
		bam_lidx_t *index2 = idx->index2 + i;
		for (k = kh_begin(index); k != kh_end(index); ++k) {
			if (kh_exist(index, k))
				free(kh_value(index, k).list);
		}
		kh_destroy(i, index);
		free(index2->offset);
	}
	free(idx->index); free(idx->index2);
	free(idx);
}

// Assembly:
testq %rdi, %rdi
je 0x16174
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x1614c
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %r12
movq (%rax,%r15,8), %r14
movl (%r14), %eax
testl %eax, %eax
je 0x16109
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x10(%r14), %rcx
movl %r13d, %edx
shrl $0x4, %edx
movl (%rcx,%rdx,4), %edx
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
jne 0x160fe
movq 0x20(%r14), %rax
movl %r13d, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdi
callq 0x32c0
movl (%r14), %eax
incl %r13d
addl $0x2, %ebp
cmpl %eax, %r13d
jne 0x160cd
movq 0x18(%r14), %rdi
callq 0x32c0
movq 0x10(%r14), %rdi
callq 0x32c0
movq 0x20(%r14), %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x32c0
movq %r15, %rax
shlq $0x4, %rax
movq 0x8(%r12,%rax), %rdi
callq 0x32c0
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x160b5
movq 0x8(%rbx), %rdi
callq 0x32c0
movq 0x10(%rbx), %rdi
callq 0x32c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32c0
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_index.c
// Function: bam_index_load
bam_index_t *bam_index_load(const char *fn)
{
	bam_index_t *idx;
	idx = bam_index_load_local(fn);
	if (idx == 0 && (strstr(fn, "ftp://") == fn || strstr(fn, "http://") == fn)) {
		char *fnidx = calloc(strlen(fn) + 5, 1);
		strcat(strcpy(fnidx, fn), ".bai");
		fprintf(stderr, "[bam_index_load] attempting to download the remote index file.\n");
		download_from_remote(fnidx);
		idx = bam_index_load_local(fn);
	}
	if (idx == 0) fprintf(stderr, "[bam_index_load] fail to load BAM index.\n");
	return idx;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x16488
testq %rax, %rax
je 0x168aa
addq $0x10, %rsp
popq %rbx
retq
leaq 0xf1a5(%rip), %rsi      # 0x25a56
movl $0x6, %edx
movq %rbx, %rdi
callq 0x31c0
testl %eax, %eax
je 0x168da
leaq 0xf194(%rip), %rsi      # 0x25a5d
movl $0x7, %edx
movq %rbx, %rdi
callq 0x31c0
testl %eax, %eax
jne 0x168f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4722
testb $0x1, %al
jne 0x168f2
movq 0x8(%rsp), %rax
jmp 0x168a4
callq 0x48cf
xorl %eax, %eax
jmp 0x168a4
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_index.c
// Function: bam_index_build2
int bam_index_build2(const char *fn, const char *_fnidx)
{
	char *fnidx;
	FILE *fpidx;
	bamFile fp;
	bam_index_t *idx;
	if ((fp = bam_open(fn, "r")) == 0) {
		fprintf(stderr, "[bam_index_build2] fail to open the BAM file.\n");
		return -1;
	}
	idx = bam_index_core(fp);
	bam_close(fp);
	if (_fnidx == 0) {
		fnidx = (char*)calloc(strlen(fn) + 5, 1);
		strcpy(fnidx, fn); strcat(fnidx, ".bai");
	} else fnidx = strdup(_fnidx);
	fpidx = fopen(fnidx, "w");
	if (fpidx == 0) {
		fprintf(stderr, "[bam_index_build2] fail to create the index file.\n");
		free(fnidx);
		return -1;
	}
	bam_index_save(idx, fpidx);
	bam_index_destroy(idx);
	fclose(fpidx);
	free(fnidx);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x107b7(%rip), %rsi     # 0x270c7
callq 0x10048
testq %rax, %rax
je 0x169c8
movq %rax, %r12
movq %rax, %rdi
callq 0x15b66
movq %rax, %rbx
movq %r12, %rdi
callq 0x10d25
testq %r14, %r14
je 0x16946
movq %r14, %rdi
callq 0x34b0
movq %rax, %r14
jmp 0x16980
movq %r15, %rdi
callq 0x32d0
leaq 0x5(%rax), %rdi
movl $0x1, %esi
callq 0x3530
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x3510
movq %r14, %rdi
callq 0x32d0
movl $0x6961622e, (%r14,%rax) # imm = 0x6961622E
movb $0x0, 0x4(%r14,%rax)
leaq 0xca26(%rip), %rsi      # 0x233ad
movq %r14, %rdi
callq 0x35f0
testq %rax, %rax
je 0x169cf
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16175
movq %rbx, %rdi
callq 0x16092
movq %r15, %rdi
callq 0x3560
movq %r14, %rdi
callq 0x32c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4914
jmp 0x169d7
movq %r14, %rdi
callq 0x48eb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x169bc
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_index.c
// Function: bam_index
int bam_index(int argc, char *argv[])
{
	if (argc < 2) {
		fprintf(stderr, "Usage: samtools index <in.bam> [<out.index>]\n");
		return 1;
	}
	if (argc >= 3) bam_index_build2(argv[1], argv[2]);
	else bam_index_build(argv[1]);
	return 0;
}

// Assembly:
pushq %rbx
cmpl $0x1, %edi
jle 0x16a10
movl %edi, %eax
movq 0x8(%rsi), %rdi
cmpl $0x2, %eax
jne 0x16a01
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x168fb
jmp 0x16a0c
movq 0x10(%rsi), %rsi
callq 0x168fb
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
callq 0x4930
movl $0x1, %ebx
jmp 0x16a0c
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_pileup.c
// Function: bam_plbuf_reset
void bam_plbuf_reset(bam_plbuf_t *buf)
{
	lbnode_t *p, *q;
	buf->max_tid = buf->max_pos = -1;
	buf->tid = buf->pos = 0;
	buf->is_eof = 0;
	for (p = buf->head; p->next;) {
		q = p->next;
		mp_free(buf->mp, p);
		p = q;
	}
	buf->head = buf->tail;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movaps 0xe626(%rip), %xmm0     # 0x25d00
movups %xmm0, 0x30(%rdi)
movl $0x0, 0x44(%rdi)
movq 0x8(%rdi), %r14
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1775f
movl $0x100, %ebp            # imm = 0x100
movq %rax, %r15
movq (%rbx), %r12
decl (%r12)
movq $0x0, 0x40(%r14)
movl 0x4(%r12), %ecx
cmpl 0x8(%r12), %ecx
jne 0x1773f
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
cmovel %ebp, %eax
movl %eax, 0x8(%r12)
movq 0x10(%r12), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3610
movq %rax, 0x10(%r12)
movl 0x4(%r12), %ecx
jmp 0x17744
movq 0x10(%r12), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r12)
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
movq 0x40(%r15), %rax
movq %r15, %r14
testq %rax, %rax
jne 0x176f7
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_pileup.c
// Function: bam_plbuf_init
bam_plbuf_t *bam_plbuf_init(bam_pileup_f func, void *data)
{
	bam_plbuf_t *buf;
	buf = (bam_plbuf_t*)calloc(1, sizeof(bam_plbuf_t));
	buf->func = func; buf->func_data = data;
	buf->mp = mp_init();
	buf->head = buf->tail = mp_alloc(buf->mp);
	buf->dummy = mp_alloc(buf->mp);
	buf->max_tid = buf->max_pos = -1;
	buf->flag_mask = BAM_DEF_MASK;
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x58, %esi
callq 0x3530
movq %rax, %r15
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl $0x1, %edi
movl $0x18, %esi
callq 0x3530
movq %rax, %rbx
movq %rax, (%r15)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3530
movq %rax, 0x10(%r15)
movq %rax, 0x8(%r15)
movl $0x2, (%rbx)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3530
movq %rax, 0x18(%r15)
movq $-0x1, 0x38(%r15)
movl $0x704, 0x50(%r15)      # imm = 0x704
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_pileup.c
// Function: bam_plbuf_destroy
void bam_plbuf_destroy(bam_plbuf_t *buf)
{
	mp_free(buf->mp, buf->dummy);
	mp_free(buf->mp, buf->head);
	if (buf->mp->cnt != 0)
		fprintf(stderr, "[bam_plbuf_destroy] memory leak: %d. Continue anyway.\n", buf->mp->cnt);
	mp_destroy(buf->mp);
	free(buf->pu);
	free(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x18(%rdi), %r14
decl (%r15)
movq $0x0, 0x40(%r14)
movl 0x4(%r15), %ecx
cmpl 0x8(%r15), %ecx
jne 0x17855
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x100, %ecx            # imm = 0x100
cmovnel %eax, %ecx
movl %ecx, 0x8(%r15)
movq 0x10(%r15), %rdi
movslq %ecx, %rsi
shlq $0x3, %rsi
callq 0x3610
movq %rax, 0x10(%r15)
movl 0x4(%r15), %ecx
jmp 0x17859
movq 0x10(%r15), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r15)
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
movq (%rbx), %r15
movq 0x8(%rbx), %r14
decl (%r15)
movq $0x0, 0x40(%r14)
movl 0x4(%r15), %ecx
cmpl 0x8(%r15), %ecx
jne 0x178ae
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x100, %ecx            # imm = 0x100
cmovnel %eax, %ecx
movl %ecx, 0x8(%r15)
movq 0x10(%r15), %rdi
movslq %ecx, %rsi
shlq $0x3, %rsi
callq 0x3610
movq %rax, 0x10(%r15)
movl 0x4(%r15), %ecx
jmp 0x178b2
movq 0x10(%r15), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r15)
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
movq (%rbx), %r14
movl (%r14), %edx
testl %edx, %edx
jne 0x17925
cmpl $0x0, 0x4(%r14)
jle 0x178fe
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x30(%rax), %rdi
callq 0x32c0
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x32c0
incq %r15
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jl 0x178d4
movq 0x10(%r14), %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x32c0
movq 0x48(%rbx), %rdi
callq 0x32c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x32c0
movq 0x166bc(%rip), %rax     # 0x2dfe8
movq (%rax), %rdi
leaq 0xe3ee(%rip), %rsi      # 0x25d24
xorl %eax, %eax
callq 0x3630
movq (%rbx), %r14
jmp 0x178ca
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_pileup.c
// Function: bam_pileup_file
int bam_pileup_file(bamFile fp, int mask, bam_pileup_f func, void *func_data)
{
	bam_plbuf_t *buf;
	int ret;
	bam1_t *b;
	b = bam_init1();
	buf = bam_plbuf_init(func, func_data);
	bam_plbuf_set_mask(buf, mask);
	while ((ret = bam_read1(fp, b)) >= 0)
		bam_plbuf_push(b, buf);
	bam_plbuf_push(0, buf);
	bam_plbuf_destroy(buf);
	bam_destroy1(b);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x3530
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x17783
movq %rax, %r15
movl %ebp, %eax
orl $0x4, %eax
testl %ebp, %ebp
movl $0x704, %ecx            # imm = 0x704
cmovnsl %eax, %ecx
movl %ecx, 0x50(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x126b5
testl %eax, %eax
js 0x17f11
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17942
jmp 0x17ef5
xorl %edi, %edi
movq %r15, %rsi
callq 0x17942
movq %r15, %rdi
callq 0x17806
testq %rbx, %rbx
je 0x17f39
movq 0x30(%rbx), %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x32c0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_lpileup.c
// Function: bam_lplbuf_reset
void bam_lplbuf_reset(bam_lplbuf_t *buf)
{
	freenode_t *p, *q;
	bam_plbuf_reset(buf->plbuf);
	for (p = buf->head; p->next;) {
		q = p->next;
		mp_free(buf->mp, p);
		p = q;
	}
	buf->head = buf->tail;
	buf->max_level = 0;
	buf->n_cur = buf->n_pre = 0;
	buf->n_nodes = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x176c8
movq 0x30(%rbx), %r14
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x18a0f
movl $0xfffffff, %ebp        # imm = 0xFFFFFFF
movl $0x100, %r15d           # imm = 0x100
movq %rax, %r12
movq 0x20(%rbx), %r13
decl (%r13)
movq $0x0, 0x8(%r14)
movl (%r14), %eax
andl %ebp, %eax
orl $0x20000000, %eax       # imm = 0x20000000
movl %eax, (%r14)
movl 0x4(%r13), %ecx
cmpl 0x8(%r13), %ecx
jne 0x189f0
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
cmovel %r15d, %eax
movl %eax, 0x8(%r13)
movq 0x10(%r13), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3610
movq %rax, 0x10(%r13)
movl 0x4(%r13), %ecx
jmp 0x189f4
movq 0x10(%r13), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r13)
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
movq 0x8(%r12), %rax
movq %r12, %r14
testq %rax, %rax
jne 0x1899f
movq 0x38(%rbx), %rax
movq %rax, 0x30(%rbx)
xorl %eax, %eax
movl %eax, 0xc(%rbx)
movq $0x0, 0x4(%rbx)
movl %eax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_lpileup.c
// Function: bam_lplbuf_init
bam_lplbuf_t *bam_lplbuf_init(bam_pileup_f func, void *data)
{
	bam_lplbuf_t *tv;
	tv = (bam_lplbuf_t*)calloc(1, sizeof(bam_lplbuf_t));
	tv->mp = mp_init();
	tv->head = tv->tail = mp_alloc(tv->mp);
	tv->func = func;
	tv->user_data = data;
	tv->plbuf = bam_plbuf_init(tview_func, tv);
	return (bam_lplbuf_t*)tv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x60, %esi
callq 0x3530
movq %rax, %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x3530
movq %rax, 0x20(%r15)
movl $0x1, (%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x3530
movq %rax, 0x38(%r15)
movq %rax, 0x30(%r15)
movq %r14, 0x48(%r15)
movq %rbx, 0x50(%r15)
leaq 0x15(%rip), %rdi        # 0x18aa7
movq %r15, %rsi
callq 0x17783
movq %rax, 0x58(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/bam_lpileup.c
// Function: bam_lplbuf_destroy
void bam_lplbuf_destroy(bam_lplbuf_t *tv)
{
	freenode_t *p, *q;
	free(tv->cur_level); free(tv->pre_level);
	bam_plbuf_destroy(tv->plbuf);
	free(tv->aux);
	for (p = tv->head; p->next;) {
		q = p->next;
		mp_free(tv->mp, p); p = q;
	}
	mp_free(tv->mp, p);
	assert(tv->mp->cnt == 0);
	mp_destroy(tv->mp);
	free(tv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x32c0
movq 0x18(%rbx), %rdi
callq 0x32c0
movq 0x58(%rbx), %rdi
callq 0x17806
movq 0x28(%rbx), %rdi
callq 0x32c0
movq 0x30(%rbx), %r15
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x18fbb
movl $0xfffffff, %ebp        # imm = 0xFFFFFFF
movl $0x100, %r12d           # imm = 0x100
movq %rax, %r14
movq 0x20(%rbx), %r13
decl (%r13)
movq $0x0, 0x8(%r15)
movl (%r15), %eax
andl %ebp, %eax
orl $0x20000000, %eax       # imm = 0x20000000
movl %eax, (%r15)
movl 0x4(%r13), %ecx
cmpl 0x8(%r13), %ecx
jne 0x18f9b
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
cmovel %r12d, %eax
movl %eax, 0x8(%r13)
movq 0x10(%r13), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3610
movq %rax, 0x10(%r13)
movl 0x4(%r13), %ecx
jmp 0x18f9f
movq 0x10(%r13), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r13)
movslq %ecx, %rcx
movq %r15, (%rax,%rcx,8)
movq 0x8(%r14), %rax
movq %r14, %r15
testq %rax, %rax
jne 0x18f4a
jmp 0x18fbe
movq %r15, %r14
movq 0x20(%rbx), %r15
decl (%r15)
movq $0x0, 0x8(%r14)
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
andl (%r14), %eax
orl $0x20000000, %eax       # imm = 0x20000000
movl %eax, (%r14)
movl 0x4(%r15), %ecx
cmpl 0x8(%r15), %ecx
jne 0x19012
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
movl $0x100, %ecx            # imm = 0x100
cmovnel %eax, %ecx
movl %ecx, 0x8(%r15)
movq 0x10(%r15), %rdi
movslq %ecx, %rsi
shlq $0x3, %rsi
callq 0x3610
movq %rax, 0x10(%r15)
movl 0x4(%r15), %ecx
jmp 0x19016
movq 0x10(%r15), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r15)
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
movq 0x20(%rbx), %r14
cmpl $0x0, (%r14)
jne 0x19078
cmpl $0x0, 0x4(%r14)
jle 0x19051
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x32c0
incq %r15
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jl 0x19038
movq 0x10(%r14), %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x32c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32c0
leaq 0xcdde(%rip), %rdi      # 0x25e5d
leaq 0xcde8(%rip), %rsi      # 0x25e6e
leaq 0xcdef(%rip), %rcx      # 0x25e7c
movl $0xbe, %edx
callq 0x3140
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/glf.c
// Function: glf3_header_read
glf3_header_t *glf3_header_read(glfFile fp)
{
	glf3_header_t *h;
	char magic[4];
	h = glf3_header_init();
	bgzf_read(fp, magic, 4);
	if (strncmp(magic, "GLF\3", 4)) {
		fprintf(stderr, "[glf3_header_read] invalid magic.\n");
		glf3_header_destroy(h);
		return 0;
	}
	bgzf_read(fp, &h->l_text, 4);
	if (glf3_is_BE) h->l_text = bam_swap_endian_4(h->l_text);
	if (h->l_text) {
		h->text = (uint8_t*)calloc(h->l_text + 1, 1);
		bgzf_read(fp, h->text, h->l_text);
	}
	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x3530
movq %rax, %rbx
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x1096a
cmpl $0x3464c47, (%r15)      # imm = 0x3464C47
jne 0x1a452
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x1096a
movslq (%rbx), %r15
testq %r15, %r15
je 0x1a445
movq %r15, %rdi
incq %rdi
movl $0x1, %esi
callq 0x3530
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x1096a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x4ab9
xorl %ebx, %ebx
jmp 0x1a445
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/glf.c
// Function: glf3_header_write
void glf3_header_write(glfFile fp, const glf3_header_t *h)
{
	int32_t x;
	bgzf_write(fp, "GLF\3", 4);
	x = glf3_is_BE? bam_swap_endian_4(h->l_text) : h->l_text;
	bgzf_write(fp, &x, 4);
	if (h->l_text) bgzf_write(fp, h->text, h->l_text);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xbda0(%rip), %rsi      # 0x26225
movl $0x4, %edx
callq 0x10c77
movl (%r14), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
movl $0x4, %edx
callq 0x10c77
movl (%r14), %edx
testl %edx, %edx
je 0x1a4b9
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x10c77
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/glf.c
// Function: glf3_ref_read
char *glf3_ref_read(glfFile fp, int *len)
{
	int32_t n, x;
	char *str;
	*len = 0;
	if (bgzf_read(fp, &n, 4) != 4) return 0;
	if (glf3_is_BE) n = bam_swap_endian_4(n);
	if (n < 0) {
		fprintf(stderr, "[glf3_ref_read] invalid reference name length: %d.\n", n);
		return 0;
	}
	str = (char*)calloc(n + 1, 1); // not necesarily n+1 in fact
	x = bgzf_read(fp, str, n);
	x += bgzf_read(fp, len, 4);
	if (x != n + 4) {
		free(str); *len = -1; return 0; // truncated
	}
	if (glf3_is_BE) *len = bam_swap_endian_4(*len);
	return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x0, (%rsi)
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x1096a
cmpl $0x4, %eax
jne 0x1a545
movl 0xc(%rsp), %r12d
testl %r12d, %r12d
js 0x1a558
movq %r12, %rdi
incq %rdi
movl $0x1, %esi
callq 0x3530
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x1096a
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x1096a
addl %ebp, %eax
movl 0xc(%rsp), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
je 0x1a548
movq %r14, %rdi
callq 0x32c0
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x13a89(%rip), %rax     # 0x2dfe8
movq (%rax), %rdi
leaq 0xbce4(%rip), %rsi      # 0x2624d
xorl %r14d, %r14d
movl %r12d, %edx
xorl %eax, %eax
callq 0x3630
jmp 0x1a548
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/glf.c
// Function: glf3_view1
void glf3_view1(const char *ref_name, const glf3_t *g3, int pos)
{
	int j;
	if (g3->rtype == GLF3_RTYPE_END) return;
	printf("%s\t%d\t%c\t%d\t%d\t%d", ref_name, pos + 1,
		   g3->rtype == GLF3_RTYPE_INDEL? '*' : "XACMGRSVTWYHKDBN"[g3->ref_base],
		   g3->depth, g3->rms_mapQ, g3->min_lk);
	if (g3->rtype == GLF3_RTYPE_SUB)
		for (j = 0; j != 10; ++j) printf("\t%d", g3->lk[j]);
	else {
		printf("\t%d\t%d\t%d\t%d\t%d\t%s\t%s\t", g3->lk[0], g3->lk[1], g3->lk[2], g3->indel_len[0], g3->indel_len[1],
			   g3->indel_len[0]? g3->indel_seq[0] : "*", g3->indel_len[1]? g3->indel_seq[1] : "*");
	}
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movzbl (%rsi), %eax
cmpq $0x10, %rax
jae 0x1a5e9
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rsi
incl %edx
movl %eax, %edi
andb $-0x10, %dil
movl $0x2a, %ecx
cmpb $0x20, %dil
je 0x1a60d
andl $0xf, %eax
leaq 0xbc8a(%rip), %rcx      # 0x26293
movsbl (%rax,%rcx), %ecx
movl 0xc(%rbx), %r8d
movzbl %r8b, %r10d
shrl $0x8, %r8d
movzbl 0x1(%rbx), %r9d
subq $0x8, %rsp
leaq 0xbc58(%rip), %rdi      # 0x26281
xorl %eax, %eax
pushq %r10
callq 0x3040
addq $0x10, %rsp
movb (%rbx), %al
andb $-0x10, %al
cmpb $0x10, %al
jne 0x1a665
movl $0x2, %r15d
leaq 0xbc44(%rip), %r14      # 0x2628f
movzbl (%rbx,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3040
incq %r15
cmpq $0xc, %r15
jne 0x1a64b
jmp 0x1a6ae
movswl 0x14(%rbx), %r8d
movswl 0x16(%rbx), %r9d
leaq 0xae8b(%rip), %r11      # 0x25501
movq %r11, %r10
testl %r8d, %r8d
je 0x1a682
movq 0x20(%rbx), %r10
movzbl 0x2(%rbx), %esi
movzbl 0x3(%rbx), %edx
movzbl 0x4(%rbx), %ecx
testw %r9w, %r9w
je 0x1a698
movq 0x28(%rbx), %r11
leaq 0xbc05(%rip), %rdi      # 0x262a4
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x3040
addq $0x10, %rsp
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x3170
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/glf.c
// Function: glf3_write1
int glf3_write1(glfFile fp, const glf3_t *g3)
{
	int r;
	uint8_t c;
	uint32_t y[2];
	c = g3->rtype<<4 | g3->ref_base;
	r = bgzf_write(fp, &c, 1);
	if (g3->rtype == GLF3_RTYPE_END) return r;
	y[0] = g3->offset;
	y[1] = g3->min_lk<<24 | g3->depth;
	if (glf3_is_BE) {
		y[0] = bam_swap_endian_4(y[0]);
		y[1] = bam_swap_endian_4(y[1]);
	}
	r += bgzf_write(fp, y, 8);
	r += bgzf_write(fp, &g3->rms_mapQ, 1);
	if (g3->rtype == GLF3_RTYPE_SUB) r += bgzf_write(fp, g3->lk, 10);
	else {
		int16_t x[2];
		r += bgzf_write(fp, g3->lk, 3);
		x[0] = glf3_is_BE? bam_swap_endian_2(g3->indel_len[0]) : g3->indel_len[0];
		x[1] = glf3_is_BE? bam_swap_endian_2(g3->indel_len[1]) : g3->indel_len[1];
		r += bgzf_write(fp, x, 4);
		if (g3->indel_len[0]) r += bgzf_write(fp, g3->indel_seq[0], abs(g3->indel_len[0]));
		if (g3->indel_len[1]) r += bgzf_write(fp, g3->indel_seq[1], abs(g3->indel_len[1]));
	}
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
leaq 0x3(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0x10c77
movl %eax, %ebp
cmpb $0x10, (%r14)
jb 0x1a7cd
movl 0x10(%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl 0xc(%r14), %eax
roll $0x18, %eax
movl %eax, 0x4(%rsi)
movq %rbx, %rdi
movl $0x8, %edx
callq 0x10c77
movl %eax, %r12d
addl %ebp, %r12d
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x10c77
movl %eax, %r15d
addl %r12d, %r15d
movb (%r14), %al
andb $-0x10, %al
cmpb $0x10, %al
jne 0x1a751
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x10c77
movl %eax, %ebp
addl %r15d, %ebp
jmp 0x1a7cd
leaq 0x2(%r14), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x10c77
movl %eax, %r12d
movl 0x14(%r14), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
movl $0x4, %edx
callq 0x10c77
movl %eax, %ebp
addl %r12d, %ebp
addl %r15d, %ebp
movzwl 0x14(%r14), %eax
testw %ax, %ax
je 0x1a7a9
movq 0x20(%r14), %rsi
movl %eax, %ecx
negw %cx
cmovsw %ax, %cx
movzwl %cx, %edx
movq %rbx, %rdi
callq 0x10c77
addl %eax, %ebp
movzwl 0x16(%r14), %eax
testw %ax, %ax
je 0x1a7cd
movq 0x28(%r14), %rsi
movl %eax, %ecx
negw %cx
cmovsw %ax, %cx
movzwl %cx, %edx
movq %rbx, %rdi
callq 0x10c77
addl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/glf.c
// Function: glf3_view
void glf3_view(glfFile fp)
{
	glf3_header_t *h;
	char *name;
	glf3_t *g3;
	int len;
	h = glf3_header_read(fp);
	g3 = glf3_init1();
	while ((name = glf3_ref_read(fp, &len)) != 0) {
		int pos = 0;
		while (glf3_read1(fp, g3) && g3->rtype != GLF3_RTYPE_END) {
			pos += g3->offset;
			glf3_view1(name, g3, pos);
		}
		free(name);
	}
	glf3_header_destroy(h);
	glf3_destroy1(g3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x1a3cf
movq %rax, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x3530
movq %rax, %rbx
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x1a4c1
testq %rax, %rax
je 0x1aa27
movq %rax, %r13
leaq 0x4(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1a7dc
testl %eax, %eax
je 0x1aa0c
xorl %ebp, %ebp
cmpb $0x10, (%rbx)
jb 0x1aa0c
addl 0x10(%rbx), %ebp
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1a5d2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1a7dc
testl %eax, %eax
jne 0x1a9e8
movq %r13, %rdi
callq 0x32c0
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a4c1
movq %rax, %r13
testq %rax, %rax
jne 0x1a9d7
movq 0x8(%r14), %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x32c0
movq 0x20(%rbx), %rdi
callq 0x32c0
movq 0x28(%rbx), %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x32c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/glf.c
// Function: glf3_view_main
int glf3_view_main(int argc, char *argv[])
{
	glfFile fp;
	if (argc == 1) {
		fprintf(stderr, "Usage: glfview <in.glf>\n");
		return 1;
	}
	fp = (strcmp(argv[1], "-") == 0)? bgzf_fdopen(fileno(stdin), "r") : bgzf_open(argv[1], "r");
	if (fp == 0) {
		fprintf(stderr, "Fail to open file '%s'\n", argv[1]);
		return 1;
	}
	glf3_view(fp);
	bgzf_close(fp);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0x1aac9
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x1aa7c
cmpb $0x0, 0x1(%rdi)
je 0x1aaaa
leaq 0xc644(%rip), %rsi      # 0x270c7
callq 0x10048
movq %rax, %r14
testq %rax, %rax
je 0x1aad0
movq %r14, %rdi
callq 0x1a995
movq %r14, %rdi
callq 0x10d25
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1351f(%rip), %rax     # 0x2dfd0
movq (%rax), %rdi
callq 0x3030
leaq 0xc607(%rip), %rsi      # 0x270c7
movl %eax, %edi
callq 0x101a3
jmp 0x1aa88
callq 0x4b01
jmp 0x1aadc
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4ae3
movl $0x1, %eax
jmp 0x1aaa2
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/faidx.c
// Function: fai_destroy
void fai_destroy(faidx_t *fai)
{
	int i;
	for (i = 0; i < fai->n; ++i) free(fai->name[i]);
	free(fai->name);
	kh_destroy(s, fai->hash);
	if (fai->rz) razf_close(fai->rz);
	free(fai);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x1b326
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x32c0
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x1b30d
movq 0x10(%rbx), %rdi
callq 0x32c0
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x1b35b
movq 0x18(%r14), %rdi
callq 0x32c0
movq 0x10(%r14), %rdi
callq 0x32c0
movq 0x20(%r14), %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x32c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b368
callq 0x22998
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/faidx.c
// Function: fai_save
void fai_save(const faidx_t *fai, FILE *fp)
{
	khint_t k;
	int i;
	for (i = 0; i < fai->n; ++i) {
		faidx1_t x;
		k = kh_get(s, fai->hash, fai->name[i]);
		x = kh_value(fai->hash, k);
#ifdef _WIN32
		fprintf(fp, "%s\t%d\t%ld\t%d\t%d\n", fai->name[i], (int)x.len, (long)x.offset, (int)x.line_blen, (int)x.line_len);
#else
		fprintf(fp, "%s\t%d\t%lld\t%d\t%d\n", fai->name[i], (int)x.len, (long long)x.offset, (int)x.line_blen, (int)x.line_len);
#endif
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
cmpl $0x0, 0x8(%rdi)
jle 0x1b4f3
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rdi, 0x18(%rsp)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%r15,8), %r10
movq %rcx, 0x8(%rsp)
movl (%rcx), %r13d
movl $0x0, %eax
testl %r13d, %r13d
je 0x1b4a1
movsbl (%r10), %ecx
testl %ecx, %ecx
movq %r15, 0x20(%rsp)
je 0x1b3f1
movb 0x1(%r10), %al
testb %al, %al
je 0x1b3f3
leaq 0x2(%r10), %rdx
movl %ecx, %esi
shll $0x5, %esi
subl %ecx, %esi
movsbl %al, %ecx
addl %esi, %ecx
movb (%rdx), %al
incq %rdx
testb %al, %al
jne 0x1b3da
jmp 0x1b3f3
xorl %ecx, %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %r13d
movl %edx, %edi
leal -0x1(%r13), %esi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %edx, %r14d
incl %r14d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movl %edi, %r12d
movl %edi, 0x14(%rsp)
movq %rsi, 0x30(%rsp)
movl %r12d, %eax
shrl $0x4, %eax
movl (%rsi,%rax,4), %ebp
leal (%r12,%r12), %r15d
andl $0x1e, %r15d
movl %ebp, %eax
movl %r15d, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x1b487
testb $0x1, %al
jne 0x1b46c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %r12d, %ecx
movq (%rax,%rcx,8), %rdi
movq %r10, %rsi
movq %r10, %rbx
callq 0x34e0
movq 0x30(%rsp), %rsi
movl 0x14(%rsp), %edi
movq %rbx, %r10
testl %eax, %eax
je 0x1b487
addl %r14d, %r12d
cmpl %r13d, %r12d
movl %r13d, %eax
movl $0x0, %ecx
cmovbl %ecx, %eax
subl %eax, %r12d
cmpl %edi, %r12d
jne 0x1b421
jmp 0x1b494
movl %r15d, %ecx
shrl %cl, %ebp
testb $0x3, %bpl
cmovel %r12d, %r13d
movl %r13d, %eax
movq 0x18(%rsp), %rbx
movq 0x20(%rsp), %r15
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rdx
movl %eax, %eax
shlq $0x4, %rax
movq (%rdx,%rax), %rcx
movq 0x8(%rdx,%rax), %r8
movq %rcx, %r9
shrq $0x30, %r9
movq %rcx, %rax
shrq $0x20, %rax
movzwl %ax, %eax
movl %eax, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0xaf02(%rip), %rsi      # 0x263db
movq %r10, %rdx
xorl %eax, %eax
callq 0x3630
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x1b39f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/faidx.c
// Function: fai_read
faidx_t *fai_read(FILE *fp)
{
	faidx_t *fai;
	char *buf, *p;
	int len, line_len, line_blen;
#ifdef _WIN32
	long offset;
#else
	long long offset;
#endif
	fai = (faidx_t*)calloc(1, sizeof(faidx_t));
	fai->hash = kh_init(s);
	buf = (char*)calloc(0x10000, 1);
	while (!feof(fp) && fgets(buf, 0x10000, fp)) {
		for (p = buf; *p && isgraph(*p); ++p);
		*p = 0; ++p;
#ifdef _WIN32
		sscanf(p, "%d%ld%d%d", &len, &offset, &line_blen, &line_len);
#else
		sscanf(p, "%d%lld%d%d", &len, &offset, &line_blen, &line_len);
#endif
		fai_insert_index(fai, buf, len, line_len, line_blen, offset);
	}
	free(buf);
	return fai;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x3530
movq %rax, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x3530
movq %rax, 0x18(%r14)
movl $0x10000, %edi          # imm = 0x10000
movl $0x1, %esi
callq 0x3530
movq %rax, %r15
movq %rbx, %rdi
callq 0x3550
testl %eax, %eax
jne 0x1b5f7
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movl $0x10000, %esi          # imm = 0x10000
movq %rbx, %rdx
callq 0x3200
testq %rax, %rax
je 0x1b5f7
movb (%r15), %bpl
movq %r15, %rdi
testb %bpl, %bpl
je 0x1b5a6
callq 0x3310
movq (%rax), %rax
movq %r15, %rdi
movsbq %bpl, %rcx
cmpw $0x0, (%rax,%rcx,2)
jns 0x1b5a6
movb 0x1(%rdi), %bpl
incq %rdi
testb %bpl, %bpl
jne 0x1b58f
movb $0x0, (%rdi)
incq %rdi
leaq 0xae3a(%rip), %rsi      # 0x263ed
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r12, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x30f0
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
movq 0x10(%rsp), %r9
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ae07
movq %rbx, %rdi
callq 0x3550
testl %eax, %eax
je 0x1b564
movq %r15, %rdi
callq 0x32c0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/samtools-0.1.7a-hybrid/faidx.c
// Function: fai_build
int fai_build(const char *fn)
{
	char *str;
	RAZF *rz;
	FILE *fp;
	faidx_t *fai;
	str = (char*)calloc(strlen(fn) + 5, 1);
	sprintf(str, "%s.fai", fn);
	rz = razf_open(fn, "r");
	if (rz == 0) {
		fprintf(stderr, "[fai_build] fail to open the FASTA file %s\n",str);
		free(str);
		return -1;
	}
	fai = fai_build_core(rz);
	razf_close(rz);
	fp = fopen(str, "wb");
	if (fp == 0) {
		fprintf(stderr, "[fai_build] fail to write FASTA index %s\n",str);
		fai_destroy(fai); free(str);
		return -1;
	}
	fai_save(fai, fp);
	fclose(fp);
	free(str);
	fai_destroy(fai);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x32d0
leaq 0x5(%rax), %rdi
movl $0x1, %esi
callq 0x3530
movq %rax, %rbx
leaq 0xadc2(%rip), %rsi      # 0x263f8
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3350
leaq 0xba7d(%rip), %rsi      # 0x270c7
movq %r14, %rdi
callq 0x21f77
testq %rax, %rax
je 0x1b6af
movq %rax, %r15
movq %rax, %rdi
callq 0x1aae4
movq %rax, %r14
movq %r15, %rdi
callq 0x22998
leaq 0x92e9(%rip), %rsi      # 0x2495d
movq %rbx, %rdi
callq 0x35f0
testq %rax, %rax
je 0x1b6b9
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1b377
movq %r15, %rdi
callq 0x3560
movq %rbx, %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x1b2fd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x4c52
jmp 0x1b6c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c16
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1b6a9