LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x35586(%rip), %rdi     # 0x6e7e8
leaq 0x35577(%rip), %rsi     # 0x6e7e0
callq 0x39480
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9b80
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x392fc
movq 0x38(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x392ed
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x39304
jmp 0x392ef
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x39292
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x32e33(%rip), %rdi     # 0x6cfb8
callq 0x43e0
testb $0x1, 0x1f(%rsp)
je 0x3a1aa
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x43e0
movq 0x10(%rsp), %rdi
callq 0x42b0
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x32e1b(%rip), %rdi     # 0x6cff0
callq 0x43e0
testb $0x1, 0x1f(%rsp)
je 0x3a1fa
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x43e0
movq 0x10(%rsp), %rdi
callq 0x42b0
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0xc8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
andb $0x1, %al
movb %al, 0xb7(%rsp)
movq %rcx, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movl $0x8, %edx
callq 0x4650
movq 0x20(%rsp), %rdi
callq 0x4640
movb %al, 0x2e(%rsp)
jmp 0x3a25e
movb 0x2e(%rsp), %al
testb $0x1, %al
jne 0x3a395
jmp 0x3a26c
movq 0x10(%rsp), %rdx
leaq 0x22bc8(%rip), %rsi     # 0x5ce40
leaq 0x50(%rsp), %rdi
callq 0x22950
jmp 0x3a284
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdx
leaq 0x225f3(%rip), %rsi     # 0x5c892
leaq 0x30(%rsp), %rdi
callq 0x4580
jmp 0x3a2ab
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xc9f0
jmp 0x3a2c1
movq 0xa8(%rsp), %rdx
movzbl 0xb7(%rsp), %esi
andl $0x1, %esi
leaq 0x70(%rsp), %rdi
callq 0x3a1b0
jmp 0x3a2e0
leaq 0x70(%rsp), %rdi
callq 0x4270
leaq 0x30(%rsp), %rdi
callq 0x4270
leaq 0x2f(%rsp), %rdi
callq 0x4490
leaq 0x50(%rsp), %rdi
callq 0x4270
movl $0x1, %edi
callq 0x44f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x3a3be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x3a37f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x3a375
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4270
leaq 0x30(%rsp), %rdi
callq 0x4270
leaq 0x2f(%rsp), %rdi
callq 0x4490
leaq 0x50(%rsp), %rdi
callq 0x4270
jmp 0x3a3be
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x3a3b1
movq 0x20(%rsp), %rdi
callq 0x4100
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4100
movq 0x98(%rsp), %rdi
callq 0x4730
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, 0x10(%rsp)
movq %rsi, 0x230(%rsp)
andb $0x1, %al
movb %al, 0x22f(%rsp)
movq %rdx, 0x220(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x8, %edx
callq 0x46a0
movq 0x18(%rsp), %rdi
leaq 0x218(%rsp), %rsi
callq 0x43a0
jmp 0x3a435
movsd 0x218(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3a57a
jp 0x3a57a
movq 0x10(%rsp), %rdx
leaq 0x22a06(%rip), %rsi     # 0x5ce63
leaq 0x48(%rsp), %rdi
callq 0x22950
jmp 0x3a469
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdx
leaq 0x22a05(%rip), %rsi     # 0x5ce89
leaq 0x28(%rsp), %rdi
callq 0x4580
jmp 0x3a490
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xc9f0
jmp 0x3a4a6
movq 0x220(%rsp), %rdx
movzbl 0x22f(%rsp), %esi
andl $0x1, %esi
leaq 0x68(%rsp), %rdi
callq 0x3a1b0
jmp 0x3a4c5
leaq 0x68(%rsp), %rdi
callq 0x4270
leaq 0x28(%rsp), %rdi
callq 0x4270
leaq 0x27(%rsp), %rdi
callq 0x4490
leaq 0x48(%rsp), %rdi
callq 0x4270
movl $0x1, %edi
callq 0x44f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3a5a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3a564
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x3a55a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4270
leaq 0x28(%rsp), %rdi
callq 0x4270
leaq 0x27(%rsp), %rdi
callq 0x4490
leaq 0x48(%rsp), %rdi
callq 0x4270
jmp 0x3a5a2
movsd 0x218(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x98(%rsp), %rdi
callq 0x41c0
movsd (%rsp), %xmm0
addq $0x238, %rsp            # imm = 0x238
retq
leaq 0x98(%rsp), %rdi
callq 0x41c0
movq 0x90(%rsp), %rdi
callq 0x4730
nopl (%rax)
// File: 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:
subq $0xc8, %rsp
movb %dil, %al
movsd %xmm0, 0xc0(%rsp)
andb $0x1, %al
movb %al, 0xbf(%rsp)
movq %rsi, 0xb0(%rsp)
movsd 0xc0(%rsp), %xmm0
leaq 0xa8(%rsp), %rdi
callq 0x4750
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3a60a
jp 0x3a60a
jmp 0x3a74f
cvttsd2si 0xc0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcb30
movq 0x8(%rsp), %rdx
leaq 0x2286c(%rip), %rsi     # 0x5ce9b
leaq 0x68(%rsp), %rdi
callq 0xcae0
jmp 0x3a63b
leaq 0x17(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4740
movq (%rsp), %rdx
leaq 0x2286c(%rip), %rsi     # 0x5cec0
leaq 0x18(%rsp), %rdi
callq 0x4580
jmp 0x3a660
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xc9f0
jmp 0x3a679
movq 0xb0(%rsp), %rdx
movzbl 0xbf(%rsp), %esi
andl $0x1, %esi
leaq 0x88(%rsp), %rdi
callq 0x3a1b0
jmp 0x3a69b
leaq 0x88(%rsp), %rdi
callq 0x4270
leaq 0x18(%rsp), %rdi
callq 0x4270
leaq 0x17(%rsp), %rdi
callq 0x4490
leaq 0x68(%rsp), %rdi
callq 0x4270
leaq 0x48(%rsp), %rdi
callq 0x4270
movl $0x1, %edi
callq 0x44f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x3a743
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x3a72f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x3a725
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4270
leaq 0x18(%rsp), %rdi
callq 0x4270
leaq 0x17(%rsp), %rdi
callq 0x4490
leaq 0x68(%rsp), %rdi
callq 0x4270
leaq 0x48(%rsp), %rdi
callq 0x4270
jmp 0x3a760
cvttsd2si 0xa8(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x4730
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4550
movq 0x28(%rsp), %rsi
leaq 0x1f(%rsp), %rdi
movl $0x1, %edx
callq 0x4620
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x41a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4220
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $-0x1, %eax
je 0x3a816
jmp 0x3a7cf
movl 0x8(%rsp), %eax
subl $0xa, %eax
je 0x3a7e5
jmp 0x3a7da
movl 0x8(%rsp), %eax
subl $0xd, %eax
je 0x3a7f1
jmp 0x3a848
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3a85e
movq 0x10(%rsp), %rdi
callq 0x45e0
cmpl $0xa, %eax
jne 0x3a80a
movq 0x10(%rsp), %rdi
callq 0x4220
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3a85e
movq 0x20(%rsp), %rdi
callq 0x4690
testb $0x1, %al
jne 0x3a826
jmp 0x3a83c
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2, %esi
callq 0x4290
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3a85e
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rdi
movsbl %al, %esi
callq 0x4280
jmp 0x3a7b2
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movl %edx, 0xe4(%rsp)
movq %rcx, 0xd8(%rsp)
movl %r8d, 0xd4(%rsp)
movq 0xd8(%rsp), %rax
movslq 0xd4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4740
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xb0(%rsp), %rdi
callq 0x4580
jmp 0x3a8e7
movq 0x18(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x4fd80
movb %al, 0x17(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x4270
leaq 0xaf(%rsp), %rdi
callq 0x4490
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3a924
jmp 0x3aa8c
movl 0xd4(%rsp), %eax
addl $0x1, %eax
cmpl 0xe4(%rsp), %eax
jge 0x3a988
movq 0xd8(%rsp), %rax
movl 0xd4(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq 0xe8(%rsp), %rdi
callq 0x4570
jmp 0x3aa8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xaf(%rsp), %rdi
callq 0x4490
jmp 0x3aa94
movq 0x18(%rsp), %rdx
leaq 0x2253e(%rip), %rsi     # 0x5ced2
leaq 0x58(%rsp), %rdi
callq 0x22950
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdx
leaq 0x2253e(%rip), %rsi     # 0x5cef7
leaq 0x38(%rsp), %rdi
callq 0x4580
jmp 0x3a9c5
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xc9f0
jmp 0x3a9db
movq 0x3260e(%rip), %rdi     # 0x6cff0
leaq 0x78(%rsp), %rsi
callq 0x43e0
jmp 0x3a9ee
leaq 0x78(%rsp), %rdi
callq 0x4270
leaq 0x38(%rsp), %rdi
callq 0x4270
leaq 0x37(%rsp), %rdi
callq 0x4490
leaq 0x58(%rsp), %rdi
callq 0x4270
movl $0x1, %edi
callq 0x44f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x3aa74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x3aa6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4270
leaq 0x38(%rsp), %rdi
callq 0x4270
leaq 0x37(%rsp), %rdi
callq 0x4490
leaq 0x58(%rsp), %rdi
callq 0x4270
jmp 0x3aa94
jmp 0x3aa8c
addq $0xf8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0x4730
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x16bb0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x503f1
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x4fe90
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x4fd80
testb $0x1, %al
jne 0x503d7
jmp 0x503d9
jmp 0x503f1
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x50398
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
andb $0x1, %al
movb %al, 0xb7(%rsp)
movq %rcx, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movl $0x10, %edx
callq 0x47b0
movq 0x20(%rsp), %rdi
callq 0x4350
movb %al, 0x2e(%rsp)
jmp 0x52eee
movb 0x2e(%rsp), %al
testb $0x1, %al
jne 0x53025
jmp 0x52efc
movq 0x10(%rsp), %rdx
leaq 0xb788(%rip), %rsi      # 0x5e690
leaq 0x50(%rsp), %rdi
callq 0x22950
jmp 0x52f14
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdx
leaq 0x9963(%rip), %rsi      # 0x5c892
leaq 0x30(%rsp), %rdi
callq 0x4580
jmp 0x52f3b
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xc9f0
jmp 0x52f51
movq 0xa8(%rsp), %rdx
movzbl 0xb7(%rsp), %esi
andl $0x1, %esi
leaq 0x70(%rsp), %rdi
callq 0x3a1b0
jmp 0x52f70
leaq 0x70(%rsp), %rdi
callq 0x4270
leaq 0x30(%rsp), %rdi
callq 0x4270
leaq 0x2f(%rsp), %rdi
callq 0x4490
leaq 0x50(%rsp), %rdi
callq 0x4270
movl $0x1, %edi
callq 0x44f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x5304e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x5300f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x53005
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4270
leaq 0x30(%rsp), %rdi
callq 0x4270
leaq 0x2f(%rsp), %rdi
callq 0x4490
leaq 0x50(%rsp), %rdi
callq 0x4270
jmp 0x5304e
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x53041
movq 0x20(%rsp), %rdi
callq 0x45d0
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x45d0
movq 0x98(%rsp), %rdi
callq 0x4730
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rax
movl 0x2bc8(%rax), %eax
addl 0x6c(%rsp), %eax
movl %eax, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x577a0
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0x2d1c(%rcx), %eax
jge 0x5778e
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
addq $0x2d20, %rdi           # imm = 0x2D20
movslq 0x60(%rsp), %rsi
callq 0x8ba0
movq %rax, %rcx
movl 0x28(%rsp), %eax
cmpl (%rcx), %eax
jge 0x5777c
movq 0x70(%rsp), %rdi
addq $0x2570, %rdi           # imm = 0x2570
movl 0x68(%rsp), %esi
callq 0x4700
movq %rax, %rdi
leaq 0x4bd1(%rip), %rsi      # 0x5c228
movq %rsi, 0x8(%rsp)
callq 0x4430
movq %rax, %rdi
movl 0x64(%rsp), %esi
incl %esi
callq 0x4700
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x4430
movq %rax, %rdi
movl 0x60(%rsp), %esi
incl %esi
callq 0x4700
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x4430
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
addq $0x2d38, %rdi           # imm = 0x2D38
movslq 0x60(%rsp), %rsi
callq 0x50190
movq %rax, %rdi
movslq 0x5c(%rsp), %rsi
callq 0x4fe90
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x43e0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x4430
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
addq $0x3048, %rdi           # imm = 0x3048
movslq 0x64(%rsp), %rsi
callq 0x8ae0
movq %rax, %rdi
movslq 0x60(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x5c(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x35ed0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x43e0
movq %rax, 0x20(%rsp)
jmp 0x57735
movq 0x20(%rsp), %rdi
leaq 0x5151(%rip), %rsi      # 0x5c892
callq 0x4430
jmp 0x57748
leaq 0x38(%rsp), %rdi
callq 0x4270
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x5760b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4270
jmp 0x577b6
jmp 0x5777e
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x575ee
jmp 0x57790
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x575d8
movq 0x70(%rsp), %rdi
addq $0x2570, %rdi           # imm = 0x2570
callq 0x42b0
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x4730
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movl 0x2bc8(%rax), %eax
addl 0x5c(%rsp), %eax
movl %eax, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq 0x60(%rsp), %rcx
cmpl 0x2d18(%rcx), %eax
jge 0x57919
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x58(%rsp), %eax
jge 0x57907
movq 0x60(%rsp), %rdi
addq $0x2770, %rdi           # imm = 0x2770
movl 0x58(%rsp), %esi
callq 0x4700
movq %rax, %rdi
leaq 0x49f6(%rip), %rsi      # 0x5c228
movq %rsi, (%rsp)
callq 0x4430
movq %rax, %rdi
movl 0x54(%rsp), %esi
incl %esi
callq 0x4700
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x4430
movq %rax, %rdi
movl 0x50(%rsp), %esi
incl %esi
callq 0x4700
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x4430
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
addq $0x3060, %rdi           # imm = 0x3060
movslq 0x54(%rsp), %rsi
callq 0x8bc0
movq %rax, %rdi
movslq 0x50(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x35ed0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x43e0
movq %rax, 0x18(%rsp)
jmp 0x578c0
movq 0x18(%rsp), %rdi
leaq 0x4fc6(%rip), %rsi      # 0x5c892
callq 0x4430
jmp 0x578d3
leaq 0x30(%rsp), %rdi
callq 0x4270
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x57805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4270
jmp 0x5792f
jmp 0x57909
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x577e8
movq 0x60(%rsp), %rdi
addq $0x2570, %rdi           # imm = 0x2570
callq 0x42b0
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4730
nopl (%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movq 0xe0(%rsp), %rax
movl 0x2bc8(%rax), %eax
movl 0xdc(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
addq $0x2170, %rdi           # imm = 0x2170
movl 0xd8(%rsp), %esi
callq 0x4700
movq %rax, %rdi
leaq 0x488f(%rip), %rsi      # 0x5c228
callq 0x4430
movq %rax, 0x30(%rsp)
movq 0xe0(%rsp), %rdi
addq $0x3078, %rdi           # imm = 0x3078
movslq 0xdc(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x35ed0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x43e0
movq %rax, 0x40(%rsp)
jmp 0x579eb
movq 0x40(%rsp), %rdi
leaq 0x4831(%rip), %rsi      # 0x5c228
callq 0x4430
movq %rax, 0x28(%rsp)
jmp 0x57a03
movq 0xe0(%rsp), %rdi
addq $0x3090, %rdi           # imm = 0x3090
movslq 0xdc(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
leaq 0x88(%rsp), %rdi
callq 0x35ed0
jmp 0x57a32
movq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x43e0
movq %rax, 0x20(%rsp)
jmp 0x57a4b
movq 0x20(%rsp), %rdi
leaq 0x47d1(%rip), %rsi      # 0x5c228
callq 0x4430
movq %rax, 0x18(%rsp)
jmp 0x57a63
movq 0xe0(%rsp), %rdi
addq $0x30a8, %rdi           # imm = 0x30A8
movslq 0xdc(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
leaq 0x68(%rsp), %rdi
callq 0x35ed0
jmp 0x57a8f
movq 0x18(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x43e0
movq %rax, 0x10(%rsp)
jmp 0x57aa5
movq 0x10(%rsp), %rdi
leaq 0x4777(%rip), %rsi      # 0x5c228
callq 0x4430
movq %rax, 0x8(%rsp)
jmp 0x57abd
movq 0xe0(%rsp), %rdi
addq $0x30c0, %rdi           # imm = 0x30C0
movslq 0xdc(%rsp), %rsi
callq 0x8c20
movsd (%rax), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x35ed0
jmp 0x57ae9
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x43e0
jmp 0x57afa
leaq 0x48(%rsp), %rdi
callq 0x4270
leaq 0x68(%rsp), %rdi
callq 0x4270
leaq 0x88(%rsp), %rdi
callq 0x4270
leaq 0xb8(%rsp), %rdi
callq 0x4270
movq 0xe0(%rsp), %rdi
addq $0x2170, %rdi           # imm = 0x2170
leaq 0x4d54(%rip), %rsi      # 0x5c892
callq 0x4430
movq 0xe0(%rsp), %rdi
addq $0x2170, %rdi           # imm = 0x2170
callq 0x42b0
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x57bd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x57bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x57bbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4270
leaq 0x68(%rsp), %rdi
callq 0x4270
leaq 0x88(%rsp), %rdi
callq 0x4270
leaq 0xb8(%rsp), %rdi
callq 0x4270
movq 0xb0(%rsp), %rdi
callq 0x4730
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x2bc8(%rax), %eax
addl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x1, 0x8(%rsp)
je 0x57c28
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x2bcc(%rcx), %eax
jne 0x57c4e
movq 0x10(%rsp), %rdi
addq $0x2370, %rdi           # imm = 0x2370
movl 0x8(%rsp), %esi
callq 0x4700
movq %rax, %rdi
leaq 0x6d63(%rip), %rsi      # 0x5e9aa
callq 0x4430
jmp 0x57c99
movq 0x10(%rsp), %rdi
addq $0x2370, %rdi           # imm = 0x2370
movl 0x8(%rsp), %esi
callq 0x4700
movq %rax, %rdi
leaq 0x45bb(%rip), %rsi      # 0x5c228
callq 0x4430
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
movslq 0xc(%rsp), %rsi
callq 0x8c20
movq (%rsp), %rdi
movsd (%rax), %xmm0
callq 0x4790
movq 0x10(%rsp), %rdi
addq $0x2370, %rdi           # imm = 0x2370
leaq 0x4be6(%rip), %rsi      # 0x5c892
callq 0x4430
movq 0x10(%rsp), %rdi
addq $0x2370, %rdi           # imm = 0x2370
callq 0x42b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
xorl %eax, %eax
movl %eax, -0xb4(%rbp)
movl %eax, %edi
callq 0x4490
movl -0xb4(%rbp), %edx
movq %rax, -0x10(%rbp)
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x2d5f4(%rip), %rsi     # 0x35024
leaq -0x60(%rbp), %rdi
callq 0x14d80
movw -0x50(%rbp), %cx
movq %rsp, %rax
movw %cx, 0x10(%rax)
movups -0x60(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x18e20
movq -0xb0(%rbp), %rdi
leaq 0x2d5c5(%rip), %rsi     # 0x3502c
callq 0x84a0
leaq 0x45b6d(%rip), %rax     # 0x4d5e0
movzbl (%rax), %edi
andl $0x1, %edi
callq 0x6e60
movl %eax, -0x64(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4850
movq -0xa8(%rbp), %rdx
leaq 0x2d592(%rip), %rsi     # 0x35034
leaq -0x88(%rbp), %rdi
callq 0x46c0
jmp 0x7ab0
leaq -0x89(%rbp), %rdi
callq 0x4530
movq -0xb0(%rbp), %rdi
movb $0x0, -0x9d(%rbp)
addq $0x8, %rdi
leaq 0x2d79f(%rip), %rsi     # 0x35274
callq 0x8520
movq %rax, -0xc0(%rbp)
jmp 0x7ae3
movq -0xc0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8560
movq %rax, -0xc8(%rbp)
jmp 0x7afc
movq -0xc8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x8560
movq %rax, -0xd0(%rbp)
jmp 0x7b15
movq -0xd0(%rbp), %rdi
movq -0xb0(%rbp), %rsi
addq $0xa8, %rsi
callq 0x85a0
movq %rax, -0xd8(%rbp)
jmp 0x7b38
movq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x85a0
movq %rax, -0xe0(%rbp)
jmp 0x7b51
movq -0xe0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x85e0
movq %rax, -0xe8(%rbp)
jmp 0x7b6a
movq -0xe8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8620
movq %rax, -0xf0(%rbp)
jmp 0x7b86
movq -0xf0(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x8520
movq %rax, -0xf8(%rbp)
jmp 0x7b9f
movq -0xf8(%rbp), %rdi
leaq -0x9d(%rbp), %rsi
callq 0x8660
jmp 0x7bb4
movq -0xb0(%rbp), %rdi
callq 0x86a0
jmp 0x7bc2
leaq -0x88(%rbp), %rdi
callq 0x42e0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x89(%rbp), %rdi
callq 0x4530
jmp 0x7c15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x42e0
movq -0x98(%rbp), %rdi
callq 0x4840
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::function_compositor<double>::function::vars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline function& vars(const std::string& v0,
                               const std::string& v1,
                               const std::string& v2,
                               const std::string& v3,
                               const std::string& v4)
         {
            v_.push_back(v0);
            v_.push_back(v1);
            v_.push_back(v2);
            v_.push_back(v3);
            v_.push_back(v4);
            return (*this);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x40, %rdi
movq 0x28(%rsp), %rsi
callq 0x1466b0
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x20(%rsp), %rsi
callq 0x1466b0
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x18(%rsp), %rsi
callq 0x1466b0
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x10(%rsp), %rsi
callq 0x1466b0
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rsi
callq 0x1466b0
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/newcount-size.cc
// Function: elimDups(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>>>>&)
void elimDups(vector<string> &words)
{
    // sort words alphabetically so we can find the duplicates
    sort(words.begin(), words.end());
	for_each(words.begin(), words.end(), 
	         [](const string &s) { cout << s << " "; });
	cout << endl;


    // unique reorders the input so that each word appears once in the
    // front part of the range 
	// returns an iterator one past the unique range
    auto end_unique = unique(words.begin(), words.end());
	for_each(words.begin(), words.end(), 
	         [](const string &s) { cout << s << " "; });
	cout << endl;

    // erase uses a vector operation to remove the nonunique elements
    words.erase(end_unique, words.end());
	for_each(words.begin(), words.end(), 
	         [](const string &s) { cout << s << " "; });
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c10
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4bd0
movq -0x8(%rbp), %rdi
callq 0x4c10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2570
movq 0xab6c(%rip), %rdi      # 0xcfd0
movq 0xab4d(%rip), %rsi      # 0xcfb8
callq 0x2150
movq -0x8(%rbp), %rdi
callq 0x4c10
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c40
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x4c70
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c10
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c40
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x25c0
movq 0xab07(%rip), %rdi      # 0xcfd0
movq 0xaae8(%rip), %rsi      # 0xcfb8
callq 0x2150
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4d40
movq -0x8(%rbp), %rdi
callq 0x4c40
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4d40
movq -0xa0(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x4cb0
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c10
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c40
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x2610
movq 0xaa77(%rip), %rdi      # 0xcfd0
movq 0xaa58(%rip), %rsi      # 0xcfb8
callq 0x2150
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: acliusBackHome[P]kamaya/dist/scanner.yy.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 229 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 228);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0xab482(%rip), %rax     # 0xc72e0
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x7265f(%rip), %rax     # 0x8e4d0
cmpw $0x0, (%rax,%rcx,2)
je 0x1be8c
movl -0x4(%rbp), %eax
movl %eax, 0xab46b(%rip)     # 0xc72ec
movq -0x10(%rbp), %rax
movq %rax, 0xab464(%rip)     # 0xc72f0
jmp 0x1be8e
movslq -0x4(%rbp), %rcx
leaq 0x72a97(%rip), %rax     # 0x8e930
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x727f3(%rip), %rax     # 0x8e6a0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x1bee6
movslq -0x4(%rbp), %rcx
leaq 0x72c4f(%rip), %rax     # 0x8eb10
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xe5, -0x4(%rbp)
jl 0x1bee4
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x72e12(%rip), %rax     # 0x8ecf0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x1be8e
movslq -0x4(%rbp), %rcx
leaq 0x72a3f(%rip), %rax     # 0x8e930
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x72e2b(%rip), %rax     # 0x8ed30
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xe4, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1bf2b
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x1bf31
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0x974f5(%rip), %rax     # 0xc6350
movl 0x8(%rax), %eax
leaq 0x9750b(%rip), %rcx     # 0xc6370
cmpl (%rcx), %eax
je 0x2ee76
leaq 0x98088(%rip), %rax     # 0xc6ef8
movl $0x0, (%rax)
leaq 0x974f3(%rip), %rax     # 0xc6370
movl (%rax), %ecx
subl $0x1, %ecx
leaq 0x974c7(%rip), %rax     # 0xc6350
movl %ecx, (%rax)
leaq 0x974de(%rip), %rax     # 0xc6370
movl (%rax), %ecx
leaq 0x974b5(%rip), %rax     # 0xc6350
movl %ecx, 0x8(%rax)
leaq 0x98053(%rip), %rax     # 0xc6ef8
movl (%rax), %ecx
leaq 0x974a2(%rip), %rax     # 0xc6350
movl %ecx, 0x4(%rax)
leaq 0x98040(%rip), %rax     # 0xc6ef8
movl (%rax), %ecx
leaq 0x97957(%rip), %rax     # 0xc6818
addl (%rax), %ecx
leaq 0x97486(%rip), %rax     # 0xc6350
movl %ecx, 0xc(%rax)
leaq 0x97944(%rip), %rax     # 0xc6818
movl (%rax), %ecx
leaq 0x9801b(%rip), %rax     # 0xc6ef8
addl (%rax), %ecx
leaq 0x98012(%rip), %rax     # 0xc6ef8
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x17230
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq $-0x1, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x33d60
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x33d90
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x171f0
movq -0x40(%rbp), %rsi
subq $0x1, %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
leaq -0x14(%rbp), %rcx
movq %rsi, %rdi
callq 0x33f80
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
leaq -0x28(%rbp), %rsi
callq 0x34010
movq %rax, -0x38(%rbp)
movb %dl, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x16700
movq -0x50(%rbp), %rdi
callq 0x321e0
movq %rax, -0x48(%rbp)
jmp 0x3208f
movq -0x48(%rbp), %rdi
callq 0x4030
movq %rax, -0x58(%rbp)
jmp 0x3209e
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x321e0
movq %rax, -0x60(%rbp)
jmp 0x320bd
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x6c(%rbp)
callq 0x41e0
movq -0x50(%rbp), %rdi
movl -0x6c(%rbp), %eax
movq -0x28(%rbp), %r9
movl %eax, %esi
leaq -0x20(%rbp), %rdx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x32200
jmp 0x320f2
leaq -0x20(%rbp), %rdi
callq 0x34200
movq $0x1, -0x40(%rbp)
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x321e0
movq %rax, -0x78(%rbp)
jmp 0x3211a
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
cmpq %rcx, %rax
jae 0x321b7
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x321a4
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq -0x40(%rbp), %rsi
callq 0x165e0
cmpq $-0x1, (%rax)
jne 0x321a4
leaq 0x5d551(%rip), %rdi     # 0x8f6a8
xorl %eax, %eax
callq 0x4080
jmp 0x32160
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %r9
leaq -0x20(%rbp), %rdx
movl $0x2, %ecx
movl $0x1, %r8d
callq 0x32200
jmp 0x32182
leaq -0x20(%rbp), %rdi
callq 0x34200
jmp 0x321a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x166a0
jmp 0x321c9
jmp 0x321a6
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x32103
leaq -0x20(%rbp), %rdi
callq 0x166a0
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x171f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0x32749
movq -0x18(%rbp), %rsi
leaq 0x5cf9d(%rip), %rdi     # 0x8f6d9
movb $0x0, %al
callq 0x4080
movb $0x0, -0x1(%rbp)
jmp 0x3274d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rsi
callq 0x32700
testb $0x1, %al
jne 0x3278a
jmp 0x327a0
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34080
addq $0x80, %rsp
popq %rbp
retq
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x45f0
movq -0x78(%rbp), %rdx
leaq 0x5cf3f(%rip), %rsi     # 0x8f6f7
leaq -0x30(%rbp), %rdi
callq 0x4450
jmp 0x327c3
leaq -0x31(%rbp), %rdi
callq 0x4380
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x15db0
jmp 0x327db
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x43f0
jmp 0x327ea
leaq -0x68(%rbp), %rdi
callq 0x4688
movl $0x28, %edi
callq 0x41c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movl $0x6, %esi
leaq -0x30(%rbp), %rdx
callq 0x73a90
jmp 0x32817
movq -0x80(%rbp), %rdi
leaq 0x9352e(%rip), %rsi     # 0xc5d50
leaq -0x1c999(%rip), %rdx    # 0x15e90
callq 0x45b0
jmp 0x32893
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x4380
jmp 0x3288a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x32881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x32881
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x4280
leaq -0x30(%rbp), %rdi
callq 0x4688
movq -0x40(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0xa8, %rdi
movq -0x18(%rbp), %rsi
callq 0x34440
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xa8, %rdi
callq 0x344a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34470
testb $0x1, %al
jne 0x32b42
jmp 0x32b51
movq -0x40(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x55ef0
jmp 0x32b6f
leaq -0x20(%rbp), %rdi
callq 0x344d0
movq 0x20(%rax), %rdi
callq 0x56e60
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x55d70
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0xa8, %rdi
movq -0x10(%rbp), %rsi
callq 0x34440
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xa8, %rdi
callq 0x344a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x344f0
testb $0x1, %al
jne 0x32bda
jmp 0x32c3a
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x566e0
movq -0x78(%rbp), %rdi
callq 0x4180
movq -0x70(%rbp), %rsi
movq %rax, %rdx
leaq 0x5cb11(%rip), %rdi     # 0x8f720
xorl %eax, %eax
callq 0x4080
jmp 0x32c18
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x32c6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x32c73
movq -0x18(%rbp), %rdi
callq 0x56d20
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0xa8, %rdi
movq -0x10(%rbp), %rsi
callq 0x34520
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x7, %esi
callq 0x31db0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x34080
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3e990
movq -0x10(%rbp), %rdi
callq 0x167a0
testb $0x1, %al
jne 0x32d8a
cmpq $0x0, -0x18(%rbp)
je 0x32d62
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34080
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3e690
jmp 0x32d88
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34080
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x60f30
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3e690
jmp 0x32d8a
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)