LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbf_open_w
pbf_t *pbf_open_w(const char *fn, int m, int g, int shift)
{
	FILE *fp;
	pbf_t *pb;
	int32_t i, v[3];
	if (fn && strcmp(fn, "-") != 0) {
		if ((fp = fopen(fn, "wb")) == NULL)
			return 0;
	} else fp = stdout;
	pb = (pbf_t*)calloc(1, sizeof(pbf_t));
	pb->fp = fp;
	pb->m = m, pb->g = g, pb->shift = shift;
	pb->pb = (pbc_t**)calloc(g, sizeof(void*));
	for (i = 0; i < g; ++i)
		pb->pb[i] = pbc_init(m);
	v[0] = pb->m, v[1] = pb->g, v[2] = pb->shift;
	fwrite("PBF\1", 1, 4, fp);
	fwrite(v, 4, 3, fp);
	pb->is_writing = 1;
	return pb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
testq %rdi, %rdi
je 0x10982
cmpb $0x2d, (%rdi)
jne 0x10966
cmpb $0x0, 0x1(%rdi)
je 0x10982
leaq 0x79da(%rip), %rsi      # 0x18347
callq 0x23c0
movq %rax, %r15
testq %rax, %rax
jne 0x1098c
xorl %r12d, %r12d
jmp 0x10a34
movq 0x105f7(%rip), %rax     # 0x20f80
movq (%rax), %r15
pushq $0x1
popq %rdi
pushq $0x70
popq %rsi
callq 0x2220
movq %rax, %r12
movq %r15, 0x10(%rsp)
movq %r15, (%rax)
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movl %ebx, 0xc(%rsp)
movl %ebx, 0x10(%rax)
movslq %ebp, %rbx
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x2220
movq %rax, %r13
movq %rax, 0x20(%r12)
xorl %r15d, %r15d
testl %ebx, %ebx
movl $0x0, %ebx
cmovgl %ebp, %ebx
cmpq %r15, %rbx
je 0x109ea
movl %r14d, %edi
callq 0x1047e
movq %rax, (%r13,%r15,8)
incq %r15
jmp 0x109d3
leaq 0x1c(%rsp), %rbx
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rbx)
leaq 0x8d8d(%rip), %rdi      # 0x19790
pushq $0x1
popq %rsi
pushq $0x4
popq %r14
movq %r14, %rdx
movq 0x10(%rsp), %r15
movq %r15, %rcx
callq 0x2410
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x2410
movl $0x1, 0x14(%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbf_close
int pbf_close(pbf_t *pb)
{
	int g;
	if (pb == 0) return 0;
	if (pb->is_writing) { // write the index
		uint64_t off;
		off = ftell(pb->fp);
		fputc('I', pb->fp);
		fwrite(&pb->n, 8, 1, pb->fp);
		fwrite(&pb->n_idx, 4, 1, pb->fp);
		fwrite(pb->idx, 8, pb->n_idx, pb->fp);
		fwrite(&off, 8, 1, pb->fp);
	}
	free(pb->idx); free(pb->ret); free(pb->invS); free(pb->buf); free(pb->sub_list);
	for (g = 0; g < pb->g; ++g) {
		free(pb->pb[g]);
		if (pb->sub) free(pb->sub[g]);
	}
	free(pb->sub); free(pb->pb);
	fclose(pb->fp);
	free(pb);
	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x10d5a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
je 0x10cd0
movq (%rbx), %rdi
callq 0x2260
movq %rsp, %r14
movq %rax, (%r14)
movq (%rbx), %rsi
pushq $0x49
popq %rdi
callq 0x21f0
leaq 0x18(%rbx), %rdi
movq (%rbx), %rcx
pushq $0x8
popq %r15
pushq $0x1
popq %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x2410
leaq 0x30(%rbx), %rdi
movq (%rbx), %rcx
pushq $0x4
popq %rsi
movq %r12, %rdx
callq 0x2410
movq (%rbx), %rcx
movq 0x38(%rbx), %rdi
movslq 0x30(%rbx), %rdx
movq %r15, %rsi
callq 0x2410
movq (%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2410
movq 0x38(%rbx), %rdi
callq 0x2050
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x68(%rbx), %rdi
callq 0x2050
movq 0x60(%rbx), %rdi
callq 0x2050
movq 0x50(%rbx), %rdi
callq 0x2050
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x10d2d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2050
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x10d28
movq (%rax,%r14,8), %rdi
callq 0x2050
incq %r14
jmp 0x10d00
movq 0x48(%rbx), %rdi
callq 0x2050
movq 0x20(%rbx), %rdi
callq 0x2050
movq (%rbx), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbf_write
int pbf_write(pbf_t *pb, uint8_t *const*a)
{
	int g;
	if (!pb->is_writing) return -1;
	if ((pb->n & ((1ULL<<pb->shift) - 1)) == 0) {
		if (pb->n_idx == pb->m_idx) {
			pb->m_idx = pb->m_idx? pb->m_idx<<1 : 8;
			pb->idx = (uint64_t*)realloc(pb->idx, pb->m_idx * 8);
		}
		pb->idx[pb->n_idx++] = ftell(pb->fp); // save the index offset
		fputc('S', pb->fp);
		for (g = 0; g < pb->g; ++g) // write S[]
			fwrite(pb->pb[g]->S, 4, pb->m, pb->fp);
	}
	fputc('B', pb->fp);
	for (g = 0; g < pb->g; ++g) {
		pbc_t *pbc = pb->pb[g];
		pbc_enc(pbc, a[g]);
		fwrite(&pbc->l, 4, 1, pb->fp);
		fwrite(pbc->u, 1, pbc->l, pb->fp);
	}
	++pb->n;
	return 0;
}

// Assembly:
cmpl $0x0, 0x14(%rdi)
je 0x10dfb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x10(%rdi), %cl
pushq $-0x1
popq %rax
shlq %cl, %rax
notq %rax
testq %rax, 0x18(%rdi)
je 0x10dff
movq (%rbx), %rsi
pushq $0x42
popq %rdi
callq 0x21f0
xorl %ebp, %ebp
pushq $0x4
popq %r15
pushq $0x1
popq %r12
movslq 0xc(%rbx), %rax
cmpq %rax, %rbp
jge 0x10de6
movq 0x20(%rbx), %rax
movq (%rax,%rbp,8), %r13
movq (%r14,%rbp,8), %rsi
movq %r13, %rdi
callq 0x104e2
leaq 0x4(%r13), %rdi
movq (%rbx), %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x2410
movq 0x18(%r13), %rdi
movslq 0x4(%r13), %rdx
movq (%rbx), %rcx
movq %r12, %rsi
callq 0x2410
incq %rbp
jmp 0x10d9f
incq 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
retq
movl 0x30(%rbx), %eax
cmpl 0x34(%rbx), %eax
jne 0x10e28
leal (%rax,%rax), %ecx
testl %eax, %eax
pushq $0x8
popq %rax
cmovnel %ecx, %eax
movl %eax, 0x34(%rbx)
movq 0x38(%rbx), %rdi
shll $0x3, %eax
movslq %eax, %rsi
callq 0x2340
movq %rax, 0x38(%rbx)
movq (%rbx), %rdi
callq 0x2260
movq 0x38(%rbx), %rcx
movslq 0x30(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x30(%rbx)
movq %rax, (%rcx,%rdx,8)
movq (%rbx), %rsi
pushq $0x53
popq %rdi
callq 0x21f0
xorl %r12d, %r12d
pushq $0x4
popq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r12
jge 0x10d8a
movq (%rbx), %rcx
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rdi
movslq 0x8(%rbx), %rdx
movq %r15, %rsi
callq 0x2410
incq %r12
jmp 0x10e54
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbf_read
const uint8_t **pbf_read(pbf_t *pb)
{
	int g;
	uint8_t t;
	if (pb->is_writing) return 0;
	fread(&t, 1, 1, pb->fp);
	if (t == 'S') {
		for (g = 0; g < pb->g; ++g)
			fread(pb->pb[g]->S, 4, pb->m, pb->fp);
		fread(&t, 1, 1, pb->fp);
	}
	if (t == 'B') {
		for (g = 0; g < pb->g; ++g) {
			int32_t l;
			fread(&l, 4, 1, pb->fp);
			fread(pb->buf, 1, l, pb->fp);
			pb->buf[l] = 0;
			if (pb->n_sub > 0 && pb->n_sub < pb->m) // subset decoding
				pbs_dec(pb->m, pb->n_sub, pb->sub[g], pb->buf, pb->pb[g]->u);
			else pbc_dec(pb->pb[g], pb->buf); // full decoding
		}
		++pb->k;
	} else return 0;
	return pb->ret;
}

// Assembly:
cmpl $0x0, 0x14(%rdi)
je 0x10e8a
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
leaq 0x3(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x20f0
movb (%r14), %al
cmpb $0x53, %al
jne 0x10efe
xorl %r15d, %r15d
pushq $0x4
popq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jge 0x10ee5
movq (%rbx), %rcx
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x10(%rax), %rdi
movslq 0x8(%rbx), %rdx
movq %r14, %rsi
callq 0x20f0
incq %r15
jmp 0x10ebc
movq (%rbx), %rcx
leaq 0x3(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x20f0
movb (%r14), %al
cmpb $0x42, %al
jne 0x10f92
xorl %ebp, %ebp
leaq 0x4(%rsp), %r14
pushq $0x4
popq %r15
pushq $0x1
popq %r12
movslq 0xc(%rbx), %rax
cmpq %rax, %rbp
jge 0x10f96
movq (%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x20f0
movq (%rbx), %rcx
movq 0x60(%rbx), %rdi
movslq 0x4(%rsp), %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x20f0
movq 0x60(%rbx), %rax
movb $0x0, (%rax,%r13)
movl 0x40(%rbx), %esi
testl %esi, %esi
jle 0x10f7c
movl 0x8(%rbx), %edi
cmpl %edi, %esi
jge 0x10f7c
movq 0x20(%rbx), %rax
movq 0x48(%rbx), %rcx
movq (%rcx,%rbp,8), %rdx
movq 0x60(%rbx), %rcx
movq (%rax,%rbp,8), %rax
movq 0x18(%rax), %r8
callq 0x10739
jmp 0x10f8d
movq 0x20(%rbx), %rax
movq 0x60(%rbx), %rsi
movq (%rax,%rbp,8), %rdi
callq 0x10509
incq %rbp
jmp 0x10f15
xorl %eax, %eax
jmp 0x10f9e
incq 0x58(%rbx)
movq 0x28(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbf_seek
int pbf_seek(pbf_t *pb, uint64_t k)
{
	int x, i, g;
	uint8_t t;
	if (pb->is_writing) return -1;
	if (k == pb->k) return 0;
	if (k > pb->k && k - pb->k <= 1<<pb->shift) {
		while (pb->k < k) pbf_read(pb);
		return 0;
	}
	if (pb->idx == 0 || k >= pb->n) return -1;
	fseek(pb->fp, pb->idx[k>>pb->shift], SEEK_SET);
	fread(&t, 1, 1, pb->fp);
	assert(t == 'S'); // a bug or corrupted file if it is not an "S" line
	for (g = 0; g < pb->g; ++g) {
		fread(pb->pb[g]->S, 4, pb->m, pb->fp);
		if (pb->n_sub > 0 && pb->n_sub < pb->m) // update pb->sub if needed
			pbf_fill_sub(pb->m, pb->pb[g]->S, pb->n_sub, pb->sub[g], pb->invS, pb->sub_list);
	}
	pb->k = k >> pb->shift << pb->shift;
	x = k & ((1<<pb->shift) - 1);
	for (i = 0; i < x; ++i) pbf_read(pb);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rax
cmpl $0x0, 0x14(%rdi)
jne 0x10fcf
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rdx
subq %rdx, %rsi
jne 0x10fdb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jbe 0x10ff2
movb 0x10(%r14), %cl
pushq $0x1
popq %rdi
shll %cl, %edi
movslq %edi, %rcx
cmpq %rcx, %rsi
jbe 0x1109a
movq 0x38(%r14), %rdx
testq %rdx, %rdx
je 0x10fcf
cmpq %rbx, 0x18(%r14)
jbe 0x10fcf
movq (%r14), %rdi
movb 0x10(%r14), %cl
movq %rbx, %rax
shrq %cl, %rax
movq (%rdx,%rax,8), %rsi
xorl %edx, %edx
callq 0x2320
movq (%r14), %rcx
leaq 0x7(%rsp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x20f0
cmpb $0x53, (%r15)
jne 0x110de
xorl %r12d, %r12d
pushq $0x4
popq %r15
movslq 0xc(%r14), %rax
cmpq %rax, %r12
jge 0x110b1
movq (%r14), %rcx
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rdi
movslq 0x8(%r14), %rdx
movq %r15, %rsi
callq 0x20f0
movl 0x40(%r14), %edx
testl %edx, %edx
jle 0x11095
movl 0x8(%r14), %edi
cmpl %edi, %edx
jge 0x11095
movq 0x20(%r14), %rax
movq 0x48(%r14), %rcx
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rsi
movq (%rcx,%r12,8), %rcx
movq 0x68(%r14), %r8
movq 0x50(%r14), %r9
callq 0x110fd
incq %r12
jmp 0x11040
cmpq %rbx, %rdx
jae 0x10fcd
movq %r14, %rdi
callq 0x10e81
movq 0x58(%r14), %rdx
jmp 0x1109a
movb 0x10(%r14), %cl
movq %rbx, %rax
shrq %cl, %rax
shlq %cl, %rax
pushq $-0x1
popq %rdx
shll %cl, %edx
movq %rax, 0x58(%r14)
notl %edx
andl %edx, %ebx
subl $0x1, %ebx
jb 0x10fcd
movq %r14, %rdi
callq 0x10e81
jmp 0x110cb
leaq 0x86b0(%rip), %rdi      # 0x19795
leaq 0x86b2(%rip), %rsi      # 0x1979e
leaq 0x86b2(%rip), %rcx      # 0x197a5
movl $0x16a, %edx            # imm = 0x16A
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbf_fill_sub
static inline void pbf_fill_sub(int m, const int32_t *S, int n_sub, pbs_dat_t *sub, int32_t *invS, int *sub_list)
{
	int i;
	for (i = 0; i < m; ++i) invS[S[i]] = i;
	for (i = 0; i < n_sub; ++i)
		sub[i].r = invS[sub_list[sub[i].i]];
	radix_sort_r(sub, sub + n_sub);
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
cmpq %rax, %rdi
je 0x11116
movslq (%rsi,%rax,4), %r10
movl %eax, (%r8,%r10,4)
incq %rax
jmp 0x11104
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %esi
cmovgl %edx, %esi
cmpq %rax, %rsi
je 0x1113b
movl 0x4(%rcx,%rax,8), %edi
movslq (%r9,%rdi,4), %rdi
movl (%r8,%rdi,4), %edi
movl %edi, (%rcx,%rax,8)
incq %rax
jmp 0x11122
movl %edx, %eax
leaq (%rcx,%rax,8), %rsi
movq %rcx, %rdi
jmp 0x1071b
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbf_subset
int pbf_subset(pbf_t *pb, int n_sub, int *sub)
{
	int i, g;
	if (n_sub <= 0 || n_sub >= pb->m || sub == 0) n_sub = 0;
	if ((pb->n_sub = n_sub) != 0) {
		pb->sub_list = (int*)realloc(pb->sub_list, n_sub * sizeof(int));
		memcpy(pb->sub_list, sub, n_sub * sizeof(int));
		for (g = 0; g < pb->g; ++g) {
			pb->sub[g] = (pbs_dat_t*)realloc(pb->sub[g], n_sub * sizeof(pbs_dat_t));
			for (i = 0; i < n_sub; ++i) pb->sub[g][i].i = i;
			pbf_fill_sub(pb->m, pb->pb[g]->S, n_sub, pb->sub[g], pb->invS, pb->sub_list);
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x1120d
movq %rdx, %r15
testq %rdx, %rdx
je 0x1120d
cmpl %esi, 0x8(%rbx)
jle 0x1120d
movl %esi, %r14d
movl %esi, 0x40(%rbx)
movq 0x50(%rbx), %rdi
leaq (,%r14,4), %r12
movq %r12, %rsi
callq 0x2340
movq %rax, 0x50(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2280
leaq (,%r14,8), %r15
xorl %r12d, %r12d
movslq 0xc(%rbx), %rax
cmpq %rax, %r12
jge 0x11211
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x2340
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x111e1
movl %ecx, 0x4(%rax,%rcx,8)
incq %rcx
jmp 0x111d3
movl 0x8(%rbx), %edi
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x10(%rax), %rsi
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rcx
movq 0x68(%rbx), %r8
movq 0x50(%rbx), %r9
movl %r14d, %edx
callq 0x110fd
incq %r12
jmp 0x111a8
andl $0x0, 0x40(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/pbwt.c
// Function: pbr_enc1
static inline int pbr_enc1(uint8_t *p, int l, int b)
{
	if (l >= 16) {
		uint8_t *q = p;
		uint32_t x, i;
		for (x = 0xfU<<28, i = 7<<2; x; x >>= 4, i -= 1<<2)
			if (x&l) *q++ = (i<<2 | (x&l)>>i) << 1 | b;
		return q - p;
	} else {
		*p = l<<1 | b;
		return 1;
	}
}

// Assembly:
cmpl $0x10, %esi
jl 0x11275
pushq $0x1c
popq %rcx
movl $0xf0000000, %r8d       # imm = 0xF0000000
movl $0xe0, %r9d
movq %rdi, %rax
testl %r8d, %r8d
je 0x11280
movl %r8d, %r10d
andl %esi, %r10d
je 0x11268
shrl %cl, %r10d
addl %r10d, %r10d
movl %r9d, %r11d
orl %edx, %r11d
orl %r10d, %r11d
movb %r11b, (%rax)
incq %rax
shrl $0x4, %r8d
addl $-0x4, %ecx
addl $-0x20, %r9d
jmp 0x11246
addl %esi, %esi
orl %edx, %esi
movb %sil, (%rdi)
pushq $0x1
popq %rax
retq
subl %edi, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_open
bgt_file_t *bgt_open(const char *prefix)
{
	char *fn = 0;
	bgt_file_t *bf = 0;
	BGZF *fp = 0;

	fn = (char*)malloc(strlen(prefix) + 9);
	sprintf(fn, "%s.bcf", prefix);
	fp = bgzf_open(fn, "rb");
	if (fp == 0) goto bgt_open_err;
	bf = (bgt_file_t*)calloc(1, sizeof(bgt_file_t));
	bf->h0 = bcf_hdr_read(fp);
	if (bf->h0 == 0) goto bgt_open_err;
	bf->idx = bcf_index_load(fn);
	if (bf->idx == 0) goto bgt_open_err;
	sprintf(fn, "%s.spl", prefix);
	bf->f = fmf_read(fn);
	if (bf->f == 0) goto bgt_open_err;
	bf->prefix = strdup(prefix);
	bgzf_close(fp);
	free(fn);
	bf->mgs = (int32_t*)calloc(bf->f->n_rows, 4);
	bgt_set_mgs(bf);
	return bf;

bgt_open_err:
	free(fn);
	if (fp) bgzf_close(fp);
	if (bf) bgt_close(bf);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
callq 0x2170
leaq 0x9(%rax), %rdi
callq 0x22e0
movq %rax, %r15
leaq 0x70ab(%rip), %rsi      # 0x18358
xorl %ebx, %ebx
movq %rax, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2400
leaq 0x7d4d(%rip), %rsi      # 0x19010
movq %r15, %rdi
callq 0x3ef4
movq %rax, %r12
testq %rax, %rax
je 0x11373
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2220
movq %rax, %rbx
movq %r12, %rdi
callq 0xa5ac
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x11373
movq %r15, %rdi
xorl %esi, %esi
callq 0x85b5
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x11373
leaq 0x7030(%rip), %rsi      # 0x18340
movq %r15, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2400
movq %r15, %rdi
callq 0x8a70
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x11373
movq %rax, %r14
movq %r13, %rdi
callq 0x2430
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x4ddc
movq %r15, %rdi
callq 0x2050
movslq 0x20(%r14), %r15
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x2220
movq %rax, %r12
movq %rax, 0x20(%rbx)
xorl %eax, %eax
cmpq %r15, %rax
jge 0x113a6
orl $-0x1, (%r12,%rax,4)
incq %rax
jmp 0x11364
movq %r15, %rdi
callq 0x2050
testq %r12, %r12
je 0x11388
movq %r12, %rdi
callq 0x4ddc
testq %rbx, %rbx
je 0x11395
movq %rbx, %rdi
callq 0x11447
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x10(%rsp)
movl (%r14), %eax
xorl %ebx, %ebx
testl %eax, %eax
movl $0x0, %ebp
movl %eax, 0xc(%rsp)
cmovgl %eax, %ebp
leaq 0x88f5(%rip), %r13      # 0x19cba
cmpq %rbx, %rbp
je 0x113e5
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rdi
movq %r13, %rsi
callq 0x2230
testl %eax, %eax
je 0x113e3
incq %rbx
jmp 0x113c5
movl %ebx, %ebp
cmpl 0xc(%rsp), %ebp
jne 0x113f2
movq 0x10(%rsp), %rax
jmp 0x11397
xorl %eax, %eax
cmpq %r15, %rax
jge 0x113eb
imulq $0x18, %rax, %rcx
addq 0x28(%r14), %rcx
xorl %edx, %edx
movslq 0x8(%rcx), %rsi
cmpq %rsi, %rdx
jge 0x11442
movq 0x10(%rcx), %rsi
movl (%rsi,%rdx,8), %edi
movl %edi, %r8d
andl $0xfffffff, %r8d        # imm = 0xFFFFFFF
xorl %ebp, %r8d
andl $0xf0000000, %edi       # imm = 0xF0000000
xorl $0x10000000, %edi       # imm = 0x10000000
orl %r8d, %edi
jne 0x1143d
movl 0x4(%rsi,%rdx,8), %esi
testl %esi, %esi
js 0x1143d
movl %esi, (%r12,%rax,4)
incq %rdx
jmp 0x11403
incq %rax
jmp 0x113f4
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_close
void bgt_close(bgt_file_t *bf)
{
	if (bf == 0) return;
	free(bf->mgs);
	if (bf->idx) hts_idx_destroy(bf->idx);
	if (bf->h0) bcf_hdr_destroy(bf->h0);
	if (bf->f) fmf_destroy(bf->f);
	free(bf->prefix);
	free(bf);
}

// Assembly:
testq %rdi, %rdi
je 0x11494
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2050
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x11467
callq 0x71c5
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x11475
callq 0xa500
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x11483
callq 0x8efb
movq (%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_reader_init
bgt_t *bgt_reader_init(const bgt_file_t *bf)
{
	char *fn;
	bgt_t *bgt;
	assert(BGT_MAX_GROUPS <= 32);
	bgt = (bgt_t*)calloc(1, sizeof(bgt_t));
	bgt->f = bf;
	fn = (char*)malloc(strlen(bf->prefix) + 9);
	sprintf(fn, "%s.pbf", bf->prefix);
	bgt->pb = pbf_open_r(fn); // FIXME: check if .pbf is present
	sprintf(fn, "%s.bcf", bf->prefix);
	bgt->bcf = bgzf_open(fn, "rb");
	bgt->b0 = bcf_init1();
	bcf_seekn(bgt->bcf, bgt->f->idx, 0);
	bgt->gtag = (uint32_t*)calloc(bgt->f->f->n_rows, 4);
	free(fn);
	return bgt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x2220
movq %rax, %rbx
movq %r14, (%rax)
movq (%r14), %r12
movq %r12, %rdi
callq 0x2170
leaq 0x9(%rax), %rdi
callq 0x22e0
movq %rax, %r15
leaq 0x6e7b(%rip), %rsi      # 0x1834a
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2400
movq %r15, %rdi
callq 0x10a46
movq %rax, 0x8(%rbx)
movq (%r14), %rdx
leaq 0x6e66(%rip), %rsi      # 0x18358
movq %r15, %rdi
xorl %eax, %eax
callq 0x2400
leaq 0x7b0d(%rip), %rsi      # 0x19010
movq %r15, %rdi
callq 0x3ef4
movq %rax, %r12
movq %rax, 0x10(%rbx)
xorl %eax, %eax
callq 0xa6a8
movq %rax, 0x18(%rbx)
movq 0x18(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0xd6cd
movq 0x8(%r14), %rax
movslq 0x20(%rax), %rdi
pushq $0x4
popq %rsi
callq 0x2220
movq %rax, 0x50(%rbx)
movq %r15, %rdi
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_reader_destroy
void bgt_reader_destroy(bgt_t *bgt)
{
	bcf_destroy1(bgt->b0);
	free(bgt->gtag); free(bgt->group); free(bgt->out);
	if (bgt->h_out) bcf_hdr_destroy(bgt->h_out);
	hts_itr_destroy(bgt->itr);
	pbf_close(bgt->pb);
	bgzf_close(bgt->bcf);
	free(bgt);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xa6b5
movq 0x50(%rbx), %rdi
callq 0x2050
movq 0x48(%rbx), %rdi
callq 0x2050
movq 0x40(%rbx), %rdi
callq 0x2050
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x1158c
callq 0xa500
movq 0x20(%rbx), %rdi
callq 0x8036
movq 0x8(%rbx), %rdi
callq 0x10c4d
movq 0x10(%rbx), %rdi
callq 0x4ddc
movq %rbx, %rdi
popq %rbx
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_add_group_core
int bgt_add_group_core(bgt_t *bgt, int n, char *const* samples, const char *expr)
{
	int i, size = 0;
	const fmf_t *f = bgt->f->f;

	if (n == BGT_SET_ALL_SAMPLES) {
		for (i = 0; i < f->n_rows; ++i)
			bgt->gtag[i] = 1;
		size = f->n_rows;
		bgt->n_groups = 1;
	} else if (n > 0 || expr != 0) {
		int err, absent;
		khash_t(s2i) *h;
		kexpr_t *ke = 0;

		if (expr) {
			ke = ke_parse(expr, &err);
			if (err && ke) {
				ke_destroy(ke);
				ke = 0;
			}
			if (ke == 0) return -1;
		}
		h = kh_init(s2i);
		for (i = 0; i < n; ++i)
			kh_put(s2i, h, samples[i], &absent);
		for (i = 0, size = 0; i < f->n_rows; ++i) {
			int to_add = 0;
			if (ke && fmf_test(f, i, ke)) to_add = 1;
			if (kh_get(s2i, h, f->rows[i].name) != kh_end(h)) {
				int mgs = bgt->f->mgs[i] >= 0? bgt->f->mgs[i] : bgt->mgs_def;
				if (mgs == 1 || mgs == 0) to_add = 1;
			}
			if (to_add) ++size, bgt->gtag[i] = bgt->n_groups + 1;
		}
		kh_destroy(s2i, h);
		ke_destroy(ke);
		++bgt->n_groups;
	} else return -1;
	return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movq (%rdi), %rax
movq 0x8(%rax), %r14
cmpl $-0x1, %esi
je 0x11629
movl %esi, %r15d
testl %esi, %esi
setle %al
testq %rcx, %rcx
sete %dl
pushq $-0x1
popq %r12
testb %dl, %al
jne 0x1173e
movq %rdi, 0x8(%rsp)
xorl %ebp, %ebp
testq %rcx, %rcx
je 0x11650
leaq 0x14(%rsp), %r13
movq %rcx, %rdi
movq %r13, %rsi
callq 0x1528c
movq %rax, %rbx
cmpl $0x0, (%r13)
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x11654
movq %rbx, %rdi
callq 0x162c2
jmp 0x1173e
xorl %eax, %eax
movslq 0x20(%r14), %r12
cmpq %r12, %rax
jge 0x11644
movq 0x50(%rdi), %rcx
movl $0x1, (%rcx,%rax,4)
incq %rax
jmp 0x1162b
movl $0x1, 0x38(%rdi)
jmp 0x1173e
xorl %ebx, %ebx
jmp 0x1165d
testq %rbx, %rbx
je 0x1173e
xorl %eax, %eax
callq 0x5876
movq %rax, %r13
testl %r15d, %r15d
cmovlel %ebp, %r15d
leaq 0x10(%rsp), %r12
cmpq %rbp, %r15
je 0x11690
movq (%rsp), %rax
movq (%rax,%rbp,8), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x5c2d
incq %rbp
jmp 0x11673
xorl %r15d, %r15d
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x8(%rsp), %rdx
movq %rbx, (%rsp)
movslq 0x20(%r14), %rax
cmpq %rax, %rbp
jge 0x11725
testq %rbx, %rbx
je 0x116c3
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x9339
testl %eax, %eax
sete %bl
jmp 0x116c5
movb $0x1, %bl
movq 0x28(%r14), %rax
movq (%rax,%r15), %rsi
movq %r13, %rdi
callq 0x58e5
cmpl (%r13), %eax
jne 0x116e6
testb %bl, %bl
movq 0x8(%rsp), %rdx
je 0x11706
jmp 0x11715
movq 0x8(%rsp), %rdx
movq (%rdx), %rax
movq 0x20(%rax), %rax
movl (%rax,%rbp,4), %eax
testl %eax, %eax
jns 0x116fc
movl 0x3c(%rdx), %eax
cmpl $0x2, %eax
setae %al
testb %bl, %al
jne 0x11715
incl %r12d
movl 0x38(%rdx), %eax
incl %eax
movq 0x50(%rdx), %rcx
movl %eax, (%rcx,%rbp,4)
movq (%rsp), %rbx
incq %rbp
addq $0x18, %r15
jmp 0x116a1
movq %rbx, %r14
movq %rdx, %rbx
movq %r13, %rdi
callq 0x5881
movq %r14, %rdi
callq 0x162c2
incl 0x38(%rbx)
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_add_group
int bgt_add_group(bgt_t *bgt, const char *expr)
{
	int is_file, ret = 0;
	is_file = bgt_is_file(expr);
	if (*expr == ':' || *expr == ',' || (*expr != '?' && is_file)) {
		int i, n;
		char **samples;
		samples = hts_readlines(expr, &n);
		ret = bgt_add_group_core(bgt, n, samples, 0);
		for (i = 0; i < n; ++i) free(samples[i]);
		free(samples);
	} else ret = bgt_add_group_core(bgt, 0, 0, expr);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x117ea
movzbl (%r14), %ecx
cmpl $0x2c, %ecx
je 0x1177e
cmpl $0x3a, %ecx
je 0x1177e
cmpb $0x3f, %cl
je 0x117d2
testl %eax, %eax
je 0x117d2
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x60a9
movq %rax, %r14
movl (%r15), %esi
xorl %r15d, %r15d
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x115b0
movl %eax, %ebx
movslq 0xc(%rsp), %rax
cmpq %rax, %r15
jge 0x117be
movq (%r14,%r15,8), %rdi
callq 0x2050
incq %r15
jmp 0x117a6
movq %r14, %rdi
callq 0x2050
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x115b0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_set_region
int bgt_set_region(bgt_t *bgt, const char *reg)
{
	if (bgt->itr) bcf_itr_destroy(bgt->itr);
	bgt->itr = bcf_itr_querys(bgt->f->idx, bgt->f->h0, reg);
	bgt->b0->shared.l = 0; // mark b0 unread
	return bgt->itr? 0 : -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x1182e
callq 0x8036
movq (%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdi
leaq -0x492e(%rip), %rdx     # 0xcf12
movq %r14, %rsi
callq 0x81e2
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rcx
andq $0x0, 0x18(%rcx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_read_core0
int bgt_read_core0(bgt_t *bgt)
{
	int i, id, row;
	row = bgt->itr? bcf_itr_next(bgt->bcf, bgt->itr, bgt->b0) : bcf_read1(bgt->bcf, bgt->b0);
	if (row < 0) return row;
	assert(bgt->b0->n_sample == 0); // there shouldn't be any sample fields
	row = -1;
	id = bcf_id2int(bgt->f->h0, BCF_DT_ID, "_row");
	assert(id > 0);
	bcf_unpack(bgt->b0, BCF_UN_INFO);
	for (i = 0; i < bgt->b0->n_info; ++i) {
		bcf_info_t *p = &bgt->b0->d.info[i];
		if (p->key == id) row = p->v1.i;
	}
	assert(row >= 0);
	return row;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
testq %rsi, %rsi
je 0x11be7
leaq -0x7402(%rip), %rcx     # 0xa7db
xorl %r8d, %r8d
callq 0x82a0
jmp 0x11bef
movq %rdx, %rsi
callq 0xa71b
testl %eax, %eax
js 0x11c55
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rax
shrq $0x28, %rax
jne 0x11c5c
movq (%rbx), %rax
movq 0x10(%rax), %rdi
leaq 0x6750(%rip), %rdx      # 0x1835f
xorl %esi, %esi
callq 0xcee5
testl %eax, %eax
jle 0x11c7b
movl %eax, %ebp
movq 0x18(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0xc692
movq 0x18(%rbx), %rcx
movzwl 0x10(%rcx), %eax
imulq $0x18, %rax, %rdx
pushq $-0x1
popq %rax
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x11c51
movq 0x78(%rcx), %rdi
cmpl %ebp, (%rdi,%rsi)
jne 0x11c4b
movl 0xc(%rdi,%rsi), %eax
addq $0x18, %rsi
jmp 0x11c39
testl %eax, %eax
js 0x11c9a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7b6a(%rip), %rdi      # 0x197cd
leaq 0x7b7a(%rip), %rsi      # 0x197e4
leaq 0x7b79(%rip), %rcx      # 0x197ea
movl $0x115, %edx            # imm = 0x115
callq 0x21b0
leaq 0x7b84(%rip), %rdi      # 0x19806
leaq 0x7b5b(%rip), %rsi      # 0x197e4
leaq 0x7b5a(%rip), %rcx      # 0x197ea
movl $0x118, %edx            # imm = 0x118
callq 0x21b0
leaq 0x7b6c(%rip), %rdi      # 0x1980d
leaq 0x7b3c(%rip), %rsi      # 0x197e4
leaq 0x7b3b(%rip), %rcx      # 0x197ea
movl $0x11e, %edx            # imm = 0x11E
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_read_core
int bgt_read_core(bgt_t *bgt)
{
	if (bgt->bed || bgt->h_al) {
		int ret;
		while ((ret = bgt_read_core0(bgt)) >= 0) {
			if (bgt->bed) {
				int r;
				r = bed_overlap(bgt->bed, bgt->h_out->id[BCF_DT_CTG][bgt->b0->rid].key, bgt->b0->pos, bgt->b0->pos + bgt->b0->rlen);
				if (bgt->bed_excl && r) continue;
				if (!bgt->bed_excl && !r) continue;
			}
			if (bgt->h_al && !al_present((khash_t(str)*)bgt->h_al, bgt->h_out, bgt->b0)) continue;
			break;
		}
		return ret;
	} else return bgt_read_core0(bgt);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0x11f08
cmpq $0x0, 0x60(%rbx)
je 0x11f76
movq %rbx, %rdi
callq 0x11bbf
movl %eax, %ebp
testl %eax, %eax
js 0x11f6d
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x11f53
movq 0x18(%rbx), %rax
movq 0x58(%rbx), %rcx
movq 0x20(%rcx), %rcx
movslq (%rax), %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rsi
movl 0x4(%rax), %edx
movl 0x8(%rax), %ecx
addl %edx, %ecx
callq 0xf6c0
cmpl $0x0, 0x30(%rbx)
setne %cl
testl %eax, %eax
setne %al
cmpb %cl, %al
je 0x11f08
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x11f6d
movq 0x18(%rbx), %rdx
movq 0x58(%rbx), %rsi
callq 0x11f84
testl %eax, %eax
je 0x11f08
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11bbf
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: al_present
static int al_present(khash_t(str) *h, const bcf_hdr_t *hdr, const bcf1_t *b)
{
	int ret = 0;
	bgt_allele_t a, r;
	khint_t k;
	kstring_t s = {0,0,0};
	memset(&a, 0, sizeof(bgt_allele_t));
	memset(&r, 0, sizeof(bgt_allele_t));
	bgt_al_from_bcf(hdr, b, &a, &r);
	bgt_al_format(&a, &s);
	k = kh_get(str, h, s.s);
	if (k == kh_end(h)) {
		bgt_al_format(&r, &s);
		k = kh_get(str, h, s.s);
		if (k != kh_end(h)) ret = 2;
	} else ret = 1;
	free(s.s); free(a.chr.s); free(r.chr.s);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x50(%rsp), %r15
movaps %xmm0, (%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, 0x20(%r15)
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, 0x20(%rcx)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0x14201
movq %r15, %rdi
movq %r14, %rsi
callq 0x12f49
movq 0x10(%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1519f
cmpl (%rbx), %eax
jne 0x1201d
leaq 0x20(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x12f49
movq 0x10(%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1519f
xorl %ebp, %ebp
cmpl (%rbx), %eax
setne %bpl
addl %ebp, %ebp
jmp 0x12020
pushq $0x1
popq %rbp
movq %r14, %rdi
callq 0x2050
movq 0x60(%rsp), %rdi
callq 0x2050
movq 0x30(%rsp), %rdi
callq 0x2050
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_read_rec
int bgt_read_rec(bgt_t *bgt, bgt_rec_t *r)
{
	int row;
	const uint8_t **a;
	r->b0 = 0, r->a[0] = r->a[1] = 0;
	if (bgt->n_out == 0) return -1;
	if ((row = bgt_read_core(bgt)) < 0) return row;
	r->b0 = bgt->b0;
	pbf_seek(bgt->pb, row);
	a = pbf_read(bgt->pb);
	r->a[0] = (uint8_t*)a[0], r->a[1] = (uint8_t*)a[1];
	return row;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
andq $0x0, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
cmpl $0x0, 0x34(%rdi)
je 0x1209e
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11ef4
movl %eax, %ebp
testl %eax, %eax
js 0x120a1
movq 0x18(%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rdi
movl %ebp, %esi
callq 0x10fad
movq 0x8(%r14), %rdi
callq 0x10e81
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x120a1
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_read
int bgt_read(bgt_t *bgt, bcf1_t *b)
{
	int ret;
	bgt_rec_t r;
	if (bgt->h_out == 0) bgt_prepare(bgt);
	if ((ret = bgt_read_rec(bgt, &r)) < 0) return ret;
	bcfcpy(b, r.b0);
	bgt_gen_gt(bgt->h_out, b, bgt->n_out, r.a, 0);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x58(%rdi)
jne 0x120c7
movq %r14, %rdi
callq 0x11882
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1204c
movl %eax, %ebp
testl %eax, %eax
js 0x120ff
leaq 0x8(%rsp), %r15
movq -0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xd378
movq 0x58(%r14), %rdi
movl 0x34(%r14), %edx
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x11cb9
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_reader_init
bgtm_t *bgtm_reader_init(int n_files, bgt_file_t *const* bf)
{
	bgtm_t *bm;
	int i;
	bm = (bgtm_t*)calloc(1, sizeof(bgtm_t));
	bm->n_bgt = n_files;
	bm->bgt = (bgt_t**)calloc(bm->n_bgt, sizeof(void*));
	for (i = 0; i < bm->n_bgt; ++i)
		bm->bgt[i] = bgt_reader_init(bf[i]);
	bm->r = (bgt_rec_t*)calloc(bm->n_bgt, sizeof(bgt_rec_t));
	return bm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
pushq $0x1
popq %rdi
movl $0xb8, %esi
callq 0x2220
movq %rax, %rbx
movl %ebp, (%rax)
movslq %ebp, %r15
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x2220
movq %rax, %r12
movq %rax, 0x38(%rbx)
xorl %r13d, %r13d
testl %r15d, %r15d
movl $0x0, %ebp
cmovgl %r15d, %ebp
cmpq %r13, %rbp
je 0x12169
movq (%r14,%r13,8), %rdi
callq 0x11495
movq %rax, (%r12,%r13,8)
incq %r13
jmp 0x12152
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x2220
movq %rax, 0x40(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_reader_destroy
void bgtm_reader_destroy(bgtm_t *bm)
{
	int i;
	free(bm->hap);
	free(bm->alcnt);
	if (bm->site_flt) ke_destroy(bm->site_flt);
	free(bm->mgs);
	free(bm->group);
	free(bm->sample_idx);
	if (bm->h_out) bcf_hdr_destroy(bm->h_out);
	free(bm->a[0]); free(bm->a[1]);
	for (i = 0; i < bm->n_aal; ++i) free(bm->aal[i].chr.s);
	free(bm->aal);
	for (i = 0; i < bm->n_fields; ++i)
		ke_destroy(bm->fields[i]);
	free(bm->fields);
	free(bm->tbl_line.s);
	for (i = 0; i < bm->n_bgt; ++i)
		bgt_reader_destroy(bm->bgt[i]);
	if (bm->h_al) {
		khint_t k;
		khash_t(str) *h = (khash_t(str)*)bm->h_al;
		for (k = 0; k < kh_end(h); ++k)
			if (kh_exist(h, k)) free((char*)kh_key(h, k));
		kh_destroy(str, h);
	}
	free(bm->r); free(bm->bgt); free(bm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb0(%rdi), %rdi
callq 0x2050
movq 0xa8(%rbx), %rdi
callq 0x2050
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x121bb
callq 0x162c2
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x20(%rbx), %rdi
callq 0x2050
movq 0x18(%rbx), %rdi
callq 0x2050
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x121e4
callq 0xa500
movq 0x58(%rbx), %rdi
callq 0x2050
movq 0x60(%rbx), %rdi
callq 0x2050
pushq $0x10
popq %r14
xorl %r15d, %r15d
movslq 0x90(%rbx), %rax
movq 0x98(%rbx), %rdi
cmpq %rax, %r15
jge 0x12222
movq (%rdi,%r14), %rdi
callq 0x2050
incq %r15
addq $0x30, %r14
jmp 0x121fd
callq 0x2050
xorl %r14d, %r14d
movslq 0x68(%rbx), %rax
movq 0x70(%rbx), %rdi
cmpq %rax, %r14
jge 0x12245
movq (%rdi,%r14,8), %rdi
callq 0x162c2
incq %r14
jmp 0x1222a
callq 0x2050
movq 0x88(%rbx), %rdi
callq 0x2050
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x12273
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x11556
incq %r14
jmp 0x12259
movq 0xa0(%rbx), %r14
testq %r14, %r14
je 0x122e0
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%r14), %eax
cmpq %rax, %r12
jae 0x122bd
movq 0x10(%r14), %rax
movq %r12, %rcx
shrq $0x4, %rcx
movl (%rax,%rcx,4), %eax
movl %r15d, %ecx
andb $0x1e, %cl
shrl %cl, %eax
testb $0x3, %al
jne 0x122b4
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x2050
incq %r12
addl $0x2, %r15d
jmp 0x12285
movq 0x18(%r14), %rdi
callq 0x2050
movq 0x10(%r14), %rdi
callq 0x2050
movq 0x20(%r14), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movq 0x40(%rbx), %rdi
callq 0x2050
movq 0x38(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_add_group
int bgtm_add_group(bgtm_t *bm, const char *expr)
{
	int i, ret = 0, size = 0;
	for (i = 0; i < bm->n_bgt; ++i)
		if ((ret = bgt_add_group(bm->bgt[i], expr)) < 0) break;
		else size += ret;
	if (i == bm->n_bgt) ++bm->n_groups; // TODO: revert bm->bgt[i]->n_groups
	return i == bm->n_bgt? size : ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %eax, %eax
xorl %ebp, %ebp
movslq (%rbx), %rcx
cmpq %rcx, %r15
jge 0x1233e
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x11750
testl %eax, %eax
js 0x1233c
addl %eax, %ebp
incq %r15
jmp 0x12319
movl (%rbx), %ecx
cmpl %r15d, %ecx
jne 0x12348
incl 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_set_region
int bgtm_set_region(bgtm_t *bm, const char *reg)
{
	int i, ret = 0;
	for (i = 0; i < bm->n_bgt; ++i)
		if ((ret = bgt_set_region(bm->bgt[i], reg)) < 0)
			break;
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
pushq $-0x1
popq %rbp
xorl %r12d, %r12d
movslq (%r15), %rax
cmpq %rax, %r12
jge 0x1238a
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x11816
incq %r12
testl %eax, %eax
jns 0x12369
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_set_start
int bgtm_set_start(bgtm_t *bm, int64_t n)
{
	int i;
	for (i = 0; i < bm->n_bgt; ++i)
		bgt_set_start(bm->bgt[i], n);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x123c0
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x11867
incq %r15
jmp 0x123a3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_set_flt_site
int bgtm_set_flt_site(bgtm_t *bm, const char *expr)
{
	int err;
	if (bm->site_flt) ke_destroy(bm->site_flt);
	bm->site_flt = ke_parse(expr, &err);
	if (err != 0) {
		if (bm->site_flt) ke_destroy(bm->site_flt);
		bm->site_flt = 0;
		return err;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x12409
callq 0x162c2
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1528c
movq %rax, %rdi
movq %rax, 0x48(%rbx)
movl (%r15), %eax
testl %eax, %eax
je 0x1243c
testq %rdi, %rdi
je 0x12435
callq 0x162c2
movl 0xc(%rsp), %eax
andq $0x0, 0x48(%rbx)
jmp 0x1243e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: add_allele
static inline bgt_allele_t *add_allele(bgt_allele_t *al, int *n, int *m, const char *s)
{
	if (*n == *m) {
		int oldm = *m;
		*m = *m? *m<<1 : 4;
		al = (bgt_allele_t*)realloc(al, *m * sizeof(bgt_allele_t));
		memset(al + oldm, 0, (*m - oldm) * sizeof(bgt_allele_t));
	}
	if (bgt_al_parse(s, &al[*n]) == 0) ++(*n);
	return al;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
cmpl (%rdx), %eax
jne 0x12f25
movq %rdx, %r12
leal (%rax,%rax), %ecx
testl %eax, %eax
pushq $0x4
popq %rdx
cmovnel %ecx, %edx
movslq %eax, %r13
movl %edx, (%r12)
movslq %edx, %rax
imulq $0x30, %rax, %rsi
movq %r14, %rdi
callq 0x2340
movq %rax, %r14
imulq $0x30, %r13, %rdi
addq %rax, %rdi
movslq (%r12), %rax
subq %r13, %rax
imulq $0x30, %rax, %rdx
xorl %esi, %esi
callq 0x21e0
movl (%rbx), %eax
cltq
imulq $0x30, %rax, %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x12c3f
testl %eax, %eax
jne 0x12f3c
incl (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_al_format
void bgt_al_format(const bgt_allele_t *a, kstring_t *s)
{
	s->l = 0;
	kputsn(a->chr.s, a->al - a->chr.s - 1, s); kputc(':', s);
	kputw(a->pos, s); kputc(':', s);
	kputw(a->rlen, s); kputc(':', s);
	kputsn(a->al, a->chr.s + a->chr.l - a->al, s);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, (%rsi)
movq 0x10(%rdi), %rdi
movl %edi, %esi
notl %esi
addl 0x18(%r14), %esi
movq %rbx, %rdx
callq 0x11a85
pushq $0x3a
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x11b3c
movl 0x24(%r14), %edi
movq %rbx, %rsi
callq 0x150c1
movl %ebp, %edi
movq %rbx, %rsi
callq 0x11b3c
movl 0x28(%r14), %edi
movq %rbx, %rsi
callq 0x150c1
movl %ebp, %edi
movq %rbx, %rsi
callq 0x11b3c
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
addl (%r14), %esi
subl %edi, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x11a85
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgt_parse_fields
kexpr_t **bgt_parse_fields(const char *str, int *_n)
{
	int m = 0, n = 0, n_par = 0, i;
	char **s = 0;
	const char *q, *p;
	kexpr_t **e = 0;
	*_n = 0;
	for (q = p = str;; ++p) {
		if (*p == '(') ++n_par;
		else if (*p == ')') --n_par;
		else if (*p == 0 || (*p == ',' && n_par == 0)) {
			if (m == n) {
				m = m? m<<1 : 16;
				s = (char**)realloc(s, m * sizeof(void*));
			}
			s[n] = (char*)calloc(p - q + 1, 1);
			strncpy(s[n++], q, p - q);
			q = p + 1;
			if (*p == 0) break;
		}
	}
	if (n_par == 0) {
		e = (kexpr_t**)calloc(n, sizeof(kexpr_t*));
		for (i = m = 0; i < n; ++i) {
			int err, j;
			e[i] = ke_parse(s[i], &err);
			if (err) {
				for (j = 0; j <= i; ++j)
					ke_destroy(e[j]);
				break;
			}
		}
		if (i < n) {
			free(e);
			e = 0, *_n = 0;
		} else *_n = n;
	}
	for (i = 0; i < n; ++i) free(s[i]);
	free(s);
	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq %rsi, 0x20(%rsp)
andl $0x0, (%rsi)
leaq 0x1(%rdi), %r13
xorl %esi, %esi
xorl %r14d, %r14d
xorl %edx, %edx
movq $0x0, 0x8(%rsp)
movq %rdi, %r12
movzbl -0x1(%r13), %eax
testl %eax, %eax
je 0x1301f
cmpl $0x29, %eax
je 0x13007
cmpl $0x28, %eax
jne 0x1300e
incl %edx
jmp 0x1309c
decl %edx
jmp 0x1309c
cmpb $0x2c, %al
sete %al
testl %edx, %edx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1309c
movl %edx, 0x10(%rsp)
cmpl %r14d, %esi
jne 0x13050
leal (%rsi,%rsi), %ebp
testl %esi, %esi
pushq $0x10
popq %rax
cmovel %eax, %ebp
movslq %ebp, %rsi
shlq $0x3, %rsi
movq 0x8(%rsp), %rdi
callq 0x2340
movq %rax, %rbx
movl %ebp, %eax
movq %rax, 0x18(%rsp)
jmp 0x1305a
movq %rsi, 0x18(%rsp)
movq 0x8(%rsp), %rbx
movq %r15, %rbp
subq %r12, %rbp
leaq 0x1(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x2220
movq %r12, %rsi
movslq %r14d, %r12
movq %rbx, 0x8(%rsp)
movq %rax, (%rbx,%r12,8)
incl %r14d
movq %rax, %rdi
movq %rbp, %rdx
callq 0x2080
cmpb $0x0, -0x1(%r13)
je 0x130a7
movq %r13, %r12
movl 0x10(%rsp), %edx
movq 0x18(%rsp), %rsi
incq %r13
incq %r15
jmp 0x12fed
cmpl $0x0, 0x10(%rsp)
je 0x130b3
xorl %r15d, %r15d
jmp 0x1311c
movslq %r14d, %rdi
pushq $0x8
popq %rsi
callq 0x2220
movq %rax, %r15
xorl %r13d, %r13d
leaq 0x14(%rsp), %rbx
cmpq %r12, %r13
jg 0x13114
movq 0x8(%rsp), %rax
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
callq 0x1528c
movq %rax, (%r15,%r13,8)
cmpl $0x0, 0x14(%rsp)
jne 0x130ef
incq %r13
jmp 0x130c9
pushq $-0x1
popq %rbx
cmpq %rbx, %r13
je 0x13106
movq 0x8(%r15,%rbx,8), %rdi
callq 0x162c2
incq %rbx
jmp 0x130f2
movq %r15, %rdi
callq 0x2050
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rsp), %rax
movl %r14d, (%rax)
xorl %ebx, %ebx
movq 0x8(%rsp), %r14
cmpq %r12, %rbx
jg 0x13136
movq (%r14,%rbx,8), %rdi
callq 0x2050
incq %rbx
jmp 0x13123
movq %r14, %rdi
callq 0x2050
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_test_mgs
int bgtm_test_mgs(const bgtm_t *bm)
{
	int i, cnt[BGT_MAX_GROUPS];
	memset(cnt, 0, BGT_MAX_GROUPS * sizeof(int));
	for (i = 0; i < bm->n_out; ++i)
		++cnt[bm->group[i]-1];
	for (i = 0; i < bm->n_out; ++i)
		if (bm->mgs[i] > cnt[bm->group[i]-1])
			return 0;
	return 1;
}

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rsp)
movaps %xmm0, -0x20(%rsp)
movaps %xmm0, -0x30(%rsp)
movaps %xmm0, -0x40(%rsp)
movaps %xmm0, -0x50(%rsp)
movaps %xmm0, -0x60(%rsp)
movaps %xmm0, -0x70(%rsp)
movaps %xmm0, -0x80(%rsp)
movl 0x4(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
cmpq %rax, %rcx
je 0x1373b
movq 0x20(%rdi), %rdx
movl (%rdx,%rax,4), %edx
decl %edx
incl -0x80(%rsp,%rdx,4)
incq %rax
jmp 0x13724
xorl %edx, %edx
movl $0x1, %eax
cmpq %rdx, %rcx
je 0x13764
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %r8
movl (%r8,%rdx,4), %r8d
movl (%rsi,%rdx,4), %esi
decl %esi
incq %rdx
cmpl -0x80(%rsp,%rsi,4), %r8d
jle 0x13742
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_assign_expr
void bgtm_assign_expr(kexpr_t *e, const bgt_info_t *ss)
{
	int i;
	char key[5];
	ke_set_int(e, "AN", ss->an);
	ke_set_int(e, "AC", ss->ac[0]);
	for (i = 0; i < ss->n_groups; ++i) {
		ke_set_int(e, gen_group_key(key, 'N', i), ss->gan[i]);
		ke_set_int(e, gen_group_key(key, 'C', i), ss->gac[i][0]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rdx
leaq 0x64ac(%rip), %rsi      # 0x19c2e
callq 0x16315
movslq (%rbx), %rdx
leaq 0x64a0(%rip), %rsi      # 0x19c31
movq %r14, %rdi
callq 0x16315
xorl %r13d, %r13d
leaq 0x3(%rsp), %r15
pushq $0xa
popq %rbp
movslq 0xc(%rbx), %rax
cmpq %rax, %r13
jge 0x13841
movw $0x4e41, 0x3(%rsp)      # imm = 0x4E41
cmpq $0x8, %r13
ja 0x137c6
leal 0x31(%r13), %eax
xorl %edx, %edx
jmp 0x137d8
leal 0x1(%r13), %eax
xorl %edx, %edx
divl %ebp
addb $0x30, %al
orb $0x30, %dl
movb $0x0, 0x7(%rsp)
movb %al, 0x5(%rsp)
movb %dl, 0x6(%rsp)
movslq 0x10(%rbx,%r13,4), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x16315
movw $0x4341, 0x3(%rsp)      # imm = 0x4341
cmpq $0x8, %r13
ja 0x13809
leal 0x31(%r13), %eax
leaq 0x1(%r13), %r12
xorl %edx, %edx
jmp 0x1381e
leaq 0x1(%r13), %r12
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
addb $0x30, %al
orb $0x30, %dl
movb $0x0, 0x7(%rsp)
movb %al, 0x5(%rsp)
movb %dl, 0x6(%rsp)
movslq 0x90(%rbx,%r13,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x16315
movq %r12, %r13
jmp 0x137a4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]bgt/bgt.c
// Function: bgtm_pass_site_flt
int bgtm_pass_site_flt(const bgt_info_t *ss, kexpr_t *flt)
{
	int is_true, err;
	if (flt == 0) return 1;
	bgtm_assign_expr(flt, ss);
	is_true = !!ke_eval_int(flt, &err);
	return err? 0 : is_true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1388b
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x13766
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1625a
testq %rax, %rax
setne %al
cmpl $0x0, (%r14)
sete %cl
andb %al, %cl
movzbl %cl, %eax
jmp 0x1388e
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq