LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xa8, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movl 0x408(%rdi), %eax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x8017
shlq $0x5, 0x20(%rsp)
xorl %ebp, %ebp
leaq 0x60(%rsp), %rbx
movb 0x20(%r12,%rbp), %r13b
movq %rbx, %rdi
callq 0x4140
movb %r13b, 0x60(%rsp,%rax)
cmpl $0x0, 0x10(%r12,%rbp)
je 0x800c
movq %rbx, %rdi
callq 0x4140
movb $0x3a, 0x60(%rsp,%rax)
addq $0x20, %rbp
cmpq %rbp, 0x20(%rsp)
jne 0x7fe5
addq $0x8, %r12
leaq 0x40(%rsp), %rbp
leaq 0x60(%rsp), %r13
movq %r15, 0x50(%rsp)
movl (%r15), %edi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x4530
cmpl $0x3f, %eax
je 0x802a
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x8134
movq %r12, %r13
movq %r14, %r15
movq %rbp, %r14
movq 0x27f4a(%rip), %rax     # 0x2ffa8
movq (%rax), %rbp
testq %rbp, %rbp
leaq 0x1f495(%rip), %rax     # 0x27500
cmoveq %rax, %rbp
leaq 0x10(%rsp), %r12
movq %r12, (%rsp)
movq %rbp, %rdi
callq 0x4140
leaq (%rax,%rbp), %rdx
movq %rsp, %rdi
movq %rbp, %rsi
movq %r14, %rbp
callq 0x618a
movl %ebx, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq (%rsp), %rax
cmpq %r12, %rax
je 0x80b5
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x80be
movups (%r12), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8176
movq %r15, %r14
movq %r13, %r12
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
movq 0x50(%rsp), %r15
leaq 0x60(%rsp), %r13
je 0x8110
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42f0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x802a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42f0
jmp 0x802a
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8160
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4807
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x621c
addq $0x4, %rbx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6234
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6684
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x8504
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x93c4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x84c0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x8(%rsp), %rdi
callq 0x6228
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x84f1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x84f1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x8(%rsp), %rdi
callq 0x6228
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, (%rdx)
jle 0xa0e8
xorl %ebp, %ebp
movl $0x2d, %edi
callq 0x4400
incl %ebp
cmpl (%rbx), %ebp
jl 0xa0d8
movl $0xa, %edi
callq 0x4400
movq %r15, %rdi
callq 0x1936a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xce8a
movq (%r12), %rdi
cmpq %rdi, 0x8(%r12)
je 0xa14d
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
movq (%rdi,%r12,8), %rsi
movl (%rbx), %eax
incl %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0xa0bc
incq %r12
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rax, %r12
jb 0xa11d
testq %rdi, %rdi
je 0xa15f
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa186
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x8(%rsp)
movq %rdi, %r14
movq %rsp, %r15
movq $0x0, (%r15)
movq 0x8(%rdi), %rdi
leaq 0x30(%rsp), %rsi
movq %r15, %rdx
callq 0x4100
movl %eax, %ecx
cmpq $0x0, (%r15)
sete %al
je 0xad49
testl %ecx, %ecx
jne 0xad49
leaq 0x43(%rsp), %r15
leaq 0x20(%rsp), %rbx
leaq 0x30(%rsp), %r12
movq %rsp, %r13
leaq 0x10(%rsp), %rbp
cmpw $0x2e, 0x43(%rsp)
je 0xad2a
movzwl 0x43(%rsp), %eax
xorl $0x2e2e, %eax           # imm = 0x2E2E
movzbl 0x45(%rsp), %ecx
orw %ax, %cx
je 0xad2a
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
callq 0x4140
leaq (%rax,%r15), %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x618a
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xb060
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xad2a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x8(%r14), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4100
movl %eax, %ecx
cmpq $0x0, (%rsp)
sete %al
je 0xad49
testl %ecx, %ecx
je 0xacce
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xad75
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x41b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4280
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%r14), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0xaf7d
leaq 0x24cec(%rip), %r15     # 0x2fb10
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4480
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xaf5c
movq %r14, 0x30(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rsp, %rdi
callq 0xac6c
movq 0x10(%rsp), %rdx
cmpq %rdx, 0x18(%rsp)
je 0xaf35
leaq 0x48(%rsp), %rbp
movl $0x1, %r13d
xorl %r14d, %r14d
leaq 0x1c7b7(%rip), %r15     # 0x27646
leaq 0x38(%rsp), %r12
shlq $0x5, %r14
addq %r14, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xafd7
movq 0x10(%rsp), %rdi
addq %r14, %rdi
movq %r12, %rsi
callq 0x43b0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0xaecd
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x10(%rsp), %rdx
addq %r14, %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xafd7
movq 0x10(%rsp), %rdi
addq %r14, %rdi
movq %r12, %rsi
callq 0x43b0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0xaf07
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x10(%rsp), %rax
movq (%rax,%r14), %rdi
callq 0xadd6
movl %r13d, %r14d
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
subq %rdx, %rax
sarq $0x5, %rax
incl %r13d
cmpq %r14, %rax
ja 0xae94
movq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x44f0
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xa1d2
leaq 0x24bb4(%rip), %r15     # 0x2fb10
movq %r15, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaf78
callq 0x44f0
movq $0x0, 0x8(%rsp)
testq %r14, %r14
je 0xaf85
movq %rbx, %rdi
callq 0x45c0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaf9d
jmp 0xaf9d
jmp 0xaf9d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa1d2
leaq 0x24b5f(%rip), %rax     # 0x2fb10
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x44f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
movq %rsi, %rdi
callq 0x4140
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x44c0
leaq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x41a0
movq 0x8(%rbx), %r15
movsbl (%r15), %edi
callq 0x45e0
movb %al, (%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x100(%r14), %r15
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x4140
leaq (%r14,%rax), %rdx
addq $0x100, %rdx            # imm = 0x100
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x618a
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0xb70a
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x48, %rbx
movq %rbx, %rdx
callq 0xb5d9
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xb42c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rsp, %rdi
callq 0xa1d2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xb45f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xb45f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rsp, %rdi
callq 0xa1d2
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x1bdec(%rip), %rdi     # 0x27267
callq 0xad7e
testb %al, %al
je 0xb4ab
leaq 0x1bde4(%rip), %rdi     # 0x2726f
callq 0xad7e
testb %al, %al
je 0xb4ab
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bdc5(%rip), %rsi     # 0x27267
leaq 0x1bdc4(%rip), %rdx     # 0x2726d
jmp 0xb4f7
leaq 0x1bdb4(%rip), %rdi     # 0x27266
callq 0xad7e
testb %al, %al
je 0xb4e2
leaq 0x1bdac(%rip), %rdi     # 0x2726e
callq 0xad7e
testb %al, %al
je 0xb4e2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd8d(%rip), %rsi     # 0x27266
leaq 0x1bd8d(%rip), %rdx     # 0x2726d
jmp 0xb4f7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd86(%rip), %rsi     # 0x27276
leaq 0x1bd81(%rip), %rdx     # 0x27278
movq %rbx, %rdi
callq 0x618a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x1bd60(%rip), %rdi     # 0x2726f
callq 0xad7e
testb %al, %al
je 0xb53f
leaq 0x1bd50(%rip), %rdi     # 0x2726f
callq 0xad7e
testb %al, %al
je 0xb53f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd39(%rip), %rsi     # 0x2726f
leaq 0x1bd38(%rip), %rdx     # 0x27275
jmp 0xb58b
leaq 0x1bd20(%rip), %rdi     # 0x27266
callq 0xad7e
testb %al, %al
je 0xb576
leaq 0x1bd18(%rip), %rdi     # 0x2726e
callq 0xad7e
testb %al, %al
je 0xb576
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd01(%rip), %rsi     # 0x2726e
leaq 0x1bd01(%rip), %rdx     # 0x27275
jmp 0xb58b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bcf2(%rip), %rsi     # 0x27276
leaq 0x1bced(%rip), %rdx     # 0x27278
movq %rbx, %rdi
callq 0x618a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x60(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rdi), %rbp
leaq 0x28(%rsp), %r14
movq 0x68(%rbx), %r15
cmpq %r15, %rbp
je 0xca9a
movq (%rbp), %rax
movq %r14, 0x18(%rsp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x5c16
movq 0x20(%rsp), %rdx
movb $0x1, %r13b
cmpq 0x8(%r12), %rdx
jne 0xca9d
testq %rdx, %rdx
je 0xca9a
movq (%r12), %rsi
movq 0x18(%rsp), %rdi
callq 0x4300
testl %eax, %eax
setne %r13b
jmp 0xca9d
xorl %r13d, %r13d
cmpq %r15, %rbp
je 0xcab9
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0xcab9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
addq $0x8, %rbp
testb %r13b, %r13b
jne 0xca49
addq $-0x8, %rbp
cmpq 0x68(%rbx), %rbp
jne 0xcba8
movl $0x68, %edi
callq 0x42e0
leaq 0x2321f(%rip), %rcx     # 0x2fd00
movq %rcx, (%rax)
leaq 0x8(%rax), %rdi
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), %rdx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
movq %rax, (%rsp)
movq %r12, %rsi
callq 0x41a0
movq (%rsp), %r12
leaq 0x48(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a832(%rip), %rsi     # 0x27369
leaq 0x1a82c(%rip), %rdx     # 0x2736a
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0x618a
addq $0x28, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x41a0
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0xcb71
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42f0
movq (%rsp), %rdi
addq $0x48, %rdi
movq 0x10(%rsp), %rsi
callq 0x41a0
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0xcb9b
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0xcba8
movq %rsp, %rdx
movq 0x8(%rsp), %rdi
callq 0x194e8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0xcbd1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x90(%rsi), %r15
subq $-0x80, %r14
cmpq %r14, %r15
je 0xcee6
leaq 0x40(%r15), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xcece
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0xced6
movq %rbx, %rdi
callq 0x795a
movq %r15, %rdi
callq 0x41e0
movq %rax, %r15
cmpq %r14, %rax
jne 0xceb3
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xcf06
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x16c50(%rip), %r14     # 0x2ffc8
leaq 0xe7e4(%rip), %rsi      # 0x27b63
movl $0xa, %edx
movq %r14, %rdi
callq 0x4370
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x4370
movq %rax, %r14
leaq 0xe159(%rip), %rsi      # 0x274ff
movl $0x1, %edx
movq %rax, %rdi
callq 0x4370
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r14, %rdi
callq 0x4370
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41d0
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x1941f
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0xc83e
movl %ebp, %ecx
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x193fe
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x19451
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0xc83e
movl %ebp, %ecx
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x19430
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
xorl %edi, %edi
callq 0x42a0
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x4170
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x43f0
movl $0x76c, %esi            # imm = 0x76C
addl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x4580
movq %rax, %r15
leaq 0xd2da(%rip), %rsi      # 0x27d15
movl $0x1, %edx
movq %rax, %rdi
callq 0x4370
xorl %edx, %edx
cmpl $0x9, 0x18(%rsp)
setl %dl
leaq 0xd2be(%rip), %r12      # 0x27d17
leaq 0xcaa0(%rip), %r14      # 0x27500
movq %r14, %rsi
cmovlq %r12, %rsi
movq %r15, %rdi
callq 0x4370
movl 0x18(%rsp), %esi
incl %esi
movq %r15, %rdi
callq 0x4580
movq %rax, %r15
leaq 0xd28e(%rip), %rsi      # 0x27d15
movl $0x1, %edx
movq %rax, %rdi
callq 0x4370
xorl %edx, %edx
cmpl $0xa, 0x14(%rsp)
setl %dl
cmovlq %r12, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4370
movl 0x14(%rsp), %esi
movq %r15, %rdi
callq 0x4580
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x154f3(%rip), %rsi     # 0x2ffc0
leaq 0x40(%rsp), %rdi
callq 0x4190
leaq 0xb0(%rsp), %rdi
callq 0x40f0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x154c0(%rip), %rsi     # 0x2ffc0
leaq 0x40(%rsp), %rdi
callq 0x4190
leaq 0xb0(%rsp), %rdi
callq 0x40f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movsbl (%rax), %edi
callq 0x4070
xorl %r14d, %r14d
cmpl $0x1, %eax
sbbq %r14, %r14
cmpq $0x2, 0x8(%rbx)
jb 0x1c7cc
movl $0x1, %r15d
movq (%rbx), %r12
movsbl -0x1(%r12,%r15), %edi
callq 0x4070
testl %eax, %eax
je 0x1c7a9
movsbl (%r12,%r15), %edi
callq 0x4070
testl %eax, %eax
je 0x1c7a9
cmpq $-0x1, %r14
cmoveq %r15, %r14
jmp 0x1c7c3
cmpq $-0x1, %r14
je 0x1c7bc
movb (%r12,%r15), %al
movb %al, (%r12,%r14)
incq %r14
jmp 0x1c7c3
movq $-0x1, %r14
incq %r15
cmpq 0x8(%rbx), %r15
jb 0x1c77f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x4310
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43b0
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1c806
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x6144
addq $0x10, %r15
cmpq %r15, %rax
je 0x1db70
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5c16
jmp 0x1dc40
movq (%r14), %rax
cmpb $0x43, (%rax)
jne 0x1db9a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x97f8(%rip), %rsi      # 0x2737e
leaq 0x97f2(%rip), %rdx      # 0x2737f
movq %rbx, %rdi
callq 0x618a
jmp 0x1dc40
movq 0x8(%r14), %rcx
leaq (%rcx,%rax), %rdx
decq %rdx
movl $0x2, %esi
leaq 0xa161(%rip), %rdi      # 0x27d12
leaq (%rcx,%rsi), %r8
cmpq $0x2, %r8
je 0x1dbd5
testq %rsi, %rsi
je 0x1dbd5
movb -0x2(%rdx,%rsi), %r8b
leaq -0x1(%rsi), %r9
cmpb -0x1(%rsi,%rdi), %r8b
movq %r9, %rsi
je 0x1dbb1
jmp 0x1dbda
testq %rsi, %rsi
je 0x1dc49
testq %rcx, %rcx
je 0x1dc2d
decq %rcx
cmpq $0x5, %rcx
movl $0x5, %edx
cmovbq %rcx, %rdx
incq %rdx
xorl %esi, %esi
leaq 0x9fbe(%rip), %rdi      # 0x27bb9
movb (%rax,%rsi), %r8b
cmpb (%rsi,%rdi), %r8b
jne 0x1dc2d
incq %rsi
cmpq %rsi, %rdx
jne 0x1dbfb
cmpq $0x5, %rcx
jb 0x1dc2d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9ea7(%rip), %rsi      # 0x27ac8
leaq 0x9ea3(%rip), %rdx      # 0x27acb
jmp 0x1db8d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xa0ac(%rip), %rsi      # 0x27d03
leaq 0xa0a7(%rip), %rdx      # 0x27d05
jmp 0x1db8d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xcca(%rip), %rsi       # 0x3004
leaq 0xce8(%rip), %rdx       # 0x3029
leaq -0x78(%rbp), %rdi
callq 0x24c4
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xcd1(%rip), %rsi       # 0x302a
leaq 0xccc(%rip), %rdx       # 0x302c
leaq -0x58(%rbp), %rdi
callq 0x24c4
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x278e
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x238f
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2130
movq -0x38(%rbp), %r12
cmpq -0x30(%rbp), %r12
je 0x23e5
movq 0x2c38(%rip), %rbx      # 0x4fd8
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
addq $0x20, %r12
cmpq -0x30(%rbp), %r12
jne 0x23a0
leaq -0x38(%rbp), %rdi
callq 0x245a
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x2403
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2130
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x243d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2130
jmp 0x243d
movq %rax, %rbx
jmp 0x243d
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x245a
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x2452
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::show[abi:cxx11]()
string 
PatternChain<T>::show()
{
    typename vector<T>::const_iterator iter;
    ostringstream showstr;

    for ( iter = chain.begin();
            iter != chain.end();
            iter++ )
    {
        showstr << iter->show();
        /*
        vector<off_t>::const_iterator off_iter;
        for ( off_iter = (iter->seq).begin();
                off_iter != (iter->seq).end();
                off_iter++ )
        {
            cout << *off_iter << ", ";
        }
        cout << "^" << iter->cnt << endl;
        */
    }
    return showstr.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2160
movq 0x8(%r14), %r15
cmpq 0x10(%r14), %r15
je 0x2780
leaq 0x10(%rsp), %rbp
movq %rsp, %r12
leaq 0x20(%rsp), %r13
movq (%r15), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rdi
callq 0x2150
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x2776
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x30, %r15
cmpq 0x10(%r14), %r15
jne 0x2744
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2190
movq 0x683c(%rip), %rsi      # 0x8fd0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27c2
movq %rax, %rbx
jmp 0x27e0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x27e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
movq 0x67e9(%rip), %rsi      # 0x8fd0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/pattern.cpp
// Function: printVector[abi:cxx11](std::vector<long, std::allocator<long>>)
string
printVector( vector<off_t> vec )
{
    ostringstream oss;
    oss << "PrintVector: " ;
    vector<off_t>::const_iterator it;
    for ( it =  vec.begin() ;
          it != vec.end() ;
          it++ )
    {
        oss << *it << "," ;
    }
    oss << endl;
    return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2160
leaq 0x378a(%rip), %rsi      # 0x6170
movl $0xd, %edx
movq %r14, %rdi
callq 0x2150
movq (%r15), %rbp
cmpq 0x8(%r15), %rbp
je 0x2a2c
movq %rsp, %r12
leaq 0x3778(%rip), %r13      # 0x617e
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x2110
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
addq $0x8, %rbp
cmpq 0x8(%r15), %rbp
jne 0x2a06
movq (%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rsp, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2190
movq 0x6568(%rip), %rsi      # 0x8fd0
movq %rsp, %rdi
callq 0x20a0
leaq 0x70(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a93
jmp 0x2a93
movq %rax, %rbx
movq 0x6533(%rip), %rsi      # 0x8fd0
movq %rsp, %rdi
callq 0x20a0
leaq 0x70(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/pattern.cpp
// Function: buildDeltas(std::vector<long, std::allocator<long>>)
vector<off_t>
buildDeltas( vector<off_t> seq ) 
{
    vector<off_t>::iterator it;
    vector<off_t> deltas;
    //ostringstream oss;
    for ( it = seq.begin() ; it != seq.end() ; it++ )
    {
        if ( it > seq.begin() ) {
            deltas.push_back( *it - *(it-1) );
            //oss << (*it - *(it-1)) << "-";
        }
    }
    //mlog(IDX_WARN, "deltas:%s", oss.str().c_str());
    //cout << "in builddeltas: " << seq.size() << " " << deltas.size() << endl; 
    return deltas;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq 0x8(%rsi), %r12
je 0x2b1d
movq %rsi, %r14
movq %rsp, %r15
cmpq (%r14), %r12
jbe 0x2b13
movq (%r12), %rax
subq -0x8(%r12), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2b08
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2b13
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4d9a
addq $0x8, %r12
cmpq 0x8(%r14), %r12
jne 0x2adf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b43
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternElem::show[abi:cxx11]() const
string 
PatternElem::show() const
{
    vector<off_t>::const_iterator iter;
    ostringstream showstr;
    showstr << "( " ;
    for (iter = seq.begin();
            iter != seq.end();
            iter++ )
    {
        showstr << *iter << " ";
    }
    showstr << ") ^" << cnt << endl;
    return showstr.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2160
leaq 0x35da(%rip), %rsi      # 0x6180
movl $0x2, %edx
movq %r15, %rdi
callq 0x2150
movq 0x8(%r14), %r13
cmpq 0x10(%r14), %r13
je 0x2bef
leaq 0x8(%rsp), %r15
leaq 0x35b8(%rip), %r12      # 0x6181
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2110
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
addq $0x8, %r13
cmpq 0x10(%r14), %r13
jne 0x2bc9
leaq 0x358d(%rip), %rsi      # 0x6183
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x2150
movq 0x20(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2190
movq 0x637f(%rip), %rsi      # 0x8fd0
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x78(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2c7b
movq %rax, %rbx
movq 0x634b(%rip), %rsi      # 0x8fd0
leaq 0x8(%rsp), %rdi
callq 0x20a0
leaq 0x78(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::compressRepeats()
void
PatternUnit::compressRepeats()
{
    if ( isSeqRepeating() && size() > 1 ) {
        cnt = size();
        off_t tmp = seq[0];
        seq.clear();
        seq.push_back(tmp);
    }
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rcx, %rax
sete %dl
je 0x306b
xorl %esi, %esi
testq %rsi, %rsi
je 0x3057
movq (%rax,%rsi), %r8
cmpq -0x8(%rax,%rsi), %r8
jne 0x306b
leaq (%rax,%rsi), %rdx
addq $0x8, %rdx
addq $0x8, %rsi
cmpq %rcx, %rdx
sete %dl
jne 0x3047
testb $0x1, %dl
je 0x30ce
movq 0x20(%rdi), %rdx
testq %rdx, %rdx
je 0x30ce
subq %rax, %rcx
movq %rcx, %rsi
shrq $0x3, %rsi
imull %edx, %esi
cmpl $0x2, %esi
jl 0x30ce
imulq %rdx, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
movq %rcx, 0x20(%rdi)
movq (%rax), %rcx
movq %rcx, (%rsp)
cmpq %rax, 0x10(%rdi)
je 0x30ab
movq %rax, 0x10(%rdi)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x30c2
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x10(%rdi)
jmp 0x30ce
addq $0x8, %rdi
movq %rsp, %rdx
callq 0x4eba
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::serialize[abi:cxx11]()
string 
PatternUnit::serialize()
{
    string buf; //let me put it in string and see if it works
    header_t seqbodysize;
    header_t totalsize;

    totalsize = bodySize(); 
    
    appendToBuffer(buf, &totalsize, sizeof(totalsize));
    appendToBuffer(buf, &init, sizeof(init));
    appendToBuffer(buf, &cnt, sizeof(cnt));
    seqbodysize = seq.size()*sizeof(off_t);
    appendToBuffer(buf, &(seqbodysize), sizeof(header_t));
    if (seqbodysize > 0 ) {
        appendToBuffer(buf, &seq[0], seqbodysize);
    }
    return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x10(%rsi), %eax
subl 0x8(%rsi), %eax
andl $-0x8, %eax
addl $0x14, %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
callq 0x2040
leaq 0x28(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2040
leaq 0x20(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2040
movl 0x10(%r14), %eax
subl 0x8(%r14), %eax
andl $-0x8, %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2040
movslq 0x8(%rsp), %rdx
testq %rdx, %rdx
jle 0x3166
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x2040
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3189
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::show[abi:cxx11]() const
string
PatternUnit::show() const
{
    ostringstream showstr;
    showstr << init << " ... ";
    showstr << PatternElem::show();
    return showstr.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2160
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x2110
leaq 0x2f9d(%rip), %rsi      # 0x61bb
movl $0x5, %edx
movq %rax, %rdi
callq 0x2150
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2b7c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x2150
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3267
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2190
movq 0x5d55(%rip), %rsi      # 0x8fd0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x98(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x32c7
jmp 0x32c4
movq %rax, %rbx
movq 0x5d02(%rip), %rsi      # 0x8fd0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x98(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/pattern.cpp
// Function: RequestPatternList::show[abi:cxx11]() const
const string
RequestPatternList::show() const
{
    vector<RequestPattern>::const_iterator it;
    vector<PatternUnit>::const_iterator it2;
    
    ostringstream oss;

    for ( it = list.begin() ;
          it != list.end() ;
          it++ )
    {
        oss << "--- offset ---" << endl;
        oss << it->offset.show();
        for ( it2 = it->length.chain.begin() ; 
              it2 != it->length.chain.end() ;
              it2++ )
        {
            oss << "--- length ---" << endl;
            oss << it2->show() << endl;
        }
    }
    return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, 0x20(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x2160
movq (%rbx), %r12
movq %rbx, 0x28(%rsp)
cmpq 0x8(%rbx), %r12
je 0x4439
movq %rsp, %rbp
leaq 0x1f4f(%rip), %rbx      # 0x624d
movl $0xe, %edx
movq %r15, %rdi
leaq 0x1f31(%rip), %rsi      # 0x623e
callq 0x2150
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x31ec
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x2150
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4372
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
movq 0x38(%r12), %r13
cmpq 0x40(%r12), %r13
je 0x4426
movl $0xe, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2150
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%r13), %rax
movq %rbp, %rdi
movq %r13, %rsi
callq *(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x2150
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x441d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x30, %r13
jmp 0x4377
addq $0x50, %r12
movq 0x28(%rsp), %rax
cmpq 0x8(%rax), %r12
jne 0x42fe
leaq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2190
movq 0x4b7e(%rip), %rsi      # 0x8fd0
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44a8
jmp 0x44a8
jmp 0x4488
jmp 0x44a8
jmp 0x44a8
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x44ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x44ab
movq %rax, %rbx
movq 0x4b1e(%rip), %rsi      # 0x8fd0
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::isPopSafe(int)
bool
PatternChain<T>::isPopSafe( int t ) 
{
    typename vector<T>::reverse_iterator rit;
    
    int total = 0;
    rit = chain.rbegin();
    while ( rit != chain.rend()
            && total < t )
    {
        total += rit->size();
        rit++;
    }
    return total == t;
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
sete %dil
testl %esi, %esi
setle %r8b
xorl %edx, %edx
orb %dil, %r8b
jne 0x49d5
addq $-0x30, %rcx
xorl %edx, %edx
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x49c1
movq 0x10(%rcx), %r8
subq 0x8(%rcx), %r8
shrq $0x3, %r8
imull %r8d, %edi
jmp 0x49c6
movl $0x1, %edi
addl %edi, %edx
cmpq %rax, %rcx
je 0x49d5
addq $-0x30, %rcx
cmpl %esi, %edx
jl 0x49a6
cmpl %esi, %edx
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::popElem(int)
bool
PatternChain<T>::popElem ( int t )
{
    if ( !isPopSafe(t) ) {
        return false;
    }

    int total = 0; // the number of elem already popped out
    while ( !chain.empty() && total < t ) {
        total += top().size();
        chain.pop_back();
    }
    assert( total == t );

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x4984
testb %al, %al
je 0x4ab3
movb %al, 0x7(%rsp)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
sete %al
testl %ebx, %ebx
setle %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x4aaa
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
leaq 0x430e(%rip), %r13      # 0x8d38
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ae2
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x4a52
movq 0x18(%rsp), %rbp
subq 0x10(%rsp), %rbp
shrq $0x3, %rbp
imull %eax, %ebp
jmp 0x4a57
movl $0x1, %ebp
movq %r13, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4a73
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x10(%r14), %rax
leaq -0x30(%rax), %rcx
movq %rcx, 0x10(%r14)
movq %r13, -0x30(%rax)
movq -0x28(%rax), %rdi
testq %rdi, %rdi
je 0x4a98
movq -0x18(%rax), %rsi
subq %rdi, %rsi
callq 0x2140
addl %ebp, %r12d
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x4aaa
cmpl %ebx, %r12d
jl 0x4a2a
cmpl %ebx, %r12d
movb 0x7(%rsp), %al
jne 0x4ac2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1855(%rip), %rdi      # 0x631e
leaq 0x1859(%rip), %rsi      # 0x6329
leaq 0x185e(%rip), %rcx      # 0x6335
movl $0xeb, %edx
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/junhe[P]libpatterndetector/./pattern.h
// Function: PatChain<PatternUnit>::show[abi:cxx11]()
virtual string show()
        {
            typename vector<T>::const_iterator iter;
            ostringstream showstr;
            for ( iter = this->chain.begin();
                    iter != this->chain.end();
                    iter++ )
            {
                vector<off_t>::const_iterator off_iter;
                showstr << iter->init << "- (" ;
                for ( off_iter = (iter->seq).begin();
                        off_iter != (iter->seq).end();
                        off_iter++ )
                {
                    showstr << *off_iter << ", ";
                }
                showstr << ")^" << iter->cnt << endl;
            }
            return showstr.str(); 
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2160
movq 0x8(%r14), %r12
cmpq 0x10(%r14), %r12
je 0x4d27
leaq 0x10(%rsp), %r15
leaq 0x1653(%rip), %r13      # 0x62d0
leaq 0x1649(%rip), %rbp      # 0x62cd
movq 0x28(%r12), %rsi
movq %r15, %rdi
callq 0x2110
movl $0x3, %edx
movq %rax, %rdi
leaq 0x1629(%rip), %rsi      # 0x62c9
callq 0x2150
movq 0x8(%r12), %rbx
cmpq 0x10(%r12), %rbx
je 0x4cd2
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x2110
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2150
addq $0x8, %rbx
jmp 0x4caa
movl $0x2, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2150
movq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x2110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
addq $0x30, %r12
cmpq 0x10(%r14), %r12
jne 0x4c84
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2190
movq 0x4290(%rip), %rsi      # 0x8fd0
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x80(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d70
jmp 0x4d70
movq %rax, %rbx
movq 0x4256(%rip), %rsi      # 0x8fd0
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x80(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/eschwabe[P]interview-practice/src/allsubsets.cpp
// Function: GetSubsets(std::set<int, std::less<int>, std::allocator<int>> const&, std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>*)
void GetSubsets(const set<int>& s, vector<set<int>>* out) {
    if(s.size() == 0 || out == nullptr) {
        return;
    }
    for(auto v : s) {
        for(auto pset : vector<set<int>>{*out}) {
            set<int> tmp(pset);
            tmp.insert(v);
            out->push_back(tmp);
        }
        out->push_back(set<int>{v});
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testq %rsi, %rsi
je 0x13db
cmpq $0x0, 0x28(%rdi)
je 0x13db
movq 0x18(%rdi), %rax
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
cmpq %rdi, %rax
je 0x13db
movq %rsi, %rbx
leaq 0x20(%rsp), %r15
leaq 0x68(%rsp), %r13
leaq 0x38(%rsp), %rbp
leaq 0xc(%rsp), %r14
movq %rax, 0x18(%rsp)
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x159e
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r15
cmpq %r15, %r12
je 0x1386
movq %r13, %rdi
movq %r12, %rsi
callq 0x172a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x172a
movq %rbp, %rdi
movq %r14, %rsi
callq 0x19ca
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x163a
movq %rbp, %rdi
callq 0x190a
movq %r13, %rdi
callq 0x190a
addq $0x30, %r12
jmp 0x133f
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1666
movl 0xc(%rsp), %eax
movl %eax, 0x38(%rsp)
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rcx
leaq 0xb(%rsp), %r8
callq 0x16a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1de8
movq %r13, %rdi
callq 0x190a
movq 0x18(%rsp), %rdi
callq 0x1120
cmpq 0x10(%rsp), %rax
jne 0x131e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x190a
jmp 0x142c
movq %rax, %rbx
jmp 0x142c
movq %rax, %rbx
jmp 0x1422
movq %rax, %rbx
jmp 0x1418
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x190a
leaq 0x68(%rsp), %rdi
callq 0x190a
leaq 0x20(%rsp), %rdi
callq 0x1666
movq %rbx, %rdi
callq 0x1170