LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1909c(%rip), %xmm3    # 0x36260
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 0x19c7d(%rip), %xmm0    # 0x36e80
mulsd 0x19c7d(%rip), %xmm0    # 0x36e88
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1d21b
sqrtsd %xmm0, %xmm0
jmp 0x1d228
callq 0x3280
movsd 0x19038(%rip), %xmm3    # 0x36260
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 0x254ae(%rip), %rsi     # 0x42708
movq %rdi, %rdx
callq 0x1d544
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
xorpd %xmm3, %xmm3
cmpeqsd %xmm3, %xmm2
movsd 0x19c15(%rip), %xmm0    # 0x36e90
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm2, %xmm0
movsd 0x18fd1(%rip), %xmm1    # 0x36260
divsd %xmm0, %xmm1
ucomisd %xmm3, %xmm1
jne 0x1d2cd
jp 0x1d2cd
leaq 0x25466(%rip), %rbx     # 0x42708
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1d544
movsd 0x18fa3(%rip), %xmm1    # 0x36260
divsd %xmm0, %xmm1
ucomisd 0x18ddf(%rip), %xmm1    # 0x360a8
jne 0x1d2cd
jnp 0x1d2a7
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2541e(%rip), %rdi     # 0x42708
callq 0x1d3fa
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x1d342
movsd 0x2540f(%rip), %xmm1    # 0x42718
movsd 0x253ff(%rip), %xmm2    # 0x42710
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 0x1d346
incq %rax
cmpq %rax, %rdx
jne 0x1d32f
xorl %eax, %eax
jmp 0x1d348
incl %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x237d9(%rip), %rdi     # 0x40fb8
callq 0x3390
testl %ebp, %ebp
je 0x1d803
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_O3/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 0x237ce(%rip), %rdi     # 0x40ff0
callq 0x3390
testl %ebp, %ebp
je 0x1d846
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_O3/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 0x1d885
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1963c(%rip), %rsi     # 0x36ec8
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0xf5f6
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19079(%rip), %rsi     # 0x36922
leaq 0x19073(%rip), %rdx     # 0x36923
leaq 0x8(%rsp), %rdi
callq 0x6d9c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6b54
movzbl %bpl, %esi
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x1d808
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 0x1d922
callq 0x3310
jmp 0x1d922
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d936
callq 0x3310
jmp 0x1d936
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d94e
callq 0x3310
jmp 0x1d94e
movq %rax, %r14
movq %rbx, %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d9ad
jnp 0x1d9df
movq 0x235f4(%rip), %rsi     # 0x40fa8
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 0x19505(%rip), %rsi     # 0x36eeb
leaq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0xf5f6
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1950e(%rip), %rsi     # 0x36f11
leaq 0x19518(%rip), %rdx     # 0x36f22
leaq 0x18(%rsp), %rdi
callq 0x6d9c
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x6b54
movzbl %bpl, %esi
leaq 0x58(%rsp), %rdi
movq %rbx, %rdx
callq 0x1d808
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 0x1da7c
callq 0x3310
jmp 0x1da7c
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1da90
callq 0x3310
jmp 0x1da90
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1daaa
callq 0x3310
jmp 0x1daaa
jmp 0x1daa7
movq %rax, %rbx
movq 0x234f7(%rip), %rsi     # 0x40fa8
leaq 0x78(%rsp), %rdi
callq 0x3420
leaq 0xf0(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1db0d
jp 0x1db0d
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 0x6c6c
leaq 0x193fc(%rip), %rsi     # 0x36f23
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0x6bfc
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19404(%rip), %rsi     # 0x36f48
leaq 0x1940e(%rip), %rdx     # 0x36f59
leaq 0x10(%rsp), %rdi
callq 0x6d9c
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x6b54
movzbl %bpl, %esi
leaq 0x50(%rsp), %rdi
movq %rbx, %rdx
callq 0x1d808
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 0x1dbc7
callq 0x3310
jmp 0x1dbc7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1dbdb
callq 0x3310
jmp 0x1dbdb
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dbf3
callq 0x3310
jmp 0x1dbf3
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dc09
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
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), %r14
movq 0x10(%r14), %rcx
cmpq 0x18(%r14), %rcx
jae 0x1dc7f
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%r14)
cmpl $-0x1, %eax
je 0x1dc8a
cmpl $0xa, %eax
je 0x1dccd
cmpl $0xd, %eax
je 0x1dcaa
movsbl %al, %esi
movq %r15, %rdi
callq 0x32c0
jmp 0x1dc4f
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
jmp 0x1dc63
cmpq $0x0, 0x8(%r15)
jne 0x1dccd
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x2, %esi
callq 0x3520
jmp 0x1dccd
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x1dcda
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1dccd
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x1dce5
incq %rax
movq %rax, 0x10(%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
jmp 0x1dcb7
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
jmp 0x1dccd
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x4(%rsp)
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 0x1dd4e
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0x1dd58
movq (%r14), %rsi
movq %r13, %rdi
callq 0x3350
testl %eax, %eax
sete %r12b
jmp 0x1dd5b
movq 0x8(%rsp), %r13
xorl %r12d, %r12d
jmp 0x1dd5b
movb $0x1, %r12b
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x1dd6d
movq %r13, %rdi
callq 0x3310
testb %r12b, %r12b
je 0x1dda0
incl %ebp
cmpl 0x4(%rsp), %ebp
jge 0x1ddaf
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 0x191a4(%rip), %rsi     # 0x36f5a
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0xf5f6
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x191ac(%rip), %rsi     # 0x36f7f
leaq 0x191ad(%rip), %rdx     # 0x36f87
leaq 0x28(%rsp), %rdi
callq 0x6d9c
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x6b54
movq 0x231f1(%rip), %rdi     # 0x40ff0
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 0x1de4d
callq 0x3310
jmp 0x1de4d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1de61
callq 0x3310
jmp 0x1de61
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1de74
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x78, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movslq %r8d, %rax
movq (%rcx,%rax,8), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x3120
leaq 0x1614b(%rip), %rsi     # 0x36f9f
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
callq 0xf5f6
movq %rbx, 0x8(%rsp)
movq 0x38(%rsp), %rdx
cmpq 0x18(%rsp), %rdx
jne 0x20e94
movl %r12d, %ebx
movq 0x10(%rsp), %r13
testq %rdx, %rdx
je 0x20ea1
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x3350
testl %eax, %eax
sete %r12b
jmp 0x20ea4
movl %r12d, %ebx
movq 0x10(%rsp), %r13
xorl %r12d, %r12d
jmp 0x20ea4
movb $0x1, %r12b
leaq 0x20(%rsp), %rax
cmpq %rax, %r13
je 0x20eb6
movq %r13, %rdi
callq 0x3310
leaq 0x40(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x20ec9
callq 0x3310
testb %r12b, %r12b
je 0x20f30
incl %ebp
cmpl %ebx, %ebp
jge 0x20f3f
movslq %ebp, %rax
movq (%r15,%rax,8), %rsi
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x3120
movl $0x2, 0x20(%r15)
addq $0x2b70, %r14           # imm = 0x2B70
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x2e318
movq %rax, %rbx
leaq 0x30(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x33e0
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x20f30
callq 0x3310
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16014(%rip), %rsi     # 0x36f5a
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0xf5f6
leaq 0x68(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1601a(%rip), %rsi     # 0x36f7f
leaq 0x1601b(%rip), %rdx     # 0x36f87
leaq 0x58(%rsp), %rdi
callq 0x6d9c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x6b54
movq 0x2005f(%rip), %rdi     # 0x40ff0
leaq 0x30(%rsp), %rsi
callq 0x32e0
leaq 0x30(%rsp), %rdi
callq 0x3150
leaq 0x58(%rsp), %rdi
callq 0x3150
leaq 0x10(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x20fda
callq 0x3310
jmp 0x20fda
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x20fee
callq 0x3310
jmp 0x20fee
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
jmp 0x21015
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
jne 0x2101a
jmp 0x21024
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21024
callq 0x3310
jmp 0x21024
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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), %r12
movq 0x8(%rdi), %rbx
subq %r12, %rbx
shrq $0x5, %rbx
testl %ebx, %ebx
jle 0x2e4c9
movq %rsi, %r14
movq 0x8(%rsi), %r15
movl %ebx, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
addq $0x8, %r12
xorl %ebp, %ebp
cmpq %r15, (%r12)
jne 0x2e4bb
testq %r15, %r15
je 0x2e4cd
movq (%r14), %rsi
movq -0x8(%r12), %rdi
movq %r15, %rdx
callq 0x3350
testl %eax, %eax
je 0x2e4cd
incq %rbp
addq $0x20, %r12
cmpq %rbp, %r13
jne 0x2e49c
jmp 0x2e4cf
xorl %ebx, %ebx
jmp 0x2e4cf
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_O3/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 0x2f032
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x96df(%rip), %rsi      # 0x38718
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0xf5f6
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x78cc(%rip), %rsi      # 0x36922
leaq 0x78c6(%rip), %rdx      # 0x36923
leaq 0x8(%rsp), %rdi
callq 0x6d9c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6b54
movzbl %bpl, %esi
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x1d808
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 0x2f0cf
callq 0x3310
jmp 0x2f0cf
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f0e3
callq 0x3310
jmp 0x2f0e3
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f0fb
callq 0x3310
jmp 0x2f0fb
movq %rax, %r14
movq %rbx, %rdi
callq 0x3440
movq %r14, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
addl 0x2bc8(%rdi), %esi
movl %esi, 0xc(%rsp)
jle 0x31f2a
leaq 0x2570(%r12), %rax
movq %rax, 0x28(%rsp)
movl 0xc(%rsp), %eax
movq %rax, 0x20(%rsp)
movl 0x2d1c(%r12), %eax
xorl %edx, %edx
leaq 0x1(%rdx), %rcx
movq %rcx, 0x10(%rsp)
testl %eax, %eax
jle 0x31f17
movq 0x2d20(%r12), %rcx
leaq (%rdx,%rdx,2), %rdx
movq %rdx, 0x30(%rsp)
xorl %edi, %edi
leaq 0x1(%rdi), %rdx
movq %rdx, 0x18(%rsp)
cmpl $0x0, (%rcx,%rdi,4)
jle 0x31f03
movl $0x8, %r14d
leaq (,%rdi,8), %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x40(%rsp)
xorl %r13d, %r13d
movq %rdi, 0x38(%rsp)
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x3550
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4492(%rip), %r15      # 0x36290
movq %r15, %rsi
callq 0x3390
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x3550
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
callq 0x3550
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq 0x2d38(%r12), %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 0x3048(%r12), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax,%rbx), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x1c311
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbp, %rdi
callq 0x3390
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4a61(%rip), %rsi      # 0x36922
callq 0x3390
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x31eda
callq 0x3310
incq %r13
movq 0x2d20(%r12), %rcx
movq 0x38(%rsp), %rdi
movslq (%rcx,%rdi,4), %rax
addq $0x20, %r14
cmpq %rax, %r13
jl 0x31dde
movl 0x2d1c(%r12), %eax
movslq %eax, %rdx
movq 0x18(%rsp), %rsi
movq %rsi, %rdi
cmpq %rdx, %rsi
jl 0x31dac
movq 0x10(%rsp), %rcx
movq %rcx, %rdx
cmpq 0x20(%rsp), %rcx
jne 0x31d88
addq $0x2570, %r12           # imm = 0x2570
movq %r12, %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 0x31f5f
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rsp)
movl 0x2d18(%rdi), %eax
testl %eax, %eax
jle 0x320ab
movq 0x10(%rsp), %rcx
addl 0x2bc8(%rcx), %esi
addq $0x2770, %rcx           # imm = 0x2770
movq %rcx, 0x20(%rsp)
movl %esi, 0xc(%rsp)
movl %esi, %ecx
movq %rcx, 0x18(%rsp)
xorl %ecx, %ecx
leaq 0x42dd(%rip), %r15      # 0x36290
leaq 0x1(%rcx), %r12
cmpl $0x0, 0xc(%rsp)
jle 0x3209c
leaq (%rcx,%rcx,2), %r14
xorl %r13d, %r13d
movq %r13, %rbp
movq 0x20(%rsp), %rdi
movl 0xc(%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(%rbp), %r13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3550
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3390
movq 0x10(%rsp), %rax
movq 0x3060(%rax), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%rbp,8), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x1c311
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x3390
movl $0x1, %edx
movq %rax, %rdi
leaq 0x48b5(%rip), %rsi      # 0x36922
callq 0x3390
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x32086
callq 0x3310
cmpq %r13, 0x18(%rsp)
jne 0x31fc9
movq 0x10(%rsp), %rax
movl 0x2d18(%rax), %eax
movslq %eax, %rdx
movq %r12, %rcx
cmpq %rdx, %r12
jl 0x31fb3
movq 0x10(%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 0x320e2
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x416f(%rip), %rsi      # 0x36290
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 0x1c311
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x3390
movq %rax, %r15
leaq 0x412a(%rip), %rsi      # 0x36290
movl $0x1, %edx
movq %rax, %rdi
callq 0x3390
movq 0x3090(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x1c311
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x3390
movq %rax, %r15
leaq 0x40ea(%rip), %rsi      # 0x36290
movl $0x1, %edx
movq %rax, %rdi
callq 0x3390
movq 0x30a8(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x1c311
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x3390
movq %rax, %r15
leaq 0x40aa(%rip), %rsi      # 0x36290
movl $0x1, %edx
movq %rax, %rdi
callq 0x3390
movq 0x30c0(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x8(%rsp), %rdi
callq 0x1c311
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 0x3222f
callq 0x3310
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32242
callq 0x3310
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32255
callq 0x3310
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32268
callq 0x3310
leaq 0x46b3(%rip), %rsi      # 0x36922
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 0x322b7
callq 0x3310
jmp 0x322b7
jmp 0x322b4
jmp 0x322cc
jmp 0x322e4
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x322cf
callq 0x3310
jmp 0x322cf
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x322e7
callq 0x3310
jmp 0x322e7
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x322fa
callq 0x3310
movq %rbx, %rdi
callq 0x3580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x32370
cmpl %r13d, %r12d
je 0x32370
leaq 0x3f46(%rip), %rsi      # 0x36290
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 0x32384
leaq 0x66bb(%rip), %rsi      # 0x38a32
movl $0x3, %edx
movq %r15, %rdi
callq 0x3390
leaq 0x4597(%rip), %rsi      # 0x36922
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_O3/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 0xe9c7(%rip), %rsi      # 0x14014
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xa1ae
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xb0fc
leaq 0xe998(%rip), %rsi      # 0x1401c
movq %rbx, %rdi
callq 0x5bf2
leaq 0x17e1d(%rip), %rax     # 0x1d4b0
leaq 0x17e0a(%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 0xe962(%rip), %rsi      # 0x14024
leaq 0xe970(%rip), %rdx      # 0x14039
leaq 0x20(%rsp), %rdi
callq 0x6080
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 0x5e2a
leaq 0x20(%rsp), %rcx
movq $0x0, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5e2a
leaq 0x20(%rsp), %rcx
movq %r15, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5e2a
leaq 0xa8(%rbx), %rdi
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
movq %r14, %rsi
callq 0x6116
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x6116
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 0x5e2a
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x61f1
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x579c
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x5dea
leaq 0x1c(%rsp), %rcx
movl %ebp, -0x4(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5e2a
leaq 0x19(%rsp), %rcx
movb $0x0, -0x1(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5e2a
movq %rbx, %rdi
callq 0x5c5e
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x57e6
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 0x5808
callq 0x33c0
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day07/ex01/iter.cpp
// Function: main
int main(void)
{
  int list[] = {0, 2, 3, -5, 6, 42, 8};
  std::string list2[] = {"Hey!", "Hello world,", "what's up?"};
  printList(list, 7);
  iter(list, 7, &fn);
  printList(list, 7);
  iter(list2, 3, &fn2);
  std::cout << std::endl;
  A list3[3];
  list3[0] = A(21);
  list3[1] = A(42);
  list3[2] = A(-42);
  iter(list3, 3, &fn3);
  std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movups 0xd33(%rip), %xmm0      # 0x205c
movups %xmm0, -0x44(%rbp)
movaps 0xd1c(%rip), %xmm0      # 0x2050
movaps %xmm0, -0x50(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xcbc(%rip), %rsi       # 0x2006
leaq 0xcb9(%rip), %rdx       # 0x200a
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
callq 0x155a
leaq -0x90(%rbp), %r15
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xc95(%rip), %rsi       # 0x200b
leaq 0xc9a(%rip), %rdx       # 0x2017
movq %r15, %rdi
callq 0x155a
leaq -0x70(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xc7f(%rip), %rsi       # 0x2018
leaq 0xc82(%rip), %rdx       # 0x2022
movq %r15, %rdi
callq 0x155a
leaq -0x50(%rbp), %rdi
movl $0x7, %esi
callq 0x1287
xorl %eax, %eax
shll -0x50(%rbp,%rax,4)
incq %rax
cmpq $0x7, %rax
jne 0x13b8
leaq -0x50(%rbp), %rdi
movl $0x7, %esi
callq 0x1287
movl $0x8, %r15d
movq 0x2bf8(%rip), %rbx      # 0x3fd8
leaq 0xc1d(%rip), %r14       # 0x2004
movq -0xb8(%rbp,%r15), %rsi
movq -0xb0(%rbp,%r15), %rdx
movq %rbx, %rdi
callq 0x10a0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10a0
addq $0x20, %r15
cmpq $0x68, %r15
jne 0x13e7
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq 0x2ba1(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1040
movabsq $0x2a00000015, %rax     # imm = 0x2A00000015
movq %rax, -0x2c(%rbp)
movl $0xffffffd6, -0x24(%rbp) # imm = 0xFFFFFFD6
xorl %r15d, %r15d
movq 0x2b75(%rip), %rbx      # 0x3fd8
leaq 0xb9a(%rip), %r14       # 0x2004
movl -0x2c(%rbp,%r15,4), %esi
movq %rbx, %rdi
callq 0x10c0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10a0
incq %r15
cmpq $0x3, %r15
jne 0x146a
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq 0x2b2a(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq $-0x60, %rbx
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x14d8
movq (%r12), %rsi
incq %rsi
callq 0x1090
addq $-0x20, %r12
addq $0x20, %rbx
jne 0x14c2
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14f6
movq %rax, %rbx
addq $-0x10, %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x1511
movq (%r15), %rsi
incq %rsi
callq 0x1090
leaq -0x20(%r15), %rax
addq $-0x10, %r15
cmpq %r14, %r15
movq %rax, %r15
jne 0x14fd
jmp 0x1552
jmp 0x1529
jmp 0x1529
jmp 0x1529
movq %rax, %rbx
xorl %r14d, %r14d
movq -0x70(%rbp,%r14), %rdi
leaq (%r12,%r14), %rax
cmpq %rdi, %rax
je 0x1548
movq (%rax), %rsi
incq %rsi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x60, %r14
jne 0x152f
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x448ed(%rip), %rax     # 0x5b308
leaq 0x44906(%rip), %rcx     # 0x5b328
movl (%rcx), %esi
xorl %ecx, %ecx
leaq 0x4547b(%rip), %rdx     # 0x5bea8
cmpl %esi, 0x8(%rax)
jne 0x16a34
movl (%rdx), %ecx
leal -0x1(%rsi), %edi
movl %edi, (%rax)
movl %esi, 0x8(%rax)
movl %ecx, 0x4(%rax)
leaq 0x44d82(%rip), %rsi     # 0x5b7c8
addl (%rsi), %ecx
movl %ecx, 0xc(%rax)
movl %ecx, (%rdx)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xef82
movq $-0x1, -0x20(%rbp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x17beb
movq $-0x1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x17bf8
leaq 0x30(%rbx), %rdi
leaq -0x20(%rbp), %rdx
callq 0x19328
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x17c17
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
addq $0x18, 0x68(%rbx)
jmp 0x17c20
leaq 0x60(%rbx), %rdi
callq 0x19462
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 0x18f9a
addq $0x78, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19ab8
movq (%r14), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, -0x30(%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 0x17d3c
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax,%r14,8), %rdx
cmpq $-0x1, %rdx
je 0x17d5e
leaq 0x2d927(%rip), %rdi     # 0x45651
movq %r14, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x4070
jmp 0x17de0
leaq 0x2d8e6(%rip), %rdi     # 0x45629
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4070
movq %r15, (%rax,%r14,8)
movq %r15, %r12
shlq $0x5, %r12
movq (%rbx), %rdi
addq %r12, %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x1d19e
testb %al, %al
jne 0x17db4
movq %r14, %r13
shlq $0x5, %r13
movq (%rbx), %rdi
addq %r13, %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x1d19e
testb %al, %al
je 0x17db4
movq (%rbx), %rax
addq %rax, %r12
addq %rax, %r13
movq %r13, %rdi
callq 0x1d170
movq %r12, %rdi
movq %rax, %rsi
callq 0x1d5f8
movq 0x60(%rbx), %rax
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x17dd7
movq %r14, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x17de0
leaq -0x30(%rbp), %rdx
callq 0x19bda
movq 0x88(%rbx), %rax
testq %rax, %rax
je 0x17e35
leaq 0x78(%rbx), %r14
subq $-0x80, %rbx
movq -0x30(%rbp), %rcx
movq %rbx, %rdx
xorl %esi, %esi
cmpq %rcx, 0x20(%rax)
setb %sil
cmovaeq %rax, %rdx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x17dfb
cmpq %rbx, %rdx
je 0x17e35
cmpq 0x20(%rdx), %rcx
jb 0x17e35
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x19cb0
movq %r14, %rdi
movq %rax, %rsi
callq 0x19d38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17f80
movq -0x40(%rbp), %rdi
cmpq %rdi, -0x38(%rbp)
je 0x17ec3
movq %rdi, -0x38(%rbp)
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
cmpq $0x21, %rax
jb 0x17f3a
movl $0x1, %r15d
leaq 0x2d945(%rip), %r12     # 0x45823
leaq -0x40(%rbp), %r13
cmpb $0x0, (%r14,%r15)
jne 0x17f26
movq 0x30(%rbx), %rax
cmpq $-0x1, (%rax,%r15,8)
jne 0x17f26
movq %r12, %rdi
callq 0x4480
movl $0x2, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %r8d
movq %r14, %r9
callq 0x17f80
movq -0x40(%rbp), %rdi
cmpq %rdi, -0x38(%rbp)
je 0x17f26
movq %rdi, -0x38(%rbp)
incq %r15
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x5, %rax
cmpq %rax, %r15
jb 0x17ee2
testq %rdi, %rdi
je 0x17f44
callq 0x42b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17f55
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x17f66
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x181f4
leaq 0x2d4bd(%rip), %rdi     # 0x456a7
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_O3/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 0x18236
shlq $0x5, %rbx
addq (%rdi), %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d46a(%rip), %rdi     # 0x456a7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x2d46f(%rip), %rsi     # 0x456c5
leaq 0x2d490(%rip), %rdx     # 0x456ed
leaq -0x58(%rbp), %rdi
callq 0xf868
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0xe50f
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 0x18295
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0x6, %esi
callq 0x333ee
leaq 0x42ab6(%rip), %rsi     # 0x5ad70
leaq -0x9d21(%rip), %rdx     # 0xe5a0
movq %r14, %rdi
callq 0x4540
jmp 0x182ef
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x182f2
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x182f2
callq 0x42b0
jmp 0x182f2
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x18300
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19ea6
addq $0xb0, %r14
cmpq %r14, %rax
je 0x184fa
movq 0x40(%rax), %rdi
callq 0x2796c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x26e80
jmp 0x18506
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x26f44
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19ea6
addq $0xb0, %r12
cmpq %r12, %rax
je 0x1857a
movq (%rbx), %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x273f2
movq (%r15), %rdx
leaq 0x2d191(%rip), %rdi     # 0x456ee
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq (%r15), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x18593
callq 0x42b0
jmp 0x18593
movq %r14, %rdi
callq 0x27870
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18fe4
movq %r14, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq