LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x78, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movslq %r8d, %rax
movq (%rcx,%rax,8), %rsi
leaq 0x38(%rsp), %r13
leaq 0x18(%rsp), %rdx
movq %r13, %rdi
callq 0x3130
movq %r13, %rdi
movq %rbx, %rsi
callq 0x21882
movl %eax, %r14d
movq %r13, %rdi
callq 0x3170
testb %r14b, %r14b
je 0x17b34
incl %ebp
cmpl %r12d, %ebp
jge 0x17b43
movslq %ebp, %rax
movq (%r15,%rax,8), %rsi
movq 0x10(%rsp), %rdi
callq 0x3600
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x103c0(%rip), %rsi     # 0x27f0a
leaq 0x18(%rsp), %rdi
movq %rbx, %rdx
callq 0xcf4d
leaq 0x103d1(%rip), %rsi     # 0x27f2f
leaq 0x58(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3130
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x601b
movq 0x1c468(%rip), %rdi     # 0x33ff0
leaq 0x38(%rsp), %rsi
callq 0x3310
leaq 0x38(%rsp), %rdi
callq 0x3170
leaq 0x58(%rsp), %rdi
callq 0x3170
leaq 0x18(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3170
jmp 0x17bca
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3170
jmp 0x17bd9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x3130
movl %r12d, 0x4(%rsp)
leaq 0xe2ad(%rip), %rsi      # 0x27f4f
leaq 0x38(%rsp), %rdi
movq %rbx, 0x8(%rsp)
movq %rbx, %rdx
callq 0xcf4d
leaq 0x10(%rsp), %r13
leaq 0x38(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x21882
movl %eax, %ebx
movq %r12, %rdi
callq 0x3170
movq %r13, %rdi
callq 0x3170
testb %bl, %bl
je 0x19d2f
incl %ebp
cmpl 0x4(%rsp), %ebp
jge 0x19d3e
movslq %ebp, %rax
leaq (%r15,%rax,8), %rsi
leaq 0x38(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x10(%rsp), %rdi
callq 0x218d2
addq $0x2b70, %r14           # imm = 0x2B70
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x218f8
leaq 0x10(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x111b6
movq %rbx, %rdi
callq 0x3170
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe1c5(%rip), %rsi      # 0x27f0a
leaq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0xcf4d
leaq 0xe1d4(%rip), %rsi      # 0x27f2f
leaq 0x58(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x3130
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x601b
movq 0x1a26b(%rip), %rdi     # 0x33ff0
leaq 0x10(%rsp), %rsi
callq 0x3310
leaq 0x10(%rsp), %rdi
callq 0x3170
leaq 0x58(%rsp), %rdi
callq 0x3170
leaq 0x38(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3170
jmp 0x19dc7
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3170
jmp 0x19dd6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x19de7
jmp 0x19ddf
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3170
jmp 0x19df1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
shrq $0x5, %rax
cltq
cmpq %rax, %r15
jge 0x21a29
addq %r12, %rdi
movq %rbx, %rsi
callq 0x21882
testb %al, %al
jne 0x21a29
incq %r15
addq $0x20, %r12
jmp 0x219fc
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdx
callq 0x3610
leaq 0x70(%rbx), %rdi
callq 0x30b0
testb %al, %al
je 0x22470
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7261(%rip), %rsi      # 0x296d8
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0xcf4d
leaq 0x5430(%rip), %rsi      # 0x278bb
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3130
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x601b
movzbl %bpl, %esi
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x176c7
leaq 0x48(%rsp), %rdi
callq 0x3170
leaq 0x8(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3170
jmp 0x224f7
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3170
jmp 0x22506
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3170
jmp 0x22515
movq %rax, %r14
movq %rbx, %rdi
callq 0x3460
movq %r14, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
addl 0x2bc8(%rdi), %esi
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %eax
movl %esi, 0xc(%rsp)
cmovgl %esi, %eax
movq %rax, 0x28(%rsp)
leaq 0x2570(%rdi), %rax
movq %rax, 0x10(%rsp)
cmpq 0x28(%rsp), %r15
je 0x244c2
imulq $0x18, %r15, %rax
movq %rax, 0x30(%rsp)
incq %r15
xorl %r14d, %r14d
movslq 0x2d1c(%rbx), %rax
cmpq %rax, %r14
jge 0x2437a
leaq 0x1(%r14), %rax
movq %rax, 0x18(%rsp)
imulq $0x18, %r14, %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
xorl %ebp, %ebp
movq 0x2d20(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %rbp
jge 0x244b8
movq %rbp, 0x40(%rsp)
movq %rbx, %rbp
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x3570
movq %rax, %rdi
leaq 0x2e4f(%rip), %rbx      # 0x27240
movq %rbx, %rsi
callq 0x3350
movq %rax, %rdi
movq %r15, %r13
movl %r15d, %esi
callq 0x3570
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3350
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x3570
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3350
movq 0x2d38(%rbp), %rcx
movq 0x38(%rsp), %r12
movq (%rcx,%r12), %rsi
addq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3350
movq %rax, %r15
movq %rbp, %rbx
movq 0x3048(%rbp), %rax
movq 0x40(%rsp), %rbp
movq 0x30(%rsp), %rcx
movq (%rax,%rcx), %rax
movq (%rax,%r12), %rax
movsd (%rax,%rbp,8), %xmm0
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x161b8
movq %r15, %rdi
movq %r12, %rsi
callq 0x3310
movq %rax, %rdi
leaq 0x3423(%rip), %rsi      # 0x278bb
callq 0x3350
leaq 0x48(%rsp), %rdi
callq 0x3170
incq %rbp
addq $0x20, 0x20(%rsp)
movq %r13, %r15
jmp 0x243bd
movq 0x18(%rsp), %r14
jmp 0x24394
movq 0x10(%rsp), %rdi
callq 0x3230
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/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
addl 0x2bc8(%rdi), %esi
xorl %r14d, %r14d
testl %esi, %esi
movl $0x0, %eax
movl %esi, 0x14(%rsp)
cmovgl %esi, %eax
movq %rax, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x2770(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x2d0e(%rip), %r12      # 0x27240
leaq 0x28(%rsp), %r13
movq 0x8(%rsp), %rax
movslq 0x2d18(%rax), %rax
cmpq %rax, %r14
jge 0x245eb
imulq $0x18, %r14, %r15
incq %r14
xorl %ebx, %ebx
cmpq %rbx, 0x20(%rsp)
je 0x24537
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x3570
movq %rax, %rdi
movq %r12, %rsi
callq 0x3350
movq %rax, %rdi
movl %r14d, %esi
callq 0x3570
movq %rax, %rdi
movq %r12, %rsi
callq 0x3350
leal 0x1(%rbx), %esi
movq %rax, %rdi
callq 0x3570
movq %rax, %rdi
movq %r12, %rsi
callq 0x3350
movq %rax, %rbp
movq 0x8(%rsp), %rax
movq 0x3060(%rax), %rax
movq (%rax,%r15), %rax
movsd (%rax,%rbx,8), %xmm0
movq %r13, %rdi
callq 0x161b8
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3310
movq %rax, %rdi
leaq 0x32e5(%rip), %rsi      # 0x278bb
callq 0x3350
movq %r13, %rdi
callq 0x3170
incq %rbx
jmp 0x24555
movq 0x8(%rsp), %rdi
addq $0x2570, %rdi           # imm = 0x2570
callq 0x3230
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3570
leaq 0x2bec(%rip), %rsi      # 0x27240
movq %rax, %rdi
callq 0x3350
movq %rax, %r15
movslq %ebp, %r13
movq 0x3078(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x161b8
movq %r15, %rdi
movq %r12, %rsi
callq 0x3310
leaq 0x2bb2(%rip), %rsi      # 0x27240
movq %rax, %rdi
callq 0x3350
movq %rax, %r15
movq 0x3090(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x161b8
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x3310
leaq 0x2b7c(%rip), %rsi      # 0x27240
movq %rax, %rdi
callq 0x3350
movq %rax, %r15
movq 0x30a8(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x161b8
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x3310
leaq 0x2b46(%rip), %rsi      # 0x27240
movq %rax, %rdi
callq 0x3350
movq %rax, %r15
movq 0x30c0(%r14), %rax
movsd (%rax,%r13,8), %xmm0
leaq 0x8(%rsp), %rdi
callq 0x161b8
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x3310
leaq 0x8(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x48(%rsp), %rdi
callq 0x3170
leaq 0x68(%rsp), %rdi
callq 0x3170
leaq 0x3163(%rip), %rsi      # 0x278bb
movq %rbx, %rdi
callq 0x3350
movq %rbx, %rdi
callq 0x3230
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3170
jmp 0x24792
jmp 0x2478f
jmp 0x2479e
jmp 0x247ad
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
jmp 0x247a1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3170
jmp 0x247b0
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl 0x2bc8(%rdi), %r15d
addl %esi, %r15d
movl 0x2bcc(%rdi), %r12d
leaq 0x2370(%rdi), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3570
cmpl $0x1, %r15d
je 0x24825
cmpl %r12d, %r15d
je 0x24825
leaq 0x2a3c(%rip), %rsi      # 0x27240
movq %rax, %rdi
callq 0x3350
movslq %ebp, %rcx
movq 0x3108(%r14), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq %rax, %rdi
callq 0x34d0
jmp 0x24834
leaq 0x51c6(%rip), %rsi      # 0x299f2
movq %rax, %rdi
callq 0x3350
leaq 0x3080(%rip), %rsi      # 0x278bb
movq %rbx, %rdi
callq 0x3350
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x33c0
movq %rax, 0x30(%rsp)
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
movq %rax, 0x28(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0xd2df(%rip), %rsi      # 0x12004
leaq 0x58(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x8e2e
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x9cdc
leaq 0xd2b2(%rip), %rsi      # 0x1200c
movq %rbx, %rdi
callq 0x51a8
leaq 0x18777(%rip), %rax     # 0x1d4e0
leaq 0x18764(%rip), %rcx     # 0x1d4d4
movl (%rcx), %ecx
cmpb $0x0, (%rax)
movl $0x7a120, %eax          # imm = 0x7A120
movl $0x55730, %edx          # imm = 0x55730
cmovnel %eax, %edx
testl %ecx, %ecx
cmovnel %ecx, %edx
movl %edx, 0x1c(%rsp)
leaq 0xd282(%rip), %rsi      # 0x12014
leaq 0x38(%rsp), %rdi
leaq 0x1b(%rsp), %r14
movq %r14, %rdx
callq 0x3180
movb $0x0, (%r14)
leaq 0x8(%rbx), %rdi
leaq 0xd4a1(%rip), %rsi      # 0x12254
callq 0x520e
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x5224
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x5224
leaq 0xa8(%rbx), %rsi
movq %rax, %rdi
callq 0x523c
leaq 0x70(%rsp), %rsi
movq %rax, %rdi
callq 0x523c
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x5256
leaq 0x38(%rsp), %rsi
movq %rax, %rdi
callq 0x526e
leaq 0x1c(%rsp), %rsi
movq %rax, %rdi
callq 0x520e
leaq 0x1b(%rsp), %rsi
movq %rax, %rdi
callq 0x5282
movq %rbx, %rdi
callq 0x529a
leaq 0x38(%rsp), %rdi
callq 0x31d0
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x36d0
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/parse_print_urls.cpp
// Function: main
int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cout << "Usage: " << argv[0] << " <filename>" << std::endl;
        std::cout << "For example on ArchLinux you could try and parse ";
        std::cout << "~/.config/chromium/Default/Current Session" << std::endl;
        return 0;
    }

    std::vector<std::shared_ptr<Command>> cmds = read_session_file(std::string(argv[1]));

    for (auto & x : cmds) {
        if (x->type == 6) {
            std::shared_ptr<CommandUpdateTabNavigation> c = std::static_pointer_cast<CommandUpdateTabNavigation>(x);
            std::cout << c->tabid << " " << c->index << " " << c->url << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
cmpl $0x2, %edi
jne 0x4653
movq 0x8(%r14), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x49be
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x42b8
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x30c0
movq -0x68(%rbp), %r15
movq -0x60(%rbp), %r14
movq 0x59fc(%rip), %r12      # 0x9fd0
leaq 0x1b13(%rip), %r13      # 0x60ee
cmpq %r14, %r15
je 0x46b3
movq (%r15), %rax
cmpl $0x6, 0xc(%rax)
jne 0x464d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4758
movq -0x50(%rbp), %rax
movl 0x14(%rax), %esi
movq %r12, %rdi
callq 0x3200
movq %rax, %rdi
movq %r13, %rsi
callq 0x3140
movq -0x50(%rbp), %rcx
movl 0x18(%rcx), %esi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
movq %r13, %rsi
callq 0x3140
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0x3130
movq %rax, %rdi
callq 0x30d0
leaq -0x48(%rbp), %rdi
callq 0x4a6a
addq $0x10, %r15
jmp 0x45db
movq 0x5976(%rip), %rbx      # 0x9fd0
leaq 0x1ad3(%rip), %rsi      # 0x6134
movq %rbx, %rdi
callq 0x3140
movq (%r14), %rsi
movq %rax, %rdi
callq 0x3140
leaq 0x1ac1(%rip), %rsi      # 0x613c
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30d0
leaq 0x1ab6(%rip), %rsi      # 0x6148
movq %rbx, %rdi
callq 0x3140
leaq 0x1ad9(%rip), %rsi      # 0x617a
movq %rbx, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30d0
jmp 0x46bc
leaq -0x68(%rbp), %rdi
callq 0x4992
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30c0
jmp 0x46f5
movq %rax, %rbx
jmp 0x46f5
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4a6a
leaq -0x68(%rbp), %rdi
callq 0x4992
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
leaq 0x40(%rdi), %rbp
movq %rbp, %rdi
callq 0x11e136
movq %rbp, %rdi
movq %r12, %rsi
callq 0x11e136
movq %rbp, %rdi
movq %r15, %rsi
callq 0x11e136
movq %rbp, %rdi
movq %r14, %rsi
callq 0x11e136
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x11e136
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x320d
movq (%rbx), %r14
movq 0x8(%rbx), %r13
movq 0x5c5b(%rip), %r15      # 0x7fd0
leaq 0x2c99(%rip), %r12      # 0x5015
cmpq %r13, %r14
je 0x239d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
addq $0x20, %r14
jmp 0x237c
movq 0x5c2c(%rip), %r14      # 0x7fd0
movq %r14, %rdi
callq 0x20a0
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x39e3
movq %rax, -0x30(%rbp)
movq (%rbx), %r12
movq 0x8(%rbx), %r15
leaq 0x2c4b(%rip), %r13      # 0x5015
cmpq %r15, %r12
je 0x23eb
movq %r14, %rdi
movq %r12, %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x2120
addq $0x20, %r12
jmp 0x23ca
movq 0x5bde(%rip), %r14      # 0x7fd0
movq %r14, %rdi
callq 0x20a0
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0x310c
movq (%rbx), %r15
movq 0x8(%rbx), %r12
leaq 0x2bfd(%rip), %rbx      # 0x5015
cmpq %r12, %r15
je 0x2439
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
addq $0x20, %r15
jmp 0x2418
movq 0x5b90(%rip), %rdi      # 0x7fd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/newcount-size.cc
// Function: main
int main()
{
    vector<string> words;

    // copy contents of each book into a single vector
    string next_word;
    while (cin >> next_word) {
        // insert next book's contents at end of words
        words.push_back(next_word);
    }

	biggies(words, 5); // biggies changes its first argument

	// alternative solution using bind and check_size function
	// NB: words was changed inside biggies, 
	//     at this point in the program words has only unique
	//     words and is in order by size
	size_t sz = 5;
	auto
	wc = find_if(words.begin(), words.end(), 
	             bind(check_size, std::placeholders::_1, sz));
	auto count = words.end() - wc;
    cout << count << " " << make_plural(count, "word", "s")
         << " of length " << sz << " or longer" << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
andq $0x0, 0x10(%rbx)
leaq -0xb0(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movaps %xmm0, (%rbx)
movb $0x0, (%rax)
movq 0x58c3(%rip), %r14      # 0x7fe0
leaq -0xc0(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x274a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3144
jmp 0x2724
leaq -0x40(%rbp), %rdi
pushq $0x5
popq %rsi
callq 0x2453
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x8e(%rip), %rax       # 0x26d7
leaq -0xd0(%rbp), %rdx
movq %rax, (%rdx)
movq $0x5, 0x8(%rdx)
callq 0x317f
movq -0x38(%rbp), %rbx
subq %rax, %rbx
sarq $0x5, %rbx
movq 0x5842(%rip), %rdi      # 0x7fd0
movq %rbx, %rsi
callq 0x2110
leaq 0x2878(%rip), %rsi      # 0x5015
movq %rax, %rdi
callq 0x2120
movq %rax, %r14
leaq 0x2855(%rip), %rsi      # 0x5004
leaq -0x80(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x2060
leaq 0x2846(%rip), %rsi      # 0x5009
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2060
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movq %rbx, %rsi
callq 0x3116
leaq -0xa0(%rbp), %rsi
movq %r14, %rdi
callq 0x2100
leaq 0x280e(%rip), %rsi      # 0x500b
movq %rax, %rdi
callq 0x2120
pushq $0x5
popq %rsi
movq %rax, %rdi
callq 0x20c0
leaq 0x2800(%rip), %rsi      # 0x5017
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20a0
leaq -0xa0(%rbp), %rdi
callq 0x2090
leaq -0x60(%rbp), %rdi
callq 0x2090
leaq -0x80(%rbp), %rdi
callq 0x2090
leaq -0xc0(%rbp), %rdi
callq 0x2090
leaq -0x40(%rbp), %rdi
callq 0x319c
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x288b
movq %rax, %rbx
jmp 0x2894
jmp 0x289f
jmp 0x289f
jmp 0x289f
jmp 0x289f
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2090
leaq -0x60(%rbp), %rdi
callq 0x2090
leaq -0x80(%rbp), %rdi
callq 0x2090
jmp 0x28a2
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x2090
leaq -0x40(%rbp), %rdi
callq 0x319c
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x98, %rsp
movups 0xd6c(%rip), %xmm0      # 0x205c
movups %xmm0, -0x34(%rbp)
movaps 0xd55(%rip), %xmm0      # 0x2050
movaps %xmm0, -0x40(%rbp)
leaq 0xd00(%rip), %rsi       # 0x2006
leaq -0xb0(%rbp), %rbx
leaq -0x4c(%rbp), %rdx
movq %rbx, %rdi
callq 0x1438
leaq -0x90(%rbp), %r15
leaq 0xce4(%rip), %rsi       # 0x200b
leaq -0x1a(%rbp), %rdx
movq %r15, %rdi
callq 0x1438
leaq -0x70(%rbp), %r15
leaq 0xcda(%rip), %rsi       # 0x2018
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x1438
leaq -0x40(%rbp), %rdi
pushq $0x7
popq %rsi
callq 0x1279
xorl %eax, %eax
cmpq $0x7, %rax
je 0x1367
shll -0x40(%rbp,%rax,4)
incq %rax
jmp 0x1358
leaq -0x40(%rbp), %rdi
pushq $0x7
popq %rsi
callq 0x1279
leaq -0x146(%rip), %rdx      # 0x1234
leaq -0xb0(%rbp), %rdi
pushq $0x3
popq %rsi
callq 0x1473
movq 0x2c48(%rip), %rdi      # 0x3fd8
callq 0x1050
movabsq $0x2a00000015, %rax     # imm = 0x2A00000015
leaq -0x4c(%rbp), %rdi
movq %rax, (%rdi)
movl $0xffffffd6, 0x8(%rdi)  # imm = 0xFFFFFFD6
leaq -0x15d(%rip), %rdx      # 0x1257
pushq $0x3
popq %rsi
callq 0x14a2
movq 0x2c15(%rip), %rdi      # 0x3fd8
callq 0x1050
pushq $0x40
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0xb0, %rdi
callq 0x1040
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x13cb
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13f7
movq %rax, %r14
addq $-0x20, %r15
movq %r15, %rdi
callq 0x1040
cmpq %rbx, %r15
jne 0x13fa
jmp 0x142f
jmp 0x140f
movq %rax, %r14
pushq $0x40
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0xb0, %rdi
callq 0x1040
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x1415
movq %r14, %rdi
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/IR.hpp
// Function: IR::address2pointer[abi:cxx11](unsigned long)
inline string address2pointer(size_t addr) {
    long long addrll = addr;
    long long sub = -1 - addrll;
    if (addrll < 0) {
      if (sub >= sectionData.size() || sub < 0) {
        return "BadAddr";
      }
    }
    return (addrll < 0) ? (string("[") + sectionData[sub].name + string("]"))
                        : ("[ebp+" + to_string(addrll) + "]");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0xd337
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0xd441
leaq 0x2bb90(%rip), %rsi     # 0x38ea5
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0xc837
leaq 0x2b27b(%rip), %rdx     # 0x385a4
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xc8d6
jmp 0xd3a8
movq %rsi, %r15
notq %r14
movq 0x30(%rsi), %rax
subq 0x28(%rsi), %rax
pushq $0x60
popq %rcx
cqto
idivq %rcx
cmpq %r14, %rax
jbe 0xd3c8
leaq 0x2d795(%rip), %rsi     # 0x3aaee
leaq -0x60(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x4130
imulq $0x60, %r14, %rdx
addq 0x28(%r15), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xd418
leaq 0x2b222(%rip), %rsi     # 0x385a4
leaq -0x80(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4130
leaq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movq %rbx, %rdi
callq 0xc95f
leaq -0x80(%rbp), %rdi
callq 0x4598
leaq -0x40(%rbp), %rdi
callq 0x4598
leaq -0x60(%rbp), %rdi
callq 0x4598
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bace(%rip), %rsi     # 0x38e9d
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0xd3ba
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x4598
jmp 0xd3f4
jmp 0xd3f1
jmp 0xd3ff
jmp 0xd40d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4598
jmp 0xd402
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4598
jmp 0xd410
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f1e1(%rip), %rax     # 0x532d8
leaq 0x3f1fa(%rip), %rcx     # 0x532f8
movl (%rcx), %esi
xorl %ecx, %ecx
leaq 0x3fd6f(%rip), %rdx     # 0x53e78
cmpl %esi, 0x8(%rax)
jne 0x14110
movl (%rdx), %ecx
leal -0x1(%rsi), %edi
movl %edi, (%rax)
movl %esi, 0x8(%rax)
movl %ecx, 0x4(%rax)
leaq 0x3f676(%rip), %rsi     # 0x53798
addl (%rsi), %ecx
movl %ecx, 0xc(%rax)
movl %ecx, (%rdx)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x24(%rbp), %r14
movl %edx, (%r14)
addq $0x18, %rdi
callq 0xcfa8
leaq 0x30(%rbx), %rdi
leaq -0x20(%rbp), %r15
orq $-0x1, (%r15)
movq %r15, %rsi
callq 0x1679a
leaq 0x60(%rbx), %rdi
callq 0x163a8
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x5, %rax
decq %rax
movq %rax, (%r15)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x16420
addq $0x78, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1704e
movq (%r15), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, -0x28(%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 0x15437
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax,%r15,8), %rdx
cmpq $-0x1, %rdx
je 0x15457
leaq 0x25238(%rip), %rdi     # 0x3a65d
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x4060
jmp 0x154bb
leaq 0x251f7(%rip), %rdi     # 0x3a635
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4060
movq %r14, (%rax,%r15,8)
movq %r14, %r12
shlq $0x5, %r12
movq (%rbx), %rdi
addq %r12, %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x19104
testb %al, %al
jne 0x154aa
shlq $0x5, %r15
movq (%rbx), %rdi
addq %r15, %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x19104
testb %al, %al
je 0x154aa
movq (%rbx), %rax
addq %rax, %r12
addq %rax, %r15
movq %r15, %rdi
callq 0x190d6
movq %r12, %rdi
movq %rax, %rsi
callq 0x19534
imulq $0x18, %r14, %rdi
addq 0x60(%rbx), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1645e
leaq 0x78(%rbx), %r14
leaq -0x28(%rbp), %rsi
movq %r14, %rdi
callq 0x172a2
subq $-0x80, %rbx
cmpq %rbx, %rax
je 0x154e0
leaq -0x28(%rbp), %rsi
movq %r14, %rdi
callq 0x172fe
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $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 0x41b0
leaq -0x40(%rbp), %rdx
pushq $0x1
popq %r15
pushq $0x1
popq %r8
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
movq %r14, %r9
callq 0x1560c
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x1556a
movq %rax, -0x38(%rbp)
pushq $0x2
popq %r12
pushq $0x1
popq %r13
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x5, %rax
cmpq %rax, %r15
jae 0x155cc
cmpb $0x0, (%r14,%r15)
jne 0x155c7
movq 0x30(%rbx), %rax
cmpq $-0x1, (%rax,%r15,8)
jne 0x155c7
leaq 0x25293(%rip), %rdi     # 0x3a82f
callq 0x4430
movq %rbx, %rdi
movq %r15, %rsi
leaq -0x40(%rbp), %rdx
movq %r12, %rcx
movl %r13d, %r8d
movq %r14, %r9
callq 0x1560c
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x155c7
movq %rax, -0x38(%rbp)
incq %r15
jmp 0x15572
leaq -0x40(%rbp), %rdi
callq 0xd238
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x155e6
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15814
leaq 0x24ea9(%rip), %rdi     # 0x3a6b3
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4060
cmpq %rbx, %r14
seta %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x157e8
testb %al, %al
je 0x1584d
shlq $0x5, %rbx
addq (%r14), %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x24e7d(%rip), %rsi     # 0x3a6d1
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4130
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0xc865
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4580
leaq -0x30(%rbp), %rdi
callq 0x4598
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0x6
popq %rsi
leaq -0x50(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x3d4cc(%rip), %rsi     # 0x52d70
leaq -0x9003(%rip), %rdx     # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x158d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x158d3
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4598
jmp 0x158d3
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17536
addq $0xb0, %r14
cmpq %r14, %rax
je 0x15ac8
movq 0x40(%rax), %rdi
callq 0x21a26
movq %rbx, %rdi
movq %rax, %rsi
callq 0x210f4
jmp 0x15ad4
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x211b2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17536
addq $0xb0, %r12
cmpq %r12, %rax
je 0x15b3f
movq (%rbx), %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x215a0
movq (%r15), %rdx
leaq 0x24bcf(%rip), %rdi     # 0x3a6fa
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4060
movq %r15, %rdi
callq 0x4598
jmp 0x15b58
movq %r14, %rdi
callq 0x21942
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x164c0
movq %r14, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::make_direct_declarator_node(std::vector<unsigned long, std::allocator<unsigned long>> const&, ParseExpression const*)
size_t ParseTree::make_direct_declarator_node(const vector<size_t> &array_size, const ParseExpression *expression) {
    size_t new_one = new_node(N_DIRECT_DEC);
    nodes[new_one].set_array_size(array_size);
    if (!array_size.empty()) {
        if (expression) {
            nodes[new_one].set_expression(*expression);
        } else {
            nodes[new_one].set_expression(ParseExpression::get_expression(0));
        }
    }
    return new_one;
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $-0x80, 0x9(%rdi)
jne 0x18fb2
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1944a
leaq -0x20(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x1cc80
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_false_list() const
const vector<size_t> &ParseNode::get_false_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_FALSE_LIST)) {
        ((ParseNode *) this)->set_false_list(vector<size_t>());
    }
    return get_field<vector<size_t>>(K_FALSE_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x1, 0xa(%rdi)
jne 0x1900c
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1945e
leaq -0x20(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x1cc80
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_next_list() const
const vector<size_t> &ParseNode::get_next_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_NEXT_LIST)) {
        ((ParseNode *) this)->set_next_list(vector<size_t>());
    }
    return get_field<vector<size_t> >(K_NEXT_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x8, 0xa(%rdi)
jne 0x1908e
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x194b6
leaq -0x20(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
movl $0x80000, %esi          # imm = 0x80000
callq 0x1cc80
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_expression_list(ParseExpression const&)
void ParseNode::add_expression_list(const ParseExpression &expr) {
    if (has_key(K_EXPRESSION_LIST)) {
        auto &list = (vector<size_t> &) get_expression_list();
        list.emplace_back(expr.get_id());
    } else {
        vector<size_t> list;
        list.emplace_back(expr.get_id());
        set_field<vector<size_t> >(K_EXPRESSION_LIST, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb $-0x80, 0xa(%rdi)
jne 0x195c3
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
andq $0x0, -0x20(%rbp)
movq %r14, %rdi
callq 0x25a2e
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x30(%rbp), %rdi
callq 0x1679a
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x800000, %esi         # imm = 0x800000
xorl %ecx, %ecx
callq 0x1af88
leaq -0x30(%rbp), %rdi
callq 0xd238
jmp 0x195e5
movq %rbx, %rdi
callq 0x190ea
movq %rax, %rbx
movq %r14, %rdi
callq 0x25a2e
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1679a
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x195f0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_array_size(unsigned long)
void ParseNode::add_array_size(size_t array_size) {
    if (has_key(K_ARRAY_SIZE)) {
        auto &list = (vector<size_t> &) get_array_size();
        list.emplace_back(array_size);
    } else {
        vector<size_t> list;
        list.emplace_back(array_size);
        set_field<vector<size_t> >(K_ARRAY_SIZE, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, -0x10(%rbp)
testb $-0x80, 0x8(%rdi)
jne 0x19650
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x10(%rbp), %rsi
callq 0x1b546
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x80, %esi
xorl %ecx, %ecx
callq 0x1af88
leaq -0x30(%rbp), %rdi
callq 0xd238
jmp 0x19664
movq %rbx, %rdi
callq 0x18efc
leaq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x1b546
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
nop