LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: ALIb
void __bea_callspec__ ALIb(PDISASM pMyDisasm)
{
    long MyNumber;
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((Int8*)(IntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8Bits[0]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
leaq 0x2(%rax), %rdx
decq %rcx
cmpq %rdx, %rcx
jae 0x2863c
movl $0x1, 0x289(%rbx)
jmp 0x286a8
movl $0x8, 0x260(%rbx)
movsbq 0x1(%rax), %r14
leaq 0x104(%rbx), %rsi
leaq 0x23ba(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x283ec
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0xe6c7(%rip), %rsi      # 0x36d40
callq 0x8170
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0xdc(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/Routines_ModRM.c
// Function: MOD_RM
void __bea_callspec__ MOD_RM(ARGTYPE* pMyArgument, PDISASM pMyDisasm)
{
    GV.DECALAGE_EIP = 0;
    if (!Security(1, pMyDisasm)) return;
    GV.MOD_ = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
    GV.RM_  = (*((UInt8*)(UIntPtr) (GV.EIP_+1))) & 0x7;
    if (GV.MOD_ == 0) {
        ModRM_0[GV.RM_](pMyArgument, pMyDisasm);
    }
    else if (GV.MOD_ == 1) {
        GV.DECALAGE_EIP++;
        ModRM_1[GV.RM_](pMyArgument, pMyDisasm);
    }
    else if (GV.MOD_ == 2) {
        if (GV.AddressSize >= 32) {
            GV.DECALAGE_EIP += 4;
        }
        else {
            GV.DECALAGE_EIP += 2;
        }
        ModRM_2[GV.RM_](pMyArgument, pMyDisasm);
    }
    else {
        ModRM_3[GV.RM_](pMyArgument, pMyDisasm);
    }

}

// Assembly:
andl $0x0, 0x244(%rsi)
movq 0x1f0(%rsi), %rax
movq 0x250(%rsi), %rcx
incq %rax
decq %rcx
cmpq %rax, %rcx
jae 0x2888e
movl $0x1, 0x289(%rsi)
retq
movzbl (%rax), %ecx
shrl $0x6, %ecx
movl %ecx, 0x218(%rsi)
movzbl (%rax), %eax
andl $0x7, %eax
movl %eax, 0x21c(%rsi)
leaq 0x20db(%rip), %rdx      # 0x2a988
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x10603(%rip), %rcx     # 0x38ec0
jmp 0x28904
xorl %ecx, %ecx
cmpl $0x20, 0x214(%rsi)
setge %cl
leal 0x2(,%rcx,2), %ecx
movl %ecx, 0x244(%rsi)
movzbl %al, %eax
leaq 0x1065e(%rip), %rcx     # 0x38f40
jmp 0x28904
movzbl %al, %eax
leaq 0x10692(%rip), %rcx     # 0x38f80
jmp 0x28904
movl $0x1, 0x244(%rsi)
movzbl %al, %eax
leaq 0x105fc(%rip), %rcx     # 0x38f00
movq (%rcx,%rax,8), %rax
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: GvEw
void __bea_callspec__ GvEw(PDISASM pMyDisasm)
{
    GV.MemDecoration = Arg2word;
    GV.OriginalOperandSize = GV.OperandSize;
    GV.OperandSize = 16;
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.OperandSize = GV.OriginalOperandSize;
    Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20c(%rdi), %eax
movl %eax, 0x208(%rdi)
movabsq $0x6600000010, %rax     # imm = 0x6600000010
movq %rax, 0x20c(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x28863
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: GvEb
void __bea_callspec__ GvEb(PDISASM pMyDisasm)
{
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 64;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 32;
    }
    else {
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 16;
    }
    Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20c(%rdi), %ebp
movabsq $0x6500000008, %rax     # imm = 0x6500000008
movq %rax, 0x20c(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x28863
xorl %eax, %eax
cmpl $0x20, %ebp
sete %al
shll $0x4, %eax
addl $0x10, %eax
cmpl $0x40, %ebp
cmovel %ebp, %eax
movl %eax, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: EbIb
void __bea_callspec__ EbIb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.ImmediatSize = 8;
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_ += GV.DECALAGE_EIP+3;
    if (!Security(0, pMyDisasm)) return;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64)*((Int8*)(UIntPtr) (GV.EIP_-1)));
    #endif
    (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_-1));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rdi)
movl $0x8, 0x260(%rdi)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x28863
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x3, %eax
addq 0x1f0(%rbx), %rax
movq %rax, 0x1f0(%rbx)
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x28d2e
movl $0x1, 0x289(%rbx)
jmp 0x28d5b
leaq 0x104(%rbx), %rsi
movsbq -0x1(%rax), %rcx
leaq 0x1cd2(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movq 0x1f0(%rbx), %rax
movzbl -0x1(%rax), %eax
movq %rax, 0x90(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_GbEb
void __bea_callspec__ test_GbEb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x2856c
movl 0xd7b9(%rip), %eax      # 0x36688
movl %eax, 0x84(%rbx)
movq 0xd7a4(%rip), %rax      # 0x36680
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_GvEv
void __bea_callspec__ test_GvEv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x285bb
movl 0xd779(%rip), %eax      # 0x36688
movl %eax, 0x84(%rbx)
movq 0xd764(%rip), %rax      # 0x36680
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x291b5
movq %rbx, %rdi
callq 0x29310
xorl %eax, %eax
cmpl $0x0, 0x289(%rbx)
jne 0x291b3
movq %rbx, %rdi
callq 0x29330
movq %rbx, %rdi
callq 0x293b5
movq %rbx, %rdi
callq 0x293ce
movl 0x78(%rbx), %eax
addl $-0xb, %eax
cmpl $0x1, %eax
ja 0x2917f
movl $0x1, 0xe8(%rbx)
cmpl $0x400, 0x24c(%rbx)     # imm = 0x400
jne 0x29195
movq %rbx, %rdi
callq 0x296b2
jmp 0x2919d
movq %rbx, %rdi
callq 0x299c5
cmpl $0x0, 0x280(%rbx)
je 0x291ab
pushq $-0x1
popq %rax
jmp 0x291b3
movl 0x1f0(%rbx), %eax
subl (%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6e93(%rip), %bpl      # 0x9280
movq 0x8acc(%rip), %rbx      # 0xaec0
testq %rbx, %rbx
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x2411
movq %r15, %rdi
callq 0x2230
movl %eax, 0x6e29(%rip)      # 0x9238
jmp 0x2440
movq %rdx, %r14
leaq 0x1(%rdx), %rdi
callq 0x21f0
movq %rax, %rbx
movq %rax, 0x8a99(%rip)      # 0xaec0
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21d0
movb $0x0, (%rbx,%r14)
movl 0x6df8(%rip), %eax      # 0x9238
cmpl $-0x1, %eax
sete %cl
testb %cl, %bpl
jne 0x2464
movq %rbx, %rdi
movl %eax, %esi
callq 0x31cb
andq $0x0, 0x8a63(%rip)      # 0xaec0
orl $-0x1, 0x6dd4(%rip)     # 0x9238
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
movl 0x68db(%rip), %r15d     # 0x920c
pushq $-0x1
popq %rbp
leaq 0x6845(%rip), %r14      # 0x9180
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x295d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21c0
testl %eax, %eax
cmovel %r12d, %ebp
incq %r12
addq $0x14, %r14
jmp 0x293e
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x6890(%rip), %ebp      # 0x920c
movq %rbp, %rdi
shlq $0x3, %rdi
callq 0x21f0
movq %rax, %r14
xorl %r12d, %r12d
leaq 0x36fd(%rip), %r15      # 0x6092
leaq 0x68e5(%rip), %r13      # 0x9281
movl %ebp, %eax
cmpq %rax, %r12
jae 0x29cd
testq %r12, %r12
movl $0x0, %edi
cmoveq %rbx, %rdi
movq %r15, %rsi
callq 0x3396
testq %rax, %rax
cmoveq %r13, %rax
movq %rax, (%r14,%r12,8)
incq %r12
movl 0x6841(%rip), %ebp      # 0x920c
jmp 0x299c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x33a8
movq %rdi, %rbx
movq %rdi, 0x7b12(%rip)      # 0xaeb8
jmp 0x33b4
movq 0x7b09(%rip), %rbx      # 0xaeb8
testq %rbx, %rbx
je 0x33e5
cmpb $0x0, (%rbx)
je 0x33e5
movq %rbx, %rdi
callq 0x2160
movslq %eax, %rcx
leaq (%rbx,%rcx), %rax
movq %rax, 0x7ae9(%rip)      # 0xaeb8
cmpb $0x0, (%rbx,%rcx)
je 0x33e7
leaq 0x1(%rax), %rcx
movq %rcx, 0x7ad8(%rip)      # 0xaeb8
movb $0x0, (%rax)
jmp 0x33e7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x1040
testq %rbx, %rbx
je 0x1149
cmpl $0x0, (%rbx)
jne 0x115f
testq %rax, %rax
je 0x1159
xorl %ecx, %ecx
negb %bpl
sbbl %ecx, %ecx
movb %cl, (%rax)
andl $0x0, (%rbx)
jmp 0x1161
xorl %ecx, %ecx
testq %rax, %rax
je 0x115f
negb %bpl
sbbl %ecx, %ecx
movb %cl, (%rax)
jmp 0x1161
movl $0x80000001, (%rbx)     # imm = 0x80000001
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3
popq %rdi
callq 0x1040
testq %rbx, %rbx
je 0x11e7
cmpl $0x0, (%rbx)
jne 0x120b
testq %rax, %rax
jne 0x11ec
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
jmp 0x1207
testq %rax, %rax
je 0x120b
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 0x120d
movl %ecx, (%rbx)
jmp 0x120d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/crypto_entropy/main.c
// Function: main
int
main(int argc, char * argv[])
{
	uint8_t buf[32];
	size_t i;

	WARNP_INIT;

	(void)argc;
	(void)argv;

	/* Get entropy enough times to trigger a reseed. */
	for (i = 0; i < RESEED_INTERVAL + 1; i++) {
		if (crypto_entropy_read(buf, 32)) {
			warn0("crypto_entropy_read(): internal error.");
			goto err0;
		}
	}

	/* Print final random value. */
	for (i = 0; i < 32; i++) {
		printf("%02x", buf[i]);
	}
	printf("\n");

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x12d2
callq 0x19dc
movl $0x102, %r15d           # imm = 0x102
movq %rsp, %rbx
pushq $0x20
popq %r14
decq %r15
je 0x1311
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1344
testl %eax, %eax
je 0x12df
leaq 0x3d0a(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x1be8
callq 0x1070
andl $0x0, (%rax)
pushq $0x1
popq %rdi
callq 0x1180
leaq 0x3d13(%rip), %rbx      # 0x502b
xorl %r14d, %r14d
cmpq $0x20, %r14
je 0x1335
movzbl (%rsp,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1090
incq %r14
jmp 0x131b
pushq $0xa
popq %rdi
callq 0x1040
xorl %edi, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/vtereshkov[P]umka-lang/src/umka_gen.c
// Function: genTryRemoveImmediateEntryPoint
int genTryRemoveImmediateEntryPoint(CodeGen *gen)
{
    Instruction *prev = getPrevInstr(gen, 1);
    if (prev && prev->opcode == OP_PUSH && prev->inlineOpcode == OP_NOP)
    {
        int entry = prev->operand.intVal;
        genRemoveInstr(gen);
        return entry;
    }
    return -1;
}

// Assembly:
movslq 0x8(%rdi), %rcx
pushq $-0x1
popq %rax
cmpl 0x1a4(%rdi), %ecx
jle 0xf858
movq %rcx, %rdx
shlq $0x5, %rdx
addq (%rdi), %rdx
movq %rdx, %rsi
addq $-0x20, %rsi
je 0xf858
cmpl $0x1, (%rsi)
jne 0xf858
cmpl $0x0, -0x1c(%rdx)
je 0xf859
retq
movl -0x8(%rdx), %eax
decl %ecx
movl %ecx, 0x8(%rdi)
andl $0x0, 0x1d8(%rdi)
movl %ecx, 0x1dc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r15d
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movl %edx, %esi
callq 0x9fa5
leaq 0x6b519(%rip), %rdi     # 0x71028
xorl %r12d, %r12d
movq %rax, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4060
testl %ebp, %ebp
cmovgl %ebp, %r12d
leaq 0x6c3d4(%rip), %r15     # 0x71f00
pushq $0x7e
popq %r13
pushq $0x2a
popq %rbp
subl $0x1, %r12d
jb 0x5baf
testb $0x1, 0x14(%rbx)
jne 0x5ba2
movq (%rbx), %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(%rbx), %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, %r14
addq %rsi, %r14
andl $0xf, %edx
movzbl (%r15,%rdx), %edi
callq 0x46d0
movslq 0x8(%rbx), %rax
movzbl (%rax,%r14), %eax
leal 0x21(%rax), %edi
cmpl $0x5e, %eax
cmovael %r13d, %edi
movq %rsp, %rsi
callq 0x5be7
jmp 0x5ba9
movl %ebp, %edi
callq 0x46d0
addq $0x28, %rbx
jmp 0x5b33
pushq $0x9
popq %rdi
callq 0x46d0
cmpq $0x0, (%rsp)
movq 0x10(%rsp), %rbx
leaq 0x6c67e(%rip), %rdi     # 0x72246
cmovneq %rbx, %rdi
callq 0x47f0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O2/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 0x24b48
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x25196
testl %eax, %eax
js 0x5c7d
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x5c88
movq %r14, %rdi
callq 0x24b55
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ebx, %ebx
leaq 0x6b02d(%rip), %rcx     # 0x71039
cmpl $0x2, %edi
jl 0x602e
movq 0x8(%rsi,%rbx,8), %rax
cmpb $0x2d, (%rax)
jne 0x6031
cmpb $0x63, 0x1(%rax)
jne 0x6031
cmpb $0x0, 0x2(%rax)
jne 0x6031
decl %edi
incq %rbx
jmp 0x600c
movq %rcx, %rax
leaq 0x6e93b(%rip), %rsi     # 0x74973
movq %rax, %rdi
callq 0xd4fb
movq %rax, %r14
callq 0x188c4
movq %rax, 0x18(%rsp)
movq %r14, %rdi
callq 0x1b04e
movq %rax, %r15
leaq 0x28(%rsp), %rsi
movq %r14, 0x20(%rsp)
movq %r14, (%rsi)
movq %rax, 0x8(%rsi)
leaq 0xbe(%rip), %rdi        # 0x612e
callq 0x21a32
movq %rax, %r12
leaq -0x42b(%rip), %rsi      # 0x5c54
movq %rax, %rdi
callq 0x21c1f
leaq -0x400(%rip), %rsi      # 0x5c8e
movq %r12, %rdi
callq 0x21c24
leaq 0xc(%rsp), %r13
andl $0x0, (%r13)
leaq 0x14(%rsp), %rbp
leaq 0x10(%rsp), %r14
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x22df0
testq %rax, %rax
je 0x60f1
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movq %r15, %rdi
movq %rax, %rsi
cmpl $0x1, %ebx
je 0x60e3
testl %ebx, %ebx
jne 0x60ea
callq 0x5c9b
jmp 0x60aa
callq 0x5e51
jmp 0x60aa
callq 0x5adc
jmp 0x60aa
movq %r12, %rdi
callq 0x21af1
movq 0x20(%rsp), %rdi
callq 0xe6d1
movq 0x18(%rsp), %rdi
callq 0x18992
movq %r15, %rdi
callq 0x1801e
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_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_13/reverse.c
// Function: main
int main(void)
{
  char str[MAXLEN] = "This is just a string";

  printf("%s\n", str);
  reverse(str);
  printf("%s\n", str);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0xec8(%rip), %rsi       # 0x2010
pushq $0x64
popq %rcx
movq %rsp, %rbx
movq %rbx, %rdi
rep  movsb (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1173
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2eb4(%rip), %rax      # 0x4034
movb (%rdi,%rax), %bpl
testb %bpl, %bpl
je 0x11af
incl %eax
movl %eax, 0x2ea3(%rip)      # 0x4034
movq %rbx, %rdi
callq 0x1173
movslq 0x2e98(%rip), %rcx      # 0x4038
leal 0x1(%rcx), %eax
movl %eax, 0x2e8f(%rip)      # 0x4038
movb %bpl, (%rbx,%rcx)
jmp 0x11b5
movl 0x2e83(%rip), %eax      # 0x4038
cltq
cmpb $0x0, (%rbx,%rax)
jne 0x11cb
andl $0x0, 0x2e70(%rip)      # 0x4034
andl $0x0, 0x2e6d(%rip)      # 0x4038
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xb0453(%rip), %r12     # 0xb5fd8
movq (%r12), %rcx
leaq 0x814ac(%rip), %rdi     # 0x8703c
pushq $0x2a
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x814bd(%rip), %rdi     # 0x87067
pushq $0x34
popq %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x814dc(%rip), %rdi     # 0x8709c
pushq $0x9
popq %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x814d0(%rip), %rdi     # 0x870a6
pushq $0x49
popq %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x81504(%rip), %rdi     # 0x870f0
pushq $0x30
popq %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x8151f(%rip), %rdi     # 0x87121
pushq $0x40
popq %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x81546(%rip), %rdi     # 0x87162
pushq $0x35
popq %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x81566(%rip), %rdi     # 0x87198
pushq $0x64
popq %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x815b5(%rip), %rdi     # 0x871fd
movq %r15, %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x815e0(%rip), %rdi     # 0x8723e
movq %r15, %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rcx
leaq 0x8160b(%rip), %rdi     # 0x8727f
pushq $0x4f
popq %rsi
movq %r14, %rdx
callq 0x49d0
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x4660
movl %ebx, %edi
callq 0x4600
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test-bcf-sr.c
// Function: write_summary_format
void write_summary_format(bcf_srs_t *sr, FILE *out)
{
    int n, i, j;
    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");
            fprintf(out, "%s:%"PRIhts_pos,
                    bcf_seqname_safe(bcf_sr_get_header(sr,i),rec),rec->pos+1);
            break;
        }

        for (i=0; i<sr->nreaders; i++)
        {
            fprintf(out, "\t");

            if ( !bcf_sr_has_line(sr,i) )
            {
                fprintf(out, "%s","-");
                continue;
            }

            bcf1_t *rec = bcf_sr_get_line(sr, i);
            if (!rec) error("bcf_sr_get_line() unexpectedly returned NULL\n");
            fprintf(out, "%s", rec->n_allele > 1 ? rec->d.allele[1] : ".");
            for (j=2; j<rec->n_allele; j++)
            {
                fprintf(out, ",%s", rec->d.allele[j]);
            }
        }
        fprintf(out, "\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x81653(%rip), %r12     # 0x872fd
movq %r14, %rdi
callq 0x22203
testl %eax, %eax
jle 0x5dfd
movl 0x30(%r14), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
pushq $-0xc
popq %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x5d48
movq 0x18(%r14), %rsi
addq $0x18, %rcx
cmpl $0x0, (%rsi,%rdx,4)
leaq 0x1(%rdx), %rdx
je 0x5ccd
movq 0x28(%r14), %rdx
movq (%rdx,%rcx,4), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x5e0c
movq -0x18(%rdx,%rcx,4), %rcx
testq %rcx, %rcx
je 0x5d21
movl 0x10(%rax), %esi
movl $0x0, %edx
testl %esi, %esi
js 0x5d23
cmpl %esi, 0x4(%rcx)
jle 0x5d21
movq 0x18(%rcx), %rcx
shlq $0x4, %rsi
movq (%rcx,%rsi), %rdx
jmp 0x5d23
xorl %edx, %edx
testq %rdx, %rdx
leaq 0x8183e(%rip), %rcx     # 0x8756b
cmoveq %rcx, %rdx
movq (%rax), %rcx
incq %rcx
movq %rbx, %rdi
leaq 0x877f2(%rip), %rsi     # 0x8d533
xorl %eax, %eax
callq 0x4730
xorl %r13d, %r13d
movslq 0x30(%r14), %rax
cmpq %rax, %r13
jge 0x5ded
pushq $0x9
popq %rdi
movq %rbx, %rsi
callq 0x4660
movq 0x18(%r14), %rax
cmpl $0x0, (%rax,%r13,4)
je 0x5dd6
movq 0x28(%r14), %rax
imulq $0x60, %r13, %rcx
movq 0x30(%rax,%rcx), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x5e0c
movzwl 0x1a(%r15), %eax
leaq 0x86a3e(%rip), %rdi     # 0x8c7d1
testw $0xfffe, %ax            # imm = 0xFFFE
je 0x5da4
movq 0x88(%r15), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x4560
pushq $0x2
popq %rbp
movzwl 0x1a(%r15), %eax
cmpq %rax, %rbp
jae 0x5de5
movq 0x88(%r15), %rax
movq (%rax,%rbp,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4730
incq %rbp
jmp 0x5daf
leaq 0x83ed8(%rip), %rdi     # 0x89cb5
movq %rbx, %rsi
callq 0x4560
incq %r13
jmp 0x5d4b
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4660
jmp 0x5caa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x814bc(%rip), %rdi     # 0x872cf
xorl %eax, %eax
callq 0x5adc
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2a7e5
testl %eax, %eax
jne 0x5eb3
pushq $0xc
popq %r12
movq %r15, %rdi
callq 0x22203
testl %eax, %eax
jle 0x5e8d
movq %r12, %r13
xorl %ebp, %ebp
movslq 0x30(%r15), %rax
cmpq %rax, %rbp
jge 0x5e41
movq 0x18(%r15), %rax
cmpl $0x0, (%rax,%rbp,4)
je 0x5e84
movq 0x28(%r15), %rax
movq (%rax,%r13,4), %rax
movq (%rax), %rdx
testq %rdx, %rdx
je 0x5e9c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c162
testl %eax, %eax
js 0x5ea5
incq %rbp
addq $0x18, %r13
jmp 0x5e52
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8142c(%rip), %rdi     # 0x872cf
jmp 0x5eac
leaq 0x8146f(%rip), %rdi     # 0x8731b
xorl %eax, %eax
callq 0x5adc
leaq 0x81447(%rip), %rdi     # 0x87301
movq %r12, %rsi
xorl %eax, %eax
callq 0x5adc
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_set_regions
int bcf_sr_set_regions(bcf_srs_t *readers, const char *regions, int is_file)
{
    if ( readers->nreaders || readers->regions )
    {
        if ( readers->regions ) bcf_sr_regions_destroy(readers->regions);
        readers->regions = bcf_sr_regions_init(regions,is_file,0,1,-2);
        bcf_sr_seek_start(readers);
        return 0;
    }

    readers->regions = bcf_sr_regions_init(regions,is_file,0,1,-2);
    if ( !readers->regions ) return -1;
    readers->explicit_regs = 1;
    readers->require_index = REQUIRE_IDX_;
    readers->regions->overlap = BCF_SR_AUX(readers)->regions_overlap;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
movq 0x48(%rdi), %rdi
je 0x20ee6
testq %rdi, %rdi
jne 0x20eeb
jmp 0x20ef0
testq %rdi, %rdi
je 0x20f1d
callq 0x20f62
xorl %ebp, %ebp
pushq $0x1
popq %rcx
pushq $-0x2
popq %r8
movq %r15, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x21031
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
callq 0x2155d
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
pushq $0x1
popq %r12
pushq $-0x2
popq %r8
movq %r15, %rdi
movl %r14d, %esi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x21031
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x20f5d
movl %r12d, 0x38(%rbx)
movl %r12d, 0x10(%rbx)
movq 0x88(%rbx), %rcx
movl 0x1d8(%rcx), %ecx
movl %ecx, 0xc8(%rax)
jmp 0x20f12
pushq $-0x1
popq %rbp
jmp 0x20f12
// File: /workspace/github_c_makefile_star2_O2/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 0x20f81
callq 0xc3d9
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20f8e
callq 0x24e31
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x20f9c
callq 0x99d1
movq 0x40(%rbx), %rdi
callq 0x45d0
movq 0x58(%rbx), %rdi
callq 0x45d0
movq 0x20(%rbx), %rdi
callq 0x45d0
cmpq $0x0, 0x80(%rbx)
je 0x21005
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x98(%rbx), %rax
cmpq %rax, %r15
jge 0x20ffc
movq 0x90(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x45d0
movq 0x80(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x45d0
incq %r15
addq $0x18, %r14
jmp 0x20fc7
movq 0x80(%rbx), %rdi
jmp 0x21007
xorl %edi, %edi
callq 0x45d0
movq 0x90(%rbx), %rdi
callq 0x45d0
movq 0x88(%rbx), %rdi
callq 0x23251
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_seek_start
static void bcf_sr_seek_start(bcf_srs_t *readers)
{
    bcf_sr_regions_t *reg = readers->regions;
    int i;
    for (i=0; i<reg->nseqs; i++)
        reg->regs[i].creg = -1;
    reg->iseq = 0;
    reg->start = -1;
    reg->end   = -1;
    reg->prev_seq = -1;
    reg->prev_start = -1;
    reg->prev_end   = -1;
}

// Assembly:
movq 0x48(%rdi), %rax
movslq 0x98(%rax), %rcx
pushq $0x10
popq %rdx
xorl %esi, %esi
cmpq %rcx, %rsi
jge 0x21586
movq 0x80(%rax), %rdi
orl $-0x1, (%rdi,%rdx)
incq %rsi
addq $0x18, %rdx
jmp 0x2156d
andl $0x0, 0x9c(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0xa0(%rax)
orl $-0x1, 0xb0(%rax)
movdqu %xmm0, 0xb8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x215bd
movq %rdi, %r14
cmpq $0x0, 0x50(%rdi)
je 0x215df
leaq 0x696dd(%rip), %rsi     # 0x8aca1
leaq 0x696e9(%rip), %rdx     # 0x8acb4
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x86fa
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %ecx, %ebx
cmpb $0x5e, (%rsi)
jne 0x215f1
movl $0x1, 0x5c(%r14)
incq %rsi
xorl %ebp, %ebp
pushq $0x1
popq %rcx
pushq $-0x2
popq %r8
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x21031
movq %rax, 0x50(%r14)
testq %rax, %rax
je 0x215d5
movl %ebx, 0x58(%r14)
movq 0x88(%r14), %rcx
movl 0x1dc(%rcx), %ecx
movl %ecx, 0xc8(%rax)
jmp 0x215d8
// File: /workspace/github_c_makefile_star2_O2/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 0x2166c
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x42f0
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x2166f
movl %ebp, %edi
callq 0x264eb
movq %rax, %rcx
movq 0x80(%rbx), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
jmp 0x21679
xorl %eax, %eax
retq
movl $0x7, 0x20(%rbx)
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x216ad
movq (%rdi), %rax
testq %rax, %rax
je 0x216a7
movq %rax, %rdi
callq 0x26eab
movq 0x80(%rbx), %rdi
popq %rbx
jmp 0x45d0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2fb19
leaq 0x2(%rsp), %rsi
movq %r12, %rdi
callq 0x87fb
testq %rax, %rax
je 0x21726
movq %rax, %r15
leaq 0x65d98(%rip), %rsi     # 0x87486
movq %r12, %rdi
callq 0x40d0
testq %rax, %rax
pushq $0x7
popq %rcx
cmoveq %rax, %rcx
addq %rax, %rcx
pushq $0x1
popq %r14
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x21739
testl %eax, %eax
jne 0x2172a
movq %r15, %rdi
callq 0x99d1
xorl %r14d, %r14d
jmp 0x2172a
andl $0x0, 0x20(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_regions_alloc
static bcf_sr_regions_t *bcf_sr_regions_alloc(void)
{
    bcf_sr_regions_t *reg = (bcf_sr_regions_t *) calloc(1, sizeof(bcf_sr_regions_t));
    if ( !reg ) return NULL;

    reg->start = reg->end = -1;
    reg->prev_start = reg->prev_end = reg->prev_seq = -1;
    return reg;
}

// Assembly:
pushq %rax
pushq $0x1
popq %rdi
movl $0xd0, %esi
callq 0x42f0
testq %rax, %rax
je 0x21cc5
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0xa0(%rax)
orl $-0x1, 0xb0(%rax)
movdqu %xmm0, 0xb8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/synced_bcf_reader.c
// Function: regions_add
static int _regions_add(bcf_sr_regions_t *reg, const char *chr, hts_pos_t start, hts_pos_t end)
{
    if ( start==-1 && end==-1 )
    {
        start = 0; end = MAX_CSI_COOR-1;
    }
    else
    {
        start--; end--; // store 0-based coordinates
    }

    if ( !reg->seq_hash )
         reg->seq_hash = khash_str2int_init();

    int iseq;
    if ( khash_str2int_get(reg->seq_hash, chr, &iseq)<0 )
    {
        // the chromosome block does not exist
        iseq = reg->nseqs++;
        reg->seq_names = (char**) realloc(reg->seq_names,sizeof(char*)*reg->nseqs);
        reg->regs = (region_t*) realloc(reg->regs,sizeof(region_t)*reg->nseqs);
        memset(&reg->regs[reg->nseqs-1],0,sizeof(region_t));
        reg->seq_names[iseq] = strdup(chr);
        reg->regs[iseq].creg = -1;
        khash_str2int_set(reg->seq_hash,reg->seq_names[iseq],iseq);
    }

    region_t *creg = &reg->regs[iseq];
    hts_expand(region1_t,creg->nregs+1,creg->mregs,creg->regs);
    creg->regs[creg->nregs].start = start;
    creg->regs[creg->nregs].end   = end;
    creg->nregs++;

    return 0; // FIXME: check for errs in this function
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
jne 0x21cf9
callq 0x23246
movq %rax, %rdi
movq %rax, 0x88(%r15)
leaq 0x14(%rsp), %rdx
movq %r12, %rsi
callq 0x22cd3
testl %eax, %eax
jns 0x21dba
movslq 0x98(%r15), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x98(%r15)
movl %eax, 0x14(%rsp)
movq 0x90(%r15), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x4870
movq %rax, 0x90(%r15)
movq 0x80(%r15), %rdi
movslq 0x98(%r15), %rax
imulq $0x18, %rax, %rsi
callq 0x4870
movq %rax, 0x80(%r15)
movslq 0x98(%r15), %rcx
imulq $0x18, %rcx, %rcx
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rax,%rcx)
andq $0x0, -0x8(%rax,%rcx)
movq %r12, %rdi
callq 0x4950
movq 0x90(%r15), %rcx
movslq 0x14(%rsp), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x80(%r15), %rax
imulq $0x18, %rdx, %rcx
orl $-0x1, 0x10(%rax,%rcx)
movq 0x88(%r15), %rdi
movq 0x90(%r15), %rax
movslq 0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rsi
callq 0x2347b
movq 0x80(%r15), %rcx
movslq 0x14(%rsp), %rax
imulq $0x18, %rax, %rdx
leaq (%rcx,%rdx), %r15
movl 0x8(%rcx,%rdx), %eax
movslq 0xc(%rcx,%rdx), %rsi
cmpl %esi, %eax
jl 0x21e0a
leal 0x1(%rax), %ecx
testl %eax, %eax
pushq $0x1
popq %rdi
cmovnsl %ecx, %edi
leaq 0x69447(%rip), %rax     # 0x8b234
movq %rax, (%rsp)
pushq $0x4
popq %rdx
pushq $0x10
popq %rcx
xorl %r8d, %r8d
movq %r15, %r9
callq 0xf517
movl %eax, 0xc(%r15)
movl 0x8(%r15), %eax
movq %rbx, %rcx
andq %r14, %rcx
decq %r14
decq %rbx
xorl %edx, %edx
cmpq $-0x1, %rcx
cmovneq %r14, %rdx
movabsq $0xffffffffffe, %rcx    # imm = 0xFFFFFFFFFFE
cmovneq %rbx, %rcx
movq (%r15), %rsi
cltq
movq %rax, %rdi
shlq $0x4, %rdi
movq %rdx, (%rsi,%rdi)
movq %rcx, 0x8(%rsi,%rdi)
incl %eax
movl %eax, 0x8(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21f23
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x207c(%rip), %r14      # 0x23ef0
pushq $0x10
popq %r15
movslq 0x98(%rbx), %rax
cmpq %rax, %r12
jge 0x21f1a
movq 0x80(%rbx), %rax
imulq $0x18, %r12, %r13
movq (%rax,%r13), %rdi
movslq 0x8(%rax,%r13), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x49b0
movq 0x80(%rbx), %rcx
leaq (%rcx,%r13), %rax
movl 0x8(%rcx,%r13), %ecx
movslq %ecx, %rdx
xorl %esi, %esi
cmpl %ecx, %esi
jge 0x21f12
movslq %esi, %rsi
movq %rsi, %rdi
shlq $0x4, %rdi
leaq 0x18(%rdi), %r8
incq %rsi
cmpq %rdx, %rsi
jge 0x21f0e
movq (%rax), %r9
leaq (%r9,%rdi), %r10
addq $0x8, %r10
movq (%r10), %r11
cmpq -0x8(%r9,%r8), %r11
jl 0x21ebc
movq (%r9,%r8), %r13
cmpq %r13, %r11
jge 0x21ef7
movq %r13, (%r10)
movq $0x1, -0x8(%r9,%r8)
andq $0x0, (%r9,%r8)
incq %rsi
addq $0x10, %r8
jmp 0x21ed1
movl %ecx, %esi
jmp 0x21ebc
incq %r12
jmp 0x21e78
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
pushq $0x1
popq %r14
movl $0x90, %esi
movq %r14, %rdi
callq 0x42f0
movq %rax, %rbx
movl $0x1e8, %esi            # imm = 0x1E8
movq %r14, %rdi
callq 0x42f0
movq %rax, 0x88(%rbx)
movq %rax, %rdi
callq 0x6fd2b
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20cfd
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x20cfd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x30(%rbx), %rax
cmpq %rax, %r12
jge 0x21fe9
movq 0x28(%rbx), %rdi
addq %r15, %rdi
movl (%r14,%r12,4), %esi
callq 0x2208b
incq %r12
addq $0x60, %r15
jmp 0x21fc7
movq 0x18(%rbx), %rdi
callq 0x45d0
movq 0x28(%rbx), %rdi
callq 0x45d0
xorl %r15d, %r15d
movslq 0x78(%rbx), %rax
movq 0x40(%rbx), %rdi
cmpq %rax, %r15
jge 0x22019
movq (%rdi,%r15,8), %rdi
callq 0x45d0
incq %r15
jmp 0x21ffe
callq 0x45d0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2202c
callq 0x20f62
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2203a
callq 0x20f62
cmpq $0x0, 0x68(%rbx)
je 0x2204a
movq 0x70(%rbx), %rdi
callq 0x45d0
cmpl $0x0, 0x7c(%rbx)
je 0x22058
movq %rbx, %rdi
callq 0x21680
movq 0x88(%rbx), %rdi
callq 0x6fd52
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