LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/probability.cpp
// Function: rgamma1(double, double)
double rgamma1(double shape, double rate) {
    gamma_distribution<double> rgamma(shape,1/rate);
	double x = rgamma(generator);

	// check for zero or infinite values (catches bug present in Visual Studio 2010)
	if (x==0)
		x = pow(10.0,-300.0);
	while ((1.0/x)==0)
		x = rgamma(generator);

    return(x);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movapd %xmm0, %xmm2
movsd 0x19d48(%rip), %xmm3    # 0x37260
movapd %xmm3, %xmm0
divsd %xmm1, %xmm0
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm1
addsd %xmm3, %xmm1
movapd %xmm2, %xmm0
cmpltsd %xmm3, %xmm0
andpd %xmm0, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movlpd %xmm0, 0x18(%rsp)
addsd 0x1a929(%rip), %xmm0    # 0x37e80
mulsd 0x1a929(%rip), %xmm0    # 0x37e88
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1d56f
sqrtsd %xmm0, %xmm0
jmp 0x1d57c
callq 0x3280
movsd 0x19ce4(%rip), %xmm3    # 0x37260
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
leaq 0x8(%rsp), %rdi
movsd %xmm1, 0x18(%rdi)
xorpd %xmm0, %xmm0
unpcklpd %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
movupd %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
leaq 0x2615a(%rip), %rsi     # 0x43708
movq %rdi, %rdx
callq 0x1d898
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
xorpd %xmm3, %xmm3
cmpeqsd %xmm3, %xmm2
movsd 0x1a8c1(%rip), %xmm0    # 0x37e90
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm2, %xmm0
movsd 0x19c7d(%rip), %xmm1    # 0x37260
divsd %xmm0, %xmm1
ucomisd %xmm3, %xmm1
jne 0x1d621
jp 0x1d621
leaq 0x26112(%rip), %rbx     # 0x43708
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1d898
movsd 0x19c4f(%rip), %xmm1    # 0x37260
divsd %xmm0, %xmm1
ucomisd 0x19a8b(%rip), %xmm1    # 0x370a8
jne 0x1d621
jnp 0x1d5fb
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/probability.cpp
// Function: sample1(std::vector<double, std::allocator<double>>&, double)
int sample1(vector<double> &p, double pSum) {
    double rand = pSum*uniform_0_1(generator);
    double z = 0;
    for (int i=0; i<int(p.size()); i++) {
        z += p[i];
        if (rand<z)
            return i+1;
    }
    return(0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x260ca(%rip), %rdi     # 0x43708
callq 0x1d74e
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x1d696
movsd 0x260bb(%rip), %xmm1    # 0x43718
movsd 0x260ab(%rip), %xmm2    # 0x43710
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
mulsd 0x8(%rsp), %xmm0
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorpd %xmm1, %xmm1
xorl %eax, %eax
addsd (%rcx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x1d69a
incq %rax
cmpq %rax, %rdx
jne 0x1d683
xorl %eax, %eax
jmp 0x1d69c
incl %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: coutAndLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
void coutAndLog(string message, bool writeToFile, ofstream &fileStream) {
    cout << message;
    if (writeToFile) {
        fileStream << message;
        fileStream.flush();
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x24485(%rip), %rdi     # 0x41fb8
callq 0x3390
testl %ebp, %ebp
je 0x1db57
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x31f0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: cerrAndLog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
void cerrAndLog(string message, bool writeToFile, ofstream &logFileStream) {
    cerr << message;
    if (writeToFile) {
        logFileStream << message;
        logFileStream.flush();
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x2447a(%rip), %rdi     # 0x41ff0
callq 0x3390
testl %ebp, %ebp
je 0x1db9a
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x31f0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: safe_ifstream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
ifstream safe_ifstream(string fileName, bool writeToFile, ofstream &logFileStream) {
    ifstream fileStream(fileName);
    if (!fileStream.is_open()) {
        cerrAndLog("\nError: failed to read from file: "+fileName+string("\n"), writeToFile, logFileStream);
        exit(1);
    }
    return(fileStream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x8, %edx
callq 0x34b0
leaq 0x78(%rbx), %rdi
callq 0x30a0
testb %al, %al
je 0x1dbd9
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a2e8(%rip), %rsi     # 0x37ec8
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0xf984
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19d25(%rip), %rsi     # 0x37922
leaq 0x19d1f(%rip), %rdx     # 0x37923
leaq 0x8(%rsp), %rdi
callq 0x6e56
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6c0e
movzbl %bpl, %esi
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x1db5c
leaq 0x48(%rsp), %rdi
callq 0x3150
leaq 0x8(%rsp), %rdi
callq 0x3150
leaq 0x28(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dc76
callq 0x3310
jmp 0x1dc76
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dc8a
callq 0x3310
jmp 0x1dc8a
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dca2
callq 0x3310
jmp 0x1dca2
movq %rax, %r14
movq %rbx, %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: stringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
double stringToDouble(string s, bool writeToFile, ofstream &logFileStream) {
    double output;
    istringstream ss(s);
    ss >> output;
    if (!output) {
        cerrAndLog("\nError: cannot convert data element '"+s+string("' to type double\n"), writeToFile, logFileStream);
        exit(1);
    }
    return(output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x34f0
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x31e0
movsd 0x10(%rsp), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jne 0x1dd01
jnp 0x1dd33
movq 0x242a0(%rip), %rsi     # 0x41fa8
leaq 0x78(%rsp), %rdi
callq 0x3420
leaq 0xf0(%rsp), %rdi
callq 0x30f0
movsd 0x8(%rsp), %xmm0
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a1b1(%rip), %rsi     # 0x37eeb
leaq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0xf984
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a1ba(%rip), %rsi     # 0x37f11
leaq 0x1a1c4(%rip), %rdx     # 0x37f22
leaq 0x18(%rsp), %rdi
callq 0x6e56
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x6c0e
movzbl %bpl, %esi
leaq 0x58(%rsp), %rdi
movq %rbx, %rdx
callq 0x1db5c
leaq 0x58(%rsp), %rdi
callq 0x3150
leaq 0x18(%rsp), %rdi
callq 0x3150
leaq 0x38(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ddd0
callq 0x3310
jmp 0x1ddd0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1dde4
callq 0x3310
jmp 0x1dde4
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ddfe
callq 0x3310
jmp 0x1ddfe
jmp 0x1ddfb
movq %rax, %rbx
movq 0x241a3(%rip), %rsi     # 0x41fa8
leaq 0x78(%rsp), %rdi
callq 0x3420
leaq 0xf0(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: doubleToInt(double, bool, std::basic_ofstream<char, std::char_traits<char>>&)
int doubleToInt(double x, bool writeToFile, ofstream &logFileStream) {
    double intpart;
    if (modf(x, &intpart)!=0.0) {
        cerrAndLog("\nError: cannot convert data element "+to_string((long long)x)+string(" to type integer\n"), writeToFile, logFileStream);
        exit(1);
    }
    return(int(intpart));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movsd %xmm0, (%rsp)
callq 0x3590
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1de61
jp 0x1de61
cvttsd2si 0x8(%rsp), %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cvttsd2si (%rsp), %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x6d26
leaq 0x1a0a8(%rip), %rsi     # 0x37f23
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0x6cb6
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a0b0(%rip), %rsi     # 0x37f48
leaq 0x1a0ba(%rip), %rdx     # 0x37f59
leaq 0x10(%rsp), %rdi
callq 0x6e56
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x6c0e
movzbl %bpl, %esi
leaq 0x50(%rsp), %rdi
movq %rbx, %rdx
callq 0x1db5c
leaq 0x50(%rsp), %rdi
callq 0x3150
leaq 0x10(%rsp), %rdi
callq 0x3150
leaq 0x30(%rsp), %rdi
callq 0x3150
leaq 0x70(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1df1b
callq 0x3310
jmp 0x1df1b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1df2f
callq 0x3310
jmp 0x1df2f
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1df47
callq 0x3310
jmp 0x1df47
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1df5d
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: safe_getline(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
istream& safe_getline(istream& is, string& t) {
	t.clear();
	istream::sentry se(is, true);
	streambuf* sb = is.rdbuf();
	for (;;) {
		int c = sb->sbumpc();
		switch(c) {
            case '\n':
                return is;
            case '\r':
                if (sb->sgetc()=='\n')
                    sb->sbumpc();
                return is;
            case EOF:
                if (t.empty())
                    is.setstate(ios::eofbit);
                return is;
            default:
                t += (char)c;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rsi)
movq (%rsi), %rax
movb $0x0, (%rax)
leaq 0xf(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3480
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %r15
movq 0x10(%r15), %rcx
cmpq 0x18(%r15), %rcx
jae 0x1e020
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%r15)
cmpl $-0x1, %eax
je 0x1dfeb
cmpl $0xa, %eax
je 0x1e009
cmpl $0xd, %eax
jne 0x1e00d
movq 0x10(%r15), %rax
cmpq 0x18(%r15), %rax
jae 0x1e02b
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1e009
movq 0x10(%r15), %rax
cmpq 0x18(%r15), %rax
jae 0x1e036
incq %rax
movq %rax, 0x10(%r15)
jmp 0x1e009
cmpq $0x0, 0x8(%r14)
jne 0x1e009
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x2, %esi
callq 0x3520
xorl %eax, %eax
jmp 0x1e01a
movsbl %al, %esi
movq %r14, %rdi
callq 0x32c0
movb $0x1, %al
testb %al, %al
jne 0x1dfa3
jmp 0x1e041
movq (%r15), %rax
movq %r15, %rdi
callq *0x50(%rax)
jmp 0x1dfb7
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
jmp 0x1dfd3
movq (%r15), %rax
movq %r15, %rdi
callq *0x50(%rax)
jmp 0x1e009
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: readPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, char const**, int)
void readPath(string argName, string &savePath, int argc, const char * argv[], int i) {
    if (string(argv[i])==argName) {
        if (i+1<argc) {
            savePath = argv[i+1];
        } else {
            cerr << "Error: there was no argument to the "+argName+string(" option\n");
            exit(1);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movslq %r8d, %rax
movq (%rcx,%rax,8), %rsi
leaq 0x8(%rsp), %r13
leaq 0x48(%rsp), %rdx
movq %r13, %rdi
callq 0x3120
movq 0x8(%r13), %rdx
cmpq 0x8(%r14), %rdx
jne 0x1e0a8
testq %rdx, %rdx
je 0x1e0ad
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x3350
testl %eax, %eax
sete %r13b
jmp 0x1e0b0
xorl %r13d, %r13d
jmp 0x1e0b0
movb $0x1, %r13b
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e0c3
callq 0x3310
testb %r13b, %r13b
je 0x1e0f5
incl %ebp
cmpl %r12d, %ebp
jge 0x1e104
movslq %ebp, %rax
movq (%r15,%rax,8), %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x3140
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x3460
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19e4f(%rip), %rsi     # 0x37f5a
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0xf984
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19e57(%rip), %rsi     # 0x37f7f
leaq 0x19e58(%rip), %rdx     # 0x37f87
leaq 0x28(%rsp), %rdi
callq 0x6e56
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x6c0e
movq 0x23e9c(%rip), %rdi     # 0x41ff0
leaq 0x8(%rsp), %rsi
callq 0x32e0
leaq 0x8(%rsp), %rdi
callq 0x3150
leaq 0x28(%rsp), %rdi
callq 0x3150
leaq 0x48(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1e1a2
callq 0x3310
jmp 0x1e1a2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1e1b6
callq 0x3310
jmp 0x1e1b6
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e1c9
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/readIn.cpp
// Function: readArgument(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, globals&, int, char const**, int)
void readArgument(string argName, globals &globals, int argc, const char * argv[], int i) {
    if (string(argv[i])=="-"+argName) {
        if (i+1<argc) {
            globals.parameterStrings[argName] = pair<string,int>(argv[i+1],2);
        } else {
            cerr << "Error: there was no argument to the "+argName+string(" option\n");
            exit(1);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movslq %r8d, %rax
movq (%rcx,%rax,8), %rsi
movq %rsp, %rdi
leaq 0x48(%rsp), %rdx
callq 0x3120
leaq 0x16ee2(%rip), %rsi     # 0x37f9f
leaq 0x28(%rsp), %rdi
movq %rbx, %rdx
callq 0xf984
movq 0x8(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x210f1
testq %rdx, %rdx
je 0x210f6
movq 0x28(%rsp), %rsi
movq (%rsp), %rdi
callq 0x3350
testl %eax, %eax
sete %r13b
jmp 0x210f9
xorl %r13d, %r13d
jmp 0x210f9
movb $0x1, %r13b
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2110c
callq 0x3310
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2111f
callq 0x3310
testb %r13b, %r13b
je 0x21186
incl %ebp
cmpl %r12d, %ebp
jge 0x21195
movslq %ebp, %rax
movq (%r15,%rax,8), %rsi
movq %rsp, %r15
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
callq 0x3120
movl $0x2, 0x20(%r15)
addq $0x2b70, %r14           # imm = 0x2B70
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e66e
movq %rax, %rbx
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x33e0
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x21186
callq 0x3310
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16dbe(%rip), %rsi     # 0x37f5a
leaq 0x28(%rsp), %rdi
movq %rbx, %rdx
callq 0xf984
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x16dc6(%rip), %rsi     # 0x37f7f
leaq 0x16dc7(%rip), %rdx     # 0x37f87
leaq 0x48(%rsp), %rdi
callq 0x6e56
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x6c0e
movq 0x20e0d(%rip), %rdi     # 0x41ff0
movq %rsp, %rsi
callq 0x32e0
movq %rsp, %rdi
callq 0x3150
leaq 0x48(%rsp), %rdi
callq 0x3150
leaq 0x28(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2122c
callq 0x3310
jmp 0x2122c
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x21240
callq 0x3310
jmp 0x21240
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
jmp 0x21266
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
jmp 0x21266
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21275
callq 0x3310
jmp 0x21275
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/./misc.h
// Function: int whichFirst<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int whichFirst(std::vector<TYPE> haystack, TYPE needle) {
    int index = 0;
    for (int i=0; i<int(haystack.size()); i++) {
        if (haystack[i]==needle) {
            break;
        }
        index++;
    }
    return(index);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
movq 0x8(%rdi), %rbx
subq %r15, %rbx
shrq $0x5, %rbx
testl %ebx, %ebx
jle 0x2e81b
movq %rsi, %r14
movq 0x8(%rsi), %r12
movl %ebx, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
addq $0x8, %r15
xorl %ebp, %ebp
movq (%r15), %rdx
cmpq %r12, %rdx
jne 0x2e80d
testq %rdx, %rdx
je 0x2e81f
movq (%r14), %rsi
movq -0x8(%r15), %rdi
callq 0x3350
testl %eax, %eax
je 0x2e81f
incq %rbp
addq $0x20, %r15
cmpq %rbp, %r13
jne 0x2e7f0
jmp 0x2e821
xorl %ebx, %ebx
jmp 0x2e821
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/writeOut.cpp
// Function: safe_ofstream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::basic_ofstream<char, std::char_traits<char>>&)
ofstream safe_ofstream(string fileName, bool writeToFile, ofstream &logFileStream) {
    ofstream fileStream(fileName);
    if (!fileStream.is_open()) {
        cerrAndLog("\nError: failed to write to file: "+fileName+string("\n"), writeToFile, logFileStream);
        exit(1);
    }
    return(fileStream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10, %edx
callq 0x35f0
leaq 0x70(%rbx), %rdi
callq 0x30a0
testb %al, %al
je 0x2f3ce
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa343(%rip), %rsi      # 0x39718
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0xf984
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8530(%rip), %rsi      # 0x37922
leaq 0x852a(%rip), %rdx      # 0x37923
leaq 0x8(%rsp), %rdi
callq 0x6e56
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6c0e
movzbl %bpl, %esi
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x1db5c
leaq 0x48(%rsp), %rdi
callq 0x3150
leaq 0x8(%rsp), %rdi
callq 0x3150
leaq 0x28(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f46b
callq 0x3310
jmp 0x2f46b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f47f
callq 0x3310
jmp 0x2f47f
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f497
callq 0x3310
jmp 0x2f497
movq %rax, %r14
movq %rbx, %rdi
callq 0x3440
movq %r14, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/writeOut.cpp
// Function: printMaxLike_alleleFreqs(globals&, int)
void printMaxLike_alleleFreqs(globals &globals, int Kindex) {
    int K = globals.Kmin+Kindex;
    
    // print values
    for (int k=0; k<K; k++) {
        for (int l=0; l<globals.loci; l++) {
            for (int j=0; j<globals.J[l]; j++) {
                globals.outputMaxLike_alleleFreqs_fileStream << K << "," << k+1 << "," << l+1 << "," << globals.uniqueAlleles[l][j] << "," << process_nan(globals.max_alleleFreqs[k][l][j]) << "\n";
            }
        }
    }
    globals.outputMaxLike_alleleFreqs_fileStream.flush();
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r13
addl 0x2bc8(%rdi), %esi
movl %esi, 0xc(%rsp)
jle 0x324b7
leaq 0x2570(%r13), %rax
movq %rax, 0x28(%rsp)
movl 0xc(%rsp), %eax
movq %rax, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x2d1c(%r13)
jle 0x3249f
movq 0x10(%rsp), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rsp)
leaq (%rax,%rax,2), %rax
movq %rax, 0x30(%rsp)
xorl %ecx, %ecx
movq 0x2d20(%r13), %rax
cmpl $0x0, (%rax,%rcx,4)
jle 0x3248c
leal 0x1(%rcx), %eax
movl %eax, 0x1c(%rsp)
movl $0x8, %r14d
leaq (,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x40(%rsp)
xorl %r12d, %r12d
movq %rcx, 0x38(%rsp)
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x3550
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4f02(%rip), %r15      # 0x37290
movq %r15, %rsi
callq 0x3390
movq %rbp, %rdi
movl 0x18(%rsp), %esi
callq 0x3550
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq %rbp, %rdi
movl 0x1c(%rsp), %esi
callq 0x3550
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq 0x2d38(%r13), %rax
movq 0x40(%rsp), %rbx
movq (%rax,%rbx), %rax
movq -0x8(%rax,%r14), %rsi
movq (%rax,%r14), %rdx
movq %rbp, %rdi
callq 0x3390
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq %r13, %r15
movq 0x3048(%r13), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax,%rbx), %rax
movsd (%rax,%r12,8), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x1c630
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbp, %rdi
callq 0x3390
movl $0x1, %edx
movq %rax, %rdi
leaq 0x54d2(%rip), %rsi      # 0x37922
callq 0x3390
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x32469
callq 0x3310
incq %r12
movq %r15, %r13
movq 0x2d20(%r15), %rax
movq 0x38(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
addq $0x20, %r14
cmpq %rax, %r12
jl 0x3236e
incq %rcx
movslq 0x2d1c(%r13), %rax
cmpq %rax, %rcx
jl 0x32337
movq 0x10(%rsp), %rcx
incq %rcx
movq %rcx, 0x10(%rsp)
cmpq 0x20(%rsp), %rcx
jne 0x32312
addq $0x2570, %r13           # imm = 0x2570
movq %r13, %rdi
callq 0x31f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x324ec
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/writeOut.cpp
// Function: printMaxLike_admixFreqs(globals&, int)
void printMaxLike_admixFreqs(globals &globals, int Kindex) {
    int K = globals.Kmin+Kindex;
    
    // print values
    for (int i=0; i<globals.n; i++) {
        for (int k=0; k<K; k++) {
            globals.outputMaxLike_admixFreqs_fileStream << K << "," << i+1 << "," << k+1 << "," << process_nan(globals.max_admixFreqs[i][k]) << "\n";
        }
    }
    globals.outputMaxLike_alleleFreqs_fileStream.flush();
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
cmpl $0x0, 0x2d18(%rdi)
jle 0x3264b
movq 0x8(%rsp), %rax
addl 0x2bc8(%rax), %esi
addq $0x2770, %rax           # imm = 0x2770
movq %rax, 0x20(%rsp)
movl %esi, 0x4(%rsp)
movl %esi, %eax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x4d4b(%rip), %r15      # 0x37290
cmpl $0x0, 0x4(%rsp)
jle 0x32629
movq 0x10(%rsp), %rax
leal 0x1(%rax), %r12d
leaq (%rax,%rax,2), %rbp
xorl %r13d, %r13d
movq %r13, %r14
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x3550
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq %r13, %rdi
movl %r12d, %esi
callq 0x3550
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
leaq 0x1(%r14), %r13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3550
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq 0x8(%rsp), %rax
movq 0x3060(%rax), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r14,8), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x1c630
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x3390
movl $0x1, %edx
movq %rax, %rdi
leaq 0x531d(%rip), %rsi      # 0x37922
callq 0x3390
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3261e
callq 0x3310
cmpq %r13, 0x18(%rsp)
jne 0x32560
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x8(%rsp), %rax
movslq 0x2d18(%rax), %rax
movq %rdx, 0x10(%rsp)
cmpq %rax, %rdx
jl 0x32545
movq 0x8(%rsp), %rdi
addq $0x2570, %rdi           # imm = 0x2570
callq 0x31f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x32682
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/writeOut.cpp
// Function: printComparisonStatistics(globals&, int)
void printComparisonStatistics(globals &globals, int Kindex) {
    int K = globals.Kmin+Kindex;
    
    globals.outputComparisonStatistics_fileStream << K << "," << process_nan(globals.AIC[Kindex]) << "," << process_nan(globals.BIC[Kindex]) << "," << process_nan(globals.DIC_Spiegelhalter[Kindex]) << "," << process_nan(globals.DIC_Gelman[Kindex]);

    globals.outputComparisonStatistics_fileStream << "\n";
    globals.outputComparisonStatistics_fileStream.flush();
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl 0x2bc8(%rdi), %esi
addl %ebp, %esi
leaq 0x2170(%rdi), %rbx
movq %rbx, %rdi
callq 0x3550
movq %rax, %r15
leaq 0x4bcf(%rip), %rsi      # 0x37290
movl $0x1, %edx
movq %rax, %rdi
callq 0x3390
movslq %ebp, %r13
movq 0x3078(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x1c630
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x3390
movq %rax, %r15
leaq 0x4b8a(%rip), %rsi      # 0x37290
movl $0x1, %edx
movq %rax, %rdi
callq 0x3390
movq 0x3090(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x1c630
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x3390
movq %rax, %r15
leaq 0x4b4a(%rip), %rsi      # 0x37290
movl $0x1, %edx
movq %rax, %rdi
callq 0x3390
movq 0x30a8(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x1c630
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x3390
movq %rax, %r15
leaq 0x4b0a(%rip), %rsi      # 0x37290
movl $0x1, %edx
movq %rax, %rdi
callq 0x3390
movq 0x30c0(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x8(%rsp), %rdi
callq 0x1c630
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x3390
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x327cf
callq 0x3310
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x327e2
callq 0x3310
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x327f5
callq 0x3310
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32808
callq 0x3310
leaq 0x5113(%rip), %rsi      # 0x37922
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rdi
callq 0x31f0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32857
callq 0x3310
jmp 0x32857
jmp 0x32854
jmp 0x3286c
jmp 0x32884
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3286f
callq 0x3310
jmp 0x3286f
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32887
callq 0x3310
jmp 0x32887
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3289a
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O1/bobverity[P]MavericK/writeOut.cpp
// Function: printEvanno(globals&, int)
void printEvanno(globals &globals, int Kindex) {
    int K = globals.Kmin+Kindex;
    
    if (K==1 || K==globals.Kmax) {
        globals.outputEvanno_fileStream << K << ",NA";
    } else {
        globals.outputEvanno_fileStream << K << "," << globals.delta_K[Kindex];
    }
    
    globals.outputEvanno_fileStream << "\n";
    globals.outputEvanno_fileStream.flush();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl 0x2bc8(%rdi), %r12d
addl %esi, %r12d
movl 0x2bcc(%rdi), %r13d
leaq 0x2370(%rdi), %rbx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3550
movq %rax, %r15
cmpl $0x1, %r12d
je 0x32910
cmpl %r13d, %r12d
je 0x32910
leaq 0x49a6(%rip), %rsi      # 0x37290
movl $0x1, %edx
movq %r15, %rdi
callq 0x3390
movslq %ebp, %rax
movq 0x3108(%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %r15, %rdi
callq 0x34a0
jmp 0x32924
leaq 0x711b(%rip), %rsi      # 0x39a32
movl $0x3, %edx
movq %r15, %rdi
callq 0x3390
leaq 0x4ff7(%rip), %rsi      # 0x37922
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O1/sipa[P]bitcoin-seeder/bitcoin.cpp
// Function: CNode::PushVersion()
void PushVersion() {
    int64 nTime = time(NULL);
    uint64 nLocalNonce = BITCOIN_SEED_NONCE;
    int64 nLocalServices = 0;
    CAddress me(CService("0.0.0.0"));
    BeginMessage("version");
    int nBestHeight = GetRequireHeight();
    string ver = "/bitcoin-seeder:0.01/";
    uint8_t fRelayTxs = 0;
    vSend << PROTOCOL_VERSION << nLocalServices << nTime << you << me << nLocalNonce << ver << nBestHeight << fRelayTxs;
    EndMessage();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x33b0
movq %rax, %r15
leaq 0xe8a9(%rip), %rsi      # 0x14014
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xa3c8
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xb338
leaq 0xe87a(%rip), %rsi      # 0x1401c
movq %rbx, %rdi
callq 0x5cfe
leaq 0x17cff(%rip), %rax     # 0x1d4b0
leaq 0x17cec(%rip), %rcx     # 0x1d4a4
movl (%rcx), %ecx
cmpb $0x0, (%rax)
movl $0x7a120, %eax          # imm = 0x7A120
movl $0x55730, %ebp          # imm = 0x55730
cmovnel %eax, %ebp
testl %ecx, %ecx
cmovnel %ecx, %ebp
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe844(%rip), %rsi      # 0x14024
leaq 0xe852(%rip), %rdx      # 0x14039
leaq 0x20(%rsp), %rdi
callq 0x6184
leaq 0x8(%rbx), %r14
leaq 0x1c(%rsp), %rcx
movl $0xea60, -0x4(%rcx)     # imm = 0xEA60
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f36
leaq 0x20(%rsp), %rcx
movq $0x0, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f36
leaq 0x20(%rsp), %rcx
movq %r15, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f36
leaq 0xa8(%rbx), %rdi
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
movq %r14, %rsi
callq 0x6214
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x6214
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
leaq 0x20(%rsp), %rcx
movq %rax, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f36
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x62ef
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x58ba
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x5ef6
leaq 0x1c(%rsp), %rcx
movl %ebp, -0x4(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f36
leaq 0x19(%rsp), %rcx
movb $0x0, -0x1(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f36
movq %rbx, %rdi
callq 0x5d6a
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5904
callq 0x33c0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5926
callq 0x33c0
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/kamaya.cpp
// Function: yyUserActon()
void yyUserActon() {
  if (yylloc.last_line != yylineno) {
    yycolumn = 0;
  }
  yylloc.first_line = yylineno - 1;
  yylloc.last_line = yylineno;
  yylloc.first_column = yycolumn;
  yylloc.last_column = yycolumn + yyleng;
  yycolumn += yyleng;
  // cout << endl << yylloc.first_line << ", " << yylloc.last_line << ", " <<
  // yylloc.first_column << ", " << yylloc.last_column << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x4599f(%rip), %rax     # 0x5c308
leaq 0x459b8(%rip), %rcx     # 0x5c328
movl (%rcx), %ecx
cmpl %ecx, 0x8(%rax)
je 0x16984
leaq 0x4652a(%rip), %rdx     # 0x5cea8
movl $0x0, (%rdx)
leal -0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x8(%rax)
leaq 0x46515(%rip), %rcx     # 0x5cea8
movl (%rcx), %edx
movl %edx, 0x4(%rax)
leaq 0x45e29(%rip), %rsi     # 0x5c7c8
addl (%rsi), %edx
movl %edx, 0xc(%rax)
movl %edx, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::new_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, NodeType)
size_t ParseTree::new_node(const string &msg, NodeType node_type) {
    node_msg.push_back(msg);
    node_parent.push_back((size_t) (-1));
    node_children.emplace_back();
    size_t this_node = node_msg.size() - 1;
    nodes.emplace_back(*this, this_node, node_type);
    last_nodes.insert(this_node);
    return this_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %edx, -0x14(%rbp)
addq $0x18, %rdi
callq 0xed9c
movq $-0x1, -0x20(%rbp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x17b4f
movq $-0x1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x17b5c
leaq 0x30(%rbx), %rdi
leaq -0x20(%rbp), %rdx
callq 0x19282
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x17b7b
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
addq $0x18, 0x68(%rbx)
jmp 0x17b84
leaq 0x60(%rbx), %rdi
callq 0x193bc
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x5, %rax
decq %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
leaq -0x14(%rbp), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x18f02
addq $0x78, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19a32
movq (%r14), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::set_parent(unsigned long, unsigned long)
void ParseTree::set_parent(size_t node_id, size_t parent) {
    if (node_id >= node_msg.size() || parent >= node_msg.size()) {
        printf("set_parent:无效的节点id(%zu, %zu)\n", node_id, parent);
        return;
    }
    if (node_parent[node_id] == (size_t) (-1)) {
        node_parent[node_id] = parent;
        if (!nodes[parent].has_key(K_BEGIN_CODE) && nodes[node_id].has_key(K_BEGIN_CODE)) {
            // 如果父节点没有K_BEGIN_CODE键值且孩子
            // 拥有键值K_BEGIN_CODE, 那么其K_BEGIN_CODE将
            // 传到其父节点也就是该节点上
            nodes[parent].set_begin_code(nodes[node_id].get_begin_code());
        }
        node_children[parent].push_back(node_id);
    } else {
        printf("该节点%zu已经有了父节点%zu, 不能再设父节点为%zu\n", node_id, node_parent[node_id], parent);
    }
    if (last_nodes.find(node_id) != last_nodes.end()) {
        last_nodes.erase(node_id);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, -0x20(%rbp)
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
sarq $0x5, %rax
cmpq %rsi, %rax
seta %cl
cmpq %rdx, %rax
seta %al
testb %al, %cl
je 0x17c96
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax,%rsi,8), %rdx
cmpq $-0x1, %rdx
je 0x17cb1
leaq 0x2e9ca(%rip), %rdi     # 0x46651
movq %r14, %rcx
xorl %eax, %eax
callq 0x4070
jmp 0x17d3a
leaq 0x2e98c(%rip), %rdi     # 0x46629
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4070
movq %r14, (%rax,%rsi,8)
movq %r14, %r15
shlq $0x5, %r15
movq (%rbx), %rdi
addq %r15, %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x1d11a
testb %al, %al
jne 0x17d0a
movq -0x20(%rbp), %rdi
shlq $0x5, %rdi
addq (%rbx), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x1d11a
testb %al, %al
je 0x17d0a
movq (%rbx), %rax
addq %rax, %r15
movq -0x20(%rbp), %rdi
shlq $0x5, %rdi
addq %rax, %rdi
callq 0x1d0ec
movq %r15, %rdi
movq %rax, %rsi
callq 0x1d574
movq 0x60(%rbx), %rax
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x17d31
movq -0x20(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x17d3a
leaq -0x20(%rbp), %rdx
callq 0x19b5e
movq 0x88(%rbx), %rdx
leaq 0x80(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x17d6f
movq -0x20(%rbp), %rsi
movq %rax, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x17d57
movq %rax, %rdx
cmpq %rax, %rcx
je 0x17d86
movq -0x20(%rbp), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x17da6
addq $0x78, %rbx
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x19c34
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19cb6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::print() const
void ParseTree::print() const {
    vector<size_t> has_next_children;
    auto *vis = new bool[get_node_num()];
    memset(vis, 0, sizeof(bool) * (get_node_num()));
    print_node(0, has_next_children, 1, true, vis);
    has_next_children.clear();
    for (size_t i = 1; i < get_node_num(); ++i) {
        if (!vis[i] && node_parent[i] == (size_t) (-1)) {
            printf("异常子树:\n");
            print_node(i, has_next_children, 2, true, vis);
            has_next_children.clear();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x20(%rdi), %r15
subq 0x18(%rdi), %r15
sarq $0x5, %r15
movq %r15, %rdi
callq 0x4030
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x41c0
leaq -0x40(%rbp), %rdx
movl $0x1, %ecx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %r8d
movq %r14, %r9
callq 0x17ef2
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x17e31
movq %rax, -0x38(%rbp)
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
cmpq $0x21, %rax
jb 0x17ea8
movl $0x1, %r15d
leaq 0x2e9d7(%rip), %r12     # 0x46823
leaq -0x40(%rbp), %r13
cmpb $0x0, (%r14,%r15)
jne 0x17e94
movq 0x30(%rbx), %rax
cmpq $-0x1, (%rax,%r15,8)
jne 0x17e94
movq %r12, %rdi
callq 0x4480
movl $0x2, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %r8d
movq %r14, %r9
callq 0x17ef2
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x17e94
movq %rax, -0x38(%rbp)
incq %r15
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x5, %rax
cmpq %rax, %r15
jb 0x17e50
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x17eb6
callq 0x42b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17ec7
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x17ed8
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::check_node(unsigned long) const
bool ParseTree::check_node(size_t node_id) const {
    if (node_id >= node_msg.size()) {
        printf("警告:树中没有节点%zu\n", node_id);
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x20(%rdi), %r14
subq 0x18(%rdi), %r14
sarq $0x5, %r14
cmpq %rsi, %r14
ja 0x1815c
leaq 0x2e555(%rip), %rdi     # 0x466a7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
cmpq %rbx, %r14
seta %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::node(unsigned long)
ParseNode &ParseTree::node(size_t node_id) {
    if (check_node(node_id)) {
        return nodes[node_id];
    }
    string info = "ParseTree::node(size_t node_id) node_id=";
    info += to_string(node_id);
    throw ParseException(EX_TREE_NO_SUCH_NODE, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
sarq $0x5, %rax
cmpq %rsi, %rax
jbe 0x1819e
shlq $0x5, %rbx
addq (%rdi), %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e502(%rip), %rdi     # 0x466a7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x2e507(%rip), %rsi     # 0x466c5
leaq 0x2e528(%rip), %rdx     # 0x466ed
leaq -0x58(%rbp), %rdi
callq 0xf65c
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0xe329
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4110
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x181fd
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0x6, %esi
callq 0x33d12
leaq 0x43b4e(%rip), %rsi     # 0x5bd70
leaq -0x9e6f(%rip), %rdx     # 0xe3ba
movq %r14, %rdi
callq 0x4540
jmp 0x18257
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x1825a
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1825a
callq 0x42b0
jmp 0x1825a
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x18268
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::get_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ParseType ParseTree::get_type(const string &type_name) {
    auto iter = type_dic.find(type_name);
    if (iter == type_dic.end()) {
        return ParseType(T_UNKNOWN);
    }
    return ParseType::get_type(iter->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa8(%rsi), %rdi
movq %rdx, %rsi
callq 0x19e18
addq $0xb0, %r14
cmpq %r14, %rax
je 0x18462
movq 0x40(%rax), %rdi
callq 0x28004
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27510
jmp 0x1846e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x275d4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::type_def(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ParseType const&)
void ParseTree::type_def(const string &type_name, const ParseType &type) {
    auto iter = type_dic.find(type_name);
    if (iter != type_dic.end()) {
        printf("ParseTree::type_def(const string &type_name, const ParseType &type): "
               "警告: 试图给已声明的类型名字%s赋予新的类型%s, 无视该操作\n", type_name.c_str(),
               type.get_info().c_str());
        return;
    }
    size_t type_id = ParseType::get_type_id(type);
    type_dic[type_name] = type_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xa8(%rdi), %r15
movq %r15, %rdi
callq 0x19e18
addq $0xb0, %r12
cmpq %r12, %rax
je 0x184e2
movq (%rbx), %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x27a86
movq (%r15), %rdx
leaq 0x2e229(%rip), %rdi     # 0x466ee
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq (%r15), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x184fb
callq 0x42b0
jmp 0x184fb
movq %r14, %rdi
callq 0x27f08
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18f4c
movq %r14, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::make_direct_declarator_node(std::vector<unsigned long, std::allocator<unsigned long>> const&, ParseExpression const*)
size_t ParseTree::make_direct_declarator_node(const vector<size_t> &array_size, const ParseExpression *expression) {
    size_t new_one = new_node(N_DIRECT_DEC);
    nodes[new_one].set_array_size(array_size);
    if (!array_size.empty()) {
        if (expression) {
            nodes[new_one].set_expression(*expression);
        } else {
            nodes[new_one].set_expression(ParseExpression::get_expression(0));
        }
    }
    return new_one;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movl $0x7, %esi
callq 0x17bc8
movq %rax, %rbx
movq %rax, %r15
shlq $0x5, %r15
movq (%r12), %rdi
addq %r15, %rdi
movq %r13, %rsi
callq 0x1d596
movq (%r13), %rax
cmpq 0x8(%r13), %rax
je 0x185b8
addq (%r12), %r15
testq %r14, %r14
jne 0x185ad
xorl %edi, %edi
callq 0x2b8a6
movq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d3c6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::make_assign_expression_node(ParseExpression const&, ParseExpression const&)
size_t ParseTree::make_assign_expression_node(
        const ParseExpression &l_expr, const ParseExpression &r_expr) {
    const ParseExpression &assign_expr = ParseExpression::get_assign_expression(l_expr, r_expr);
    size_t new_one = new_node(N_EXPRESSION);
    nodes[new_one].set_expression(assign_expr);
    return new_one;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2cfea
movq %rax, %r14
movq %rbx, %rdi
movl $0xf, %esi
callq 0x17bc8
movq %rax, %r15
movq %rax, %rdi
shlq $0x5, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
callq 0x1d3c6
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_true_list() const
const vector<size_t> &ParseNode::get_true_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_TRUE_LIST)) {
        ((ParseNode *) this)->set_true_list(vector<size_t>());
    }
    return get_field<vector<size_t>>(K_TRUE_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $-0x80, 0x9(%rdi)
jne 0x1cf9b
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rdi
movl $0x8000, %esi           # imm = 0x8000
xorl %ecx, %ecx
callq 0x1f918
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1cf9b
callq 0x42b0
movq %rbx, %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x22aa8
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1cfc0
callq 0x42b0
movq %rbx, %rdi
callq 0x4560