LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::Create(char const*)
bool CXMLTree::Create(const char* pszPath)
{
	xmlDocPtr pstDoc = xmlParseFile(pszPath);
	if (pstDoc != NULL) {
		xmlNodePtr pstRoot = xmlDocGetRootElement(pstDoc);
		if (pstRoot != NULL) {
			ParseNode(pstRoot, (char *)(pstRoot->name));
		}
		xmlFreeDoc(pstDoc);
	} else {
		return false;
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4570
movq %rax, %rbx
testq %rax, %rax
je 0x52c5
movq %rbx, %rdi
callq 0x4490
testq %rax, %rax
je 0x52bd
movq %rax, %r15
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x5aba
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x52fe
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45f0
testq %rbx, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::GetNode(CXMLNode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<CXMLNode*, std::allocator<CXMLNode*>>&)
void CXMLTree::GetNode(CXMLNode* pCNode, const std::string& strPath, std::vector<CXMLNode *>& vecNode)
{
	std::string strName = GetNodeName(strPath);
	if (pCNode != NULL && !strName.empty()) {
		std::vector<CXMLNode *> vecChild =  pCNode->GetChildren(strName);
		if (IsLastName(strName, strPath)) {
			for (unsigned int uiCount = 0; uiCount < vecChild.size(); ++uiCount) {
				vecNode.push_back(vecChild[uiCount]);
			}
		} else {
			for (unsigned int uiCount = 0; uiCount < vecChild.size(); ++uiCount) {
				GetNode(vecChild[uiCount], strPath.c_str() + strName.length(), vecNode);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %rdi
callq 0x58cc
testq %r12, %r12
je 0x57d1
cmpq $0x0, 0x30(%rsp)
je 0x57d1
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r12, %rsi
callq 0x4f02
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x593c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
testb %al, %al
je 0x574b
cmpq %rdi, %rcx
je 0x57bf
movl $0x1, %ebp
xorl %eax, %eax
leaq (%rdi,%rax,8), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5727
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x572f
movq %rbx, %rdi
callq 0x603a
movl %ebp, %eax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x570c
jmp 0x57bf
cmpq %rdi, %rcx
je 0x57bf
movl $0x1, %r13d
xorl %eax, %eax
leaq 0x48(%rsp), %r12
movq (%rdi,%rax,8), %rbp
movq (%r14), %rsi
addq 0x30(%rsp), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x5aba
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x5696
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x57a3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
movl %r13d, %eax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
incl %r13d
cmpq %rax, %rcx
ja 0x575d
testq %rdi, %rdi
je 0x57d1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57ec
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x583d
jmp 0x5802
movq %rax, %rbx
jmp 0x5826
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x5826
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x583d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5858
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::GetNodeName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string CXMLTree::GetNodeName(const std::string& strPath)
{
	size_t sizeStart = strPath.find_first_not_of('/');
	if (sizeStart == std::string::npos) {
		return std::string();
	}

	size_t sizeEnd = strPath.find_first_of('/', sizeStart);
	if (sizeEnd == std::string::npos) {
		sizeEnd = strPath.length();
	}
	return strPath.substr(sizeStart, sizeEnd - sizeStart);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x4270
cmpq $-0x1, %rax
je 0x591f
movq %rax, %r15
movq %r14, %rdi
movl $0x2f, %esi
movq %rax, %rdx
callq 0x43e0
cmpq $-0x1, %rax
jne 0x5909
movq 0x8(%r14), %rax
subq %r15, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4310
jmp 0x5932
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::IsLastName(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 CXMLTree::IsLastName(const std::string& strName, const std::string& strPath)
{
	size_t sizePos = strPath.find(strName);
	if (sizePos == std::string::npos) {
		return false;
	} else {
		sizePos += strName.length();
		while (sizePos < strPath.length()) {
			if (strPath[sizePos] != '/') {
				break;
			}
			++ sizePos;
		}
	}
	return sizePos == strPath.length();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq (%rsi), %rsi
movq 0x8(%r15), %rcx
xorl %r14d, %r14d
movq %rdx, %rdi
xorl %edx, %edx
callq 0x4590
cmpq $-0x1, %rax
je 0x5989
addq 0x8(%r15), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jae 0x5982
movq (%rbx), %rdx
cmpb $0x2f, (%rdx,%rax)
jne 0x5982
incq %rax
cmpq %rcx, %rax
jb 0x5971
movq %rcx, %rax
cmpq %rcx, %rax
sete %r14b
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/XMLTree.cpp
// Function: CXMLTree::FreeNode(CXMLNode*)
void CXMLTree::FreeNode(CXMLNode* pCNode)
{
	std::vector<CXMLNode *> vecNode = pCNode->GetChildren();
	for (unsigned int uiCount = 0; uiCount < vecNode.size(); ++uiCount) {
		FreeNode(vecNode[uiCount]);
	}
	delete pCNode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x78, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x5b8a
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x59e6
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
movq %r14, %rdi
callq 0x5992
movl %ebp, %ecx
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x59c1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5a05
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5a29
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/XMLParser.cpp
// Function: CXMLParser::ParseAttribute(CXMLNode*, CClassDetail*)
void CXMLParser::ParseAttribute(CXMLNode* pCNode, CClassDetail* pCDetail)
{
    BT_AUTO(mapAttribute, pCNode->GetAttribute());
    const string& strName = pCNode->GetName();
    for (BT_AUTO(iterAttr, mapAttribute.begin()); iterAttr != mapAttribute.end(); ++iterAttr) {
        const string& strAttr = iterAttr->first;
        pCDetail->AddAttribute(strName + NUtility::First2Up(strAttr), strAttr);
        //pCDetail->AddAttribute(strName, strAttr);

    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
addq $0x48, %rsi
leaq 0x68(%rsp), %rdi
callq 0x7182
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4e60
leaq 0x70(%rsp), %rbp
movq 0x10(%rbp), %r14
cmpq %rbp, %r14
je 0x6c8d
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r15
leaq 0x20(%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x7ec5
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4360
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6c16
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x6c1e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0xc98e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c5d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6c79
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x41e0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x6bce
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ca8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x68(%rsp), %rdi
callq 0x5af8
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6d24
movq %rax, %rbx
jmp 0x6d09
movq %rax, %rbx
jmp 0x6ced
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6ced
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6d09
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d24
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42f0
leaq 0x68(%rsp), %rdi
callq 0x5af8
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/Utility.cpp
// Function: NUtility::Daemonize()
void Daemonize()
{
	if (fork() != 0) {
		exit(0);
	}
	setsid();
	int iFd = -1;
	if ((iFd = open("/dev/null", O_RDWR, 0)) != -1) {
		dup2(iFd, STDIN_FILENO);
		dup2(iFd, STDOUT_FILENO);
		dup2(iFd, STDERR_FILENO);
		if (iFd > STDERR_FILENO) {
			close(iFd);
		}
	}
}

// Assembly:
pushq %rbx
callq 0x40b0
testl %eax, %eax
jne 0x7e7e
callq 0x4340
leaq 0x1f2c8(%rip), %rdi     # 0x27101
movl $0x2, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4210
cmpl $-0x1, %eax
je 0x7e7c
movl %eax, %ebx
movl %eax, %edi
xorl %esi, %esi
callq 0x42b0
movl %ebx, %edi
movl $0x1, %esi
callq 0x42b0
movl %ebx, %edi
movl $0x2, %esi
callq 0x42b0
cmpl $0x3, %ebx
jl 0x7e7c
movl %ebx, %edi
popq %rbx
jmp 0x4620
popq %rbx
retq
xorl %edi, %edi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O3/fffrankkk[P]XmlCode/src/Utility.cpp
// Function: NUtility::EnableCoreFile()
void EnableCoreFile()
{
	struct rlimit stLimit = {0, 0};
	if (getrlimit(RLIMIT_CORE, &stLimit) == 0) {
		stLimit.rlim_cur = RLIM_INFINITY;
		setrlimit(RLIMIT_CORE, &stLimit);
	}
}

// Assembly:
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x4, %edi
callq 0x4420
testl %eax, %eax
jne 0x7eb4
movq %rsp, %rsi
movq $-0x1, (%rsi)
movl $0x4, %edi
callq 0x4290
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7ffb
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 0x7ff0
movq %rbx, %rdi
callq 0x4140
movb $0x3a, 0x60(%rsp,%rax)
addq $0x20, %rbp
cmpq %rbp, 0x20(%rsp)
jne 0x7fc9
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 0x800e
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x8118
movq %r12, %r13
movq %r14, %r15
movq %rbp, %r14
movq 0x27f66(%rip), %rax     # 0x2ffa8
movq (%rax), %rbp
testq %rbp, %rbp
leaq 0x1f4b1(%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 0x61a0
movl %ebx, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq (%rsp), %rax
cmpq %r12, %rax
je 0x8099
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x80a2
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 0x815a
movq %r15, %r14
movq %r13, %r12
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
movq 0x50(%rsp), %r15
leaq 0x60(%rsp), %r13
je 0x80f4
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42f0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x800e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42f0
jmp 0x800e
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 0x8144
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_O3/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 0x6238
addq $0x4, %rbx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6250
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x669e
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x84f0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x93b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x84ac
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x8(%rsp), %rdi
callq 0x6244
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x84dd
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x84dd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
leaq 0x8(%rsp), %rdi
callq 0x6244
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa0ec
xorl %ebp, %ebp
movl $0x2d, %edi
callq 0x4400
incl %ebp
cmpl (%rbx), %ebp
jl 0xa0dc
movl $0xa, %edi
callq 0x4400
movq %r15, %rdi
callq 0x1925a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xce0c
movq (%r12), %rdi
cmpq %rdi, 0x8(%r12)
je 0xa151
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 0xa0c0
incq %r12
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rax, %r12
jb 0xa121
testq %rdi, %rdi
je 0xa163
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 0xa18a
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xad35
testl %ecx, %ecx
jne 0xad35
leaq 0x43(%rsp), %r15
leaq 0x20(%rsp), %rbx
leaq 0x30(%rsp), %r12
movq %rsp, %r13
leaq 0x10(%rsp), %rbp
cmpw $0x2e, 0x43(%rsp)
je 0xad16
movzwl 0x43(%rsp), %eax
xorl $0x2e2e, %eax           # imm = 0x2E2E
movzbl 0x45(%rsp), %ecx
orw %ax, %cx
je 0xad16
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
callq 0x4140
leaq (%rax,%r15), %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x61a0
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xaff6
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xad16
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 0xad35
testl %ecx, %ecx
je 0xacba
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 0xad61
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaf20
leaq 0x24d00(%rip), %rax     # 0x2fb10
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
callq 0x4480
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0xaf28
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0xac58
movq (%rsp), %rdx
cmpq %rdx, 0x8(%rsp)
je 0xaf0e
leaq 0x48(%rsp), %r13
movl $0x1, %ebp
xorl %r14d, %r14d
leaq 0x1c7d8(%rip), %r15     # 0x27646
leaq 0x38(%rsp), %r12
shlq $0x5, %r14
addq %r14, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xaf6d
movq (%rsp), %rdi
addq %r14, %rdi
movq %r12, %rsi
callq 0x43b0
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xaeab
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42f0
movq (%rsp), %rdx
addq %r14, %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xaf6d
movq (%rsp), %rdi
addq %r14, %rdi
movq %r12, %rsi
callq 0x43b0
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xaee3
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42f0
movq (%rsp), %rax
movq (%rax,%r14), %rdi
callq 0xadc2
movl %ebp, %r14d
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
subq %rdx, %rax
sarq $0x5, %rax
incl %ebp
cmpq %r14, %rax
ja 0xae73
movq 0x20(%rsp), %rdi
callq 0x44f0
movq %rsp, %rdi
callq 0xa1d6
movq %rbx, %rdi
callq 0x45c0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaf40
jmp 0xaf40
jmp 0xaf40
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa1d6
movq 0x20(%rsp), %rdi
callq 0x44f0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61a0
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0xb6ae
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x48, %rbx
movq %rbx, %rdx
callq 0xb579
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xb3cc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rsp, %rdi
callq 0xa1d6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xb3ff
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xb3ff
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rsp, %rdi
callq 0xa1d6
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1be4c(%rip), %rdi     # 0x27267
callq 0xad6a
testb %al, %al
je 0xb44b
leaq 0x1be44(%rip), %rdi     # 0x2726f
callq 0xad6a
testb %al, %al
je 0xb44b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1be25(%rip), %rsi     # 0x27267
leaq 0x1be24(%rip), %rdx     # 0x2726d
jmp 0xb497
leaq 0x1be14(%rip), %rdi     # 0x27266
callq 0xad6a
testb %al, %al
je 0xb482
leaq 0x1be0c(%rip), %rdi     # 0x2726e
callq 0xad6a
testb %al, %al
je 0xb482
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bded(%rip), %rsi     # 0x27266
leaq 0x1bded(%rip), %rdx     # 0x2726d
jmp 0xb497
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bde6(%rip), %rsi     # 0x27276
leaq 0x1bde1(%rip), %rdx     # 0x27278
movq %rbx, %rdi
callq 0x61a0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bdc0(%rip), %rdi     # 0x2726f
callq 0xad6a
testb %al, %al
je 0xb4df
leaq 0x1bdb0(%rip), %rdi     # 0x2726f
callq 0xad6a
testb %al, %al
je 0xb4df
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd99(%rip), %rsi     # 0x2726f
leaq 0x1bd98(%rip), %rdx     # 0x27275
jmp 0xb52b
leaq 0x1bd80(%rip), %rdi     # 0x27266
callq 0xad6a
testb %al, %al
je 0xb516
leaq 0x1bd78(%rip), %rdi     # 0x2726e
callq 0xad6a
testb %al, %al
je 0xb516
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd61(%rip), %rsi     # 0x2726e
leaq 0x1bd61(%rip), %rdx     # 0x27275
jmp 0xb52b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd52(%rip), %rsi     # 0x27276
leaq 0x1bd4d(%rip), %rdx     # 0x27278
movq %rbx, %rdi
callq 0x61a0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x28(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq 0x60(%rdi), %rbp
cmpq 0x68(%rdi), %rbp
je 0xca3f
leaq 0x18(%rsp), %r14
movq (%rbp), %rax
movq %r14, 0x8(%rsp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5c26
movq 0x10(%rsp), %rdx
cmpq 0x8(%r15), %rdx
jne 0xca00
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0xca0a
movq (%r15), %rsi
movq %r13, %rdi
callq 0x4300
testl %eax, %eax
setne %r12b
jmp 0xca0d
movb $0x1, %r12b
movq 0x8(%rsp), %r13
jmp 0xca0d
xorl %r12d, %r12d
cmpq %r14, %r13
je 0xca22
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x42f0
movq 0x68(%rbx), %rax
testb %r12b, %r12b
je 0xca36
addq $0x8, %rbp
cmpq %rax, %rbp
jne 0xc9ba
jmp 0xca3f
cmpq %rax, %rbp
jne 0xcb29
movl $0x68, %edi
callq 0x42e0
movq %rax, %r12
leaq 0x232ad(%rip), %rax     # 0x2fd00
movq %rax, (%r12)
leaq 0x8(%r12), %rdi
leaq 0x18(%r12), %rax
movq %rax, 0x8(%r12)
xorl %eax, %eax
movq %rax, 0x10(%r12)
movb %al, 0x18(%r12)
leaq 0x28(%r12), %r13
leaq 0x38(%r12), %rcx
movq %rcx, 0x28(%r12)
movq %rax, 0x30(%r12)
movb %al, 0x38(%r12)
leaq 0x58(%r12), %rcx
movq %rcx, 0x48(%r12)
movq %rax, 0x50(%r12)
movb %al, 0x58(%r12)
movq %r12, 0x30(%rsp)
movq %r15, %rsi
callq 0x41a0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a8ad(%rip), %rsi     # 0x27369
leaq 0x1a8a7(%rip), %rdx     # 0x2736a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x61a0
movq %r13, %rdi
movq %r15, %rsi
callq 0x41a0
leaq 0x48(%r12), %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xcaf7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %r15, %rdi
movq 0x28(%rsp), %rsi
callq 0x41a0
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0xcb18
movq %r12, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0xcb29
addq $0x60, %rbx
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x193d8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xcb52
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42f0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xce68
leaq 0x40(%r15), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xce50
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0xce58
movq %rbx, %rdi
callq 0x7950
movq %r15, %rdi
callq 0x41e0
movq %rax, %r15
cmpq %r14, %rax
jne 0xce35
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xce88
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x42f0
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16d60(%rip), %r14     # 0x2ffc8
leaq 0xe8f4(%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 0xe269(%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 0x1930f
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0xc7ae
movl %ebp, %ecx
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x192ee
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x19341
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0xc7ae
movl %ebp, %ecx
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x19320
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd442(%rip), %rsi      # 0x27d15
movl $0x1, %edx
movq %rax, %rdi
callq 0x4370
xorl %edx, %edx
cmpl $0x9, 0x18(%rsp)
setl %dl
leaq 0xd426(%rip), %r12      # 0x27d17
leaq 0xcc08(%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 0xd3f6(%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 0x1565b(%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 0x15628(%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_O3/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 0x4070
xorl %r14d, %r14d
cmpl $0x1, %eax
sbbq %r14, %r14
movq 0x8(%rbx), %r12
cmpq $0x2, %r12
jb 0x1c631
movl $0x1, %r15d
movq (%rbx), %r13
movsbl -0x1(%r13,%r15), %edi
callq 0x4070
testl %eax, %eax
je 0x1c609
movsbl (%r13,%r15), %edi
callq 0x4070
testl %eax, %eax
je 0x1c609
cmpq $-0x1, %r14
cmoveq %r15, %r14
jmp 0x1c629
cmpq $-0x1, %r14
je 0x1c622
movb (%r13,%r15), %al
movb %al, (%r13,%r14)
incq %r14
movq 0x8(%rbx), %r12
jmp 0x1c629
movq $-0x1, %r14
incq %r15
cmpq %r12, %r15
jb 0x1c5de
movq %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 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1c669
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42f0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x615a
addq $0x10, %r15
cmpq %r15, %rax
je 0x1d9d0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5c26
jmp 0x1daa0
movq (%r14), %rax
cmpb $0x43, (%rax)
jne 0x1d9fa
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9998(%rip), %rsi      # 0x2737e
leaq 0x9992(%rip), %rdx      # 0x2737f
movq %rbx, %rdi
callq 0x61a0
jmp 0x1daa0
movq 0x8(%r14), %rcx
leaq (%rcx,%rax), %rdx
decq %rdx
movl $0x2, %esi
leaq 0xa301(%rip), %rdi      # 0x27d12
leaq (%rcx,%rsi), %r8
cmpq $0x2, %r8
je 0x1da35
testq %rsi, %rsi
je 0x1da35
movb -0x2(%rdx,%rsi), %r8b
leaq -0x1(%rsi), %r9
cmpb -0x1(%rsi,%rdi), %r8b
movq %r9, %rsi
je 0x1da11
jmp 0x1da3a
testq %rsi, %rsi
je 0x1daa9
testq %rcx, %rcx
je 0x1da8d
decq %rcx
cmpq $0x5, %rcx
movl $0x5, %edx
cmovbq %rcx, %rdx
incq %rdx
xorl %esi, %esi
leaq 0xa15e(%rip), %rdi      # 0x27bb9
movb (%rax,%rsi), %r8b
cmpb (%rsi,%rdi), %r8b
jne 0x1da8d
incq %rsi
cmpq %rsi, %rdx
jne 0x1da5b
cmpq $0x5, %rcx
jb 0x1da8d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xa047(%rip), %rsi      # 0x27ac8
leaq 0xa043(%rip), %rdx      # 0x27acb
jmp 0x1d9ed
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 0xa24c(%rip), %rsi      # 0x27d03
leaq 0xa247(%rip), %rdx      # 0x27d05
jmp 0x1d9ed
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x277a
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 0x2770
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x30, %r15
cmpq 0x10(%r14), %r15
jne 0x273e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2190
movq 0x6842(%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 0x27bc
movq %rax, %rbx
jmp 0x27da
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x27da
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
movq 0x67ef(%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_O3/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 0x371e(%rip), %rsi      # 0x6100
movl $0xd, %edx
movq %r14, %rdi
callq 0x2150
movq (%r15), %rbp
cmpq 0x8(%r15), %rbp
je 0x2a28
movq %rsp, %r12
leaq 0x370c(%rip), %r13      # 0x610e
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 0x2a02
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 0x656c(%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 0x2a8f
jmp 0x2a8f
movq %rax, %rbx
movq 0x6537(%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_O3/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
movq 0x8(%rsi), %rax
cmpq %rax, %r12
je 0x2b1f
movq %rsi, %r14
movq %rsp, %r15
cmpq (%r14), %r12
jbe 0x2b16
movq (%r12), %rcx
subq -0x8(%r12), %rcx
movq %rcx, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2b07
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2b16
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4ca0
movq 0x8(%r14), %rax
addq $0x8, %r12
cmpq %rax, %r12
jne 0x2ade
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 0x2b45
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3568(%rip), %rsi      # 0x6110
movl $0x2, %edx
movq %r15, %rdi
callq 0x2150
movq 0x8(%r14), %r13
cmpq 0x10(%r14), %r13
je 0x2bf1
leaq 0x8(%rsp), %r15
leaq 0x3546(%rip), %r12      # 0x6111
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 0x2bcb
leaq 0x351b(%rip), %rsi      # 0x6113
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 0x637d(%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 0x2c7d
movq %rax, %rbx
movq 0x6349(%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_O3/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), %rsi
cmpq %rsi, %rax
je 0x3001
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x2ff0
movq (%rax,%rcx), %rdx
cmpq -0x8(%rax,%rcx), %rdx
jne 0x3062
leaq (%rax,%rcx), %rdx
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %rsi, %rdx
jne 0x2fe0
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x3062
movq %rsi, %rdx
subq %rax, %rdx
movq %rdx, %r8
shrq $0x3, %r8
imull %ecx, %r8d
cmpl $0x2, %r8d
jl 0x3062
imulq %rcx, %rdx
shrq $0x3, %rdx
movslq %edx, %rcx
movq %rcx, 0x20(%rdi)
movq (%rax), %rcx
movq %rcx, (%rsp)
cmpq %rsi, %rax
je 0x3043
movq %rax, 0x10(%rdi)
movq %rax, %rsi
cmpq 0x18(%rdi), %rsi
je 0x3056
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x10(%rdi)
jmp 0x3062
addq $0x8, %rdi
movq %rsp, %rdx
callq 0x4dc0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f99(%rip), %rsi      # 0x614b
movl $0x5, %edx
movq %rax, %rdi
callq 0x2150
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2b7e
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 0x31fb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2190
movq 0x5dc1(%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 0x325b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x325b
jmp 0x3258
movq %rax, %rbx
movq 0x5d6e(%rip), %rsi      # 0x8fd0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x98(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop