LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: Disasm
int __bea_callspec__ Disasm (PDISASM pMyDisasm) {

    if (InitVariables(pMyDisasm)) {
        (void) AnalyzeOpcode(pMyDisasm);
        if (!GV.OutOfBlock) {
            FixArgSizeForMemoryOperand(pMyDisasm);
            FixREXPrefixes(pMyDisasm);
            FillSegmentsRegisters(pMyDisasm);
            CompleteInstructionFields(pMyDisasm);
            #ifndef BEA_LIGHT_DISASSEMBLY
                if (GV.SYNTAX_ == ATSyntax) {
                    BuildCompleteInstructionATSyntax(pMyDisasm);
                }
                else {
                    BuildCompleteInstruction(pMyDisasm);
                }
            #endif
            if (GV.ERROR_OPCODE) {
                return -1;
            }
            else {
                return (int) (GV.EIP_-(*pMyDisasm).EIP);
            }
        }
        else {
            return 0;
        }
    }
    else {
        return -1;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2b408
movq 0x1f0(%rbx), %rax
movzbl (%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl (%rax), %eax
leaq 0xdb1c(%rip), %rcx      # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
xorl %eax, %eax
cmpl $0x0, 0x289(%rbx)
jne 0x2b406
movq %rbx, %rdi
callq 0x2b58a
movl 0x284(%rbx), %eax
movl %eax, 0x1e9(%rbx)
movb 0x288(%rbx), %al
movb %al, 0x1ed(%rbx)
movq %rbx, %rdi
callq 0x2b64a
movl 0x78(%rbx), %eax
addl $-0xb, %eax
cmpl $0x1, %eax
ja 0x2b3d2
movl $0x1, 0xe8(%rbx)
cmpl $0x400, 0x24c(%rbx)     # imm = 0x400
jne 0x2b3e8
movq %rbx, %rdi
callq 0x2b92e
jmp 0x2b3f0
movq %rbx, %rdi
callq 0x2bc43
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, 0x280(%rbx)
jne 0x2b406
movl 0x1f0(%rbx), %eax
subl (%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/redis_parse.c
// Function: createStringObject
static void *createStringObject(const redisReadTask *task, char *str, size_t len) {
	static char *record = NULL;
	static int score = -1;

	if (with_scores && record != NULL)
		score = atoi(str);
	else {
		record = malloc(len + 1);
		memcpy(record, str, len);
		record[len] = '\0';	
	}

	if (!with_scores || score != -1) {
		process_record(record, score);
		record = NULL;
		score = -1;
	}

	redisReply *r;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movb 0x7e93(%rip), %bpl      # 0xa280
movq 0x9acc(%rip), %rbx      # 0xbec0
testq %rbx, %rbx
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x2411
movq %r15, %rdi
callq 0x2230
movl %eax, 0x7e29(%rip)      # 0xa238
jmp 0x2440
movq %rdx, %r14
leaq 0x1(%rdx), %rdi
callq 0x21f0
movq %rax, %rbx
movq %rax, 0x9a99(%rip)      # 0xbec0
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21d0
movb $0x0, (%rbx,%r14)
movl 0x7df8(%rip), %eax      # 0xa238
cmpl $-0x1, %eax
sete %cl
testb %cl, %bpl
jne 0x246a
movq %rbx, %rdi
movl %eax, %esi
callq 0x31f1
movq $0x0, 0x9a60(%rip) # 0xbec0
movl $0xffffffff, 0x7dce(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/redis_parse.c
// Function: column_to_index
int column_to_index(char *key) {
	int i, index = -1;

	for (i = 0; i < columns_count; ++i)
		if (strcmp(columns[i], key) == 0)
			index = i;
	
	return index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x789c(%rip), %r15d     # 0xa20c
testq %r15, %r15
je 0x29a6
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x77fc(%rip), %r14      # 0xa180
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21c0
testl %eax, %eax
cmovel %r12d, %ebp
incq %r12
addq $0x14, %r14
cmpq %r12, %r15
jne 0x2987
jmp 0x29ab
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/redis_parse.c
// Function: to_fields
char **to_fields(char *record) {
	char **fields = (char **)malloc(sizeof(char*) * columns_count);
	char *field;
	int i;

	for(i = 0; i < columns_count; ++i) {
		field = xstrtok(i == 0 ? record : NULL, "|");
		if (field == NULL)
			field = empty;
		fields[i] = field;
	}

	return fields;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x7843(%rip), %r15d     # 0xa20c
leaq (,%r15,8), %rdi
callq 0x21f0
movq %rax, %r14
testq %r15, %r15
je 0x2a1c
xorl %r12d, %r12d
leaq 0x46aa(%rip), %r15      # 0x7092
leaq 0x7892(%rip), %r13      # 0xa281
testq %r12, %r12
movl $0x0, %edi
cmoveq %rbx, %rdi
movq %r15, %rsi
callq 0x33ac
testq %rax, %rax
cmoveq %r13, %rax
movq %rax, (%r14,%r12,8)
incq %r12
movl 0x77f5(%rip), %eax      # 0xa20c
cmpq %rax, %r12
jb 0x29ef
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/winton[P]redis_parse/redis_parse.c
// Function: xstrtok
char *xstrtok(char *line, char *delims) {
	static char *saveline = NULL;
	char *p;
	int n;

	if(line != NULL)
		saveline = line;

	if (saveline == NULL || *saveline == '\0')
		return NULL;
	
	n = strcspn(saveline, delims);
	p = saveline;

	saveline += n;

	if (*saveline != '\0')
		*saveline++ = '\0';

	return p;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x33be
movq %rdi, %rbx
movq %rdi, 0x8afc(%rip)      # 0xbeb8
jmp 0x33ca
movq 0x8af3(%rip), %rbx      # 0xbeb8
testq %rbx, %rbx
je 0x33fb
cmpb $0x0, (%rbx)
je 0x33fb
movq %rbx, %rdi
callq 0x2160
movslq %eax, %rcx
leaq (%rbx,%rcx), %rax
movq %rax, 0x8ad3(%rip)      # 0xbeb8
cmpb $0x0, (%rbx,%rcx)
je 0x33fd
leaq 0x1(%rax), %rcx
movq %rcx, 0x8ac2(%rip)      # 0xbeb8
movb $0x0, (%rax)
jmp 0x33fd
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/strindex.c
// Function: main
int main(void)
{
  char s[] = "this is first string";
  char t[] = "this";

  printf("%d", strindex(s, t));

  return 0;
}

// Assembly:
pushq %rax
leaq 0xecc(%rip), %rax       # 0x2010
xorl %esi, %esi
movb $0x74, %dl
leaq 0xed6(%rip), %rcx       # 0x2025
cmpb $0x74, %dl
jne 0x116f
movb $0x74, %dil
xorl %edx, %edx
cmpb %dil, (%rax,%rdx)
jne 0x116f
movb 0x1(%rdx,%rcx), %dil
incq %rdx
cmpq $0x4, %rdx
jne 0x1159
jmp 0x1181
incl %esi
movb 0x1(%rax), %dl
incq %rax
cmpl $0x14, %esi
jne 0x114f
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0xea2(%rip), %rdi       # 0x202a
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/strindex.c
// Function: strindex
int strindex(char *s, char *t)
{
  char *first;
  char *second;
  int pos = 0;

  while (*s != '\0')
  {
    if (*s == *t)
    {
      first = s;
      second = t;

      while (*first++ == *second++)
      {
        if (*second == '\0')
          return pos;
      }
    }
    pos++;
    s++;
  }

  return -1;
}

// Assembly:
movb (%rdi), %r8b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %r8b, %r8b
je 0x11d2
movb (%rsi), %dl
xorl %ecx, %ecx
cmpb %dl, %r8b
jne 0x11c4
xorl %r8d, %r8d
movl %edx, %r9d
cmpb %r9b, (%rdi,%r8)
jne 0x11c4
movb 0x1(%rsi,%r8), %r9b
incq %r8
testb %r9b, %r9b
jne 0x11af
jmp 0x11d3
incl %ecx
movb 0x1(%rdi), %r8b
incq %rdi
testb %r8b, %r8b
jne 0x11a4
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/boolean.c
// Function: SH_Boolean__init
SH_Boolean*
SH_Boolean__init(sh_bool_t value, int* err) {
	SH_Boolean* obj = (SH_Boolean*)malloc(sizeof(SH_Boolean));

	__cascade(err, (SH_Boolean*)0);

	if ((SH_Boolean*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Boolean*)0;
	}

	obj->value = (value == SH_FALSE ? SH_FALSE : SH_TRUE);

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %edi
callq 0x1040
testq %rbx, %rbx
je 0x114e
cmpl $0x0, (%rbx)
jne 0x1164
testq %rax, %rax
je 0x115e
xorl %ecx, %ecx
negb %bpl
sbbl %ecx, %ecx
movb %cl, (%rax)
movl $0x0, (%rbx)
jmp 0x1166
xorl %ecx, %ecx
testq %rax, %rax
je 0x1164
negb %bpl
sbbl %ecx, %ecx
movb %cl, (%rax)
jmp 0x1166
movl $0x80000001, (%rbx)     # imm = 0x80000001
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/boolean.c
// Function: SH_Boolean__to_s
sh_char_t*
SH_Boolean__to_s(SH_Boolean* obj, int* err) {
	sh_char_t* str = (sh_char_t*)malloc(sizeof(sh_char_t) * 3);

	__cascade(err, (sh_char_t*)0);

	if ((sh_char_t*)0 == str) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (sh_char_t*)0;
	}

	str[0] = SH_CHAR_C('?');
	str[1] = SH_Boolean__true(obj, err) ? SH_CHAR_C('1') : SH_CHAR_C('0');
	str[2] = SH_CHAR_C(0);

	__clear(err);
	return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, %edi
callq 0x1040
testq %rbx, %rbx
je 0x11f1
cmpl $0x0, (%rbx)
jne 0x1215
testq %rax, %rax
jne 0x11f6
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
jmp 0x1211
testq %rax, %rax
je 0x1215
movb $0x3f, (%rax)
cmpb $0x0, (%r14)
sete %dl
xorb $0x31, %dl
xorl %ecx, %ecx
movb %dl, 0x1(%rax)
movb $0x0, 0x2(%rax)
testq %rbx, %rbx
je 0x1217
movl %ecx, (%rbx)
jmp 0x1217
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/md5.c
// Function: MD5Update
void MD5Update(ctx, buf, len)
    struct MD5Context *ctx; unsigned char *buf; unsigned len;
{
    uint32_t t;

    /* Update bitcount */

    t = ctx->bits[0];
    if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
	ctx->bits[1]++; 	/* Carry from low to high */
    ctx->bits[1] += len >> 29;

    t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */

    /* Handle any leading odd-sized chunks */

    if (t) {
	unsigned char *p = (unsigned char *) ctx->in + t;

	t = 64 - t;
	if (len < t) {
	    memcpy(p, buf, len);
	    return;
	}
	memcpy(p, buf, t);
	byteReverse(ctx->in, 16);
	MD5Transform(ctx->buf, (uint32_t *) ctx->in);
	buf += t;
	len -= t;
    }
    /* Process data in 64-byte chunks */

    while (len >= 64) {
	memcpy(ctx->in, buf, 64);
	byteReverse(ctx->in, 16);
	MD5Transform(ctx->buf, (uint32_t *) ctx->in);
	buf += 64;
	len -= 64;
    }

    /* Handle any remaining bytes of data. */

    memcpy(ctx->in, buf, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
leal (,%rdx,8), %ecx
movl %edx, %edi
shrl $0x1d, %edi
addl %eax, %ecx
movl %ecx, 0x10(%rbx)
adcl %edi, 0x14(%rbx)
movq %rsi, %r14
shrl $0x3, %eax
andl $0x3f, %eax
je 0x12a5
leaq (%rbx,%rax), %rdi
addq $0x18, %rdi
movl $0x40, %ecx
subl %eax, %ecx
movl %edx, %ebp
subl %ecx, %ebp
jae 0x12a9
movl %edx, %edx
jmp 0x1318
movl %edx, %ebp
jmp 0x12c9
leaq 0x18(%rbx), %r15
movl %ecx, %r12d
movq %r14, %rsi
movq %r12, %rdx
callq 0x10b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1328
addq %r12, %r14
cmpl $0x40, %ebp
jb 0x130f
leaq 0x18(%rbx), %r15
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%r15)
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1328
addq $0x40, %r14
addl $-0x40, %ebp
cmpl $0x3f, %ebp
ja 0x12d2
addq $0x18, %rbx
movl %ebp, %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/md5fa.c
// Function: main
int main(int argc, char *argv[])
{
	int i;
	if (argc == 1) md5_one("-");
	else for (i = 1; i < argc; ++i) md5_one(argv[i]);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jne 0x1b28
leaq 0x14ff(%rip), %rdi      # 0x3020
callq 0x1b4f
jmp 0x1b47
jle 0x1b47
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x1b4f
incq %r15
cmpq %r15, %r14
jne 0x1b36
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/pileup_mod.c
// Function: process_pileup
void process_pileup(sam_hdr_t *h, const bam_pileup1_t *p,
                    int tid, int pos, int n) {
    kstring_t s = {0,0};
    printf("%s\t%d\t", sam_hdr_tid2name(h, tid), pos);
    int i;
    for (i = 0; i < n; i++, p++) {
        if (p->is_del) {
            putchar('*');
            continue;
        }

        uint8_t *seq = bam_get_seq(p->b);
        uint8_t *qual = bam_get_qual(p->b);
        unsigned char c = seq_nt16_str[bam_seqi(seq, p->qpos)];
        putchar(c);
        kputc(MIN('~','!'+qual[p->qpos]), &s);
    }
    putchar('\t');
    puts(s.l ? s.s : "");

    free(s.s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rsi, %r14
movl %edx, %esi
callq 0xbaf0
leaq 0x891fb(%rip), %rdi     # 0x8f028
xorl %r15d, %r15d
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x4060
testl %ebx, %ebx
jle 0x5f42
movq $0x0, (%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
testb $0x1, 0x14(%r14)
jne 0x5eea
movq (%r14), %rcx
movl 0x14(%rcx), %edx
movl 0x18(%rcx), %eax
shll $0x2, %edx
addq 0x38(%rcx), %rdx
movzwl 0x12(%rcx), %esi
addq %rdx, %rsi
incl %eax
sarl %eax
movl 0x8(%r14), %ecx
movl %ecx, %edx
sarl %edx
movslq %edx, %rdx
movzbl (%rdx,%rsi), %edx
shll $0x2, %ecx
notb %cl
andb $0x4, %cl
shrl %cl, %edx
movslq %eax, %r15
addq %rsi, %r15
andl $0xf, %edx
leaq 0x8a060(%rip), %rax     # 0x8ff00
movzbl (%rax,%rdx), %edi
callq 0x46d0
movslq 0x8(%r14), %rax
movb (%rax,%r15), %r15b
leaq 0x2(%rbp), %rax
cmpq %rax, %r13
jae 0x5ef6
movq %rax, %rcx
shrq $0x3e, %rcx
movq %rax, %rdx
shrq %rdx
testq %rcx, %rcx
movl $0x0, %r12d
cmoveq %rdx, %r12
addq %rax, %r12
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x4870
testq %rax, %rax
jne 0x5efd
jmp 0x5f22
movl $0x2a, %edi
callq 0x46d0
jmp 0x5f22
movq %r13, %r12
movq (%rsp), %rax
leal 0x21(%r15), %ecx
cmpb $0x5e, %r15b
movzbl %cl, %ecx
movl $0x7e, %edx
cmovael %edx, %ecx
movb %cl, (%rax,%rbp)
movb $0x0, 0x1(%rax,%rbp)
incq %rbp
movq %r12, %r13
movq %rax, (%rsp)
addq $0x28, %r14
decl %ebx
jne 0x5e51
testq %rbp, %rbp
leaq 0x8a2d5(%rip), %rbx     # 0x9020d
movq (%rsp), %r15
cmovneq %r15, %rbx
jmp 0x5f49
leaq 0x8a2c4(%rip), %rbx     # 0x9020d
movl $0x9, %edi
callq 0x46d0
movq %rbx, %rdi
callq 0x47f0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/pileup_mod.c
// Function: pileup_cd_create
int pileup_cd_create(void *data, const bam1_t *b, bam_pileup_cd *cd) {
    hts_base_mod_state *m = hts_base_mod_state_alloc();
    if (bam_parse_basemod(b, m) < 0) {
        hts_base_mod_state_free(m);
        return -1;
    }
    cd->p = m;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
callq 0x2e4d8
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x2eb09
testl %eax, %eax
js 0x5f9a
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x5fa7
movq %r14, %rdi
callq 0x2e4e7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/pileup_mod.c
// Function: main
int main(int argc, char **argv) {
    int compact = 0;
    while (argc > 1 && strcmp(argv[1], "-c") == 0) {
        compact++;
        argc--;
        argv++;
    }

    samFile *in = sam_open(argc > 1 ? argv[1] : "-", "r");
    bam1_t *b = bam_init1();
    sam_hdr_t *h = sam_hdr_read(in);

    // Pileup iterator with constructor/destructor to parse base mod tags
    plp_dat dat = {
        .fp = in,
        .h = h,
    };
    bam_plp_t iter = bam_plp_init(readaln, &dat);
    bam_plp_constructor(iter, pileup_cd_create);
    bam_plp_destructor(iter, pileup_cd_destroy);

    const bam_pileup1_t *p;
    int tid, pos, n = 0;
    while ((p = bam_plp_auto(iter, &tid, &pos, &n)) != 0) {
        switch (compact) {
        case 0:
            process_mod_pileup1(h, p, tid, pos, n);
            break;
        case 1:
            process_mod_pileup2(h, p, tid, pos, n);
            break;
        default:
            process_pileup(h, p, tid, pos, n);
            break;
        }
    }
    bam_plp_destroy(iter);

    sam_close(in);
    bam_destroy1(b);
    sam_hdr_destroy(h);

    return n != 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x88c33(%rip), %rcx     # 0x8f039
xorl %ebx, %ebx
cmpl $0x2, %edi
jl 0x6430
decl %edi
xorl %ebx, %ebx
movq 0x8(%rsi,%rbx,8), %rax
cmpb $0x2d, (%rax)
jne 0x6433
cmpb $0x63, 0x1(%rax)
jne 0x6433
cmpb $0x0, 0x2(%rax)
jne 0x6433
incq %rbx
cmpl %ebx, %edi
jne 0x6411
movl %edi, %ebx
movq %rcx, %rax
leaq 0x8c56e(%rip), %rsi     # 0x929a8
movq %rax, %rdi
callq 0x1050c
movq %rax, %r14
callq 0x1d2d5
movq %rax, 0x18(%rsp)
movq %r14, %rdi
callq 0x200a1
movq %rax, %r15
leaq 0x28(%rsp), %rsi
movq %r14, 0x20(%rsp)
movq %r14, (%rsi)
movq %rax, 0x8(%rsi)
leaq 0xd9(%rip), %rdi        # 0x654b
callq 0x2a322
movq %rax, %r12
leaq -0x510(%rip), %rsi      # 0x5f71
movq %rax, %rdi
callq 0x2a59c
leaq -0x4e3(%rip), %rsi      # 0x5fad
movq %r12, %rdi
callq 0x2a5a1
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x2bd5d
testq %rax, %rax
je 0x650e
leaq 0x14(%rsp), %r13
leaq 0x10(%rsp), %rbp
leaq 0xc(%rsp), %r14
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movq %r15, %rdi
movq %rax, %rsi
cmpl $0x1, %ebx
je 0x64ec
testl %ebx, %ebx
jne 0x64f3
callq 0x5fba
jmp 0x64f8
callq 0x61f4
jmp 0x64f8
callq 0x5e0c
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x2bd5d
testq %rax, %rax
jne 0x64c9
movq %r12, %rdi
callq 0x2a3fb
movq 0x20(%rsp), %rdi
callq 0x1176e
movq 0x18(%rsp), %rdi
callq 0x1d3ab
movq %r15, %rdi
callq 0x1c982
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_13/reverse.c
// Function: reverse
void reverse(char str[])
{
  static int i = 0;
  static int j = 0;

  if (str[i] != '\0')
  {
    char c = str[i++];
    reverse(str);

    str[j++] = c;
  }

  // if whole reverse process is complete, reset the static variables to make this function reusable
  if (str[j] == '\0')
  {
    i = 0;
    j = 0;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x2eaa(%rip), %rax      # 0x4034
movb (%rdi,%rax), %bpl
testb %bpl, %bpl
je 0x11b9
incl %eax
movl %eax, 0x2e99(%rip)      # 0x4034
movq %rbx, %rdi
callq 0x117d
movslq 0x2e8e(%rip), %rcx      # 0x4038
leal 0x1(%rcx), %eax
movl %eax, 0x2e85(%rip)      # 0x4038
movb %bpl, (%rbx,%rcx)
jmp 0x11bf
movl 0x2e79(%rip), %eax      # 0x4038
cltq
cmpb $0x0, (%rbx,%rax)
jne 0x11d5
xorl %eax, %eax
movl %eax, 0x2e65(%rip)      # 0x4034
movl %eax, 0x2e63(%rip)      # 0x4038
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/test-bcf-sr.c
// Function: usage
void HTS_NORETURN usage(int exit_code)
{
    fprintf(stderr, "Usage: test-bcf-sr [OPTIONS] vcf-list.txt\n");
    fprintf(stderr, "       test-bcf-sr [OPTIONS] --args file1.bcf [...]\n");
    fprintf(stderr, "Options:\n");
    fprintf(stderr, "       --args                   pass filenames directly in argument list\n");
    fprintf(stderr, "       --no-index               allow streaming\n");
    fprintf(stderr, "   -o, --output <file>          output file (stdout if not set)\n");
    fprintf(stderr, "   -O, --output-fmt <fmt>       fmt: vcf,bcf,summary\n");
    fprintf(stderr, "   -p, --pair <logic[+ref]>     logic: snps,indels,both,snps+ref,indels+ref,both+ref,exact,some,all\n");
    fprintf(stderr, "   -r, --regions <reg_list>     comma-separated list of regions\n");
    fprintf(stderr, "   -t, --targets <reg_list>     comma-separated list of targets\n");
    fprintf(stderr, "   -u, --usefptr                use hfile pointer interface on reader addition\n");
    fprintf(stderr, "\n");
    exit(exit_code);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xd0005(%rip), %r14     # 0xd5fd8
movq (%r14), %rcx
leaq 0xa905f(%rip), %rdi     # 0xaf03c
movl $0x2a, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa9071(%rip), %rdi     # 0xaf067
movl $0x34, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa908d(%rip), %rdi     # 0xaf09c
movl $0x9, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa907e(%rip), %rdi     # 0xaf0a6
movl $0x49, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa90af(%rip), %rdi     # 0xaf0f0
movl $0x30, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa90c7(%rip), %rdi     # 0xaf121
movl $0x40, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa90ef(%rip), %rdi     # 0xaf162
movl $0x35, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa910c(%rip), %rdi     # 0xaf198
movl $0x64, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa9158(%rip), %rdi     # 0xaf1fd
movl $0x40, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa9180(%rip), %rdi     # 0xaf23e
movl $0x40, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rcx
leaq 0xa91a8(%rip), %rdi     # 0xaf27f
movl $0x4f, %esi
movl $0x1, %edx
callq 0x49d0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x4660
movl %ebx, %edi
callq 0x4600
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/test/test-bcf-sr.c
// Function: write_vcf_bcf_format
void write_vcf_bcf_format(bcf_srs_t *sr, bcf_hdr_t *hdr, vcfFile *vcf_out,
                          const char *fmt_type)
{
    int i, n;
    if (bcf_hdr_write(vcf_out, hdr) != 0)
        error("Couldn't write %s header\n", fmt_type);

    while ((n = bcf_sr_next_line(sr)) > 0) {
        for (i=0; i<sr->nreaders; i++)
        {
            if ( !bcf_sr_has_line(sr,i) ) continue;
            bcf1_t *rec = bcf_sr_get_line(sr, i);
            if (!rec) error("bcf_sr_get_line() unexpectedly returned NULL\n");
            if (vcf_write(vcf_out, hdr, rec) < 0)
                error("vcf_write() failed\n");
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x34e76
testl %eax, %eax
jne 0x6354
movq %r15, %rdi
callq 0x2a569
testl %eax, %eax
jle 0x6333
movl 0x30(%r15), %eax
testl %eax, %eax
jle 0x62d7
movl $0xc, %r12d
xorl %r13d, %r13d
movq 0x18(%r15), %rcx
cmpl $0x0, (%rcx,%r13,4)
je 0x6322
movq 0x28(%r15), %rax
movq (%rax,%r12,4), %rax
movq (%rax), %rdx
testq %rdx, %rdx
je 0x633d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37476
testl %eax, %eax
js 0x6346
movl 0x30(%r15), %eax
incq %r13
movslq %eax, %rcx
addq $0x18, %r12
cmpq %rcx, %r13
jl 0x62f4
jmp 0x62d7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xa8f8b(%rip), %rdi     # 0xaf2cf
jmp 0x634d
leaq 0xa8fce(%rip), %rdi     # 0xaf31b
xorl %eax, %eax
callq 0x5f2c
leaq 0xa8fa6(%rip), %rdi     # 0xaf301
movq %r12, %rsi
xorl %eax, %eax
callq 0x5f2c
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_regions_destroy
void bcf_sr_regions_destroy(bcf_sr_regions_t *reg)
{
    int i;
    free(reg->fname);
    if ( reg->itr ) tbx_itr_destroy(reg->itr);
    if ( reg->tbx ) tbx_destroy(reg->tbx);
    if ( reg->file ) hts_close(reg->file);
    if ( reg->als ) free(reg->als);
    if ( reg->als_str.s ) free(reg->als_str.s);
    free(reg->line.s);
    if ( reg->regs )
    {
         // free only in-memory names, tbx names are const
        for (i=0; i<reg->nseqs; i++)
        {
            free(reg->seq_names[i]);
            free(reg->regs[i].regs);
        }
    }
    free(reg->regs);
    free(reg->seq_names);
    khash_str2int_destroy(reg->seq_hash);
    free(reg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x45d0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x28f58
callq 0xe271
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28f65
callq 0x2db71
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x28f73
callq 0xae96
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x28f81
callq 0x45d0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x28f8f
callq 0x45d0
movq 0x20(%rbx), %rdi
callq 0x45d0
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x28fef
cmpl $0x0, 0x98(%rbx)
jle 0x28ff1
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x90(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x45d0
movq 0x80(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x45d0
incq %r15
movslq 0x98(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x28fb3
movq 0x80(%rbx), %rdi
jmp 0x28ff1
xorl %edi, %edi
callq 0x45d0
movq 0x90(%rbx), %rdi
callq 0x45d0
movq 0x88(%rbx), %r14
testq %r14, %r14
je 0x29031
movq 0x18(%r14), %rdi
callq 0x45d0
movq 0x10(%r14), %rdi
callq 0x45d0
movq 0x20(%r14), %rdi
callq 0x45d0
movq %r14, %rdi
callq 0x45d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_set_targets
int bcf_sr_set_targets(bcf_srs_t *readers, const char *targets, int is_file, int alleles)
{
    if ( readers->nreaders || readers->targets )
    {
        hts_log_error("Must call bcf_sr_set_targets() before bcf_sr_add_reader()");
        return -1;
    }
    if ( targets[0]=='^' )
    {
        readers->targets_exclude = 1;
        targets++;
    }
    readers->targets = bcf_sr_regions_init(targets,is_file,0,1,-2);
    if ( !readers->targets ) return -1;
    readers->targets_als = alleles;
    readers->targets->overlap = BCF_SR_AUX(readers)->targets_overlap;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x30(%rdi)
jne 0x296cc
movq %rdi, %r14
cmpq $0x0, 0x50(%rdi)
je 0x296f2
leaq 0x8962e(%rip), %rsi     # 0xb2d01
leaq 0x8963a(%rip), %rdx     # 0xb2d14
movl $0x1, %edi
xorl %eax, %eax
callq 0x9b31
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %ecx, %ebx
cmpb $0x5e, (%rsi)
jne 0x29704
movl $0x1, 0x5c(%r14)
incq %rsi
xorl %ebp, %ebp
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x2903e
movq %rax, 0x50(%r14)
testq %rax, %rax
je 0x296e6
movl %ebx, 0x58(%r14)
movq 0x88(%r14), %rcx
movl 0x1dc(%rcx), %ecx
movl %ecx, 0xc8(%rax)
jmp 0x296eb
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_set_threads
int bcf_sr_set_threads(bcf_srs_t *files, int n_threads)
{
    if (!(files->n_threads = n_threads))
        return 0;

    files->p = calloc(1, sizeof(*files->p));
    if (!files->p) {
        files->errnum = no_memory;
        return -1;
    }
    if (!(files->p->pool = hts_tpool_init(n_threads)))
        return -1;

    return 0;
}

// Assembly:
movl %esi, 0x7c(%rdi)
testl %esi, %esi
je 0x29787
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x42f0
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x2978a
movl %ebp, %edi
callq 0x2f8f5
movq %rax, %rcx
movq 0x80(%rbx), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
jmp 0x29796
xorl %eax, %eax
retq
movl $0x7, 0x20(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_destroy_threads
void bcf_sr_destroy_threads(bcf_srs_t *files) {
    if (!files->p)
        return;

    if (files->p->pool)
        hts_tpool_destroy(files->p->pool);
    free(files->p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x297ca
movq (%rdi), %rax
testq %rax, %rax
je 0x297c4
movq %rax, %rdi
callq 0x30327
movq 0x80(%rbx), %rdi
popq %rbx
jmp 0x45d0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_add_reader
int bcf_sr_add_reader(bcf_srs_t *files, const char *fname)
{
    char fmode[5];
    int ret = 0;
    const char *idxname = NULL;

    strcpy(fmode, "r");
    vcf_open_mode(fmode+1, fname, NULL);
    htsFile* file_ptr = hts_open(fname, fmode);
    if ( ! file_ptr ) {
        files->errnum = open_failed;
        return 0;
    }
    //get idx name and pass to add_hreader
    idxname = strstr(fname, HTS_IDX_DELIM);
    idxname += idxname ? sizeof(HTS_IDX_DELIM) - 1 : 0;
    if (!(ret = bcf_sr_add_hreader(files, file_ptr, 1, idxname))) {
        hts_close(file_ptr);    //failed, close the file
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3(%rsp), %rdi
movw $0x72, -0x1(%rdi)
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x3db7e
leaq 0x2(%rsp), %rsi
movq %r12, %rdi
callq 0x9c34
testq %rax, %rax
je 0x29849
movq %rax, %r15
leaq 0x85c7b(%rip), %rsi     # 0xaf486
movq %r12, %rdi
callq 0x40d0
testq %rax, %rax
movl $0x7, %ecx
cmoveq %rax, %rcx
addq %rax, %rcx
movl $0x1, %r14d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2985f
testl %eax, %eax
jne 0x29850
movq %r15, %rdi
callq 0xae96
xorl %r14d, %r14d
jmp 0x29850
movl $0x0, 0x20(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: regions_sort_and_merge
void _regions_sort_and_merge(bcf_sr_regions_t *reg)
{
    if ( !reg ) return;

    int i;
    for (i=0; i<reg->nseqs; i++)
    {
        qsort(reg->regs[i].regs, reg->regs[i].nregs, sizeof(*reg->regs[i].regs), regions_cmp);
        regions_merge(&reg->regs[i]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2a284
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x98(%rdi)
jle 0x2a279
movq 0x80(%rbx), %rax
xorl %r15d, %r15d
leaq 0x296c(%rip), %r14      # 0x2cb3c
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,2), %r12
movq (%rax,%r12), %rdi
movslq 0x8(%rax,%r12), %rsi
movl $0x10, %edx
movq %r14, %rcx
callq 0x49b0
movq 0x80(%rbx), %rax
movslq 0x8(%rax,%r12), %rcx
testq %rcx, %rcx
jle 0x2a266
addq %rax, %r12
xorl %esi, %esi
leal 0x1(%rsi), %edx
cmpl %ecx, %edx
jge 0x2a260
movq (%r12), %rdi
movslq %esi, %rdx
movq %rdx, %r8
shlq $0x4, %r8
leaq (%rdi,%r8), %rsi
addq $0x8, %rsi
incq %rdx
addq %r8, %rdi
addq $0x18, %rdi
movq (%rsi), %r8
cmpq -0x8(%rdi), %r8
jl 0x2a260
movq (%rdi), %r9
cmpq %r9, %r8
jge 0x2a243
movq %r9, (%rsi)
movq $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
incq %rdx
addq $0x10, %rdi
cmpq %rdx, %rcx
jne 0x2a22f
jmp 0x2a266
movl %edx, %esi
cmpl %ecx, %edx
jl 0x2a208
incq %r15
movslq 0x98(%rbx), %rcx
cmpq %rcx, %r15
jl 0x2a1d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_init
bcf_srs_t *bcf_sr_init(void)
{
    bcf_srs_t *files = (bcf_srs_t*) calloc(1,sizeof(bcf_srs_t));
    files->aux = (aux_t*) calloc(1,sizeof(aux_t));
    bcf_sr_sort_init(&BCF_SR_AUX(files)->sort);
    bcf_sr_set_opt(files,BCF_SR_REGIONS_OVERLAP,1);
    bcf_sr_set_opt(files,BCF_SR_TARGETS_OVERLAP,0);
    return files;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x90, %esi
callq 0x42f0
movq %rax, %rbx
movl $0x1, %edi
movl $0x1e8, %esi            # imm = 0x1E8
callq 0x42f0
movq %rax, 0x88(%rbx)
movq %rax, %rdi
callq 0x92211
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x28b91
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x28b91
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_destroy
void bcf_sr_destroy(bcf_srs_t *files)
{
    int i;
    int *autoclose = BCF_SR_AUX(files)->closefile;

    for (i=0; i<files->nreaders; i++)
        bcf_sr_destroy1(&files->readers[i], autoclose[i]);
    free(files->has_line);
    free(files->readers);
    for (i=0; i<files->n_smpl; i++) free(files->samples[i]);
    free(files->samples);
    if (files->targets) bcf_sr_regions_destroy(files->targets);
    if (files->regions) bcf_sr_regions_destroy(files->regions);
    if (files->tmps.m) free(files->tmps.s);
    if (files->n_threads) bcf_sr_destroy_threads(files);
    bcf_sr_sort_destroy(&BCF_SR_AUX(files)->sort);
    free(autoclose);
    free(files->aux);
    free(files);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %rax
movq 0x1e0(%rax), %r14
cmpl $0x0, 0x30(%rdi)
jle 0x2a325
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %rdi
addq %r15, %rdi
movl (%r14,%r12,4), %esi
callq 0x2a3cf
incq %r12
movslq 0x30(%rbx), %rax
addq $0x60, %r15
cmpq %rax, %r12
jl 0x2a305
movq 0x18(%rbx), %rdi
callq 0x45d0
movq 0x28(%rbx), %rdi
callq 0x45d0
cmpl $0x0, 0x78(%rbx)
jle 0x2a359
xorl %r15d, %r15d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x45d0
incq %r15
movslq 0x78(%rbx), %rax
cmpq %rax, %r15
jl 0x2a340
movq 0x40(%rbx), %rdi
callq 0x45d0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2a370
callq 0x28f39
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2a37e
callq 0x28f39
cmpq $0x0, 0x68(%rbx)
je 0x2a38e
movq 0x70(%rbx), %rdi
callq 0x45d0
cmpl $0x0, 0x7c(%rbx)
je 0x2a39c
movq %rbx, %rdi
callq 0x2979d
movq 0x88(%rbx), %rdi
callq 0x9223d
movq %r14, %rdi
callq 0x45d0
movq 0x88(%rbx), %rdi
callq 0x45d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_destroy1
static void bcf_sr_destroy1(bcf_sr_t *reader, int closefile)
{
    free(reader->fname);
    if ( reader->tbx_idx ) tbx_destroy(reader->tbx_idx);
    if ( reader->bcf_idx ) hts_idx_destroy(reader->bcf_idx);
    bcf_hdr_destroy(reader->header);
    if (closefile) {
        hts_close(reader->file);
    }
    if ( reader->itr ) tbx_itr_destroy(reader->itr);
    int j;
    for (j=0; j<reader->mbuffer; j++)
        bcf_destroy1(reader->buffer[j]);
    free(reader->buffer);
    free(reader->samples);
    free(reader->filter_ids);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x45d0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2a3ef
callq 0x2db71
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2a3fd
callq 0xb00f
movq 0x18(%rbx), %rdi
callq 0x34000
testl %ebp, %ebp
je 0x2a412
movq (%rbx), %rdi
callq 0xae96
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x2a420
callq 0xe271
cmpl $0x0, 0x3c(%rbx)
jle 0x2a442
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x353d5
incq %r14
movslq 0x3c(%rbx), %rax
cmpq %rax, %r14
jl 0x2a429
movq 0x30(%rbx), %rdi
callq 0x45d0
movq 0x50(%rbx), %rdi
callq 0x45d0
movq 0x48(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_remove_reader
void bcf_sr_remove_reader(bcf_srs_t *files, int i)
{
    assert( !files->samples );  // not ready for this yet
    int *autoclose = BCF_SR_AUX(files)->closefile;

    bcf_sr_sort_remove_reader(files, &BCF_SR_AUX(files)->sort, i);
    bcf_sr_destroy1(&files->readers[i], autoclose[i]);
    if ( i+1 < files->nreaders )
    {
        memmove(&files->readers[i], &files->readers[i+1], (files->nreaders-i-1)*sizeof(bcf_sr_t));
        memmove(&files->has_line[i], &files->has_line[i+1], (files->nreaders-i-1)*sizeof(int));
        memmove(&autoclose[i], &autoclose[i+1], (files->nreaders-i-1)*sizeof(int));
    }
    files->nreaders--;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x40(%rdi)
jne 0x2a54a
movl %esi, %ebp
movq %rdi, %rbx
movq 0x88(%rdi), %rsi
movq 0x1e0(%rsi), %r12
movl %ebp, %edx
callq 0x9218a
movslq %ebp, %r13
leaq (,%r13,2), %r15
addq %r13, %r15
shlq $0x5, %r15
movq 0x28(%rbx), %rdi
addq %r15, %rdi
movl (%r12,%r13,4), %esi
callq 0x2a3cf
leal 0x1(%r13), %ecx
movl 0x30(%rbx), %eax
cmpl %eax, %ecx
jge 0x2a536
leaq (%r12,%r13,4), %rdx
movq %rdx, (%rsp)
movq 0x28(%rbx), %rdx
addq %rdx, %r15
movslq %ecx, %rbp
leaq (,%rbp,2), %rsi
addq %rbp, %rsi
shlq $0x5, %rsi
addq %rdx, %rsi
movl %r13d, %r14d
notl %r14d
addl %r14d, %eax
cltq
shlq $0x5, %rax
leaq (%rax,%rax,2), %rdx
movq %r15, %rdi
callq 0x4860
movq 0x18(%rbx), %rax
leaq (%rax,%r13,4), %rdi
leaq (%rax,%rbp,4), %rsi
movl 0x30(%rbx), %eax
addl %r14d, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x4860
leaq (%r12,%rbp,4), %rsi
addl 0x30(%rbx), %r14d
movslq %r14d, %rdx
shlq $0x2, %rdx
movq (%rsp), %rdi
callq 0x4860
movl 0x30(%rbx), %eax
decl %eax
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x88a02(%rip), %rdi     # 0xb2f53
leaq 0x88a0b(%rip), %rsi     # 0xb2f63
leaq 0x88a18(%rip), %rcx     # 0xb2f77
movl $0x1f6, %edx            # imm = 0x1F6
callq 0x42e0
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: reader_seek
static int _reader_seek(bcf_sr_t *reader, const char *seq, hts_pos_t start, hts_pos_t end)
{
    if ( end>=MAX_CSI_COOR )
    {
        hts_log_error("The coordinate is out of csi index limit: %"PRIhts_pos, end+1);
        exit(1);
    }
    if ( reader->itr )
    {
        hts_itr_destroy(reader->itr);
        reader->itr = NULL;
    }
    reader->nbuffer = 0;
    if ( reader->tbx_idx )
    {
        int tid = tbx_name2id(reader->tbx_idx, seq);
        if ( tid==-1 ) return -1;    // the sequence not present in this file
        reader->itr = tbx_itr_queryi(reader->tbx_idx,tid,start,end+1);
    }
    else
    {
        int tid = bcf_hdr_name2id(reader->header, seq);
        if ( tid==-1 ) return -1;    // the sequence not present in this file
        reader->itr = bcf_itr_queryi(reader->bcf_idx,tid,start,end+1);
    }
    if (!reader->itr) {
        hts_log_error("Could not seek: %s:%"PRIhts_pos"-%"PRIhts_pos, seq, start + 1, end + 1);
        abort();
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movabsq $0xfffffffffff, %rax    # imm = 0xFFFFFFFFFFF
cmpq %rax, %rcx
jge 0x2b8bd
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x2b804
callq 0xe271
movq $0x0, 0x20(%r12)
movl $0x0, 0x38(%r12)
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x2b83e
movq %r15, %rsi
callq 0x2cb68
cmpl $-0x1, %eax
je 0x2b8ac
movq 0x8(%r12), %rcx
movq 0x18(%rcx), %rdi
leaq 0x1(%rbx), %rcx
leaq 0x1c6a(%rip), %r8       # 0x2d4a6
jmp 0x2b865
movq 0x18(%r12), %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x32f65
cmpl $-0x1, %eax
je 0x2b8ac
movq 0x10(%r12), %rdi
leaq 0x1(%rbx), %rcx
leaq 0xacb5(%rip), %r8       # 0x3651a
movl %eax, %esi
movq %r14, %rdx
callq 0xd6bd
movq %rax, %rcx
movq %rax, 0x20(%r12)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x2b8b1
incq %r14
incq %rbx
leaq 0x879b3(%rip), %rsi     # 0xb323e
leaq 0x879e7(%rip), %rdx     # 0xb3279
movl $0x1, %edi
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x9b31
callq 0x4260
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
incq %rbx
leaq 0x87977(%rip), %rsi     # 0xb323e
leaq 0x8797d(%rip), %rdx     # 0xb324b
movl $0x1, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x9b31
movl $0x1, %edi
callq 0x4600
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_regions_seek
int bcf_sr_regions_seek(bcf_sr_regions_t *reg, const char *seq)
{
    reg->iseq = reg->start = reg->end = -1;
    if ( khash_str2int_get(reg->seq_hash, seq, &reg->iseq) < 0 ) return -1;  // sequence seq not in regions

    // using in-memory regions
    if ( reg->regs )
    {
        reg->regs[reg->iseq].creg = -1;
        return 0;
    }

    // reading regions from tabix
    if ( reg->itr ) tbx_itr_destroy(reg->itr);
    reg->itr = tbx_itr_querys(reg->tbx, seq);
    if ( reg->itr ) return 0;

    return -1;
}

// Assembly:
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x9c(%rdi)
movl $0xffffffff, 0xac(%rdi) # imm = 0xFFFFFFFF
movq 0x88(%rdi), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x2c1ab
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rdx), %eax
testl %eax, %eax
je 0x2c081
movq %rax, 0x8(%rsp)
leal -0x1(%rax), %edi
movb (%rsi), %cl
testb %cl, %cl
movq %rbx, 0x10(%rsp)
je 0x2c089
leaq 0x1(%rsi), %rax
movl $0x811c9dc5, %r13d      # imm = 0x811C9DC5
movzbl %cl, %ecx
xorl %r13d, %ecx
imull $0x1000193, %ecx, %r13d # imm = 0x1000193
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x2c069
jmp 0x2c08f
xorl %r14d, %r14d
jmp 0x2c12a
movl $0x811c9dc5, %r13d      # imm = 0x811C9DC5
andl %edi, %r13d
movq 0x10(%rdx), %r8
movl $0x1, %r12d
movl %r13d, %r14d
movq %rdx, 0x20(%rsp)
movl %edi, 0x4(%rsp)
movq %r8, 0x18(%rsp)
movl %r14d, %eax
shrl $0x4, %eax
movl (%r8,%rax,4), %ebp
leal (%r14,%r14), %r15d
andl $0x1e, %r15d
movl %ebp, %eax
movl %r15d, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x2c10e
testb $0x1, %al
jne 0x2c0f6
movq 0x18(%rdx), %rax
movl %r14d, %ecx
movq (%rax,%rcx,8), %rdi
movq %rsi, %rbx
callq 0x46f0
movq 0x18(%rsp), %r8
movl 0x4(%rsp), %edi
movq 0x20(%rsp), %rdx
movq %rbx, %rsi
testl %eax, %eax
je 0x2c10e
addl %r12d, %r14d
andl %edi, %r14d
incl %r12d
cmpl %r13d, %r14d
jne 0x2c0ad
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x2c19d
movl %r15d, %ecx
shrl %cl, %ebp
testb $0x3, %bpl
movq 0x8(%rsp), %rax
cmovnel %eax, %r14d
movq 0x10(%rsp), %rbx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %eax, %r14d
je 0x2c19d
movq 0x20(%rdx), %rax
movl %r14d, %ecx
movslq (%rax,%rcx,4), %rax
movl %eax, 0x9c(%rbx)
movq 0x80(%rbx), %rcx
testq %rcx, %rcx
je 0x2c15c
leaq (%rax,%rax,2), %rax
movl $0xffffffff, 0x10(%rcx,%rax,8) # imm = 0xFFFFFFFF
xorl %ecx, %ecx
jmp 0x2c19d
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2c170
movq %rsi, %r14
callq 0xe271
movq %r14, %rsi
movq (%rbx), %rcx
movq 0x18(%rcx), %rdi
leaq 0x9ea(%rip), %rdx       # 0x2cb68
leaq -0x1eac8(%rip), %r8     # 0xd6bd
leaq 0x131a(%rip), %r9       # 0x2d4a6
callq 0x10131
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: set_variant_boundaries
static void _set_variant_boundaries(bcf1_t *rec, hts_pos_t *beg, hts_pos_t *end)
{
    hts_pos_t off;
    if ( rec->n_allele )
    {
        off = rec->rlen;
        bcf_unpack(rec, BCF_UN_STR);
        int i;
        for (i=1; i<rec->n_allele; i++)
        {
            // Make symbolic alleles start at POS, although this is not strictly true for
            // <DEL>,<INS> where POS should be the position BEFORE the deletion/insertion.
            // However, since arbitrary symbolic alleles can be defined by the user, we
            // will simplify the interpretation of --targets-overlap and --region-overlap.
            int j = 0;
            char *ref = rec->d.allele[0];
            char *alt = rec->d.allele[i];
            while ( ref[j] && alt[j] && ref[j]==alt[j] ) j++;
            if ( off > j ) off = j;
            if ( !off ) break;
        }
    }
    else
        off = 0;

    *beg = rec->pos + off;
    *end = rec->pos + rec->rlen - 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpw $0x0, 0x1a(%rdi)
je 0x2c65d
movq 0x8(%r14), %r12
movq %r14, %rdi
movl $0x1, %esi
callq 0x3dd0f
movq 0x18(%r14), %rax
testl $0xfffe0000, %eax       # imm = 0xFFFE0000
je 0x2c660
shrl $0x10, %eax
movq 0x88(%r14), %rcx
movq (%rcx), %rdx
movb (%rdx), %sil
movl $0x1, %edi
testb %sil, %sil
je 0x2c644
movq (%rcx,%rdi,8), %r9
xorl %r8d, %r8d
movl %esi, %r10d
cmpb (%r9,%r8), %r10b
jne 0x2c647
movb 0x1(%rdx,%r8), %r10b
incq %r8
testb %r10b, %r10b
jne 0x2c62f
jmp 0x2c647
xorl %r8d, %r8d
cmpq %r8, %r12
cmovgeq %r8, %r12
testq %r12, %r12
je 0x2c65d
incq %rdi
cmpq %rax, %rdi
jne 0x2c620
jmp 0x2c660
xorl %r12d, %r12d
addq (%r14), %r12
movq %r12, (%r15)
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq %rcx, %rax
decq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/synced_bcf_reader.c
// Function: regions_cmp
static int regions_cmp(const void *aptr, const void *bptr)
{
    region1_t *a = (region1_t*)aptr;
    region1_t *b = (region1_t*)bptr;
    if ( a->start < b->start ) return -1;
    if ( a->start > b->start ) return 1;
    if ( a->end < b->end ) return -1;
    if ( a->end > b->end ) return 1;
    return 0;
}

// Assembly:
movq (%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, (%rdi)
jl 0x2cb65
movl $0x1, %eax
jg 0x2cb65
movq 0x8(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x8(%rdi)
jl 0x2cb65
setg %al
movzbl %al, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/bcf_sr_sort.c
// Function: bcf_sr_sort_set_active
int bcf_sr_sort_set_active(sr_sort_t *srt, int idx)
{
    hts_expand(int,idx+1,srt->mactive,srt->active);
    srt->nactive = 1;
    srt->active[srt->nactive - 1] = idx;
    return 0; // FIXME: check for errs in this function
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq 0x1c8(%rdi), %rsi
cmpl %ebx, %esi
jg 0x8fa83
leal 0x1(%rbx), %eax
testl %ebx, %ebx
movl $0x1, %ecx
cmovnsl %eax, %ecx
movslq %ecx, %rdi
leaq 0x1d0(%r14), %r9
leaq 0x2e422(%rip), %rax     # 0xbde88
movq %rax, (%rsp)
movl $0x4, %edx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x11bb5
movl %eax, 0x1c8(%r14)
movl $0x1, 0x1c4(%r14)
movq 0x1d0(%r14), %rax
movl %ebx, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/bcf_sr_sort.c
// Function: bcf_sr_sort_add_active
int bcf_sr_sort_add_active(sr_sort_t *srt, int idx)
{
    hts_expand(int,idx+1,srt->mactive,srt->active);
    srt->nactive++;
    srt->active[srt->nactive - 1] = idx;
    return 0; // FIXME: check for errs in this function
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq 0x1c8(%rdi), %rsi
cmpl %ebx, %esi
jg 0x8faf0
leal 0x1(%rbx), %eax
testl %ebx, %ebx
movl $0x1, %ecx
cmovnsl %eax, %ecx
movslq %ecx, %rdi
leaq 0x1d0(%r14), %r9
leaq 0x2e3cc(%rip), %rax     # 0xbde9f
movq %rax, (%rsp)
movl $0x4, %edx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x11bb5
movl %eax, 0x1c8(%r14)
movslq 0x1c4(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c4(%r14)
movq 0x1d0(%r14), %rcx
movl %ebx, (%rcx,%rax,4)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq