LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x40, 0x20c(%rax)
jne 0x4e31c
movq -0x8(%rbp), %rax
movl $0x65, 0x210(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x20c(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rax
movl $0x40, 0x20c(%rax)
jmp 0x4e3a9
movq -0x8(%rbp), %rax
cmpl $0x20, 0x20c(%rax)
jne 0x4e369
movq -0x8(%rbp), %rax
movl $0x65, 0x210(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x20c(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rax
movl $0x20, 0x20c(%rax)
jmp 0x4e3a7
movq -0x8(%rbp), %rax
movl $0x65, 0x210(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x20c(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rax
movl $0x10, 0x20c(%rax)
jmp 0x4e3a9
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dd40
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x88000000, 0x144(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x260(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x210(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x20c(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rax
movl $0x20, 0x20c(%rax)
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x4e499
jmp 0x4e4e6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
subq $0x1, %rax
movsbq (%rax), %rcx
leaq 0x2f99(%rip), %rdx      # 0x5145b
callq 0x4d3a0
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
subq $0x1, %rax
movzbl (%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: Eb
void __bea_callspec__ Eb(PDISASM pMyDisasm)
{
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x210(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x20c(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rax
movl $0x20, 0x20c(%rax)
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: Ev
void __bea_callspec__ Ev(PDISASM pMyDisasm)
{
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg1qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg1dword;
    }
    else {
        GV.MemDecoration = Arg1word;
    }
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x40, 0x20c(%rax)
jne 0x4eb19
movq -0x8(%rbp), %rax
movl $0x4, 0x210(%rax)
jmp 0x4eb46
movq -0x8(%rbp), %rax
cmpl $0x20, 0x20c(%rax)
jne 0x4eb36
movq -0x8(%rbp), %rax
movl $0x3, 0x210(%rax)
jmp 0x4eb44
movq -0x8(%rbp), %rax
movl $0x2, 0x210(%rax)
jmp 0x4eb46
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ed20
cmpl $0x0, %eax
je 0x4ed02
movq -0x10(%rbp), %rdi
callq 0x4efc0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x289(%rax)
jne 0x4ecf9
movq -0x10(%rbp), %rdi
callq 0x4f010
movq -0x10(%rbp), %rdi
callq 0x4f220
movq -0x10(%rbp), %rdi
callq 0x4f290
movq -0x10(%rbp), %rdi
callq 0x4f820
movq -0x10(%rbp), %rax
cmpl $0x400, 0x24c(%rax)     # imm = 0x400
jne 0x4ecc3
movq -0x10(%rbp), %rdi
callq 0x4f850
jmp 0x4eccc
movq -0x10(%rbp), %rdi
callq 0x50000
movq -0x10(%rbp), %rax
cmpl $0x0, 0x280(%rax)
je 0x4ece2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ed09
movq -0x10(%rbp), %rax
movq 0x1f0(%rax), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movl %eax, -0x4(%rbp)
jmp 0x4ed09
movl $0x0, -0x4(%rbp)
jmp 0x4ed09
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: FixREXPrefixes
void __bea_callspec__ FixREXPrefixes (PDISASM pMyDisasm) {

    (*pMyDisasm).Prefix.REX.W_ = GV.REX.W_;
    (*pMyDisasm).Prefix.REX.R_ = GV.REX.R_;
    (*pMyDisasm).Prefix.REX.X_ = GV.REX.X_;
    (*pMyDisasm).Prefix.REX.B_ = GV.REX.B_;
    (*pMyDisasm).Prefix.REX.state = GV.REX.state;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x284(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1e9(%rax)
movq -0x8(%rbp), %rax
movb 0x285(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1ea(%rax)
movq -0x8(%rbp), %rax
movb 0x286(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1eb(%rax)
movq -0x8(%rbp), %rax
movb 0x287(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1ec(%rax)
movq -0x8(%rbp), %rax
movb 0x288(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1ed(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
testb $0x1, 0xaea5(%rip)      # 0xd270
je 0x23e8
cmpq $0x0, 0xcadb(%rip)      # 0xeeb0
je 0x23e8
movq -0x10(%rbp), %rdi
callq 0x2210
movl %eax, 0xae42(%rip)      # 0xd228
jmp 0x241f
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x21e0
movq %rax, 0xcab4(%rip)      # 0xeeb0
movq 0xcaad(%rip), %rdi      # 0xeeb0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x21b0
movq 0xca99(%rip), %rax      # 0xeeb0
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
testb $0x1, 0xae4a(%rip)      # 0xd270
je 0x2431
cmpl $-0x1, 0xadf9(%rip)     # 0xd228
je 0x2458
movq 0xca78(%rip), %rdi      # 0xeeb0
movl 0xadea(%rip), %esi      # 0xd228
callq 0x45e0
movq $0x0, 0xca62(%rip) # 0xeeb0
movl $0xffffffff, 0xadd0(%rip) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xa159(%rip), %eax      # 0xd1fc
jae 0x30d8
movslq -0xc(%rbp), %rax
leaq 0xa0c0(%rip), %rdi      # 0xd170
imulq $0x14, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x30cb
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x30cd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x309a
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl 0xa0fa(%rip), %eax      # 0xd1fc
movl %eax, %edi
shlq $0x3, %rdi
callq 0x21e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xa0db(%rip), %eax      # 0xd1fc
jae 0x317c
cmpl $0x0, -0x1c(%rbp)
jne 0x3133
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x313b
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x313b
movq -0x28(%rbp), %rdi
leaq 0x6f53(%rip), %rsi      # 0xa099
callq 0x4950
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3161
leaq 0xa114(%rip), %rax      # 0xd271
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3118
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/redis_parse.c
// Function: limit_reached
bool limit_reached(struct query *q) {
	if (q->limit == -1 || q->displayed >= q->limit)
		return true;
	q->displayed++;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
je 0x45c2
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jl 0x45c8
movb $0x1, -0x1(%rbp)
jmp 0x45d9
movq -0x10(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4972
movq -0x10(%rbp), %rax
movq %rax, 0xa536(%rip)      # 0xeea8
cmpq $0x0, 0xa52e(%rip)      # 0xeea8
je 0x498b
movq 0xa525(%rip), %rax      # 0xeea8
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4995
movq $0x0, -0x8(%rbp)
jmp 0x49f9
movq 0xa50c(%rip), %rdi      # 0xeea8
movq -0x18(%rbp), %rsi
callq 0x2150
movl %eax, -0x24(%rbp)
movq 0xa4f9(%rip), %rax      # 0xeea8
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %ecx
movq 0xa4eb(%rip), %rax      # 0xeea8
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0xa4de(%rip)      # 0xeea8
movq 0xa4d7(%rip), %rax      # 0xeea8
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x49f1
movq 0xa4c8(%rip), %rax      # 0xeea8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xa4ba(%rip)      # 0xeea8
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/winton[P]redis_parse/redis_parse.c
// Function: createReplyObject
static redisReply *createReplyObject(int type) {
	redisReply *r = calloc(1,sizeof(*r));

	if (r == NULL)
		return NULL;

	r->type = type;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4a3f
movq $0x0, -0x8(%rbp)
jmp 0x4a50
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movq 0xeba(%rip), %rax       # 0x2010
movq %rax, -0x20(%rbp)
movq 0xeb7(%rip), %rax       # 0x2018
movq %rax, -0x18(%rbp)
movl 0xeb5(%rip), %eax       # 0x2020
movl %eax, -0x10(%rbp)
movb 0xeb0(%rip), %al        # 0x2024
movb %al, -0xc(%rbp)
movl 0xea8(%rip), %eax       # 0x2025
movl %eax, -0x25(%rbp)
movb 0xea3(%rip), %al        # 0x2029
movb %al, -0x21(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x25(%rbp), %rsi
callq 0x11b0
movl %eax, %esi
leaq 0xe8b(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x124b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x1231
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x122f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x122d
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1252
jmp 0x11f1
jmp 0x1231
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
callq 0x1040
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x116c
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x116c
movq $0x0, -0x8(%rbp)
jmp 0x11c3
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1190
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1186
movq -0x18(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x11c3
movzbl -0x9(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x11bb
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x3, %edi
callq 0x1040
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x136a
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x136a
movq $0x0, -0x8(%rbp)
jmp 0x13e0
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x138e
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1384
movq -0x18(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x13e0
movq -0x20(%rbp), %rax
movb $0x3f, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1050
movzbl %al, %edx
movl $0x30, %eax
movl $0x31, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x2(%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x13d8
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12bc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1e60
jmp 0x12be
movq $0x0, -0x38(%rbp)
cmpq $0x101, -0x38(%rbp)     # imm = 0x101
jae 0x1310
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x13a0
cmpl $0x0, %eax
je 0x1300
jmp 0x12e5
leaq 0x9d18(%rip), %rdi      # 0xb004
movb $0x0, %al
callq 0x2170
callq 0x1060
movl $0x0, (%rax)
jmp 0x1359
jmp 0x1302
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x12c6
movq $0x0, -0x38(%rbp)
cmpq $0x20, -0x38(%rbp)
jae 0x1344
movq -0x38(%rbp), %rax
movzbl -0x30(%rbp,%rax), %esi
leaq 0x9cfc(%rip), %rdi      # 0xb02b
movb $0x0, %al
callq 0x1080
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1318
leaq 0x9ee1(%rip), %rdi      # 0xb22c
movb $0x0, %al
callq 0x1080
xorl %edi, %edi
callq 0x1160
movl $0x1, %edi
callq 0x1160
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x3ea80
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3f730
cmpl $0x0, %eax
jge 0x5d81
movq -0x28(%rbp), %rdi
callq 0x3eaa0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d93
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0xea6(%rip), %rsi       # 0x2010
movl $0x64, %edx
callq 0x1040
leaq -0x70(%rbp), %rsi
leaq 0xef5(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1030
leaq -0x70(%rbp), %rdi
callq 0x11b0
leaq -0x70(%rbp), %rsi
leaq 0xeda(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x2e75(%rip), %rcx      # 0x403c
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1215
movq -0x8(%rbp), %rax
movl 0x2e62(%rip), %ecx      # 0x403c
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x2e57(%rip)      # 0x403c
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11b0
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movl 0x2e3c(%rip), %ecx      # 0x4040
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2e31(%rip)      # 0x4040
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq 0x2e20(%rip), %rcx      # 0x4040
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x123d
movl $0x0, 0x2e09(%rip)      # 0x403c
movl $0x0, 0x2e03(%rip)      # 0x4040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test-bcf-sr.c
// Function: error
void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) HTS_NORETURN
error(const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5b15
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x12c469(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4680
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x45d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x12c42e(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x108458(%rip), %rsi    # 0x10e004
movb $0x0, %al
callq 0x46f0
movq 0x12c416(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x10846b(%rip), %rsi    # 0x10e02f
movb $0x0, %al
callq 0x46f0
movq 0x12c3fe(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x108488(%rip), %rsi    # 0x10e064
movb $0x0, %al
callq 0x46f0
movq 0x12c3e6(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x10847a(%rip), %rsi    # 0x10e06e
movb $0x0, %al
callq 0x46f0
movq 0x12c3ce(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x1084ac(%rip), %rsi    # 0x10e0b8
movb $0x0, %al
callq 0x46f0
movq 0x12c3b6(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x1084c5(%rip), %rsi    # 0x10e0e9
movb $0x0, %al
callq 0x46f0
movq 0x12c39e(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x1084ee(%rip), %rsi    # 0x10e12a
movb $0x0, %al
callq 0x46f0
movq 0x12c386(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x10850c(%rip), %rsi    # 0x10e160
movb $0x0, %al
callq 0x46f0
movq 0x12c36e(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x108559(%rip), %rsi    # 0x10e1c5
movb $0x0, %al
callq 0x46f0
movq 0x12c356(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x108582(%rip), %rsi    # 0x10e206
movb $0x0, %al
callq 0x46f0
movq 0x12c33e(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x1085ab(%rip), %rsi    # 0x10e247
movb $0x0, %al
callq 0x46f0
movq 0x12c326(%rip), %rax    # 0x131fd0
movq (%rax), %rdi
leaq 0x108864(%rip), %rsi    # 0x10e518
movb $0x0, %al
callq 0x46f0
movl -0x4(%rbp), %edi
callq 0x45d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x48c00
cmpl $0x0, %eax
je 0x5fec
movq -0x20(%rbp), %rsi
leaq 0x1082e4(%rip), %rdi    # 0x10e2c9
movb $0x0, %al
callq 0x5ae0
jmp 0x5fee
movq -0x8(%rbp), %rdi
callq 0x39a40
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jle 0x60be
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x60b9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x602e
jmp 0x60ab
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x6060
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x6068
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x6068
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6085
leaq 0x108219(%rip), %rdi    # 0x10e297
movb $0x0, %al
callq 0x5ae0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4ba60
cmpl $0x0, %eax
jge 0x60a9
leaq 0x108241(%rip), %rdi    # 0x10e2e3
movb $0x0, %al
callq 0x5ae0
jmp 0x60ab
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x600a
jmp 0x5fee
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/synced_bcf_reader.c
// Function: bcf_sr_strerror
char *bcf_sr_strerror(int errnum)
{
    switch (errnum)
    {
        case open_failed:
            return strerror(errno);
        case not_bgzf:
            return "not compressed with bgzip";
        case idx_load_failed:
            return "could not load index";
        case file_type_error:
            return "unknown file type";
        case api_usage_error:
            return "API usage error";
        case header_error:
            return "could not parse header";
        case no_eof:
            return "no BGZF EOF marker; file may be truncated";
        case no_memory:
            return "Out of memory";
        case vcf_parse_error:
            return "VCF parse error";
        case bcf_read_error:
            return "BCF read error";
        case noidx_error:
            return "merge of unindexed files failed";
        default: return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0x37c9a
movq -0x18(%rbp), %rax
leaq 0xda1b9(%rip), %rcx     # 0x111db0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x4050
movl (%rax), %edi
callq 0x4120
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda1d4(%rip), %rax     # 0x111df0
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda1de(%rip), %rax     # 0x111e0a
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda1e6(%rip), %rax     # 0x111e1f
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda1eb(%rip), %rax     # 0x111e31
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda1ee(%rip), %rax     # 0x111e41
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda1f8(%rip), %rax     # 0x111e58
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xd8a73(%rip), %rax     # 0x1106e0
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda208(%rip), %rax     # 0x111e82
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda20b(%rip), %rax     # 0x111e92
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xda20d(%rip), %rax     # 0x111ea1
movq %rax, -0x8(%rbp)
jmp 0x37ca5
leaq 0xd6f49(%rip), %rax     # 0x10ebea
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x37fd8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x38026
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x37ff0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x380b0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x38200
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
callq 0x38600
movl $0x0, -0x4(%rbp)
jmp 0x3809a
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x38200
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x3805e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3809a
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movl 0x1d8(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl %ecx, 0xc8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x380e1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11230
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x380f7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3ef90
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3810f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xc9d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x38127
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x3813f
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x381b3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x98(%rcx), %eax
jge 0x381b1
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x45a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38161
jmp 0x381b3
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x3ae60
movq -0x8(%rbp), %rdi
callq 0x45a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x98(%rcx), %eax
jge 0x38652
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3861b
movq -0x10(%rbp), %rax
movl $0x0, 0x9c(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0xa8(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xb0(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq $-0x1, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0xc0(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x386db
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x38701
movl $0x1, %edi
leaq 0xd97da(%rip), %rsi     # 0x111ec1
leaq 0xd97e6(%rip), %rdx     # 0x111ed4
movb $0x0, %al
callq 0xa790
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3878c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x38724
movq -0x10(%rbp), %rax
movl $0x1, 0x5c(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
callq 0x38200
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x3875c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3878c
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movl 0x1dc(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl %ecx, 0xc8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl %eax, 0x7c(%rcx)
cmpl $0x0, %eax
jne 0x387c7
movl $0x0, -0x4(%rbp)
jmp 0x38832
movl $0x1, %edi
movl $0x10, %esi
callq 0x42e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x38806
movq -0x10(%rbp), %rax
movl $0x7, 0x20(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38832
movl -0x14(%rbp), %edi
callq 0x41c50
movq -0x10(%rbp), %rcx
movq 0x80(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x3882b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38832
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x3885c
jmp 0x38890
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
cmpq $0x0, (%rax)
je 0x38880
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq (%rax), %rdi
callq 0x42b20
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x45a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x1d(%rbp), %rdi
leaq 0xd8d56(%rip), %rsi     # 0x111620
callq 0x4450
leaq -0x1d(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x502e0
movq -0x18(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
callq 0xa8b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x38910
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3896c
movq -0x18(%rbp), %rdi
leaq 0xd5b33(%rip), %rsi     # 0x10e44e
callq 0x40b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl $0x7, %ecx
cmpq $0x0, %rdx
cmovneq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl $0x1, %edx
callq 0x38980
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x38966
movq -0x38(%rbp), %rdi
callq 0xc9d0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/synced_bcf_reader.c
// Function: init_filters
static int *init_filters(bcf_hdr_t *hdr, const char *filters, int *nfilters)
{
    kstring_t str = {0,0,0};
    const char *tmp = filters, *prev = filters;
    int nout = 0, *out = NULL;
    while ( 1 )
    {
        if ( *tmp==',' || !*tmp )
        {
            int *otmp = (int*) realloc(out, (nout+1)*sizeof(int));
            if (!otmp)
                goto err;
            out = otmp;
            if ( tmp-prev==1 && *prev=='.' )
            {
                out[nout] = -1;
                nout++;
            }
            else
            {
                str.l = 0;
                kputsn(prev, tmp-prev, &str);
                out[nout] = bcf_hdr_id2int(hdr, BCF_DT_ID, str.s);
                if ( out[nout]>=0 ) nout++;
            }
            if ( !*tmp ) break;
            prev = tmp+1;
        }
        tmp++;
    }
    if ( str.m ) free(str.s);
    *nfilters = nout;
    return out;

 err:
    if (str.m) free(str.s);
    free(out);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4240
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x390cc
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x3919d
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x4840
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x390f2
jmp 0x391d1
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jne 0x39131
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x39131
movq -0x58(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x39186
movq $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rax
subq %rax, %rsi
leaq -0x38(%rbp), %rdx
callq 0x3bd50
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x46d10
movl %eax, %edx
movq -0x58(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x58(%rbp), %rax
movslq -0x4c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x39184
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x39186
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x39191
jmp 0x391ae
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x390b3
cmpq $0x0, -0x30(%rbp)
je 0x391be
movq -0x28(%rbp), %rdi
callq 0x45a0
movl -0x4c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x391f2
cmpq $0x0, -0x30(%rbp)
je 0x391e1
movq -0x28(%rbp), %rdi
callq 0x45a0
movq -0x58(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0xd0, %esi
callq 0x42e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3922c
movq $0x0, -0x8(%rbp)
jmp 0x3927e
movq -0x10(%rbp), %rax
movq $-0x1, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0xa0(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xb0(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq $-0x1, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)