LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/Option.cpp
// Function: COption::Parse(int const&, char**, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void COption::Parse(const int& iArgc, char* pszArgv[], RST_C& CRst)
{
	char szShortOpt[OPT_MAXNUM << 1] = {0};
	for (unsigned int uiCount = 0; uiCount < m_uiOptNum; ++uiCount) {
		szShortOpt[strlen(szShortOpt)] = m_stLongOpt[uiCount].val;
		if(m_stLongOpt[uiCount].has_arg != no_argument) {
			szShortOpt[strlen(szShortOpt)] = ':';
		}	
	}
	int iChar = -1;
	while ((iChar = getopt_long(iArgc, pszArgv, szShortOpt, m_stLongOpt, NULL)) != -1) {
		if (iChar == '?') {
			continue;
		}
		CRst.push_back(std::make_pair(iChar, std::string(optarg != NULL ? optarg : "")));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %r13
movaps %xmm0, 0x30(%r13)
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movl 0x408(%rdi), %eax
movq %rdi, 0x38(%rsp)
leaq 0x8(%rdi), %r12
shlq $0x5, %rax
movq %rax, 0x40(%rsp)
xorl %ebp, %ebp
movq %r12, 0x30(%rsp)
movq 0x38(%rsp), %rbx
cmpq %rbp, 0x40(%rsp)
je 0x7734
movq %r15, %r12
movq %r14, %r15
movb 0x20(%rbx,%rbp), %r14b
movq %r13, %rdi
callq 0x4140
movb %r14b, 0x70(%rsp,%rax)
cmpl $0x0, 0x10(%rbx,%rbp)
je 0x7723
movq %r13, %rdi
callq 0x4140
movb $0x3a, 0x70(%rsp,%rax)
addq $0x20, %rbp
movq %r15, %r14
movq %r12, %r15
movq 0x30(%rsp), %r12
jmp 0x76f0
leaq 0x18(%rsp), %rbp
leaq 0x70(%rsp), %rcx
movl (%r15), %edi
movq %r14, %rsi
movq %rcx, %r13
movq %rcx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x4560
movq %r13, %rcx
cmpl $0x3f, %eax
je 0x773e
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x7804
movq 0x1a849(%rip), %rax     # 0x21fb8
movq (%rax), %rsi
testq %rsi, %rsi
leaq 0x10d6e(%rip), %rax     # 0x184ea
cmoveq %rax, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5480
movl %ebx, 0x48(%rsp)
leaq 0x60(%rsp), %rcx
movq %rcx, 0x50(%rsp)
movq 0x8(%rsp), %rax
cmpq %rbp, %rax
je 0x77b8
movq %rax, 0x50(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x77bf
movups (%rbp), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %rbp, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7836
leaq 0x50(%rsp), %rdi
callq 0x4160
leaq 0x8(%rsp), %rdi
callq 0x4160
movq %r13, %rcx
jmp 0x773e
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4160
leaq 0x8(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/Main.cpp
// Function: CMain::Core(tagOption*)
void CMain::Core(OPTION_S* pstOpt)
{
    CXMLParser CParser;
    BT_AUTO(vecDetail, CParser.Parse(pstOpt->m_szXMLFile));
    CClassDetail* pCRoot = CParser.ParseRoot(pstOpt->m_szXMLFile);
//    PrintDetail(vecDetail);
    Inc(vecDetail, pCRoot);
    Src(vecDetail, pCRoot);

/*
    for (BT_AUTO(iterDetail, vecDetail.begin()); iterDetail != vecDetail.end(); ++iterDetail) {
        //PrintDetail(*iterDetail, 1);
        vector<string> vecDeclare = (*iterDetail)->GenerateGet("CConfig");
        for (size_t zuCount = 0; zuCount < vecDeclare.size(); ++zuCount) {
            cout << vecDeclare[zuCount] << endl;
        }
    }

    //vector<string> vecDeclare = CCfgDetail.GenerateDeclare();
    vector<string> vecDeclare = CCfgDetail.GenerateGet();
    for (size_t zuCount = 0; zuCount < vecDeclare.size(); ++zuCount) {
        cout << vecDeclare[zuCount] << endl;
    }

*/

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5bc8
addq $0x4, %rbx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5bde
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x5fc0
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x7ae0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x8274
leaq 0x10(%rsp), %rdi
callq 0x6ee2
leaq 0x8(%rsp), %rdi
callq 0x5bd4
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x7acd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6ee2
leaq 0x8(%rsp), %rdi
callq 0x5bd4
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/Main.cpp
// Function: CMain::PrintDetail(CClassDetail*, int const&)
void CMain::PrintDetail(CClassDetail* pCDetail, const int& iLevel)
{
    for (int iCount = 0; iCount < iLevel; ++iCount) {
        printf("-");
    }
    printf("\n");
    pCDetail->Print();
    vector<CClassDetail *> vecChildren = pCDetail->GetChildren();
    for (size_t zuCount = 0; zuCount < vecChildren.size(); ++zuCount) {
        PrintDetail(vecChildren[zuCount], iLevel + 1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x2d
popq %rbp
cmpl (%rbx), %r12d
jge 0x8916
movl %ebp, %edi
callq 0x4420
incl %r12d
jmp 0x8905
pushq $0xa
popq %rdi
callq 0x4420
movq %r15, %rdi
callq 0x10368
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xaece
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x896d
movq (%rax,%r12,8), %rsi
movl (%rbx), %eax
incl %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x88ea
incq %r12
jmp 0x893b
leaq 0x8(%rsp), %rdi
callq 0x6ee2
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6ee2
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/Dir.cpp
// Function: CDir::Read(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>>>>&)
bool CDir::Read(std::vector<std::string>& CFileName)
{
	struct dirent stEntry;
	struct dirent* pstResult = NULL;
	int iRet = readdir_r(m_pstDir, &stEntry, &pstResult);
	while (pstResult != NULL) {
		if (iRet != 0) {
			return false;
		}
		if (strcmp(stEntry.d_name, ".") != 0 && strcmp(stEntry.d_name, "..") != 0) {
			CFileName.push_back(std::string(stEntry.d_name));
		}
		iRet = readdir_r(m_pstDir, &stEntry, &pstResult);
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq 0x8(%rdi), %rdi
leaq 0x30(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0x4100
leaq 0x43(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x94ce
testl %eax, %eax
jne 0x94ce
cmpw $0x2e, (%r13)
je 0x94bd
movq %r13, %rdi
leaq 0xedb9(%rip), %rsi      # 0x18247
pushq $0x3
popq %rdx
callq 0x4310
testl %eax, %eax
je 0x94bd
movq %rbp, %rdi
movq %r13, %rsi
leaq 0x7(%rsp), %rdx
callq 0x5480
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x9722
movq %rbp, %rdi
callq 0x4160
movq 0x8(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4100
jmp 0x946e
testq %rcx, %rcx
sete %al
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/Dir.cpp
// Function: CDir::Remove(char const*)
void CDir::Remove(const char* pszDir)
{
	//check directory
	if (IsDir(pszDir)) {
		CDir CDirReader;
	    if (!CDirReader.Open(pszDir)) {
	        return;
		}

		std::vector<std::string> CFileName;
		CDirReader.Read(CFileName);
		for (unsigned int uiCount = 0; uiCount < CFileName.size(); ++uiCount){
			CFileName[uiCount] = "/" + CFileName[uiCount];
			CFileName[uiCount] = pszDir + CFileName[uiCount];
			Remove(CFileName[uiCount].c_str());
	    }
		CDirReader.Close();
	}
	remove(pszDir);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x950c
testb %al, %al
je 0x9656
leaq 0x185a8(%rip), %rax     # 0x21b20
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
callq 0x44a0
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x966c
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x20(%rsp), %rdi
callq 0x9430
xorl %r12d, %r12d
leaq 0xf07b(%rip), %r14      # 0x18630
leaq 0x30(%rsp), %r15
movl %r12d, %r12d
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
subq %rdx, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x9639
movq %r12, %r13
shlq $0x5, %r13
addq %r13, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x96ab
movq (%rsp), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x43a0
movq %r15, %rdi
callq 0x4160
movq (%rsp), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x96ab
movq (%rsp), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x43a0
movq %r15, %rdi
callq 0x4160
movq (%rsp), %rax
movq (%rax,%r13), %rdi
callq 0x9554
incl %r12d
jmp 0x95ba
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x9416
movq %rsp, %rdi
callq 0x8ad0
movq %r14, %rdi
callq 0x93c4
movq %rbx, %rdi
callq 0x45e0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %rdi
callq 0x93c4
jmp 0x965e
jmp 0x967e
jmp 0x967e
jmp 0x967e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8ad0
leaq 0x20(%rsp), %rdi
callq 0x93c4
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassPara.cpp
// Function: CClassPara::Parse(CLASS_S const*)
void CClassPara::Parse(const CLASS_S* pstOpt)
{
    m_strParaName = m_strName = pstOpt->m_szName;
    m_strName[0] = toupper(m_strName[0]);
    vector<string> vecMem;
    string strText = pstOpt->m_szMember;
    BT_Split(vecMem, strText, stMem);
    for_each(vecMem.begin(), vecMem.end(), TYPESEP_S(m_vecMember));
//    for_each(m_vecMember.begin(), m_vecMember.end(), stPrint);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x4640
leaq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x41c0
movq 0x8(%rbx), %r15
movsbl (%r15), %edi
callq 0x4600
movb %al, (%r15)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
addq $0x100, %r14            # imm = 0x100
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x5480
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x9c3f
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x48, %rbx
movq %rbx, %rdx
callq 0x9b65
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x8ad0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x9a1c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x8ad0
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassPara.cpp
// Function: CClassPara::GetIncDir[abi:cxx11]()
string CClassPara::GetIncDir()
{
    if (CDir::Exist("./inc/") && CDir::Exist("./src/")) {
        return string("./inc/");
    } else if (CDir::Exist("../inc/") && CDir::Exist("../src/")) {
        return string("../inc/");
    }
    return string("./");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe814(%rip), %rdi      # 0x18251
callq 0x94fc
testb %al, %al
je 0x9a64
leaq 0xe80c(%rip), %rdi      # 0x18259
callq 0x94fc
testb %al, %al
je 0x9a64
leaq 0xe7f4(%rip), %rsi      # 0x18251
leaq 0xf(%rsp), %rdx
jmp 0x9a9e
leaq 0xe7e5(%rip), %rdi      # 0x18250
callq 0x94fc
testb %al, %al
je 0x9a92
leaq 0xe7dd(%rip), %rdi      # 0x18258
callq 0x94fc
testb %al, %al
je 0x9a92
leaq 0xe7c5(%rip), %rsi      # 0x18250
leaq 0xe(%rsp), %rdx
jmp 0x9a9e
leaq 0xe7c7(%rip), %rsi      # 0x18260
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x5480
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassPara.cpp
// Function: CClassPara::GetSrcDir[abi:cxx11]()
string CClassPara::GetSrcDir()
{
    if (CDir::Exist("./src/") && CDir::Exist("./src/")) {
        return string("./src/");
    } else if (CDir::Exist("../inc/") && CDir::Exist("../src/")) {
        return string("../src/");
    }
    return string("./");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe79a(%rip), %rdi      # 0x18259
callq 0x94fc
testb %al, %al
je 0x9ae6
leaq 0xe78a(%rip), %rdi      # 0x18259
callq 0x94fc
testb %al, %al
je 0x9ae6
leaq 0xe77a(%rip), %rsi      # 0x18259
leaq 0xf(%rsp), %rdx
jmp 0x9b20
leaq 0xe763(%rip), %rdi      # 0x18250
callq 0x94fc
testb %al, %al
je 0x9b14
leaq 0xe75b(%rip), %rdi      # 0x18258
callq 0x94fc
testb %al, %al
je 0x9b14
leaq 0xe74b(%rip), %rsi      # 0x18258
leaq 0xe(%rsp), %rdx
jmp 0x9b20
leaq 0xe745(%rip), %rsi      # 0x18260
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x5480
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassDetail.cpp
// Function: CClassDetail::AddAttribute(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&)
void CClassDetail::AddAttribute(const string& strName, const string& strAttr)
{
    BT_AUTO(iterMem, m_vecAttr.begin());
    for (; iterMem != m_vecAttr.end() && (*iterMem)->GetName() != strName; ++iterMem);
    if (iterMem == m_vecAttr.end()) {
        CClassMember* pCMem = new CClassMember;
        pCMem->SetName(strName);
        pCMem->SetType("a");
        pCMem->SetAttrName(strAttr);
        m_vecAttr.push_back(pCMem);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x60(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rdi), %rbx
leaq 0x18(%rsp), %r13
cmpq 0x68(%r12), %rbx
je 0xacad
movq (%rbx), %rsi
addq $0x8, %rsi
movq %r13, %rdi
callq 0x4410
movq %r13, %rdi
movq %r15, %rsi
callq 0x10409
movl %eax, %ebp
movq %r13, %rdi
callq 0x4160
testb %bpl, %bpl
je 0xacb2
addq $0x8, %rbx
jmp 0xac77
movq %rbx, %rax
jmp 0xacb7
movq 0x68(%r12), %rax
cmpq %rax, %rbx
jne 0xad2f
pushq $0x68
popq %rdi
callq 0x42f0
movq %rax, %r12
movq %rax, %rdi
callq 0xaa30
movq %r12, 0x10(%rsp)
leaq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x41c0
leaq 0xd66b(%rip), %rsi      # 0x18353
leaq 0x18(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x5480
leaq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x41c0
leaq 0x18(%rsp), %rdi
callq 0x4160
addq $0x48, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x41c0
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x10414
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassDetail.cpp
// Function: CClassDetail::AddMember(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&)
void CClassDetail::AddMember(const string& strName, const string& strType)
{
    BT_AUTO(iterMem, m_vecMem.begin());
    for (; iterMem != m_vecMem.end() && (*iterMem)->GetName() != strName; ++iterMem);
    if (iterMem == m_vecMem.end()) {
        CClassMember* pCMem = new CClassMember;
        pCMem->SetName(strName);
        pCMem->SetType("c");
        m_vecMem.push_back(pCMem);
    } else {
        CClassMember* pCMem = *iterMem;
        if (strType == "c+" && strType != pCMem->GetType()) {
            pCMem->SetType("c+");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x48(%rdi), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rdi), %rbx
leaq 0x10(%rsp), %r13
cmpq 0x50(%r12), %rbx
je 0xadb3
movq (%rbx), %rsi
addq $0x8, %rsi
movq %r13, %rdi
callq 0x4410
movq %r13, %rdi
movq %r15, %rsi
callq 0x10409
movl %eax, %ebp
movq %r13, %rdi
callq 0x4160
testb %bpl, %bpl
je 0xadb8
addq $0x8, %rbx
jmp 0xad7d
movq %rbx, %rax
jmp 0xadbd
movq 0x50(%r12), %rax
cmpq %rax, %rbx
je 0xae3d
movq (%rbx), %rbx
leaq 0xd2f1(%rip), %rsi      # 0x180bd
movq %r14, %rdi
callq 0x10431
testb %al, %al
je 0xaea1
addq $0x28, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4410
movq %r14, %rdi
movq %r15, %rsi
callq 0x10409
movl %eax, %ebp
movq %r15, %rdi
callq 0x4160
testb %bpl, %bpl
je 0xaea1
leaq 0xd2a8(%rip), %rsi      # 0x180bd
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5480
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x41c0
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0xaea1
pushq $0x68
popq %rdi
callq 0x42f0
movq %rax, %r14
movq %rax, %rdi
callq 0xaa30
movq %r14, 0x8(%rsp)
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x41c0
leaq 0xdc4c(%rip), %rsi      # 0x18ab4
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5480
addq $0x28, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x41c0
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x10414
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaeb4
jmp 0xaec3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0xaec6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassDetail.cpp
// Function: CClassDetail::GetChildren()
vector<CClassDetail *> CClassDetail::GetChildren()
{
    vector<CClassDetail *> vecChildren;
    for (BT_AUTO(iterChild, m_mapChildren.begin()); iterChild != m_mapChildren.end(); ++iterChild) {
        vecChildren.push_back(iterChild->second);
    }
    return vecChildren;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x90(%rsi), %r15
subq $-0x80, %r14
cmpq %r14, %r15
je 0xaf0d
leaq 0x40(%r15), %rsi
movq %rbx, %rdi
callq 0x6720
movq %r15, %rdi
callq 0x41f0
movq %rax, %r15
jmp 0xaeef
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6ee2
movq %r14, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassDetail.cpp
// Function: CClassDetail::Print()
void CClassDetail::Print()
{
    cout << "node name:"<< m_strName << "\t" << m_strType << endl;
    for (unsigned int uiCount = 0; uiCount < m_vecMem.size(); ++uiCount) {
        m_vecMem[uiCount]->Print();
    }
    for (unsigned int uiCount = 0; uiCount < m_vecAttr.size(); ++uiCount) {
        m_vecAttr[uiCount]->Print();
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x11c52(%rip), %rdi     # 0x21fc8
leaq 0x87d0(%rip), %rsi      # 0x18b4d
callq 0x42e0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x4270
leaq 0x8154(%rip), %rsi      # 0x184e9
movq %rax, %rdi
callq 0x42e0
leaq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x4270
movq %rax, %rdi
callq 0x4180
xorl %eax, %eax
movl %eax, %r14d
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x103d9
movq (%rax,%r14,8), %rdi
callq 0xab06
leal 0x1(%r14), %eax
jmp 0x103b3
xorl %eax, %eax
movl %eax, %r14d
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x10401
movq (%rax,%r14,8), %rdi
callq 0xab06
leal 0x1(%r14), %eax
jmp 0x103db
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetDate[abi:cxx11]()
string CClassCont::GetDate()
{
    time_t timeNow = time(NULL);
    struct tm stTm;
    localtime_r(&timeNow, &stTm);
    ostringstream ossDate;
    ossDate << 1900 + stTm.tm_year  << "-" << (stTm.tm_mon < 9 ? "0" : "") << stTm.tm_mon + 1 << "-" << \
        (stTm.tm_mday < 10 ? "0" : "") << stTm.tm_mday;
    return ossDate.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, %rbx
xorl %edi, %edi
callq 0x42b0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x41a0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x4400
movl $0x76c, %esi            # imm = 0x76C
addl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x45b0
leaq 0x7d17(%rip), %rsi      # 0x18cff
movq %rax, %rdi
callq 0x42e0
cmpl $0x9, 0x20(%rsp)
leaq 0x7d05(%rip), %r15      # 0x18d01
leaq 0x74e7(%rip), %r14      # 0x184ea
movq %r14, %rsi
cmovlq %r15, %rsi
movq %rax, %rdi
callq 0x42e0
movl 0x20(%rsp), %esi
incl %esi
movq %rax, %rdi
callq 0x45b0
leaq 0x7cd8(%rip), %rsi      # 0x18cff
movq %rax, %rdi
callq 0x42e0
cmpl $0xa, 0x1c(%rsp)
cmovlq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x42e0
movl 0x1c(%rsp), %esi
movq %rax, %rdi
callq 0x45b0
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x4500
leaq 0x48(%rsp), %rdi
callq 0x40b0
movq %rbx, %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x40b0
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::IncSet(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&)
string CClassCont::IncSet(const string& strType, const string& strName)
{
    string strCont = Inc("void", \
                         string("Set") + ToName(strName), \
                         string("const ") + strType + "&", \
                         ToVar(strType, strName)\
                        );
    MergeSpace(strCont);
    return string("\t\t") + strCont;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x7750(%rip), %rsi      # 0x18cb1
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
callq 0x5480
leaq 0x77d1(%rip), %rsi      # 0x18d48
leaq 0x118(%rsp), %rdi
leaq 0x16(%rsp), %rdx
callq 0x5480
leaq 0xf8(%rsp), %rdi
movq %r14, %rdx
callq 0x11950
leaq 0x38(%rsp), %rdi
leaq 0x118(%rsp), %rsi
leaq 0xf8(%rsp), %rdx
callq 0x8a12
leaq 0x77f1(%rip), %rsi      # 0x18dab
leaq 0x98(%rsp), %rdi
leaq 0x15(%rsp), %rdx
callq 0x5480
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
movq %r15, %rdx
callq 0x8a79
leaq 0x76cb(%rip), %rdx      # 0x18cb6
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1046a
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1197e
andl $0x0, (%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0xd8(%rsp), %r8
leaq 0x78(%rsp), %r9
callq 0x1179c
leaq 0x78(%rsp), %rdi
callq 0x4160
leaq 0xd8(%rsp), %rdi
callq 0x4160
leaq 0xb8(%rsp), %rdi
callq 0x4160
leaq 0x98(%rsp), %rdi
callq 0x4160
leaq 0x38(%rsp), %rdi
callq 0x4160
leaq 0xf8(%rsp), %rdi
callq 0x4160
leaq 0x118(%rsp), %rdi
callq 0x4160
leaq 0x18(%rsp), %rdi
callq 0x4160
leaq 0x58(%rsp), %rsi
callq 0x11bea
leaq 0x6e40(%rip), %rsi      # 0x184e8
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x5480
leaq 0x18(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a79
leaq 0x18(%rsp), %rdi
callq 0x4160
leaq 0x58(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4160
jmp 0x11703
jmp 0x11700
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x1177b
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4160
jmp 0x1171c
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x4160
jmp 0x1172e
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x4160
jmp 0x11740
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x4160
jmp 0x11752
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4160
leaq 0xf8(%rsp), %rdi
callq 0x4160
leaq 0x118(%rsp), %rdi
callq 0x4160
leaq 0x18(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
movq %rax, %rbx
jmp 0x1175c
movq %rax, %rbx
jmp 0x11769
movq %rax, %rbx
jmp 0x11776
movq %rax, %rbx
jmp 0x11780
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::Inc(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&, bool)
string CClassCont::Inc(const string& strRet, const string& strName, const string& strType, const string& strPara, bool bConst)
{
    string strCont = string("inline ")+strRet + " " + strName + "(";
    if (!strType.empty()) {
        strCont += strType + " " + strPara;
    }
    strCont += ")";
    if (bConst) {
        strCont += " const";
    }
    strCont += ";";
    return strCont;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x751f(%rip), %rsi      # 0x18ce1
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5480
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r13, %rdx
callq 0x8a79
leaq 0x756b(%rip), %rdx      # 0x18d55
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1046a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x8a79
leaq 0x7570(%rip), %rdx      # 0x18d82
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x1046a
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x70(%rsp), %rdi
callq 0x4160
leaq 0x50(%rsp), %rdi
callq 0x4160
cmpq $0x0, 0x8(%r15)
je 0x11895
leaq 0x7500(%rip), %rdx      # 0x18d55
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x8a98
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x8a79
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x4650
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x6cc2(%rip), %rsi      # 0x1855e
movq %rbx, %rdi
callq 0x4630
cmpb $0x0, 0xc0(%rsp)
je 0x118bd
leaq 0x7434(%rip), %rsi      # 0x18ce9
movq %rbx, %rdi
callq 0x4630
leaq 0x6afb(%rip), %rsi      # 0x183bf
movq %rbx, %rdi
callq 0x4630
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x4160
jmp 0x118f2
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x1193f
jmp 0x1193c
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x4160
jmp 0x11912
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x11921
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x4160
jmp 0x11930
movq %rax, %r14
leaq 0x50(%rsp), %rdi
jmp 0x11942
movq %rax, %r14
jmp 0x11947
movq %rax, %r14
movq %rbx, %rdi
callq 0x4160
movq %r14, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::MergeSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CClassCont::MergeSpace(string& strCont)
{
    size_t zuPos =  isspace(strCont[0]) != 0 ? 0 : string::npos;
    for (size_t zuCount = 1; zuCount < strCont.length(); ++zuCount) {
        if (isspace(strCont[zuCount - 1]) != 0 && isspace(strCont[zuCount]) != 0) {
            if (zuPos == string::npos) {
                zuPos = zuCount;
            }
            continue;
        } else if (zuPos != string::npos){
            strCont[zuPos ++] = strCont[zuCount];
        }
    }
    strCont = strCont.substr(0, zuPos);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movsbl (%rax), %edi
callq 0x4060
xorl %r14d, %r14d
cmpl $0x1, %eax
sbbq %r14, %r14
pushq $0x1
popq %r15
pushq $-0x1
popq %r12
cmpq 0x8(%rbx), %r15
jae 0x11c68
movq (%rbx), %r13
movsbl -0x1(%r13,%r15), %edi
callq 0x4060
testl %eax, %eax
je 0x11c47
movsbl (%r13,%r15), %edi
callq 0x4060
testl %eax, %eax
je 0x11c47
cmpq $-0x1, %r14
cmoveq %r15, %r14
jmp 0x11c5d
movq %r12, %rax
cmpq $-0x1, %r14
je 0x11c60
movb (%r13,%r15), %al
movb %al, (%r13,%r14)
incq %r14
movq %r14, %rax
incq %r15
movq %rax, %r14
jmp 0x11c16
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x4320
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43a0
movq %r15, %rdi
callq 0x4160
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::IncAdd(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&)
string CClassCont::IncAdd(const string& strType, const string& strName)
{
    string strCont = Inc("void", \
                         string("Add") + ToName(strName), \
                         string("const ") + strType + "&", \
                         ToVar(strType, strName)\
                        );
    MergeSpace(strCont);
    return string("\t\t") + strCont;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x6ff4(%rip), %rsi      # 0x18cb1
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
callq 0x5480
leaq 0x7098(%rip), %rsi      # 0x18d6b
leaq 0x118(%rsp), %rdi
leaq 0x16(%rsp), %rdx
callq 0x5480
leaq 0xf8(%rsp), %rdi
movq %r14, %rdx
callq 0x11950
leaq 0x38(%rsp), %rdi
leaq 0x118(%rsp), %rsi
leaq 0xf8(%rsp), %rdx
callq 0x8a12
leaq 0x7095(%rip), %rsi      # 0x18dab
leaq 0x98(%rsp), %rdi
leaq 0x15(%rsp), %rdx
callq 0x5480
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
movq %r15, %rdx
callq 0x8a79
leaq 0x6f6f(%rip), %rdx      # 0x18cb6
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1046a
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1197e
andl $0x0, (%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0xd8(%rsp), %r8
leaq 0x78(%rsp), %r9
callq 0x1179c
leaq 0x78(%rsp), %rdi
callq 0x4160
leaq 0xd8(%rsp), %rdi
callq 0x4160
leaq 0xb8(%rsp), %rdi
callq 0x4160
leaq 0x98(%rsp), %rdi
callq 0x4160
leaq 0x38(%rsp), %rdi
callq 0x4160
leaq 0xf8(%rsp), %rdi
callq 0x4160
leaq 0x118(%rsp), %rdi
callq 0x4160
leaq 0x18(%rsp), %rdi
callq 0x4160
leaq 0x58(%rsp), %rsi
callq 0x11bea
leaq 0x66e4(%rip), %rsi      # 0x184e8
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x5480
leaq 0x18(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a79
leaq 0x18(%rsp), %rdi
callq 0x4160
leaq 0x58(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4160
jmp 0x11e5f
jmp 0x11e5c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x11ed7
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4160
jmp 0x11e78
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x4160
jmp 0x11e8a
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x4160
jmp 0x11e9c
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x4160
jmp 0x11eae
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4160
leaq 0xf8(%rsp), %rdi
callq 0x4160
leaq 0x118(%rsp), %rdi
callq 0x4160
leaq 0x18(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
movq %rax, %rbx
jmp 0x11eb8
movq %rax, %rbx
jmp 0x11ec5
movq %rax, %rbx
jmp 0x11ed2
movq %rax, %rbx
jmp 0x11edc
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::IncGet(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&)
string CClassCont::IncGet(const string& strType, const string& strName)
{
    string strCont = Inc(string("const ") + strType + "&", \
                         string("Get") + ToName(strName), \
                         "",\
                         ""
                        );
    MergeSpace(strCont);
    return string("\t\t") + strCont;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x6e97(%rip), %rsi      # 0x18dab
leaq 0x110(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5480
leaq 0x30(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movq %r15, %rdx
callq 0x8a79
leaq 0x6d74(%rip), %rdx      # 0x18cb6
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1046a
leaq 0x64ec(%rip), %rsi      # 0x18444
leaq 0xd0(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x5480
leaq 0xb0(%rsp), %rdi
movq %r14, %rdx
callq 0x11950
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x8a12
leaq 0x654c(%rip), %rsi      # 0x184ea
leaq 0x90(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x5480
leaq 0x6533(%rip), %rsi      # 0x184ea
leaq 0x70(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x5480
andl $0x0, (%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xf0(%rsp), %rcx
leaq 0x90(%rsp), %r8
leaq 0x70(%rsp), %r9
callq 0x1179c
leaq 0x70(%rsp), %rdi
callq 0x4160
leaq 0x90(%rsp), %rdi
callq 0x4160
leaq 0xf0(%rsp), %rdi
callq 0x4160
leaq 0xb0(%rsp), %rdi
callq 0x4160
leaq 0xd0(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x110(%rsp), %rdi
callq 0x4160
leaq 0x50(%rsp), %rsi
callq 0x11bea
leaq 0x648a(%rip), %rsi      # 0x184e8
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x5480
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a79
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x50(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x120b7
jmp 0x120b4
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x1212f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4160
jmp 0x120d0
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x4160
jmp 0x120e2
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x4160
jmp 0x120f4
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x4160
jmp 0x12106
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x110(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
movq %rax, %rbx
jmp 0x12113
movq %rax, %rbx
jmp 0x1211d
movq %rax, %rbx
jmp 0x12127
movq %rax, %rbx
jmp 0x12134
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::IncGetConst(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&)
string CClassCont::IncGetConst(const string& strType, const string& strName)
{
    string strCont = Inc(string("const ") + strType + "&", \
                         string("Get") + ToName(strName), \
                         "",\
                         "",\
                         true\
                        );
    MergeSpace(strCont);
    return string("\t\t") + strCont;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x6c3f(%rip), %rsi      # 0x18dab
leaq 0x110(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5480
leaq 0x30(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movq %r15, %rdx
callq 0x8a79
leaq 0x6b1c(%rip), %rdx      # 0x18cb6
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1046a
leaq 0x6294(%rip), %rsi      # 0x18444
leaq 0xd0(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x5480
leaq 0xb0(%rsp), %rdi
movq %r14, %rdx
callq 0x11950
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x8a12
leaq 0x62f4(%rip), %rsi      # 0x184ea
leaq 0x90(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x5480
leaq 0x62db(%rip), %rsi      # 0x184ea
leaq 0x70(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x5480
movl $0x1, (%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xf0(%rsp), %rcx
leaq 0x90(%rsp), %r8
leaq 0x70(%rsp), %r9
callq 0x1179c
leaq 0x70(%rsp), %rdi
callq 0x4160
leaq 0x90(%rsp), %rdi
callq 0x4160
leaq 0xf0(%rsp), %rdi
callq 0x4160
leaq 0xb0(%rsp), %rdi
callq 0x4160
leaq 0xd0(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x110(%rsp), %rdi
callq 0x4160
leaq 0x50(%rsp), %rsi
callq 0x11bea
leaq 0x622f(%rip), %rsi      # 0x184e8
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x5480
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a79
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x50(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x12312
jmp 0x1230f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x1238a
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4160
jmp 0x1232b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x4160
jmp 0x1233d
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x4160
jmp 0x1234f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x4160
jmp 0x12361
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x30(%rsp), %rdi
callq 0x4160
leaq 0x110(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
movq %rax, %rbx
jmp 0x1236e
movq %rax, %rbx
jmp 0x12378
movq %rax, %rbx
jmp 0x12382
movq %rax, %rbx
jmp 0x1238f
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetPrev(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CClassCont::GetPrev(const string& strType)
{
    map<string, string>::iterator iterPrev = m_mapPrev.find(strType);
    if (iterPrev != m_mapPrev.end()) {
        return iterPrev->second;
    }
    if (strType[0] == 'C') {
        return "C";
    }
    if (BT_EndsWith(strType, "_S")) {
        return "st";
    }
    if (BT_StartsWith(strType, "vector")) {
        return "vec";
    }
    return string();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x5af4
addq $0x10, %r15
cmpq %r15, %rax
je 0x125be
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4410
jmp 0x1261c
movq (%r14), %rax
cmpb $0x43, (%rax)
jne 0x125d4
leaq 0x5d9b(%rip), %rsi      # 0x18368
leaq 0xf(%rsp), %rdx
jmp 0x12614
leaq 0x6721(%rip), %rsi      # 0x18cfc
movq %r14, %rdi
callq 0x14e21
testb %al, %al
je 0x125f5
leaq 0x66ff(%rip), %rsi      # 0x18ced
leaq 0xe(%rsp), %rdx
jmp 0x12614
leaq 0x65a7(%rip), %rsi      # 0x18ba3
movq %r14, %rdi
callq 0x14e91
testb %al, %al
je 0x12629
leaq 0x64a3(%rip), %rsi      # 0x18ab2
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x5480
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x1261c
nop
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetMacroIfndef(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CClassCont::GetMacroIfndef(const string& strName)
{
    string strMacro = BT_ToUpperCopy(strName);
    BT_ReplaceAll(strMacro, ".", "_");
    strMacro += "_";
    return string("#ifndef ") + strMacro + "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x4690
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x14edc
leaq 0x10(%rsp), %rdi
callq 0x4450
leaq 0x5bcf(%rip), %rsi      # 0x18248
leaq 0x66db(%rip), %rdx      # 0x18d5b
leaq 0x30(%rsp), %rdi
callq 0x14c56
leaq 0x66ca(%rip), %rsi      # 0x18d5b
leaq 0x30(%rsp), %rdi
callq 0x4630
leaq 0x6661(%rip), %rsi      # 0x18d03
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5480
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x8a79
leaq 0x671e(%rip), %rdx      # 0x18dea
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1046a
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x50(%rsp), %rdi
callq 0x4160
leaq 0x30(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x12716
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4160
jmp 0x12736
jmp 0x12733
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4450
jmp 0x12740
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetMacroDefine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CClassCont::GetMacroDefine(const string& strName)
{
    string strMacro = BT_ToUpperCopy(strName);
    BT_ReplaceAll(strMacro, ".", "_");
    strMacro += "_";
    return string("#define ") + strMacro + "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x4690
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x14edc
leaq 0x10(%rsp), %rdi
callq 0x4450
leaq 0x5ac3(%rip), %rsi      # 0x18248
leaq 0x65cf(%rip), %rdx      # 0x18d5b
leaq 0x30(%rsp), %rdi
callq 0x14c56
leaq 0x65be(%rip), %rsi      # 0x18d5b
leaq 0x30(%rsp), %rdi
callq 0x4630
leaq 0x655e(%rip), %rsi      # 0x18d0c
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5480
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x8a79
leaq 0x6612(%rip), %rdx      # 0x18dea
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1046a
leaq 0x10(%rsp), %rdi
callq 0x4160
leaq 0x50(%rsp), %rdi
callq 0x4160
leaq 0x30(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x12822
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4160
jmp 0x12842
jmp 0x1283f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4450
jmp 0x1284c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::SrcCore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CClassCont::SrcCore(const string& strClass)
{
    return \
        string("/*******************************************************************************\n") + \
        string(" * thread interface\n") + \
        string(" *******************************************************************************/\n") +\
        strClass + string("::Core()\n{\n}\n");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x417b(%rip), %rsi      # 0x18bae
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5480
leaq 0x43c3(%rip), %rsi      # 0x18e0c
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x5480
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x8a12
leaq 0x41ba(%rip), %rsi      # 0x18c30
leaq 0x28(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x5480
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x8a12
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movq %r14, %rdx
callq 0x8a79
leaq 0x4363(%rip), %rsi      # 0x18e21
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x5480
leaq 0xc8(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a12
leaq 0x8(%rsp), %rdi
callq 0x4160
leaq 0xc8(%rsp), %rdi
callq 0x4160
leaq 0xa8(%rsp), %rdi
callq 0x4160
leaq 0x28(%rsp), %rdi
callq 0x4160
leaq 0x88(%rsp), %rdi
callq 0x4160
leaq 0x48(%rsp), %rdi
callq 0x4160
leaq 0x68(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4160
jmp 0x14b51
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x4160
jmp 0x14b63
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x4160
jmp 0x14b75
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4160
jmp 0x14b84
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4160
leaq 0x48(%rsp), %rdi
callq 0x4160
leaq 0x68(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
movq %rax, %rbx
jmp 0x14b91
movq %rax, %rbx
jmp 0x14b9b
nop
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]split/splittest.cpp
// Function: main
int main(void) {
    string str = "this will be split on\ttabs\tand spaces";
    vector<string> s = split(str, " \t");
    for (vector<string>::iterator c = s.begin(); c != s.end(); ++c) {
        cout << *c << endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0xce6(%rip), %rsi       # 0x3004
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x23d0
leaq 0xcf8(%rip), %rsi       # 0x302a
leaq -0x50(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x23d0
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x26f7
leaq -0x50(%rbp), %rdi
callq 0x2070
movq -0x30(%rbp), %rbx
movq 0x2c74(%rip), %r14      # 0x4fd8
cmpq -0x28(%rbp), %rbx
je 0x2383
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
addq $0x20, %rbx
jmp 0x2364
leaq -0x30(%rbp), %rdi
callq 0x240c
leaq -0x70(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2070
jmp 0x23bf
movq %rax, %rbx
jmp 0x23bf
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x240c
leaq -0x70(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/example.cpp
// Function: main
int main()
{
    // build the vector for requests
    vector<Request> reqs;
    off_t offs[] = {0,3,7,14,17,21,28,31,35,42,46,50,54,58};
    off_t lens[] = {2,2,2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
    
    int n = sizeof(offs)/sizeof(off_t);
    int i;
    for ( i = 0 ; i < n ; i++ ) {
        reqs.push_back( Request( offs[i], lens[i] ) ); 
    }

    // check the requests, just to make sure
    cout << "*** Offset;Length ***" << endl;
    vector<Request>::iterator it;
    for ( it = reqs.begin() ; it != reqs.end() ; it++ ) {
        cout << it->offset << ";" << it->length << endl;
    }

    // OK, detect and show the patterns
    cout << endl;
    cout << "*** Pattern Found ***" << endl;
    RequestPatternList plist;
    PatternUtil::getReqPatList( reqs, plist );
    cout << plist.show() << endl;

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
xorl %r12d, %r12d
leaq 0x2cef(%rip), %r13      # 0x5010
leaq 0x40(%rsp), %r14
pushq $0x2
popq %r15
cmpq $0x70, %r12
je 0x2350
movq (%r12,%r13), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x29b6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26e4
addq $0x8, %r12
jmp 0x232a
movq 0x5c81(%rip), %rdi      # 0x7fd8
leaq 0x2d22(%rip), %rsi      # 0x5080
callq 0x2110
movq %rax, %rdi
callq 0x2090
movq (%rsp), %r15
movq 0x5c62(%rip), %rbx      # 0x7fd8
leaq 0x2d19(%rip), %r14      # 0x5096
cmpq 0x8(%rsp), %r15
je 0x23b4
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
movq %r14, %rsi
callq 0x2110
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
addq $0x10, %r15
jmp 0x237d
movq 0x5c1d(%rip), %rdi      # 0x7fd8
callq 0x2090
movq 0x5c11(%rip), %rdi      # 0x7fd8
leaq 0x2cca(%rip), %rsi      # 0x5098
callq 0x2110
movq %rax, %rdi
callq 0x2090
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rsp, %rdi
callq 0x2e56
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x37c8
movq 0x5bcf(%rip), %rdi      # 0x7fd8
leaq 0x40(%rsp), %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
leaq 0x40(%rsp), %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x2480
movq %rsp, %rdi
callq 0x26b0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2449
movq %rax, %rbx
jmp 0x245b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x2480
jmp 0x2470
jmp 0x246d
jmp 0x246d
jmp 0x246d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26b0
movq %rbx, %rdi
callq 0x21a0